diff --git a/.github/workflows/nannou.yml b/.github/workflows/nannou.yml
index 066fc267a..88f758f74 100644
--- a/.github/workflows/nannou.yml
+++ b/.github/workflows/nannou.yml
@@ -24,6 +24,8 @@ jobs:
   # A colleciton of cargo verifications that should pass before landing PRs.
   cargo:
     runs-on: ubuntu-latest
+    env:
+      CARGO_TARGET_WASM32_UNKNOWN_UNKNOWN_LINKER: "lld"
     strategy:
       fail-fast: false
       matrix:
@@ -31,10 +33,10 @@ jobs:
           - command: cargo fmt --verbose --all -- --check
           - command: cargo check --locked --workspace
           - command: cargo check --locked --examples --workspace
-          - command: cargo test --locked --lib --bins --all-features --workspace
-          - command: cargo doc --locked --all-features --workspace
+          - command: cargo test --locked --lib --bins --workspace --features "egui"
+          - command: cargo doc --locked --workspace --features "egui"
           - command: cargo test --locked -p nannou_core --no-default-features --features "libm serde"
-          - command: cargo build --locked -p nannou --features "wasm-experimental" --target wasm32-unknown-unknown
+#          - command: cargo build --locked -p nannou --target wasm32-unknown-unknown
           - command: mdbook build guide/
           - command: cargo test --locked -p book_tests
     steps:
diff --git a/Cargo.lock b/Cargo.lock
index b67d037f8..9ed23c10a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4,9 +4,9 @@ version = 3
 
 [[package]]
 name = "ab_glyph"
-version = "0.2.23"
+version = "0.2.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80179d7dd5d7e8c285d67c4a1e652972a92de7475beddfb92028c76463b13225"
+checksum = "79faae4620f45232f599d9bc7b290f88247a0834162c4495ab2f02d60004adfb"
 dependencies = [
  "ab_glyph_rasterizer",
  "owned_ttf_parser",
@@ -20,72 +20,65 @@ checksum = "c71b1793ee61086797f5c80b6efa2b8ffa6d5dd703f118545808a7f2e27f7046"
 
 [[package]]
 name = "accesskit"
-version = "0.11.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76eb1adf08c5bcaa8490b9851fd53cca27fa9880076f178ea9d29f05196728a8"
-dependencies = [
- "enumn",
- "serde",
-]
-
-[[package]]
-name = "accesskit"
-version = "0.12.3"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74a4b14f3d99c1255dcba8f45621ab1a2e7540a0009652d33989005a4d0bfc6b"
+checksum = "6cf780eb737f2d4a49ffbd512324d53ad089070f813f7be7f99dbd5123a7f448"
 
 [[package]]
 name = "accesskit_consumer"
-version = "0.16.1"
+version = "0.22.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c17cca53c09fbd7288667b22a201274b9becaa27f0b91bf52a526db95de45e6"
+checksum = "3bdfa1638ddd6eb9c752def95568df8b3ad832df252e9156d2eb783b201ca8a9"
 dependencies = [
- "accesskit 0.12.3",
+ "accesskit",
+ "immutable-chunkmap",
 ]
 
 [[package]]
 name = "accesskit_macos"
-version = "0.10.1"
+version = "0.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd3b6ae1eabbfbced10e840fd3fce8a93ae84f174b3e4ba892ab7bcb42e477a7"
+checksum = "c236a84ff1111defc280cee755eaa953d0b24398786851b9d28322c6d3bb1ebd"
 dependencies = [
- "accesskit 0.12.3",
+ "accesskit",
  "accesskit_consumer",
  "objc2",
+ "objc2-app-kit",
+ "objc2-foundation",
  "once_cell",
 ]
 
 [[package]]
 name = "accesskit_windows"
-version = "0.15.1"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "afcae27ec0974fc7c3b0b318783be89fd1b2e66dd702179fe600166a38ff4a0b"
+checksum = "5d7f43d24b16b3e76bef248124fbfd2493c3a9860edb5aae1010c890e826de5e"
 dependencies = [
- "accesskit 0.12.3",
+ "accesskit",
  "accesskit_consumer",
- "once_cell",
  "paste",
  "static_assertions",
- "windows 0.48.0",
+ "windows 0.54.0",
 ]
 
 [[package]]
 name = "accesskit_winit"
-version = "0.15.0"
+version = "0.20.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88e39fcec2e10971e188730b7a76bab60647dacc973d4591855ebebcadfaa738"
+checksum = "755535e6bf711a42dac28b888b884b10fc00ff4010d9d3bd871c5f5beae5aa78"
 dependencies = [
- "accesskit 0.12.3",
+ "accesskit",
  "accesskit_macos",
  "accesskit_windows",
+ "raw-window-handle",
  "winit",
 ]
 
 [[package]]
 name = "addr2line"
-version = "0.21.0"
+version = "0.22.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a30b2e23b9e17a9f90641c7ab1549cd9b44f296d3ccbf309d2863cfe398a0cb"
+checksum = "6e4503c46a5c0c7844e948c9a4d6acd9f50cccb4de1c48eb9e291ea17470c678"
 dependencies = [
  "gimli",
 ]
@@ -109,11 +102,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011"
 dependencies = [
  "cfg-if 1.0.0",
- "getrandom 0.2.12",
+ "getrandom 0.2.15",
  "once_cell",
- "serde",
  "version_check",
- "zerocopy 0.7.32",
+ "zerocopy 0.7.35",
 ]
 
 [[package]]
@@ -134,11 +126,17 @@ dependencies = [
  "mp4parse",
 ]
 
+[[package]]
+name = "aligned-vec"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4aa90d7ce82d4be67b64039a3d588d38dbcc6736577de4a847025ce5b0c468d1"
+
 [[package]]
 name = "allocator-api2"
-version = "0.2.16"
+version = "0.2.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0942ffc6dcaadf03badf6e6a2d0228460359d5e34b57ccdc720b7382dfbd5ec5"
+checksum = "5c6cb57a04249c6480766f7f7cef5467412af1490f8d1e243141daddada3264f"
 
 [[package]]
 name = "alsa"
@@ -159,7 +157,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37fe60779335388a88c01ac6c3be40304d1e349de3ada3b15f7808bb90fa9dce"
 dependencies = [
  "alsa-sys",
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "libc",
 ]
 
@@ -175,20 +173,23 @@ dependencies = [
 
 [[package]]
 name = "android-activity"
-version = "0.4.3"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64529721f27c2314ced0890ce45e469574a73e5e6fdd6e9da1860eb29285f5e0"
+checksum = "ef6978589202a00cd7e118380c448a08b6ed394c3a8df3a430d0898e3a42d046"
 dependencies = [
  "android-properties",
- "bitflags 1.3.2",
+ "bitflags 2.6.0",
  "cc",
+ "cesu8",
+ "jni 0.21.1",
  "jni-sys",
  "libc",
  "log",
- "ndk 0.7.0",
+ "ndk 0.9.0",
  "ndk-context",
- "ndk-sys 0.4.1+23.1.7779620",
- "num_enum 0.6.1",
+ "ndk-sys 0.6.0+11769913",
+ "num_enum 0.7.2",
+ "thiserror",
 ]
 
 [[package]]
@@ -227,6 +228,12 @@ dependencies = [
  "winapi 0.3.9",
 ]
 
+[[package]]
+name = "anyhow"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3d1d046238990b9cf5bcde22a3fb3584ee5cf65fb2765f454ed428c7a0063da"
+
 [[package]]
 name = "approx"
 version = "0.3.2"
@@ -245,6 +252,41 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "arbitrary"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d5a26814d8dcb93b0e5a0ff3c6d80a8843bafb21b39e8e18a6f05471870e110"
+
+[[package]]
+name = "arboard"
+version = "3.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fb4009533e8ff8f1450a5bcbc30f4242a1d34442221f72314bea1f5dc9c7f89"
+dependencies = [
+ "clipboard-win",
+ "core-graphics",
+ "image 0.25.1",
+ "log",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-foundation",
+ "parking_lot 0.12.3",
+ "windows-sys 0.48.0",
+ "x11rb",
+]
+
+[[package]]
+name = "arg_enum_proc_macro"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ae92a5119aa49cdbcf6b9f893fe4e1d98b04ccbf82ee0584ad948a44a734dea"
+dependencies = [
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
+]
+
 [[package]]
 name = "arrayref"
 version = "0.3.7"
@@ -271,9 +313,12 @@ name = "arrayvec"
 version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
-dependencies = [
- "serde",
-]
+
+[[package]]
+name = "as-raw-xcb-connection"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "175571dd1d178ced59193a6fc02dde1b972eb0bc56c892cde9beeceac5bf0f6b"
 
 [[package]]
 name = "ascii"
@@ -316,79 +361,56 @@ dependencies = [
 
 [[package]]
 name = "async-channel"
-version = "1.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81953c529336010edd6d8e358f886d9581267795c61b19475b71314bffa46d35"
-dependencies = [
- "concurrent-queue",
- "event-listener 2.5.3",
- "futures-core",
-]
-
-[[package]]
-name = "async-channel"
-version = "2.2.0"
+version = "2.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f28243a43d821d11341ab73c80bed182dc015c514b951616cf79bd4af39af0c3"
+checksum = "89b47800b0be77592da0afd425cc03468052844aff33b84e33cc696f64e77b6a"
 dependencies = [
  "concurrent-queue",
- "event-listener 5.2.0",
- "event-listener-strategy 0.5.0",
+ "event-listener-strategy",
  "futures-core",
  "pin-project-lite",
 ]
 
 [[package]]
 name = "async-executor"
-version = "1.8.0"
+version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17ae5ebefcc48e7452b4987947920dac9450be1110cadf34d1b8c116bdbaf97c"
+checksum = "c8828ec6e544c02b0d6691d21ed9f9218d0384a82542855073c2a3f58304aaf0"
 dependencies = [
- "async-lock 3.3.0",
  "async-task",
  "concurrent-queue",
- "fastrand 2.0.1",
- "futures-lite 2.3.0",
+ "fastrand",
+ "futures-lite",
  "slab",
 ]
 
 [[package]]
 name = "async-fs"
-version = "1.6.0"
+version = "2.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "279cf904654eeebfa37ac9bb1598880884924aab82e290aa65c9e77a0e142e06"
+checksum = "ebcd09b382f40fcd159c2d695175b2ae620ffa5f3bd6f664131efff4e8b9e04a"
 dependencies = [
- "async-lock 2.8.0",
- "autocfg 1.1.0",
+ "async-lock",
  "blocking",
- "futures-lite 1.13.0",
-]
-
-[[package]]
-name = "async-lock"
-version = "2.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "287272293e9d8c41773cec55e365490fe034813a2f172f502d6ddcf75b2f582b"
-dependencies = [
- "event-listener 2.5.3",
+ "futures-lite",
 ]
 
 [[package]]
 name = "async-lock"
-version = "3.3.0"
+version = "3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d034b430882f8381900d3fe6f0aaa3ad94f2cb4ac519b429692a1bc2dda4ae7b"
+checksum = "ff6e472cdea888a4bd64f342f09b3f50e1886d32afe8df3d663c01140b811b18"
 dependencies = [
- "event-listener 4.0.3",
- "event-listener-strategy 0.4.0",
+ "event-listener 5.3.1",
+ "event-listener-strategy",
  "pin-project-lite",
 ]
 
 [[package]]
 name = "async-task"
-version = "4.7.0"
+version = "4.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fbb36e985947064623dbd357f727af08ffd077f93d696782f3c56365fa2e2799"
+checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de"
 
 [[package]]
 name = "atomic-waker"
@@ -428,26 +450,49 @@ version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0dde43e75fd43e8a1bf86103336bc699aa8d17ad1be60c76c0bdfd4828e19b78"
 dependencies = [
- "autocfg 1.1.0",
+ "autocfg 1.3.0",
 ]
 
 [[package]]
 name = "autocfg"
-version = "1.1.0"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
+
+[[package]]
+name = "av1-grain"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6678909d8c5d46a42abcf571271e15fdbc0a225e3646cf23762cd415046c78bf"
+dependencies = [
+ "anyhow",
+ "arrayvec 0.7.4",
+ "log",
+ "nom 7.1.3",
+ "num-rational 0.4.2",
+ "v_frame",
+]
+
+[[package]]
+name = "avif-serialize"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+checksum = "876c75a42f6364451a033496a14c44bffe41f5f4a8236f697391f11024e596d2"
+dependencies = [
+ "arrayvec 0.7.4",
+]
 
 [[package]]
 name = "backtrace"
-version = "0.3.69"
+version = "0.3.73"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2089b7e3f35b9dd2d0ed921ead4f6d318c27680d4a5bd167b3ee120edb105837"
+checksum = "5cc23269a4f8976d0a4d2e7109211a419fe30e8d88d677cd60b6bc79c5732e0a"
 dependencies = [
  "addr2line",
  "cc",
  "cfg-if 1.0.0",
  "libc",
- "miniz_oxide 0.7.2",
+ "miniz_oxide 0.7.4",
  "object",
  "rustc-demangle",
 ]
@@ -479,32 +524,76 @@ checksum = "3441f0f7b02788e948e47f457ca01f1d7e6d92c693bc132c22b087d3141c03ff"
 
 [[package]]
 name = "base64"
-version = "0.13.1"
+version = "0.21.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
+checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
 
 [[package]]
 name = "base64"
-version = "0.21.7"
+version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
 [[package]]
 name = "bevy"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4bc7e09282a82a48d70ade0c4c1154b0fd7882a735a39c66766a5d0f4718ea9"
+checksum = "8e938630e9f472b1899c78ef84aa907081b23bad8333140e2295c620485b6ee7"
 dependencies = [
  "bevy_internal",
 ]
 
+[[package]]
+name = "bevy-inspector-egui"
+version = "0.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "094e2d697a9dcbbd62fc6ff133d1d95990f66b6c4d25cdfb528f4b102c6a3ed1"
+dependencies = [
+ "bevy-inspector-egui-derive",
+ "bevy_app",
+ "bevy_asset",
+ "bevy_color",
+ "bevy_core",
+ "bevy_core_pipeline",
+ "bevy_ecs",
+ "bevy_egui",
+ "bevy_hierarchy",
+ "bevy_log",
+ "bevy_math",
+ "bevy_pbr",
+ "bevy_reflect",
+ "bevy_render",
+ "bevy_state",
+ "bevy_time",
+ "bevy_utils",
+ "bevy_window",
+ "bytemuck",
+ "egui",
+ "fuzzy-matcher",
+ "image 0.24.9",
+ "once_cell",
+ "pretty-type-name",
+ "smallvec 1.13.2",
+]
+
+[[package]]
+name = "bevy-inspector-egui-derive"
+version = "0.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "161d93f4b3a9246a87485e30ccf4cc927f204a14f26df42da977e383f0a0ec5d"
+dependencies = [
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
+]
+
 [[package]]
 name = "bevy_a11y"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68080288c932634f6563d3a8299efe0ddc9ea6787539c4c771ba250d089a94f0"
+checksum = "3e613f0e7d5a92637e59744f7185e374c9a59654ecc6d7575adcec9581db1363"
 dependencies = [
- "accesskit 0.12.3",
+ "accesskit",
  "bevy_app",
  "bevy_derive",
  "bevy_ecs",
@@ -512,52 +601,64 @@ dependencies = [
 
 [[package]]
 name = "bevy_animation"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7aa37683b1281e1ba8cf285644e6e3f0704f14b3901c5ee282067ff7ff6f4a56"
+checksum = "23aa4141df149b743e69c90244261c6372bafb70d9f115885de48a75fc28fd9b"
 dependencies = [
  "bevy_app",
  "bevy_asset",
+ "bevy_color",
  "bevy_core",
+ "bevy_derive",
  "bevy_ecs",
  "bevy_hierarchy",
+ "bevy_log",
  "bevy_math",
  "bevy_reflect",
  "bevy_render",
  "bevy_time",
  "bevy_transform",
  "bevy_utils",
+ "blake3",
+ "fixedbitset 0.5.7",
+ "petgraph 0.6.5",
+ "ron",
+ "serde",
+ "thiserror",
+ "thread_local",
+ "uuid 1.9.1",
 ]
 
 [[package]]
 name = "bevy_app"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d41731817993f92e4363dd3335558e779e290bc71eefc0b5547052b85810907e"
+checksum = "6f548e9dab7d10c5f99e3b504c758c4bf87aa67df9bcb9cc8b317a0271770e72"
 dependencies = [
  "bevy_derive",
  "bevy_ecs",
  "bevy_reflect",
  "bevy_tasks",
  "bevy_utils",
+ "console_error_panic_hook",
  "downcast-rs",
+ "thiserror",
  "wasm-bindgen",
  "web-sys",
 ]
 
 [[package]]
 name = "bevy_asset"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "935984568f75867dd7357133b06f4b1502cd2be55e4642d483ce597e46e63bff"
+checksum = "f9d198e4c3419215de2ad981d4e734bbfab46469b7575e3b7150c912b9ec5175"
 dependencies = [
  "async-broadcast",
  "async-fs",
- "async-lock 2.8.0",
+ "async-lock",
  "bevy_app",
  "bevy_asset_macros",
  "bevy_ecs",
- "bevy_log",
  "bevy_reflect",
  "bevy_tasks",
  "bevy_utils",
@@ -566,12 +667,14 @@ dependencies = [
  "crossbeam-channel",
  "downcast-rs",
  "futures-io",
- "futures-lite 1.13.0",
+ "futures-lite",
  "js-sys",
- "parking_lot 0.12.1",
+ "notify-debouncer-full",
+ "parking_lot 0.12.3",
  "ron",
  "serde",
  "thiserror",
+ "uuid 1.9.1",
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "web-sys",
@@ -579,135 +682,190 @@ dependencies = [
 
 [[package]]
 name = "bevy_asset_macros"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f48b9bbe4ec605e4910b5cd1e1a0acbfbe0b80af5f3bcc4489a9fdd1e80058c"
+checksum = "11b2cbeba287a4b44e116c33dbaf37dce80a9d84477b2bb35ff459999d6c9e1b"
 dependencies = [
  "bevy_macro_utils",
- "proc-macro2 1.0.79",
- "quote 1.0.35",
- "syn 2.0.53",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
 ]
 
 [[package]]
 name = "bevy_audio"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18a69889e1bfa4dbac4e641536b94f91c441da55796ad9832e77836b8264688b"
+checksum = "e41ecf15d0aae31bdb6d2b5cc590f966451e9736ddfee634c8f1ca5af1ac4342"
 dependencies = [
  "bevy_app",
  "bevy_asset",
  "bevy_derive",
  "bevy_ecs",
+ "bevy_hierarchy",
  "bevy_math",
  "bevy_reflect",
  "bevy_transform",
  "bevy_utils",
- "oboe 0.5.0",
+ "cpal 0.15.3",
  "rodio",
 ]
 
+[[package]]
+name = "bevy_color"
+version = "0.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a933306f5c7dc9568209180f482b28b5f40d2f8d5b361bc1b270c0a588752c0"
+dependencies = [
+ "bevy_math",
+ "bevy_reflect",
+ "bytemuck",
+ "encase",
+ "serde",
+ "thiserror",
+ "wgpu-types",
+]
+
+[[package]]
+name = "bevy_common_assets"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f631ce2863f3b6f1af3fa24143363b9fbd21c44218caad495a17b83e6968256"
+dependencies = [
+ "anyhow",
+ "bevy",
+ "serde",
+ "serde_json",
+ "thiserror",
+ "toml 0.8.14",
+]
+
 [[package]]
 name = "bevy_core"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3daa24502a14839509f02407bc7e48299fe84d260877de23b60662de0f4f4b6c"
+checksum = "6ddeed5ebf2fa75a4d4f32e2da9c60f11037e36252695059a151c6685cd3d72b"
 dependencies = [
  "bevy_app",
  "bevy_ecs",
- "bevy_math",
  "bevy_reflect",
  "bevy_tasks",
  "bevy_utils",
- "bytemuck",
+ "uuid 1.9.1",
 ]
 
 [[package]]
 name = "bevy_core_pipeline"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4b77c4fca6e90edbe2e72da7bc9aa7aed7dfdfded0920ae0a0c845f5e11084a"
+checksum = "1b978220b5edc98f2c5cbbd14c118c74b3ec7216e5416d3c187c1097279b009b"
 dependencies = [
  "bevy_app",
  "bevy_asset",
+ "bevy_color",
  "bevy_core",
  "bevy_derive",
  "bevy_ecs",
- "bevy_log",
  "bevy_math",
  "bevy_reflect",
  "bevy_render",
  "bevy_transform",
  "bevy_utils",
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
+ "nonmax",
  "radsort",
  "serde",
+ "smallvec 1.13.2",
+ "thiserror",
 ]
 
 [[package]]
 name = "bevy_derive"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f484318350462c58ba3942a45a656c1fd6b6e484a6b6b7abc3a787ad1a51e500"
+checksum = "c8a8173bad3ed53fa158806b1beda147263337d6ef71a093780dd141b74386b1"
 dependencies = [
  "bevy_macro_utils",
- "quote 1.0.35",
- "syn 2.0.53",
+ "quote 1.0.36",
+ "syn 2.0.69",
 ]
 
 [[package]]
 name = "bevy_diagnostic"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa38ca5967d335cc1006a0e0f1a86c350e2f15fd1878449f61d04cd57a7c4060"
+checksum = "0b7f82011fd70048be282526a99756d54bf00e874edafa9664ba0dc247678f03"
 dependencies = [
  "bevy_app",
  "bevy_core",
  "bevy_ecs",
- "bevy_log",
+ "bevy_tasks",
  "bevy_time",
  "bevy_utils",
+ "const-fnv1a-hash",
  "sysinfo",
 ]
 
 [[package]]
 name = "bevy_ecs"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7709fbd22f81fb681534cd913c41e1cd18b17143368743281195d7f024b61aea"
+checksum = "2c77fdc3a7230eff2fcebe4bd17c155bd238c660a0089d0f98c39ba0d461b923"
 dependencies = [
- "async-channel 1.9.0",
+ "arrayvec 0.7.4",
  "bevy_ecs_macros",
  "bevy_ptr",
  "bevy_reflect",
  "bevy_tasks",
  "bevy_utils",
- "downcast-rs",
- "event-listener 2.5.3",
- "fixedbitset 0.4.2",
- "rustc-hash",
+ "bitflags 2.6.0",
+ "concurrent-queue",
+ "fixedbitset 0.5.7",
+ "nonmax",
+ "petgraph 0.6.5",
  "serde",
  "thiserror",
- "thread_local",
 ]
 
 [[package]]
 name = "bevy_ecs_macros"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8843aa489f159f25cdcd9fee75cd7d221a7098a71eaa72cb2d6b40ac4e3f1ba"
+checksum = "9272b511958525306cd141726d3ca59740f79fc0707c439b55a007bcc3497308"
 dependencies = [
  "bevy_macro_utils",
- "proc-macro2 1.0.79",
- "quote 1.0.35",
- "syn 2.0.53",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
+]
+
+[[package]]
+name = "bevy_egui"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e4a90f30f2849a07d91e393b10c0cc05df09b5773c010ddde57dd8b583be230"
+dependencies = [
+ "arboard",
+ "bevy",
+ "bytemuck",
+ "console_log",
+ "crossbeam-channel",
+ "egui",
+ "js-sys",
+ "log",
+ "thread_local",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+ "webbrowser",
+ "winit",
 ]
 
 [[package]]
 name = "bevy_encase_derive"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5328a3715e933ebbff07d0e99528dc423c4f7a53590ed1ac19a120348b028990"
+checksum = "f0452d8254c8bfae4bff6caca2a8be3b0c1b2e1a72b93e9b9f6a21c8dff807e0"
 dependencies = [
  "bevy_macro_utils",
  "encase_derive_impl",
@@ -715,14 +873,13 @@ dependencies = [
 
 [[package]]
 name = "bevy_gilrs"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b81ca2ebf66cbc7f998f1f142b15038ffe3c4ae1d51f70adda26dcf51b0c4ca"
+checksum = "fbad8e59470c3d5cf25aa8c48462c4cf6f0c6314538c68ab2f5cf393146f0fc2"
 dependencies = [
  "bevy_app",
  "bevy_ecs",
  "bevy_input",
- "bevy_log",
  "bevy_time",
  "bevy_utils",
  "gilrs",
@@ -731,39 +888,54 @@ dependencies = [
 
 [[package]]
 name = "bevy_gizmos"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db232274ddca2ae452eb2731b98267b795d133ddd14013121bc7daddde1c7491"
+checksum = "bdbb0556f0c6e45f4a17aef9c708c06ebf15ae1bed4533d7eddb493409f9f025"
 dependencies = [
  "bevy_app",
  "bevy_asset",
- "bevy_core",
+ "bevy_color",
  "bevy_core_pipeline",
  "bevy_ecs",
+ "bevy_gizmos_macros",
  "bevy_math",
  "bevy_pbr",
  "bevy_reflect",
  "bevy_render",
  "bevy_sprite",
+ "bevy_time",
  "bevy_transform",
  "bevy_utils",
+ "bytemuck",
+]
+
+[[package]]
+name = "bevy_gizmos_macros"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ef351a4b6498c197d1317c62f46ba84b69fbde3dbeb57beb2e744bbe5b7c3e0"
+dependencies = [
+ "bevy_macro_utils",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
 ]
 
 [[package]]
 name = "bevy_gltf"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85adc6b1fc86687bf67149e0bafaa4d6da432232fa956472d1b37f19121d3ace"
+checksum = "cfd7abeaf3f28afd1f8999c2169aa17b40a37ad11253cf7dd05017024b65adc6"
 dependencies = [
- "base64 0.13.1",
+ "base64 0.22.1",
  "bevy_animation",
  "bevy_app",
  "bevy_asset",
+ "bevy_color",
  "bevy_core",
  "bevy_core_pipeline",
  "bevy_ecs",
  "bevy_hierarchy",
- "bevy_log",
  "bevy_math",
  "bevy_pbr",
  "bevy_reflect",
@@ -776,19 +948,19 @@ dependencies = [
  "percent-encoding 2.3.1",
  "serde",
  "serde_json",
+ "smallvec 1.13.2",
  "thiserror",
 ]
 
 [[package]]
 name = "bevy_hierarchy"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06bd477152ce2ae1430f5e0a4f19216e5785c22fee1ab23788b5982dc59d1a55"
+checksum = "802eca6f341d19ade790ccfaba7044be4d823b708087eb5ac4c1f74e4ea0916a"
 dependencies = [
  "bevy_app",
  "bevy_core",
  "bevy_ecs",
- "bevy_log",
  "bevy_reflect",
  "bevy_utils",
  "smallvec 1.13.2",
@@ -796,29 +968,31 @@ dependencies = [
 
 [[package]]
 name = "bevy_input"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cab9a599189b2a694c182d60cd52219dd9364f9892ff542d87799b8e45d9e6dc"
+checksum = "2d050f1433f48ca23f1ea078734ebff119a3f76eb7d221725ab0f1fd9f81230b"
 dependencies = [
  "bevy_app",
  "bevy_ecs",
  "bevy_math",
  "bevy_reflect",
  "bevy_utils",
+ "smol_str",
  "thiserror",
 ]
 
 [[package]]
 name = "bevy_internal"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f124bece9831afd80897815231072d51bfe3ac58c6bb58eca8880963b6d0487c"
+checksum = "8ddd2b23e44d3a1f8ae547cbee5b6661f8135cc456c5de206e8648789944e7a1"
 dependencies = [
  "bevy_a11y",
  "bevy_animation",
  "bevy_app",
  "bevy_asset",
  "bevy_audio",
+ "bevy_color",
  "bevy_core",
  "bevy_core_pipeline",
  "bevy_derive",
@@ -837,6 +1011,7 @@ dependencies = [
  "bevy_render",
  "bevy_scene",
  "bevy_sprite",
+ "bevy_state",
  "bevy_tasks",
  "bevy_text",
  "bevy_time",
@@ -849,48 +1024,49 @@ dependencies = [
 
 [[package]]
 name = "bevy_log"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0dc10ba1d225a8477b9e80a1bf797d8a8b8274e83c9b24fb4d9351aec9229755"
+checksum = "bab641fd0de254915ab746165a07677465b2d89b72f5b49367d73b9197548a35"
 dependencies = [
  "android_log-sys",
  "bevy_app",
  "bevy_ecs",
  "bevy_utils",
- "console_error_panic_hook",
- "tracing-log 0.1.4",
+ "tracing-log",
  "tracing-subscriber",
  "tracing-wasm",
 ]
 
 [[package]]
 name = "bevy_macro_utils"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e566640c6b6dced73d2006c764c2cffebe1a82be4809486c4a5d7b4b50efed4d"
+checksum = "c3ad860d35d74b35d4d6ae7f656d163b6f475aa2e64fc293ee86ac901977ddb7"
 dependencies = [
- "proc-macro2 1.0.79",
- "quote 1.0.35",
- "rustc-hash",
- "syn 2.0.53",
- "toml_edit 0.20.7",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
+ "toml_edit 0.22.14",
 ]
 
 [[package]]
 name = "bevy_math"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58ddc2b76783939c530178f88e5711a1b01044d7b02db4033e2eb8b43b6cf4ec"
+checksum = "51bd6ce2174d3237d30e0ab5b2508480cc7593ca4d96ffb3a3095f9fc6bbc34c"
 dependencies = [
+ "bevy_reflect",
  "glam",
- "serde",
+ "rand 0.8.5",
+ "smallvec 1.13.2",
+ "thiserror",
 ]
 
 [[package]]
 name = "bevy_mikktspace"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ec4962977a746d870170532fc92759e04d3dbcae8b7b82e7ca3bb83b1d75277"
+checksum = "b7ce4266293629a2d10459cc112dffe3b3e9229a4f2b8a4d20061b8dd53316d0"
 dependencies = [
  "glam",
 ]
@@ -901,7 +1077,8 @@ version = "0.1.0"
 dependencies = [
  "bevy",
  "bevy_nannou_draw",
- "bevy_nannou_render",
+ "bevy_nannou_isf",
+ "bevy_nannou_video",
 ]
 
 [[package]]
@@ -909,41 +1086,48 @@ name = "bevy_nannou_draw"
 version = "0.1.0"
 dependencies = [
  "bevy",
+ "bytemuck",
  "lyon",
  "nannou_core",
- "nannou_mesh",
  "num-traits",
+ "rayon",
  "rusttype",
+ "uuid 1.9.1",
 ]
 
 [[package]]
-name = "bevy_nannou_render"
+name = "bevy_nannou_isf"
 version = "0.1.0"
 dependencies = [
  "bevy",
- "bevy_nannou_draw",
- "bevy_nannou_wgpu",
- "lyon",
- "nannou_core",
- "wgpu-types",
+ "bevy-inspector-egui",
+ "bevy_egui",
+ "bytemuck",
+ "isf",
+ "meval",
+ "thiserror",
 ]
 
 [[package]]
-name = "bevy_nannou_wgpu"
+name = "bevy_nannou_video"
 version = "0.1.0"
 dependencies = [
  "bevy",
- "wgpu-types",
-]
+ "rayon",
+ "serde",
+ "thiserror",
+ "video-rs",
+]
 
 [[package]]
 name = "bevy_pbr"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "520bfd2a898c74f84ea52cfb8eb061f37373ad15e623489d5f75d27ebd6138fe"
+checksum = "3effe8ff28899f14d250d0649ca9868dbe68b389d0f2b7af086759b8e16c6e3d"
 dependencies = [
  "bevy_app",
  "bevy_asset",
+ "bevy_color",
  "bevy_core_pipeline",
  "bevy_derive",
  "bevy_ecs",
@@ -953,68 +1137,70 @@ dependencies = [
  "bevy_transform",
  "bevy_utils",
  "bevy_window",
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "bytemuck",
- "fixedbitset 0.4.2",
- "naga_oil",
+ "fixedbitset 0.5.7",
+ "nonmax",
  "radsort",
  "smallvec 1.13.2",
- "thread_local",
+ "static_assertions",
 ]
 
 [[package]]
 name = "bevy_ptr"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c77ec20c8fafcdc196508ef5ccb4f0400a8d193cb61f7b14a36ed9a25ad423cf"
+checksum = "c115c97a5c8a263bd0aa7001b999772c744ac5ba797d07c86f25734ce381ea69"
 
 [[package]]
 name = "bevy_reflect"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7921f15fc944c9c8ad01d7dbcea6505b8909c6655cd9382bab1407181556038"
+checksum = "406ea0fce267169c2320c7302d97d09f605105686346762562c5f65960b5ca2f"
 dependencies = [
- "bevy_math",
  "bevy_ptr",
  "bevy_reflect_derive",
  "bevy_utils",
  "downcast-rs",
  "erased-serde",
  "glam",
+ "petgraph 0.6.5",
  "serde",
  "smallvec 1.13.2",
  "smol_str",
  "thiserror",
+ "uuid 1.9.1",
 ]
 
 [[package]]
 name = "bevy_reflect_derive"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4a8c5475f216e751ef4452a1306b00711f33d2d04d9f149e4c845dfeb6753a0"
+checksum = "0427fdb4425fc72cc96d45e550df83ace6347f0503840de116c76a40843ba751"
 dependencies = [
  "bevy_macro_utils",
- "proc-macro2 1.0.79",
- "quote 1.0.35",
- "syn 2.0.53",
- "uuid 1.8.0",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
+ "uuid 1.9.1",
 ]
 
 [[package]]
 name = "bevy_render"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bdefdd3737125b0d94a6ff20bb70fa8cfe9d7d5dcd72ba4dfe6c5f1d30d9f6e4"
+checksum = "4c48acf1ff4267c231def4cbf573248d42ac60c9952108822d505019460bf36d"
 dependencies = [
- "async-channel 1.9.0",
+ "async-channel",
  "bevy_app",
  "bevy_asset",
+ "bevy_color",
  "bevy_core",
  "bevy_derive",
+ "bevy_diagnostic",
  "bevy_ecs",
  "bevy_encase_derive",
  "bevy_hierarchy",
- "bevy_log",
  "bevy_math",
  "bevy_mikktspace",
  "bevy_reflect",
@@ -1024,23 +1210,24 @@ dependencies = [
  "bevy_transform",
  "bevy_utils",
  "bevy_window",
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "bytemuck",
  "codespan-reporting",
  "downcast-rs",
  "encase",
- "futures-lite 1.13.0",
+ "futures-lite",
  "hexasphere",
- "image 0.24.9",
+ "image 0.25.1",
  "js-sys",
  "ktx2",
- "naga 0.13.0",
+ "naga 0.20.0",
  "naga_oil",
+ "nonmax",
  "ruzstd",
+ "send_wrapper",
  "serde",
  "smallvec 1.13.2",
  "thiserror",
- "thread_local",
  "wasm-bindgen",
  "web-sys",
  "wgpu",
@@ -1048,21 +1235,21 @@ dependencies = [
 
 [[package]]
 name = "bevy_render_macros"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64d86bfc5a1e7fbeeaec0c4ceab18155530f5506624670965db3415f75826bea"
+checksum = "72ddf4a96d71519c8eca3d74dabcb89a9c0d50ab5d9230638cb004145f46e9ed"
 dependencies = [
  "bevy_macro_utils",
- "proc-macro2 1.0.79",
- "quote 1.0.35",
- "syn 2.0.53",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
 ]
 
 [[package]]
 name = "bevy_scene"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7df078b5e406e37c8a1c6ba0d652bf105fde713ce3c3efda7263fe27467eee5"
+checksum = "b7a9f0388612a116f02ab6187aeab66e52c9e91abbc21f919b8b50230c4d83e7"
 dependencies = [
  "bevy_app",
  "bevy_asset",
@@ -1073,61 +1260,86 @@ dependencies = [
  "bevy_render",
  "bevy_transform",
  "bevy_utils",
- "ron",
  "serde",
  "thiserror",
- "uuid 1.8.0",
+ "uuid 1.9.1",
 ]
 
 [[package]]
 name = "bevy_sprite"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7cc0c9d946e17e3e0aaa202f182837bc796c4f862b2e5a805134f873f21cf7f"
+checksum = "d837e33ed27b9f2e5212eca4bdd5655a9ee64c52914112e6189c043cb25dd1ec"
 dependencies = [
  "bevy_app",
  "bevy_asset",
+ "bevy_color",
  "bevy_core_pipeline",
  "bevy_derive",
  "bevy_ecs",
- "bevy_log",
  "bevy_math",
  "bevy_reflect",
  "bevy_render",
  "bevy_transform",
  "bevy_utils",
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "bytemuck",
- "fixedbitset 0.4.2",
+ "fixedbitset 0.5.7",
  "guillotiere",
  "radsort",
  "rectangle-pack",
  "thiserror",
 ]
 
+[[package]]
+name = "bevy_state"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0959984092d56885fd3b320ea84fb816821bad6bfa3040b9d4ee850d3273233d"
+dependencies = [
+ "bevy_app",
+ "bevy_ecs",
+ "bevy_hierarchy",
+ "bevy_reflect",
+ "bevy_state_macros",
+ "bevy_utils",
+]
+
+[[package]]
+name = "bevy_state_macros"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "887a98bfa268258377cd073f5bb839518d3a1cd6b96ed81418145485b69378e6"
+dependencies = [
+ "bevy_macro_utils",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
+]
+
 [[package]]
 name = "bevy_tasks"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4fefa7fe0da8923525f7500e274f1bd60dbd79918a25cf7d0dfa0a6ba15c1cf"
+checksum = "5a8bfb8d484bdb1e9bec3789c75202adc5e608c4244347152e50fb31668a54f9"
 dependencies = [
- "async-channel 1.9.0",
+ "async-channel",
  "async-executor",
- "async-task",
  "concurrent-queue",
- "futures-lite 1.13.0",
+ "futures-lite",
  "wasm-bindgen-futures",
 ]
 
 [[package]]
 name = "bevy_text"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a9a79d49ca06170d69149949b134c14e8b99ace1444c1ca2cd4743b19d5b055"
+checksum = "454fd29b7828244356b2e0ce782e6d0a6f26b47f521456accde3a7191b121727"
 dependencies = [
  "ab_glyph",
  "bevy_app",
  "bevy_asset",
+ "bevy_color",
  "bevy_ecs",
  "bevy_math",
  "bevy_reflect",
@@ -1143,9 +1355,9 @@ dependencies = [
 
 [[package]]
 name = "bevy_time"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6250d76eed3077128b6a3d004f9f198b01107800b9824051e32bb658054e837"
+checksum = "a6c3d3d14ee8b0dbe4819fd516cc75509b61946134d78e0ee89ad3d1835ffe6c"
 dependencies = [
  "bevy_app",
  "bevy_ecs",
@@ -1157,9 +1369,9 @@ dependencies = [
 
 [[package]]
 name = "bevy_transform"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d541e0c292edbd96afae816ee680e02247422423ccd5dc635c1e211a20ed64be"
+checksum = "97e8aa6b16be573277c6ceda30aebf1d78af7c6ede19b448dcb052fb8601d815"
 dependencies = [
  "bevy_app",
  "bevy_ecs",
@@ -1171,19 +1383,19 @@ dependencies = [
 
 [[package]]
 name = "bevy_ui"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d785e3b75dabcb2a8ad0d50933f8f3446d59e512cabc2d2a145e28c2bb8792ba"
+checksum = "38d9f864c646f3742ff77f67bcd89a13a7ab024b68ca2f1bfbab8245bcb1c06c"
 dependencies = [
  "bevy_a11y",
  "bevy_app",
  "bevy_asset",
+ "bevy_color",
  "bevy_core_pipeline",
  "bevy_derive",
  "bevy_ecs",
  "bevy_hierarchy",
  "bevy_input",
- "bevy_log",
  "bevy_math",
  "bevy_reflect",
  "bevy_render",
@@ -1193,7 +1405,7 @@ dependencies = [
  "bevy_utils",
  "bevy_window",
  "bytemuck",
- "serde",
+ "nonmax",
  "smallvec 1.13.2",
  "taffy",
  "thiserror",
@@ -1201,54 +1413,51 @@ dependencies = [
 
 [[package]]
 name = "bevy_utils"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7915222f4a08ccc782e08d10b751b42e5f9d786e697d0cb3fd09333cb7e8b6ea"
+checksum = "7fab364910e8f5839578aba9cfda00a8388e9ebe352ceb8491a742ce6af9ec6e"
 dependencies = [
  "ahash",
  "bevy_utils_proc_macros",
- "getrandom 0.2.12",
- "hashbrown 0.14.3",
- "instant",
- "nonmax",
- "petgraph 0.6.4",
- "thiserror",
+ "getrandom 0.2.15",
+ "hashbrown 0.14.5",
+ "thread_local",
  "tracing",
- "uuid 1.8.0",
+ "web-time",
 ]
 
 [[package]]
 name = "bevy_utils_proc_macros"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7aafecc952b6b8eb1a93c12590bd867d25df2f4ae1033a01dfdfc3c35ebccfff"
+checksum = "ad9db261ab33a046e1f54b35f885a44f21fcc80aa2bc9050319466b88fe58fe3"
 dependencies = [
- "proc-macro2 1.0.79",
- "quote 1.0.35",
- "syn 2.0.53",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
 ]
 
 [[package]]
 name = "bevy_window"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41ee72bf7f974000e9b31bb971a89387f1432ba9413f35c4fef59fef49767260"
+checksum = "c9ea5777f933bf7ecaeb3af1a30845720ec730e007972ca7d4aba2d3512abe24"
 dependencies = [
  "bevy_a11y",
  "bevy_app",
  "bevy_ecs",
- "bevy_input",
  "bevy_math",
  "bevy_reflect",
  "bevy_utils",
  "raw-window-handle",
+ "smol_str",
 ]
 
 [[package]]
 name = "bevy_winit"
-version = "0.12.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1eb71f287eca9006dda998784c7b931e400ae2cc4c505da315882a8b082f21ad"
+checksum = "f8c2213bbf14debe819ec8ad4913f233c596002d087bc6f1f20d533e2ebaf8c6"
 dependencies = [
  "accesskit_winit",
  "approx 0.5.1",
@@ -1258,10 +1467,13 @@ dependencies = [
  "bevy_ecs",
  "bevy_hierarchy",
  "bevy_input",
+ "bevy_log",
  "bevy_math",
+ "bevy_reflect",
  "bevy_tasks",
  "bevy_utils",
  "bevy_window",
+ "cfg-if 1.0.0",
  "crossbeam-channel",
  "raw-window-handle",
  "wasm-bindgen",
@@ -1275,7 +1487,7 @@ version = "0.69.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a00dc851838a2120612785d195287475a3ac45514741da670b735818822129a0"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "cexpr",
  "clang-sys",
  "itertools",
@@ -1283,12 +1495,12 @@ dependencies = [
  "lazycell",
  "log",
  "prettyplease",
- "proc-macro2 1.0.79",
- "quote 1.0.35",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
  "regex",
  "rustc-hash",
  "shlex",
- "syn 2.0.53",
+ "syn 2.0.69",
  "which",
 ]
 
@@ -1307,6 +1519,12 @@ version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb"
 
+[[package]]
+name = "bit_field"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc827186963e592360843fb5ba4b973e145841266c1357f7180c43526f2e5b61"
+
 [[package]]
 name = "bitflags"
 version = "1.3.2"
@@ -1315,9 +1533,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.5.0"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1"
+checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
 dependencies = [
  "serde",
 ]
@@ -1340,6 +1558,12 @@ dependencies = [
  "cfg-if 1.0.0",
 ]
 
+[[package]]
+name = "bitstream-io"
+version = "2.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "415f8399438eb5e4b2f73ed3152a3448b98149dda642a957ee704e1daa5cf1d8"
+
 [[package]]
 name = "blake3"
 version = "1.5.1"
@@ -1359,39 +1583,26 @@ version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0d8c1fef690941d3e7788d328517591fecc684c084084702d6ff1641e993699a"
 
-[[package]]
-name = "block-sys"
-version = "0.1.0-beta.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fa55741ee90902547802152aaf3f8e5248aab7e21468089560d4c8840561146"
-dependencies = [
- "objc-sys",
-]
-
 [[package]]
 name = "block2"
-version = "0.2.0-alpha.6"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8dd9e63c1744f755c2f60332b88de39d341e5e86239014ad839bd71c106dec42"
+checksum = "2c132eebf10f5cad5289222520a4a058514204aed6d791f1cf4fe8088b82d15f"
 dependencies = [
- "block-sys",
- "objc2-encode",
+ "objc2",
 ]
 
 [[package]]
 name = "blocking"
-version = "1.5.1"
+version = "1.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a37913e8dc4ddcc604f0c6d3bf2887c995153af3611de9e23c352b44c1b9118"
+checksum = "703f41c54fc768e63e091340b424302bb1c29ef4aa0c7f10fe849dfb114d29ea"
 dependencies = [
- "async-channel 2.2.0",
- "async-lock 3.3.0",
+ "async-channel",
  "async-task",
- "fastrand 2.0.1",
  "futures-io",
- "futures-lite 2.3.0",
+ "futures-lite",
  "piper",
- "tracing",
 ]
 
 [[package]]
@@ -1413,36 +1624,42 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "built"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6a6c0b39c38fd754ac338b00a88066436389c0f029da5d37d1e01091d9b7c17"
+
 [[package]]
 name = "bumpalo"
-version = "3.15.4"
+version = "3.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ff69b9dd49fd426c69a0db9fc04dd934cdb6645ff000864d98f7e2af8830eaa"
+checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
 
 [[package]]
 name = "bytecount"
-version = "0.6.7"
+version = "0.6.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1e5f035d16fc623ae5f74981db80a439803888314e3a555fd6f04acd51a3205"
+checksum = "5ce89b21cab1437276d2650d57e971f9d548a2d9037cc231abdc0562b97498ce"
 
 [[package]]
 name = "bytemuck"
-version = "1.15.0"
+version = "1.16.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d6d68c57235a3a081186990eca2867354726650f42f7516ca50c28d6281fd15"
+checksum = "b236fc92302c97ed75b38da1f4917b5cdda4984745740f153a5d3059e48d725e"
 dependencies = [
  "bytemuck_derive",
 ]
 
 [[package]]
 name = "bytemuck_derive"
-version = "1.6.0"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4da9a32f3fed317401fa3c862968128267c3106685286e15d5aaa3d7389c2f60"
+checksum = "1ee891b04274a59bd38b412188e24b849617b2e45a0fd8d057deb63e7403761b"
 dependencies = [
- "proc-macro2 1.0.79",
- "quote 1.0.35",
- "syn 2.0.53",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
 ]
 
 [[package]]
@@ -1451,6 +1668,12 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
+[[package]]
+name = "byteorder-lite"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"
+
 [[package]]
 name = "bytes"
 version = "0.4.12"
@@ -1464,9 +1687,9 @@ dependencies = [
 
 [[package]]
 name = "bytes"
-version = "1.5.0"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2bd12c1caf447e69cd4528f47f94d203fd2582878ecb9e9465484c4148a8223"
+checksum = "514de17de45fdb8dc022b1a7975556c53c86f9f0aa5f534b98977b171857c2c9"
 
 [[package]]
 name = "bytesize"
@@ -1512,16 +1735,37 @@ dependencies = [
 
 [[package]]
 name = "calloop"
-version = "0.10.6"
+version = "0.12.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52e0d00eb1ea24371a97d2da6201c6747a633dc6dc1988ef503403b4c59504a8"
+checksum = "fba7adb4dd5aa98e5553510223000e7148f621165ec5f9acd7113f6ca4995298"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.6.0",
  "log",
- "nix 0.25.1",
- "slotmap",
+ "polling",
+ "rustix",
+ "slab",
  "thiserror",
- "vec_map",
+]
+
+[[package]]
+name = "calloop-wayland-source"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f0ea9b9476c7fad82841a8dbb380e2eae480c21910feba80725b46931ed8f02"
+dependencies = [
+ "calloop",
+ "rustix",
+ "wayland-backend",
+ "wayland-client",
+]
+
+[[package]]
+name = "camino"
+version = "1.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e0ec6b951b160caa93cc0c7b209e5a3bff7aae9062213451ac99493cd844c239"
+dependencies = [
+ "serde",
 ]
 
 [[package]]
@@ -1569,7 +1813,7 @@ dependencies = [
  "rustc-workspace-hack",
  "rustfix",
  "same-file",
- "semver",
+ "semver 0.9.0",
  "serde",
  "serde_ignored",
  "serde_json",
@@ -1578,42 +1822,45 @@ dependencies = [
  "tar",
  "tempfile",
  "termcolor",
- "toml",
+ "toml 0.5.11",
  "unicode-width",
- "url 2.5.0",
+ "url 2.5.2",
  "walkdir",
  "winapi 0.3.9",
 ]
 
 [[package]]
 name = "cargo-platform"
-version = "0.1.7"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "694c8807f2ae16faecc43dc17d74b3eb042482789fd0eb64b39a2e04e087053f"
+checksum = "24b1f0365a6c6bb4020cd05806fd0d33c44d38046b8bd7f0e40814b9763cabfc"
 dependencies = [
  "serde",
 ]
 
 [[package]]
 name = "cargo_metadata"
-version = "0.10.0"
+version = "0.15.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8de60b887edf6d74370fc8eb177040da4847d971d6234c7b13a6da324ef0caf"
+checksum = "eee4243f1f26fc7a42710e7439c149e2b10b05472f88090acce52632f231a73a"
 dependencies = [
- "semver",
+ "camino",
+ "cargo-platform",
+ "semver 1.0.23",
  "serde",
- "serde_derive",
  "serde_json",
+ "thiserror",
 ]
 
 [[package]]
 name = "cc"
-version = "1.0.90"
+version = "1.0.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8cd6604a82acf3039f1144f54b8eb34e91ffba622051189e71b781822d5ee1f5"
+checksum = "74b6a57f98764a267ff415d50a25e6e166f3831a5071af4995296ea97d210490"
 dependencies = [
  "jobserver",
  "libc",
+ "once_cell",
 ]
 
 [[package]]
@@ -1628,7 +1875,17 @@ version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
 dependencies = [
- "nom",
+ "nom 7.1.3",
+]
+
+[[package]]
+name = "cfg-expr"
+version = "0.15.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d067ad48b8650848b989a59a86c6c36a995d02d2bf778d45c3c5d57bc2718f02"
+dependencies = [
+ "smallvec 1.13.2",
+ "target-lexicon",
 ]
 
 [[package]]
@@ -1649,29 +1906,35 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e"
 
+[[package]]
+name = "cfg_aliases"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
+
 [[package]]
 name = "chrono"
-version = "0.4.35"
+version = "0.4.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8eaf5903dcbc0a39312feb77df2ff4c76387d591b9fc7b04a238dcf8bb62639a"
+checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
 dependencies = [
  "android-tzdata",
  "iana-time-zone",
  "js-sys",
  "num-traits",
  "wasm-bindgen",
- "windows-targets 0.52.4",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
 name = "clang-sys"
-version = "1.7.0"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67523a3b4be3ce1989d607a828d036249522dd9c1c8de7f4dd2dae43a37369d1"
+checksum = "0b023947811758c97c59bf9d1c188fd619ad4718dcaa767947df1cadb14f39f4"
 dependencies = [
  "glob",
  "libc",
- "libloading 0.8.3",
+ "libloading 0.8.4",
 ]
 
 [[package]]
@@ -1695,6 +1958,15 @@ version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4bfbf56724aa9eca8afa4fcfadeb479e722935bb2a0900c2d37e0cc477af0688"
 
+[[package]]
+name = "clipboard-win"
+version = "5.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79f4473f5144e20d9aceaf2972478f06ddf687831eafeeb434fbaf0acc4144ad"
+dependencies = [
+ "error-code",
+]
+
 [[package]]
 name = "cloudabi"
 version = "0.0.3"
@@ -1721,10 +1993,35 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
 
 [[package]]
-name = "com-rs"
-version = "0.2.1"
+name = "com"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e17887fd17353b65b1b2ef1c526c83e26cd72e74f598a8dc1bee13a48f3d9f6"
+dependencies = [
+ "com_macros",
+]
+
+[[package]]
+name = "com_macros"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d375883580a668c7481ea6631fc1a8863e33cc335bf56bfad8d7e6d4b04b13a5"
+dependencies = [
+ "com_macros_support",
+ "proc-macro2 1.0.86",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "com_macros_support"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf43edc576402991846b093a7ca18a3477e0ef9c588cde84964b5d3e43016642"
+checksum = "ad899a1087a9296d5644792d7cb72b8e34c1bec8e7d4fbc002230169a6e8710c"
+dependencies = [
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 1.0.109",
+]
 
 [[package]]
 name = "combine"
@@ -1741,11 +2038,11 @@ dependencies = [
 
 [[package]]
 name = "combine"
-version = "4.6.6"
+version = "4.6.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "35ed6e9d84f0b51a7f52daf1c7d71dd136fd7a3f41a8462b8cdb8c78d920fad4"
+checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd"
 dependencies = [
- "bytes 1.5.0",
+ "bytes 1.6.0",
  "memchr",
 ]
 
@@ -1769,11 +2066,11 @@ dependencies = [
 
 [[package]]
 name = "concurrent-queue"
-version = "2.4.0"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d16048cd947b08fa32c24458a22f5dc5e835264f689f4f5653210c69fd107363"
+checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973"
 dependencies = [
- "crossbeam-utils 0.8.19",
+ "crossbeam-utils 0.8.20",
 ]
 
 [[package]]
@@ -1786,6 +2083,22 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "console_log"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be8aed40e4edbf4d3b4431ab260b63fdc40f5780a4766824329ea0f1eefe3c0f"
+dependencies = [
+ "log",
+ "web-sys",
+]
+
+[[package]]
+name = "const-fnv1a-hash"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32b13ea120a812beba79e34316b3942a857c86ec1593cb34f27bb28272ce2cca"
+
 [[package]]
 name = "const_panic"
 version = "0.2.8"
@@ -1884,14 +2197,14 @@ checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
 
 [[package]]
 name = "core-graphics"
-version = "0.22.3"
+version = "0.23.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2581bbab3b8ffc6fcbd550bf46c355135d16e9ff2a6ea032ad6b9bf1d7efe4fb"
+checksum = "c07782be35f9e1140080c6b96f0d44b739e2278479f64e02fdab4e32dfd8b081"
 dependencies = [
  "bitflags 1.3.2",
  "core-foundation 0.9.4",
  "core-graphics-types",
- "foreign-types 0.3.2",
+ "foreign-types 0.5.0",
  "libc",
 ]
 
@@ -1998,25 +2311,25 @@ dependencies = [
  "serde",
  "serde_derive",
  "serde_json",
- "url 2.5.0",
+ "url 2.5.2",
 ]
 
 [[package]]
 name = "crc32fast"
-version = "1.4.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3855a8a784b474f333699ef2bbca9db2c4a1f6d9088a90a2d25b1eb53111eaa"
+checksum = "a97769d94ddab943e4510d138150169a2758b5ef3eb191a9ee688de3e23ef7b3"
 dependencies = [
  "cfg-if 1.0.0",
 ]
 
 [[package]]
 name = "crossbeam-channel"
-version = "0.5.12"
+version = "0.5.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab3db02a9c5b5121e1e42fbdb1aeb65f5e02624cc58c43f2884c6ccac0b82f95"
+checksum = "33480d6946193aa8033910124896ca395333cae7e2d1113d1fef6c3272217df2"
 dependencies = [
- "crossbeam-utils 0.8.19",
+ "crossbeam-utils 0.8.20",
 ]
 
 [[package]]
@@ -2037,7 +2350,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d"
 dependencies = [
  "crossbeam-epoch 0.9.18",
- "crossbeam-utils 0.8.19",
+ "crossbeam-utils 0.8.20",
 ]
 
 [[package]]
@@ -2046,7 +2359,7 @@ version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "058ed274caafc1f60c4997b5fc07bf7dc7cca454af7c6e81edffe5f33f70dace"
 dependencies = [
- "autocfg 1.1.0",
+ "autocfg 1.3.0",
  "cfg-if 0.1.10",
  "crossbeam-utils 0.7.2",
  "lazy_static",
@@ -2061,7 +2374,7 @@ version = "0.9.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
 dependencies = [
- "crossbeam-utils 0.8.19",
+ "crossbeam-utils 0.8.20",
 ]
 
 [[package]]
@@ -2081,16 +2394,22 @@ version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c3c7c73a2d1e9fc0886a08b93e98eb643461230d5f1925e4036204d5f2e261a8"
 dependencies = [
- "autocfg 1.1.0",
+ "autocfg 1.3.0",
  "cfg-if 0.1.10",
  "lazy_static",
 ]
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.19"
+version = "0.8.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "248e3bacc7dc6baa3b21e405ee045c3047101a49145e7e9eca583ab4c2ca5345"
+checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80"
+
+[[package]]
+name = "crunchy"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
 
 [[package]]
 name = "crypto-hash"
@@ -2121,9 +2440,9 @@ dependencies = [
 
 [[package]]
 name = "curl-sys"
-version = "0.4.72+curl-8.6.0"
+version = "0.4.73+curl-8.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29cbdc8314c447d11e8fd156dcdd031d9e02a7a976163e396b548c03153bc9ea"
+checksum = "450ab250ecf17227c39afb9a2dd9261dc0035cb80f2612472fc0c4aac2dcb84d"
 dependencies = [
  "cc",
  "libc",
@@ -2135,14 +2454,20 @@ dependencies = [
  "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "cursor-icon"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96a6ac251f4a2aca6b3f91340350eab87ae57c3f127ffeb585e92bd336717991"
+
 [[package]]
 name = "d3d12"
-version = "0.7.0"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e16e44ab292b1dddfdaf7be62cfd8877df52f2f3fde5858d95bab606be259f20"
+checksum = "b28bfe653d79bd16c77f659305b195b82bb5ce0c0eb2a4846b82ddbd77586813"
 dependencies = [
- "bitflags 2.5.0",
- "libloading 0.8.3",
+ "bitflags 2.6.0",
+ "libloading 0.8.4",
  "winapi 0.3.9",
 ]
 
@@ -2164,8 +2489,8 @@ checksum = "859d65a907b6852c9361e3185c862aae7fafd2887876799fa55f5f99dc40d610"
 dependencies = [
  "fnv",
  "ident_case",
- "proc-macro2 1.0.79",
- "quote 1.0.35",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
  "strsim 0.10.0",
  "syn 1.0.109",
 ]
@@ -2177,7 +2502,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c972679f83bdf9c42bd905396b6c3588a843a17f0f16dfcfa3e2c5d57441835"
 dependencies = [
  "darling_core",
- "quote 1.0.35",
+ "quote 1.0.36",
  "syn 1.0.109",
 ]
 
@@ -2198,9 +2523,9 @@ checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f"
 
 [[package]]
 name = "data-encoding"
-version = "2.5.0"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e962a19be5cfc3f3bf6dd8f61eb50107f356ad6270fbb3ed41476571db78be5"
+checksum = "e8566979429cf69b49a5c740c60791108e86440e8be149bbea4fe54d2c32d6e2"
 
 [[package]]
 name = "deflate"
@@ -2224,14 +2549,29 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "330c60081dcc4c72131f8eb70510f1ac07223e5d4163db481a04a0befcffa412"
 dependencies = [
- "libloading 0.8.3",
+ "libloading 0.8.4",
+]
+
+[[package]]
+name = "document-features"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef5282ad69563b5fc40319526ba27e0e7363d552a896f0297d54f767717f9b95"
+dependencies = [
+ "litrs",
 ]
 
 [[package]]
 name = "downcast-rs"
-version = "1.2.0"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75b325c5dbd37f80359721ad39aca5a29fb04c89279657cffdda8736d0c0b9d2"
+
+[[package]]
+name = "dpi"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ea835d29036a4087793836fa931b08837ad5e957da9e23886b29586fb9b6650"
+checksum = "f25c0e292a7ca6d6498557ff1df68f32c99850012b6ea401cf8daf771f22ff53"
 
 [[package]]
 name = "dtoa"
@@ -2241,97 +2581,46 @@ checksum = "56899898ce76aaf4a0f24d914c97ea6ed976d42fec6ad33fcbb0a1103e07b2b0"
 
 [[package]]
 name = "ecolor"
-version = "0.23.0"
+version = "0.28.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cfdf4e52dbbb615cfd30cf5a5265335c217b5fd8d669593cea74a517d9c605af"
+checksum = "2e6b451ff1143f6de0f33fc7f1b68fecfd2c7de06e104de96c4514de3f5396f8"
 dependencies = [
  "bytemuck",
- "serde",
+ "emath",
 ]
 
 [[package]]
 name = "egui"
-version = "0.23.0"
+version = "0.28.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8bd69fed5fcf4fbb8225b24e80ea6193b61e17a625db105ef0c4d71dde6eb8b7"
+checksum = "20c97e70a2768de630f161bb5392cbd3874fcf72868f14df0e002e82e06cb798"
 dependencies = [
- "accesskit 0.11.2",
  "ahash",
+ "emath",
  "epaint",
  "nohash-hasher",
- "serde",
-]
-
-[[package]]
-name = "egui-wgpu"
-version = "0.23.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62d4c9ab93d9528c184ef1d695c8c99b2e6d50833696ec3f513063efeee0fe77"
-dependencies = [
- "bytemuck",
- "epaint",
- "log",
- "thiserror",
- "type-map",
- "wgpu",
-]
-
-[[package]]
-name = "egui_demo_lib"
-version = "0.23.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "157bdb4408d324d9035c1b5cc517c6c4f0b8067195a931402a282c464f366cd7"
-dependencies = [
- "egui",
- "egui_extras",
- "egui_plot",
- "log",
- "unicode_names2",
-]
-
-[[package]]
-name = "egui_extras"
-version = "0.23.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68ffe3fe5c00295f91c2a61a74ee271c32f74049c94ba0b1cea8f26eb478bc07"
-dependencies = [
- "egui",
- "enum-map",
- "log",
- "mime_guess",
- "serde",
-]
-
-[[package]]
-name = "egui_plot"
-version = "0.23.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7f33a00fe8eb1ba56535b3dbacdecc7a1365a328908a97c5f3c81bb466be72b"
-dependencies = [
- "egui",
 ]
 
 [[package]]
 name = "either"
-version = "1.10.0"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11157ac094ffbdde99aa67b23417ebdd801842852b500e395a45a9c0aac03e4a"
+checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
 
 [[package]]
 name = "emath"
-version = "0.23.0"
+version = "0.28.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ef2b29de53074e575c18b694167ccbe6e5191f7b25fe65175a0d905a32eeec0"
+checksum = "0a6a21708405ea88f63d8309650b4d77431f4bc28fb9d8e6f77d3963b51249e6"
 dependencies = [
  "bytemuck",
- "serde",
 ]
 
 [[package]]
 name = "encase"
-version = "0.6.1"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fce2eeef77fd4a293a54b62aa00ac9daebfbcda4bf8998c5a815635b004aa1c"
+checksum = "5a9299a95fa5671ddf29ecc22b00e121843a65cb9ff24911e394b4ae556baf36"
 dependencies = [
  "const_panic",
  "encase_derive",
@@ -2341,83 +2630,51 @@ dependencies = [
 
 [[package]]
 name = "encase_derive"
-version = "0.6.1"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e520cde08cbf4f7cc097f61573ec06ce467019803de8ae82fb2823fa1554a0e"
+checksum = "07e09decb3beb1fe2db6940f598957b2e1f7df6206a804d438ff6cb2a9cddc10"
 dependencies = [
  "encase_derive_impl",
 ]
 
 [[package]]
 name = "encase_derive_impl"
-version = "0.6.1"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fe2568f851fd6144a45fa91cfed8fe5ca8fc0b56ba6797bfc1ed2771b90e37c"
+checksum = "fd31dbbd9743684d339f907a87fe212cb7b51d75b9e8e74181fe363199ee9b47"
 dependencies = [
- "proc-macro2 1.0.79",
- "quote 1.0.35",
- "syn 2.0.53",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
 ]
 
 [[package]]
 name = "encoding_rs"
-version = "0.8.33"
+version = "0.8.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7268b386296a025e474d5140678f75d6de9493ae55a5d709eeb9dd08149945e1"
+checksum = "b45de904aa0b010bce2ab45264d0631681847fa7b6f2eaa7dab7619943bc4f59"
 dependencies = [
  "cfg-if 1.0.0",
 ]
 
 [[package]]
-name = "enum-map"
-version = "2.7.3"
+name = "env_logger"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6866f3bfdf8207509a033af1a75a7b08abda06bbaaeae6669323fd5a097df2e9"
+checksum = "44533bbbb3bb3c1fa17d9f2e4e38bbbaf8396ba82193c4cb1b6445d711445d36"
 dependencies = [
- "enum-map-derive",
- "serde",
-]
-
-[[package]]
-name = "enum-map-derive"
-version = "0.17.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f282cfdfe92516eb26c2af8589c274c7c17681f5ecc03c18255fe741c6aa64eb"
-dependencies = [
- "proc-macro2 1.0.79",
- "quote 1.0.35",
- "syn 2.0.53",
-]
-
-[[package]]
-name = "enumn"
-version = "0.1.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fd000fd6988e73bbe993ea3db9b1aa64906ab88766d654973924340c8cddb42"
-dependencies = [
- "proc-macro2 1.0.79",
- "quote 1.0.35",
- "syn 2.0.53",
-]
-
-[[package]]
-name = "env_logger"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44533bbbb3bb3c1fa17d9f2e4e38bbbaf8396ba82193c4cb1b6445d711445d36"
-dependencies = [
- "atty",
- "humantime",
- "log",
- "regex",
- "termcolor",
+ "atty",
+ "humantime",
+ "log",
+ "regex",
+ "termcolor",
 ]
 
 [[package]]
 name = "epaint"
-version = "0.23.0"
+version = "0.28.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58067b840d009143934d91d8dcb8ded054d8301d7c11a517ace0a99bb1e1595e"
+checksum = "3f0dcc0a0771e7500e94cd1cb797bd13c9f23b9409bdc3c824e2cbc562b7fa01"
 dependencies = [
  "ab_glyph",
  "ahash",
@@ -2425,8 +2682,7 @@ dependencies = [
  "ecolor",
  "emath",
  "nohash-hasher",
- "parking_lot 0.12.1",
- "serde",
+ "parking_lot 0.12.3",
 ]
 
 [[package]]
@@ -2437,18 +2693,19 @@ checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
 
 [[package]]
 name = "erased-serde"
-version = "0.3.31"
+version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c138974f9d5e7fe373eb04df7cae98833802ae4b11c24ac7039a21d5af4b26c"
+checksum = "24e2389d65ab4fab27dc2a5de7b191e1f6617d1f1c8855c0dc569c94a4cbb18d"
 dependencies = [
  "serde",
+ "typeid",
 ]
 
 [[package]]
 name = "errno"
-version = "0.3.8"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a258e46cdc063eb8519c00b9fc845fc47bcfca4130e2f08e88665ceda8474245"
+checksum = "534c5cf6194dfab3db3242765c03bbe257cf92f22b38f6bc0c58d59108a820ba"
 dependencies = [
  "libc",
  "windows-sys 0.52.0",
@@ -2463,6 +2720,12 @@ dependencies = [
  "version_check",
 ]
 
+[[package]]
+name = "error-code"
+version = "3.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0474425d51df81997e2f90a21591180b38eccf27292d755f3e30750225c175b"
+
 [[package]]
 name = "ether-dream"
 version = "0.2.5"
@@ -2485,9 +2748,9 @@ dependencies = [
 
 [[package]]
 name = "euclid"
-version = "0.22.9"
+version = "0.22.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87f253bc5c813ca05792837a0ff4b3a580336b224512d48f7eda1d7dd9210787"
+checksum = "e0f0eb73b934648cd7a4a61f1b15391cd95dab0b4da6e2e66c2a072c144b4a20"
 dependencies = [
  "num-traits",
 ]
@@ -2511,20 +2774,9 @@ checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0"
 
 [[package]]
 name = "event-listener"
-version = "4.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67b215c49b2b248c855fb73579eb1f4f26c38ffdc12973e20e07b91d78d5646e"
-dependencies = [
- "concurrent-queue",
- "parking",
- "pin-project-lite",
-]
-
-[[package]]
-name = "event-listener"
-version = "5.2.0"
+version = "5.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b5fb89194fa3cad959b833185b3063ba881dbfc7030680b314250779fb4cc91"
+checksum = "6032be9bd27023a771701cc49f9f053c751055f71efb2e0ae5c15809093675ba"
 dependencies = [
  "concurrent-queue",
  "parking",
@@ -2533,21 +2785,11 @@ dependencies = [
 
 [[package]]
 name = "event-listener-strategy"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "958e4d70b6d5e81971bebec42271ec641e7ff4e170a6fa605f2b8a8b65cb97d3"
-dependencies = [
- "event-listener 4.0.3",
- "pin-project-lite",
-]
-
-[[package]]
-name = "event-listener-strategy"
-version = "0.5.0"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "feedafcaa9b749175d5ac357452a9d41ea2911da598fde46ce1fe02c37751291"
+checksum = "0f214dc438f977e6d4e3500aaa277f5ad94ca83fbbd9b1a15713ce2344ccc5a1"
 dependencies = [
- "event-listener 5.2.0",
+ "event-listener 5.3.1",
  "pin-project-lite",
 ]
 
@@ -2562,17 +2804,31 @@ dependencies = [
  "hrtf",
  "nannou",
  "nannou_audio",
- "nannou_egui",
- "nannou_isf",
  "nannou_laser",
  "nannou_osc",
  "pitch_calc",
  "ringbuf",
  "time_calc",
- "tokio 1.36.0",
+ "tokio 1.38.0",
  "walkdir",
 ]
 
+[[package]]
+name = "exr"
+version = "1.72.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "887d93f60543e9a9362ef8a21beedd0a833c5d9610e18c67abe15a5963dcb1a4"
+dependencies = [
+ "bit_field",
+ "flume",
+ "half",
+ "lebe",
+ "miniz_oxide 0.7.4",
+ "rayon-core",
+ "smallvec 1.13.2",
+ "zune-inflate",
+]
+
 [[package]]
 name = "failure"
 version = "0.1.8"
@@ -2589,34 +2845,59 @@ version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "aa4da3c766cd7a0db8242e326e9e4e081edd567072893ed320008189715366a4"
 dependencies = [
- "proc-macro2 1.0.79",
- "quote 1.0.35",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
  "syn 1.0.109",
  "synstructure",
 ]
 
 [[package]]
 name = "fastrand"
-version = "1.9.0"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fc0510504f03c51ada170672ac806f1f105a88aa97a5281117e1ddc3368e51a"
+
+[[package]]
+name = "fdeflate"
+version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e51093e27b0797c359783294ca4f0a911c270184cb10f85783b118614a1501be"
+checksum = "4f9bfee30e4dedf0ab8b422f03af778d9612b63f502710fc500a334ebe2de645"
 dependencies = [
- "instant",
+ "simd-adler32",
 ]
 
 [[package]]
-name = "fastrand"
-version = "2.0.1"
+name = "ffmpeg-next"
+version = "7.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25cbce373ec4653f1a01a31e8a5e5ec0c622dc27ff9c4e6606eefef5cbbed4a5"
+checksum = "ddfce5242643c8a57b5a44b7e933ccbde85f9508d1379e578e97eee4a9d4334b"
+dependencies = [
+ "bitflags 2.6.0",
+ "ffmpeg-sys-next",
+ "libc",
+]
 
 [[package]]
-name = "fdeflate"
-version = "0.3.4"
+name = "ffmpeg-sys-next"
+version = "7.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f9bfee30e4dedf0ab8b422f03af778d9612b63f502710fc500a334ebe2de645"
+checksum = "972a460dd8e901b737ce0482bf71a837e1751e3dd7c8f8b0a4ead808e7f174a5"
 dependencies = [
- "simd-adler32",
+ "bindgen",
+ "cc",
+ "libc",
+ "num_cpus",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "file-id"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6584280525fb2059cba3db2c04abf947a1a29a45ddae89f3870f8281704fafc9"
+dependencies = [
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -2649,15 +2930,21 @@ version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
+[[package]]
+name = "fixedbitset"
+version = "0.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
+
 [[package]]
 name = "flate2"
-version = "1.0.28"
+version = "1.0.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46303f565772937ffe1d394a4fac6f411c6013172fadde9dcdb1e147a086940e"
+checksum = "5f54427cfd1c7829e2a139fcefea601bf088ebca651d2bf53ebc600eac295dae"
 dependencies = [
  "crc32fast",
  "libz-sys",
- "miniz_oxide 0.7.2",
+ "miniz_oxide 0.7.4",
 ]
 
 [[package]]
@@ -2671,11 +2958,17 @@ dependencies = [
 
 [[package]]
 name = "float_next_after"
-version = "0.1.5"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fc612c5837986b7104a87a0df74a5460931f1c5274be12f8d0f40aa2f30d632"
+checksum = "8bf7cc16383c4b8d58b9905a8509f02926ce3058053c056376248d958c9df1e8"
+
+[[package]]
+name = "flume"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55ac459de2512911e4b674ce33cf20befaba382d05b62b008afc1c8b57cbf181"
 dependencies = [
- "num-traits",
+ "spin",
 ]
 
 [[package]]
@@ -2709,9 +3002,9 @@ version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1a5c6c585bc94aaf2c7b51dd4c2ba22680844aba4c687be581871a6f518c5742"
 dependencies = [
- "proc-macro2 1.0.79",
- "quote 1.0.35",
- "syn 2.0.53",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
 ]
 
 [[package]]
@@ -2840,28 +3133,13 @@ version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1"
 
-[[package]]
-name = "futures-lite"
-version = "1.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49a9d51ce47660b1e808d3c990b4709f2f415d928835a17dfd16991515c46bce"
-dependencies = [
- "fastrand 1.9.0",
- "futures-core",
- "futures-io",
- "memchr",
- "parking",
- "pin-project-lite",
- "waker-fn",
-]
-
 [[package]]
 name = "futures-lite"
 version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "52527eb5074e35e9339c6b4e8d12600c7128b68fb25dcb9fa9dec18f7c25f3a5"
 dependencies = [
- "fastrand 2.0.1",
+ "fastrand",
  "futures-core",
  "futures-io",
  "parking",
@@ -2874,9 +3152,9 @@ version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac"
 dependencies = [
- "proc-macro2 1.0.79",
- "quote 1.0.35",
- "syn 2.0.53",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
 ]
 
 [[package]]
@@ -2909,6 +3187,15 @@ dependencies = [
  "slab",
 ]
 
+[[package]]
+name = "fuzzy-matcher"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54614a3312934d066701a80f20f15fa3b56d67ac7722b39eea5b4c9dd1d66c94"
+dependencies = [
+ "thread_local",
+]
+
 [[package]]
 name = "fwdansi"
 version = "1.1.0"
@@ -2928,6 +3215,16 @@ dependencies = [
  "wikipedia",
 ]
 
+[[package]]
+name = "gethostname"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0176e0459c2e4a1fe232f984bca6890e681076abb9934f6cea7c326f3fc47818"
+dependencies = [
+ "libc",
+ "windows-targets 0.48.5",
+]
+
 [[package]]
 name = "getrandom"
 version = "0.1.16"
@@ -2941,9 +3238,9 @@ dependencies = [
 
 [[package]]
 name = "getrandom"
-version = "0.2.12"
+version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "190092ea657667030ac6a35e305e62fc4dd69fd98ac98631e5d3a2b1575a12b5"
+checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
 dependencies = [
  "cfg-if 1.0.0",
  "js-sys",
@@ -2962,24 +3259,34 @@ dependencies = [
  "weezl",
 ]
 
+[[package]]
+name = "gif"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fb2d69b19215e18bb912fa30f7ce15846e301408695e44e0ef719f1da9e19f2"
+dependencies = [
+ "color_quant",
+ "weezl",
+]
+
 [[package]]
 name = "gilrs"
-version = "0.10.6"
+version = "0.10.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "499067aa54af19f88732dc418f61f23d5912de1518665bb0eca034ca0d07574c"
+checksum = "3f226b8f4d9bc7da93de8efd8747c6b1086409ca3f4b6d51e9a7f5461a9183fe"
 dependencies = [
  "fnv",
  "gilrs-core",
  "log",
- "uuid 1.8.0",
+ "uuid 1.9.1",
  "vec_map",
 ]
 
 [[package]]
 name = "gilrs-core"
-version = "0.5.11"
+version = "0.5.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85c132270a155f2548e67d66e731075c336c39098afc555752f3df8f882c720e"
+checksum = "b922f294d9f062af517ea0bd0a036ddcf11c2842211c2f9c71a3ceee859e10b6"
 dependencies = [
  "core-foundation 0.9.4",
  "inotify 0.10.2",
@@ -2988,19 +3295,19 @@ dependencies = [
  "libc",
  "libudev-sys",
  "log",
- "nix 0.28.0",
- "uuid 1.8.0",
+ "nix 0.29.0",
+ "uuid 1.9.1",
  "vec_map",
  "wasm-bindgen",
  "web-sys",
- "windows 0.54.0",
+ "windows 0.57.0",
 ]
 
 [[package]]
 name = "gimli"
-version = "0.28.1"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253"
+checksum = "40ecd4077b5ae9fd2e9e169b102c6c330d0605168eb0e8bf79952b256dbefffd"
 
 [[package]]
 name = "git2"
@@ -3014,7 +3321,7 @@ dependencies = [
  "log",
  "openssl-probe",
  "openssl-sys",
- "url 2.5.0",
+ "url 2.5.2",
 ]
 
 [[package]]
@@ -3026,14 +3333,25 @@ dependencies = [
  "curl",
  "git2",
  "log",
- "url 2.5.0",
+ "url 2.5.2",
+]
+
+[[package]]
+name = "gl_generator"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a95dfc23a2b4a9a2f5ab41d194f8bfda3cabec42af4e39f08c339eb2a0c124d"
+dependencies = [
+ "khronos_api",
+ "log",
+ "xml-rs",
 ]
 
 [[package]]
 name = "glam"
-version = "0.24.2"
+version = "0.27.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5418c17512bdf42730f9032c74e1ae39afc408745ebb2acf72fbc4691c17945"
+checksum = "9e05e7e6723e3455f4818c7b26e855439f7546cf617ef669d1adedb8669e5cb9"
 dependencies = [
  "bytemuck",
  "libm",
@@ -3056,15 +3374,15 @@ dependencies = [
  "aho-corasick",
  "bstr",
  "log",
- "regex-automata 0.4.6",
- "regex-syntax 0.8.2",
+ "regex-automata 0.4.7",
+ "regex-syntax 0.8.4",
 ]
 
 [[package]]
 name = "glow"
-version = "0.12.3"
+version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca0fe580e4b60a8ab24a868bc08e2f03cbcb20d3d676601fa909386713333728"
+checksum = "bd348e04c43b32574f2de31c8bb397d96c9fcfa1371bd4ca6d8bdc464ab121b1"
 dependencies = [
  "js-sys",
  "slotmap",
@@ -3074,9 +3392,9 @@ dependencies = [
 
 [[package]]
 name = "gltf"
-version = "1.4.0"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b78f069cf941075835822953c345b9e1edd67ae347b81ace3aea9de38c2ef33"
+checksum = "e3ce1918195723ce6ac74e80542c5a96a40c2b26162c1957a5cd70799b8cacf7"
 dependencies = [
  "byteorder",
  "gltf-json",
@@ -3086,21 +3404,21 @@ dependencies = [
 
 [[package]]
 name = "gltf-derive"
-version = "1.4.0"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "438ffe1a5540d75403feaf23636b164e816e93f6f03131674722b3886ce32a57"
+checksum = "14070e711538afba5d6c807edb74bcb84e5dbb9211a3bf5dea0dfab5b24f4c51"
 dependencies = [
  "inflections",
- "proc-macro2 1.0.79",
- "quote 1.0.35",
- "syn 2.0.53",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
 ]
 
 [[package]]
 name = "gltf-json"
-version = "1.4.0"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "655951ba557f2bc69ea4b0799446bae281fa78efae6319968bdd2c3e9a06d8e1"
+checksum = "e6176f9d60a7eab0a877e8e96548605dedbde9190a7ae1e80bbcc1c9af03ab14"
 dependencies = [
  "gltf-derive",
  "serde",
@@ -3108,11 +3426,20 @@ dependencies = [
  "serde_json",
 ]
 
+[[package]]
+name = "glutin_wgl_sys"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c8098adac955faa2d31079b65dc48841251f69efd3ac25477903fc424362ead"
+dependencies = [
+ "gl_generator",
+]
+
 [[package]]
 name = "glyph_brush_layout"
-version = "0.2.3"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc32c2334f00ca5ac3695c5009ae35da21da8c62d255b5b96d56e2597a637a38"
+checksum = "7b1e288bfd2f6c0313f78bf5aa538356ad481a3bb97e9b7f93220ab0066c5992"
 dependencies = [
  "ab_glyph",
  "approx 0.5.1",
@@ -3125,7 +3452,7 @@ version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fbcd2dba93594b227a1f57ee09b8b9da8892c34d55aa332e034a228d0fe6a171"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "gpu-alloc-types",
 ]
 
@@ -3135,47 +3462,47 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "98ff03b468aa837d70984d55f5d3f846f6ec31fe34bbb97c4f85219caeee1ca4"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
 ]
 
 [[package]]
 name = "gpu-allocator"
-version = "0.22.0"
+version = "0.25.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce95f9e2e11c2c6fadfce42b5af60005db06576f231f5c92550fdded43c423e8"
+checksum = "6f56f6318968d03c18e1bcf4857ff88c61157e9da8e47c5f29055d60e1228884"
 dependencies = [
- "backtrace",
  "log",
+ "presser",
  "thiserror",
  "winapi 0.3.9",
- "windows 0.44.0",
+ "windows 0.52.0",
 ]
 
 [[package]]
 name = "gpu-descriptor"
-version = "0.2.4"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc11df1ace8e7e564511f53af41f3e42ddc95b56fd07b3f4445d2a6048bc682c"
+checksum = "9c08c1f623a8d0b722b8b99f821eb0ba672a1618f0d3b16ddbee1cedd2dd8557"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "gpu-descriptor-types",
- "hashbrown 0.14.3",
+ "hashbrown 0.14.5",
 ]
 
 [[package]]
 name = "gpu-descriptor-types"
-version = "0.1.2"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6bf0b36e6f090b7e1d8a4b49c0cb81c1f8376f72198c65dd3ad9ff3556b8b78c"
+checksum = "fdf242682df893b86f33a73828fb09ca4b2d3bb6cc95249707fc684d27484b91"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
 ]
 
 [[package]]
 name = "grid"
-version = "0.10.0"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eec1c01eb1de97451ee0d60de7d81cf1e72aabefb021616027f3d1c3ec1c723c"
+checksum = "be136d9dacc2a13cc70bb6c8f902b414fb2641f8db1314637c6b7933411a8f82"
 
 [[package]]
 name = "guillotiere"
@@ -3183,7 +3510,7 @@ version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b62d5865c036cb1393e23c50693df631d3f5d7bcca4c04fe4cc0fd592e74a782"
 dependencies = [
- "euclid 0.22.9",
+ "euclid 0.22.10",
  "svg_fmt",
 ]
 
@@ -3205,6 +3532,16 @@ dependencies = [
  "tokio-io",
 ]
 
+[[package]]
+name = "half"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dd08c532ae367adf81c312a4580bc67f1d0fe8bc9c460520283f4c0ff277888"
+dependencies = [
+ "cfg-if 1.0.0",
+ "crunchy",
+]
+
 [[package]]
 name = "hashbrown"
 version = "0.12.3"
@@ -3213,9 +3550,9 @@ checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
 
 [[package]]
 name = "hashbrown"
-version = "0.14.3"
+version = "0.14.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
 dependencies = [
  "ahash",
  "allocator-api2",
@@ -3224,19 +3561,25 @@ dependencies = [
 
 [[package]]
 name = "hassle-rs"
-version = "0.10.0"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1397650ee315e8891a0df210707f0fc61771b0cc518c3023896064c5407cb3b0"
+checksum = "af2a7e73e1f34c48da31fb668a907f250794837e08faa144fd24f0b8b741e890"
 dependencies = [
- "bitflags 1.3.2",
- "com-rs",
+ "bitflags 2.6.0",
+ "com",
  "libc",
- "libloading 0.7.4",
+ "libloading 0.8.4",
  "thiserror",
  "widestring",
  "winapi 0.3.9",
 ]
 
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
 [[package]]
 name = "hermit-abi"
 version = "0.1.19"
@@ -3252,6 +3595,12 @@ version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
 
+[[package]]
+name = "hermit-abi"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fbf6a919d6cf397374f7dfeeea91d974c7c0a7221d0d0f4f20d859d329e53fcc"
+
 [[package]]
 name = "hex"
 version = "0.3.2"
@@ -3266,9 +3615,9 @@ checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
 [[package]]
 name = "hexasphere"
-version = "9.1.0"
+version = "12.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7cb3df16a7bcb1b5bc092abd55e14f77ca70aea14445026e264586fc62889a10"
+checksum = "edd6b038160f086b0a7496edae34169ae22f328793cbe2b627a5a3d8373748ec"
 dependencies = [
  "constgebra",
  "glam",
@@ -3343,9 +3692,9 @@ dependencies = [
 
 [[package]]
 name = "httparse"
-version = "1.8.0"
+version = "1.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d897f394bad6a705d5f4104762e116a75639e470d80901eed05a860a95cb1904"
+checksum = "0fcc0b4a115bf80b728eb8ea024ad5bd707b615bfed49e0665b6e0f86fd082d9"
 
 [[package]]
 name = "humantime"
@@ -3353,7 +3702,7 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "df004cfca50ef23c36850aaaa59ad52cc70d0e90243c3c7737a4dd32dc7a3c4f"
 dependencies = [
- "quick-error",
+ "quick-error 1.2.3",
 ]
 
 [[package]]
@@ -3470,7 +3819,7 @@ dependencies = [
  "globset",
  "log",
  "memchr",
- "regex-automata 0.4.6",
+ "regex-automata 0.4.7",
  "same-file",
  "walkdir",
  "winapi-util",
@@ -3510,14 +3859,14 @@ dependencies = [
  "bytemuck",
  "byteorder",
  "color_quant",
- "gif",
- "jpeg-decoder",
+ "gif 0.11.4",
+ "jpeg-decoder 0.1.22",
  "num-iter",
  "num-rational 0.3.2",
  "num-traits",
  "png 0.16.8",
  "scoped_threadpool",
- "tiff",
+ "tiff 0.6.1",
 ]
 
 [[package]]
@@ -3530,7 +3879,54 @@ dependencies = [
  "byteorder",
  "color_quant",
  "num-traits",
+]
+
+[[package]]
+name = "image"
+version = "0.25.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd54d660e773627692c524beaad361aca785a4f9f5730ce91f42aabe5bce3d11"
+dependencies = [
+ "bytemuck",
+ "byteorder",
+ "color_quant",
+ "exr",
+ "gif 0.13.1",
+ "image-webp",
+ "num-traits",
  "png 0.17.13",
+ "qoi",
+ "ravif",
+ "rayon",
+ "rgb",
+ "tiff 0.9.1",
+ "zune-core",
+ "zune-jpeg",
+]
+
+[[package]]
+name = "image-webp"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d730b085583c4d789dfd07fdcf185be59501666a90c97c40162b37e4fdad272d"
+dependencies = [
+ "byteorder-lite",
+ "thiserror",
+]
+
+[[package]]
+name = "imgref"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44feda355f4159a7c757171a77de25daf6411e217b4cabd03bd6650690468126"
+
+[[package]]
+name = "immutable-chunkmap"
+version = "2.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4419f022e55cc63d5bbd6b44b71e1d226b9c9480a47824c706e9d54e5c40c5eb"
+dependencies = [
+ "arrayvec 0.7.4",
 ]
 
 [[package]]
@@ -3539,19 +3935,18 @@ version = "1.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
 dependencies = [
- "autocfg 1.1.0",
+ "autocfg 1.3.0",
  "hashbrown 0.12.3",
- "serde",
 ]
 
 [[package]]
 name = "indexmap"
-version = "2.2.5"
+version = "2.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b0b929d511467233429c45a44ac1dcaa21ba0f5ba11e4879e6ed28ddb4f9df4"
+checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
 dependencies = [
  "equivalent",
- "hashbrown 0.14.3",
+ "hashbrown 0.14.5",
 ]
 
 [[package]]
@@ -3593,14 +3988,22 @@ dependencies = [
 
 [[package]]
 name = "instant"
-version = "0.1.12"
+version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
+checksum = "e0242819d153cba4b4b05a5a8f2a7e9bbf97b6055b2a002b395c96b5ff3c0222"
 dependencies = [
  "cfg-if 1.0.0",
- "js-sys",
- "wasm-bindgen",
- "web-sys",
+]
+
+[[package]]
+name = "interpolate_name"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c34819042dc3d3971c46c2190835914dfbe0c3c13f61449b2997f4e9722dfa60"
+dependencies = [
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
 ]
 
 [[package]]
@@ -3625,7 +4028,8 @@ dependencies = [
 [[package]]
 name = "isf"
 version = "0.1.0"
-source = "git+https://github.com/nannou-org/isf?branch=master#99424e5b5b1fc6bb4c72a4e8cc64867ac06160be"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4245b851171e14276eebb3380557d72633ec5c98bce01ae05b4dd8e64bc70c8"
 dependencies = [
  "serde",
  "serde_json",
@@ -3649,9 +4053,9 @@ checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4"
 
 [[package]]
 name = "itoa"
-version = "1.0.10"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1a46d1a171d865aa5f83f92695765caa047a9b4cbae2cbf37dbd613a793fd4c"
+checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
 [[package]]
 name = "jni"
@@ -3660,7 +4064,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c6df18c2e3db7e453d3c6ac5b3e9d5182664d28788126d39b91f2d1e22b017ec"
 dependencies = [
  "cesu8",
- "combine 4.6.6",
+ "combine 4.6.7",
  "jni-sys",
  "log",
  "thiserror",
@@ -3675,7 +4079,7 @@ checksum = "1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97"
 dependencies = [
  "cesu8",
  "cfg-if 1.0.0",
- "combine 4.6.6",
+ "combine 4.6.7",
  "jni-sys",
  "log",
  "thiserror",
@@ -3691,9 +4095,9 @@ checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130"
 
 [[package]]
 name = "jobserver"
-version = "0.1.28"
+version = "0.1.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab46a6e9526ddef3ae7f787c06f0f2600639ba80ea3eade3d8e670a2230f51d6"
+checksum = "d2b099aaa34a9751c5bf0878add70444e1ed2dd73f347be99003d4577277de6e"
 dependencies = [
  "libc",
 ]
@@ -3707,6 +4111,12 @@ dependencies = [
  "rayon",
 ]
 
+[[package]]
+name = "jpeg-decoder"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f5d4a7da358eff58addd2877a45865158f0d78c911d43a5784ceb7bbf52833b0"
+
 [[package]]
 name = "js-sys"
 version = "0.3.69"
@@ -3728,15 +4138,21 @@ dependencies = [
 
 [[package]]
 name = "khronos-egl"
-version = "4.1.0"
+version = "6.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c2352bd1d0bceb871cb9d40f24360c8133c11d7486b68b5381c1dd1a32015e3"
+checksum = "6aae1df220ece3c0ada96b8153459b67eebe9ae9212258bb0134ae60416fdf76"
 dependencies = [
  "libc",
- "libloading 0.7.4",
+ "libloading 0.8.4",
  "pkg-config",
 ]
 
+[[package]]
+name = "khronos_api"
+version = "3.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2db585e1d738fc771bf08a151420d3ed193d9d895a36df7f6f8a9456b911ddc"
+
 [[package]]
 name = "kqueue"
 version = "1.0.8"
@@ -3777,9 +4193,9 @@ dependencies = [
 
 [[package]]
 name = "lazy_static"
-version = "1.4.0"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
 [[package]]
 name = "lazycell"
@@ -3787,6 +4203,12 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
 
+[[package]]
+name = "lebe"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03087c2bad5e1034e8cace5926dec053fb3790248370865f5117a7d0213354c8"
+
 [[package]]
 name = "lewton"
 version = "0.9.4"
@@ -3811,9 +4233,9 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.153"
+version = "0.2.155"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"
+checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
 
 [[package]]
 name = "libflate"
@@ -3827,6 +4249,17 @@ dependencies = [
  "take_mut",
 ]
 
+[[package]]
+name = "libfuzzer-sys"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a96cfd5557eb82f2b83fed4955246c988d331975a002961b07c81584d107e7f7"
+dependencies = [
+ "arbitrary",
+ "cc",
+ "once_cell",
+]
+
 [[package]]
 name = "libgit2-sys"
 version = "0.9.2"
@@ -3853,12 +4286,12 @@ dependencies = [
 
 [[package]]
 name = "libloading"
-version = "0.8.3"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c2a198fb6b0eada2a8df47933734e6d35d350665a33a3593d7164fa52c75c19"
+checksum = "e310b3a6b5907f99202fcdb4960ff45b93735d7c7d96b760fcff8db2dc0e103d"
 dependencies = [
  "cfg-if 1.0.0",
- "windows-targets 0.52.4",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -3869,9 +4302,9 @@ checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"
 
 [[package]]
 name = "libnghttp2-sys"
-version = "0.1.9+1.58.0"
+version = "0.1.10+1.61.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b57e858af2798e167e709b9d969325b6d8e9d50232fcbc494d7d54f976854a64"
+checksum = "959c25552127d2e1fa72f0e52548ec04fc386e827ba71a7bd01db46a447dc135"
 dependencies = [
  "cc",
  "libc",
@@ -3883,7 +4316,7 @@ version = "0.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3af92c55d7d839293953fcd0fda5ecfe93297cfde6ffbdec13b41d99c0ba6607"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "libc",
  "redox_syscall 0.4.1",
 ]
@@ -3914,9 +4347,9 @@ dependencies = [
 
 [[package]]
 name = "libz-sys"
-version = "1.1.15"
+version = "1.1.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "037731f5d3aaa87a5675e895b63ddff1a87624bc29f77004ea829809654e48f6"
+checksum = "c15da26e5af7e25c90b37a2d75cdbf940cf4a55316de9d84c679c9b8bfabf82e"
 dependencies = [
  "cc",
  "libc",
@@ -3932,9 +4365,15 @@ checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.4.13"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"
+
+[[package]]
+name = "litrs"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "01cda141df6706de531b6c46c3a33ecca755538219bd484262fa09410c13539c"
+checksum = "b4ce301924b7887e9d637144fdade93f9dfff9b60981d4ac161db09720d39aa5"
 
 [[package]]
 name = "lock_api"
@@ -3947,25 +4386,34 @@ dependencies = [
 
 [[package]]
 name = "lock_api"
-version = "0.4.11"
+version = "0.4.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c168f8615b12bc01f9c17e2eb0cc07dcae1940121185446edc3744920e8ef45"
+checksum = "07af8b9cdd281b7915f413fa73f29ebd5d55d0d3f0155584dade1ff18cea1b17"
 dependencies = [
- "autocfg 1.1.0",
+ "autocfg 1.3.0",
  "scopeguard",
 ]
 
 [[package]]
 name = "log"
-version = "0.4.21"
+version = "0.4.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c"
+checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
+
+[[package]]
+name = "loop9"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fae87c125b03c1d2c0150c90365d7d6bcc53fb73a9acaef207d2d065860f062"
+dependencies = [
+ "imgref",
+]
 
 [[package]]
 name = "lyon"
-version = "0.17.10"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf0510ed5e3e2fb80f3db2061ef5ca92d87bfda1a624bb1eacf3bd50226e4cbb"
+checksum = "91e7f9cda98b5430809e63ca5197b06c7d191bf7e26dfc467d5a3f0290e2a74f"
 dependencies = [
  "lyon_algorithms",
  "lyon_tessellation",
@@ -3973,12 +4421,12 @@ dependencies = [
 
 [[package]]
 name = "lyon_algorithms"
-version = "0.17.7"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8037f716541ba0d84d3de05c0069f8068baf73990d55980558b84d944c8a244a"
+checksum = "a3bca95f9a4955b3e4a821fbbcd5edfbd9be2a9a50bb5758173e5358bfb4c623"
 dependencies = [
  "lyon_path",
- "sid",
+ "num-traits",
 ]
 
 [[package]]
@@ -3994,32 +4442,34 @@ dependencies = [
 
 [[package]]
 name = "lyon_geom"
-version = "0.17.7"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "71d89ccbdafd83d259403e22061be27bccc3254bba65cdc5303250c4227c8c8e"
+checksum = "edecfb8d234a2b0be031ab02ebcdd9f3b9ee418fb35e265f7a540a48d197bff9"
 dependencies = [
- "arrayvec 0.5.2",
- "euclid 0.22.9",
+ "arrayvec 0.7.4",
+ "euclid 0.22.10",
  "num-traits",
 ]
 
 [[package]]
 name = "lyon_path"
-version = "0.17.7"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b0a59fdf767ca0d887aa61d1b48d4bbf6a124c1a45503593f7d38ab945bfbc0"
+checksum = "9c08a606c7a59638d6c6aa18ac91a06aa9fb5f765a7efb27e6a4da58700740d7"
 dependencies = [
- "lyon_geom 0.17.7",
+ "lyon_geom 1.0.5",
+ "num-traits",
 ]
 
 [[package]]
 name = "lyon_tessellation"
-version = "0.17.10"
+version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7230e08dd0638048e46f387f255dbe7a7344a3e6705beab53242b5af25635760"
+checksum = "579d42360a4b09846eff2feef28f538696c7d6c7439bfa65874ff3cbe0951b2c"
 dependencies = [
  "float_next_after",
  "lyon_path",
+ "num-traits",
 ]
 
 [[package]]
@@ -4064,6 +4514,16 @@ version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2532096657941c2fea9c289d370a250971c689d4f143798ff67113ec042024a5"
 
+[[package]]
+name = "maybe-rayon"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ea1f30cedd69f0a2954655f7188c6a834246d2bcf1e315e2ac40c4b24dc9519"
+dependencies = [
+ "cfg-if 1.0.0",
+ "rayon",
+]
+
 [[package]]
 name = "maybe-uninit"
 version = "2.0.0"
@@ -4072,15 +4532,15 @@ checksum = "60302e4db3a61da70c0cb7991976248362f30319e88850c487b9b95bbf059e00"
 
 [[package]]
 name = "memchr"
-version = "2.7.1"
+version = "2.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "523dc4f511e55ab87b694dc30d0f820d60906ef06413f93d4d7a1385599cc149"
+checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 
 [[package]]
 name = "memmap2"
-version = "0.5.10"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83faa42c0a078c393f6b29d5db232d8be22776a891f8f56e5284faee4a20b327"
+checksum = "fe751422e4a8caa417e13c3ea66452215d7d63e19e604f4980461212f3ae1322"
 dependencies = [
  "libc",
 ]
@@ -4091,7 +4551,7 @@ version = "0.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "043175f069eda7b85febe4a74abbaeff828d9f8b448515d3151a14a3542811aa"
 dependencies = [
- "autocfg 1.1.0",
+ "autocfg 1.3.0",
 ]
 
 [[package]]
@@ -4100,16 +4560,16 @@ version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce"
 dependencies = [
- "autocfg 1.1.0",
+ "autocfg 1.3.0",
 ]
 
 [[package]]
 name = "metal"
-version = "0.26.0"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "623b5e6cefd76e58f774bd3cc0c6f5c7615c58c03a97815245a25c3c9bdee318"
+checksum = "5637e166ea14be6063a3f8ba5ccb9a4159df7d8f6d61c02fc3d480b1f90dcfcb"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "block",
  "core-graphics-types",
  "foreign-types 0.5.0",
@@ -4118,6 +4578,16 @@ dependencies = [
  "paste",
 ]
 
+[[package]]
+name = "meval"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f79496a5651c8d57cd033c5add8ca7ee4e3d5f7587a4777484640d9cb60392d9"
+dependencies = [
+ "fnv",
+ "nom 1.2.4",
+]
+
 [[package]]
 name = "mime"
 version = "0.3.17"
@@ -4126,9 +4596,9 @@ checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
 
 [[package]]
 name = "mime_guess"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4192263c238a5f0d0c6bfd21f336a313a4ce1c450542449ca191bb657b4642ef"
+checksum = "f7c44f8e672c00fe5308fa235f821cb4198414e1c77935c1ab6948d3fd78550e"
 dependencies = [
  "mime",
  "unicase",
@@ -4156,14 +4626,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a92518e98c078586bc6c934028adcca4c92a53d6a958196de835170a01d84e4b"
 dependencies = [
  "adler",
- "autocfg 1.1.0",
+ "autocfg 1.3.0",
 ]
 
 [[package]]
 name = "miniz_oxide"
-version = "0.7.2"
+version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d811f3e15f28568be3407c8e7fdb6514c1cda3cb30683f15b6a1a1dc4ea14a7"
+checksum = "b8a240ddb74feaf34a79a7add65a741f3167852fba007066dcac1ca548d89c08"
 dependencies = [
  "adler",
  "simd-adler32",
@@ -4245,58 +4715,57 @@ dependencies = [
 
 [[package]]
 name = "naga"
-version = "0.13.0"
+version = "0.14.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1ceaaa4eedaece7e4ec08c55c640ba03dbb73fb812a6570a59bcf1930d0f70e"
+checksum = "ae585df4b6514cf8842ac0f1ab4992edc975892704835b549cf818dc0191249e"
 dependencies = [
  "bit-set",
- "bitflags 2.5.0",
- "codespan-reporting",
- "hexf-parse",
- "indexmap 1.9.3",
+ "bitflags 2.6.0",
+ "indexmap 2.2.6",
  "log",
  "num-traits",
- "petgraph 0.6.4",
  "pp-rs",
  "rustc-hash",
- "serde",
- "spirv",
- "termcolor",
+ "spirv 0.2.0+1.5.4",
  "thiserror",
- "unicode-xid 0.2.4",
 ]
 
 [[package]]
 name = "naga"
-version = "0.14.2"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae585df4b6514cf8842ac0f1ab4992edc975892704835b549cf818dc0191249e"
+checksum = "e536ae46fcab0876853bd4a632ede5df4b1c2527a58f6c5a4150fe86be858231"
 dependencies = [
+ "arrayvec 0.7.4",
  "bit-set",
- "bitflags 2.5.0",
- "indexmap 2.2.5",
+ "bitflags 2.6.0",
+ "codespan-reporting",
+ "hexf-parse",
+ "indexmap 2.2.6",
  "log",
  "num-traits",
  "pp-rs",
  "rustc-hash",
- "spirv",
+ "spirv 0.3.0+sdk-1.3.268.0",
+ "termcolor",
  "thiserror",
+ "unicode-xid 0.2.4",
 ]
 
 [[package]]
 name = "naga_oil"
-version = "0.10.1"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ac54c77b3529887f9668d3dd81e955e58f252b31a333f836e3548c06460b958"
+checksum = "275d9720a7338eedac966141089232514c84d76a246a58ef501af88c5edf402f"
 dependencies = [
  "bit-set",
  "codespan-reporting",
  "data-encoding",
- "indexmap 1.9.3",
- "naga 0.13.0",
+ "indexmap 2.2.6",
+ "naga 0.20.0",
  "once_cell",
  "regex",
- "regex-syntax 0.7.5",
+ "regex-syntax 0.8.4",
  "rustc-hash",
  "thiserror",
  "tracing",
@@ -4316,29 +4785,29 @@ dependencies = [
 name = "nannou"
 version = "0.19.0"
 dependencies = [
+ "bevy",
+ "bevy-inspector-egui",
+ "bevy_common_assets",
+ "bevy_egui",
+ "bevy_nannou",
  "find_folder",
  "futures 0.3.30",
- "getrandom 0.2.12",
- "image 0.23.14",
+ "getrandom 0.2.15",
+ "image 0.25.1",
  "instant",
  "lyon",
  "nannou_core",
- "nannou_mesh",
- "nannou_wgpu",
  "noise",
  "notosans",
  "num_cpus",
  "pennereq",
  "rusttype",
  "serde",
- "serde_derive",
  "serde_json",
- "tokio 1.36.0",
- "toml",
+ "tokio 1.38.0",
+ "toml 0.8.14",
  "walkdir",
  "web-sys",
- "wgpu",
- "winit",
 ]
 
 [[package]]
@@ -4356,41 +4825,9 @@ version = "0.19.0"
 dependencies = [
  "glam",
  "num-traits",
- "palette",
  "rand 0.8.5",
 ]
 
-[[package]]
-name = "nannou_egui"
-version = "0.19.0"
-dependencies = [
- "egui",
- "egui-wgpu",
- "nannou",
- "winit",
-]
-
-[[package]]
-name = "nannou_egui_demo_app"
-version = "0.1.0"
-dependencies = [
- "egui_demo_lib",
- "nannou",
- "nannou_egui",
-]
-
-[[package]]
-name = "nannou_isf"
-version = "0.1.0"
-dependencies = [
- "hotglsl",
- "isf",
- "nannou",
- "thiserror",
- "threadpool",
- "walkdir",
-]
-
 [[package]]
 name = "nannou_laser"
 version = "0.19.0"
@@ -4401,14 +4838,6 @@ dependencies = [
  "thiserror",
 ]
 
-[[package]]
-name = "nannou_mesh"
-version = "0.19.0"
-dependencies = [
- "nannou_core",
- "serde",
-]
-
 [[package]]
 name = "nannou_new"
 version = "0.19.0"
@@ -4435,25 +4864,12 @@ dependencies = [
  "zip",
 ]
 
-[[package]]
-name = "nannou_wgpu"
-version = "0.19.0"
-dependencies = [
- "futures 0.3.30",
- "image 0.23.14",
- "instant",
- "num_cpus",
- "tokio 1.36.0",
- "wgpu",
-]
-
 [[package]]
 name = "native-tls"
-version = "0.2.11"
+version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07226173c32f2926027b63cce4bcd8076c3552846cbe7925f3aaffeac0a3b92e"
+checksum = "a8614eb2c83d59d1c8cc974dd3f920198647674a0a035e1af1fa58707e317466"
 dependencies = [
- "lazy_static",
  "libc",
  "log",
  "openssl",
@@ -4487,29 +4903,30 @@ dependencies = [
 
 [[package]]
 name = "ndk"
-version = "0.7.0"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "451422b7e4718271c8b5b3aadf5adedba43dc76312454b387e98fae0fc951aa0"
+checksum = "2076a31b7010b17a38c01907c45b945e8f11495ee4dd588309718901b1f7a5b7"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.6.0",
  "jni-sys",
- "ndk-sys 0.4.1+23.1.7779620",
- "num_enum 0.5.11",
- "raw-window-handle",
+ "log",
+ "ndk-sys 0.5.0+25.2.9519653",
+ "num_enum 0.7.2",
  "thiserror",
 ]
 
 [[package]]
 name = "ndk"
-version = "0.8.0"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2076a31b7010b17a38c01907c45b945e8f11495ee4dd588309718901b1f7a5b7"
+checksum = "c3f42e7bbe13d351b6bead8286a43aac9534b82bd3cc43e47037f012ebfd62d4"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "jni-sys",
  "log",
- "ndk-sys 0.5.0+25.2.9519653",
+ "ndk-sys 0.6.0+11769913",
  "num_enum 0.7.2",
+ "raw-window-handle",
  "thiserror",
 ]
 
@@ -4542,8 +4959,8 @@ checksum = "0df7ac00c4672f9d5aece54ee3347520b7e20f158656c7db2e6de01902eb7a6c"
 dependencies = [
  "darling",
  "proc-macro-crate 1.3.1",
- "proc-macro2 1.0.79",
- "quote 1.0.35",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
  "syn 1.0.109",
 ]
 
@@ -4558,18 +4975,18 @@ dependencies = [
 
 [[package]]
 name = "ndk-sys"
-version = "0.4.1+23.1.7779620"
+version = "0.5.0+25.2.9519653"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3cf2aae958bd232cac5069850591667ad422d263686d75b52a065f9badeee5a3"
+checksum = "8c196769dd60fd4f363e11d948139556a344e79d451aeb2fa2fd040738ef7691"
 dependencies = [
  "jni-sys",
 ]
 
 [[package]]
 name = "ndk-sys"
-version = "0.5.0+25.2.9519653"
+version = "0.6.0+11769913"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c196769dd60fd4f363e11d948139556a344e79d451aeb2fa2fd040738ef7691"
+checksum = "ee6cda3051665f1fb8d9e08fc35c96d5a244fb1be711a03b71118828afc9a873"
 dependencies = [
  "jni-sys",
 ]
@@ -4586,38 +5003,19 @@ dependencies = [
 ]
 
 [[package]]
-name = "nix"
-version = "0.23.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f3790c00a0150112de0f4cd161e3d7fc4b2d8a5542ffc35f099a2562aecb35c"
-dependencies = [
- "bitflags 1.3.2",
- "cc",
- "cfg-if 1.0.0",
- "libc",
- "memoffset 0.6.5",
-]
-
-[[package]]
-name = "nix"
-version = "0.24.3"
+name = "new_debug_unreachable"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa52e972a9a719cecb6864fb88568781eb706bac2cd1d4f04a648542dbf78069"
-dependencies = [
- "bitflags 1.3.2",
- "cfg-if 1.0.0",
- "libc",
- "memoffset 0.6.5",
-]
+checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"
 
 [[package]]
 name = "nix"
-version = "0.25.1"
+version = "0.23.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f346ff70e7dbfd675fe90590b92d59ef2de15a8779ae305ebcbfd3f0caf59be4"
+checksum = "8f3790c00a0150112de0f4cd161e3d7fc4b2d8a5542ffc35f099a2562aecb35c"
 dependencies = [
- "autocfg 1.1.0",
  "bitflags 1.3.2",
+ "cc",
  "cfg-if 1.0.0",
  "libc",
  "memoffset 0.6.5",
@@ -4625,13 +5023,13 @@ dependencies = [
 
 [[package]]
 name = "nix"
-version = "0.28.0"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab2156c4fce2f8df6c499cc1c763e4394b7482525bf2a9701c9d79d215f519e4"
+checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "cfg-if 1.0.0",
- "cfg_aliases",
+ "cfg_aliases 0.2.1",
  "libc",
 ]
 
@@ -4658,6 +5056,12 @@ dependencies = [
  "rand_xorshift 0.2.0",
 ]
 
+[[package]]
+name = "nom"
+version = "1.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5b8c256fd9471521bcb84c3cdba98921497f1a331cbc15b8030fc63b82050ce"
+
 [[package]]
 name = "nom"
 version = "7.1.3"
@@ -4674,13 +5078,19 @@ version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "610a5acd306ec67f907abe5567859a3c693fb9886eb1f012ab8f2a47bef3db51"
 
+[[package]]
+name = "noop_proc_macro"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0676bb32a98c1a483ce53e500a81ad9c3d5b3f7c920c28c24e9cb0980d0b5bc8"
+
 [[package]]
 name = "notify"
 version = "6.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6205bd8bb1e454ad2e27422015fb5e4f2bcc7e08fa8f27058670d208324a4d2d"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "crossbeam-channel",
  "filetime",
  "fsevent-sys",
@@ -4693,6 +5103,20 @@ dependencies = [
  "windows-sys 0.48.0",
 ]
 
+[[package]]
+name = "notify-debouncer-full"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49f5dab59c348b9b50cf7f261960a20e389feb2713636399cd9082cd4b536154"
+dependencies = [
+ "crossbeam-channel",
+ "file-id",
+ "log",
+ "notify",
+ "parking_lot 0.12.3",
+ "walkdir",
+]
+
 [[package]]
 name = "notosans"
 version = "0.1.0"
@@ -4724,7 +5148,7 @@ version = "0.1.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4703ad64153382334aa8db57c637364c322d3372e097840c72000dabdcf6156e"
 dependencies = [
- "num-bigint",
+ "num-bigint 0.1.44",
  "num-complex 0.1.43",
  "num-integer",
  "num-iter",
@@ -4744,6 +5168,16 @@ dependencies = [
  "rustc-serialize",
 ]
 
+[[package]]
+name = "num-bigint"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
 [[package]]
 name = "num-complex"
 version = "0.1.43"
@@ -4769,8 +5203,8 @@ version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "876a53fff98e03a936a674b29568b0e605f06b29372c2489ff4de23f1949743d"
 dependencies = [
- "proc-macro2 1.0.79",
- "quote 1.0.35",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
  "syn 1.0.109",
 ]
 
@@ -4780,9 +5214,9 @@ version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202"
 dependencies = [
- "proc-macro2 1.0.79",
- "quote 1.0.35",
- "syn 2.0.53",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
 ]
 
 [[package]]
@@ -4796,11 +5230,11 @@ dependencies = [
 
 [[package]]
 name = "num-iter"
-version = "0.1.44"
+version = "0.1.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d869c01cc0c455284163fd0092f1f93835385ccab5a98a0dcc497b2f8bf055a9"
+checksum = "1429034a0490724d0075ebb2bc9e875d6503c3cf69e235a8941aa757d83ef5bf"
 dependencies = [
- "autocfg 1.1.0",
+ "autocfg 1.3.0",
  "num-integer",
  "num-traits",
 ]
@@ -4811,7 +5245,7 @@ version = "0.1.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ee314c74bd753fc86b4780aa9475da469155f3848473a261d2d18e35245a784e"
 dependencies = [
- "num-bigint",
+ "num-bigint 0.1.44",
  "num-integer",
  "num-traits",
  "rustc-serialize",
@@ -4823,18 +5257,29 @@ version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "12ac428b1cb17fce6f731001d307d351ec70a6d202fc2e60f7d4c5e42d8f4f07"
 dependencies = [
- "autocfg 1.1.0",
+ "autocfg 1.3.0",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-rational"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
+dependencies = [
+ "num-bigint 0.4.6",
  "num-integer",
  "num-traits",
 ]
 
 [[package]]
 name = "num-traits"
-version = "0.2.18"
+version = "0.2.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da0df0e5185db44f69b44f26786fe401b6c293d1907744beaa7fa62b2e5a517a"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
 dependencies = [
- "autocfg 1.1.0",
+ "autocfg 1.3.0",
  "libm",
 ]
 
@@ -4857,15 +5302,6 @@ dependencies = [
  "num_enum_derive 0.5.11",
 ]
 
-[[package]]
-name = "num_enum"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a015b430d3c108a207fd776d2e2196aaf8b1cf8cf93253e3a097ff3085076a1"
-dependencies = [
- "num_enum_derive 0.6.1",
-]
-
 [[package]]
 name = "num_enum"
 version = "0.7.2"
@@ -4882,23 +5318,11 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dcbff9bc912032c62bf65ef1d5aea88983b420f4f839db1e9b0c281a25c9c799"
 dependencies = [
  "proc-macro-crate 1.3.1",
- "proc-macro2 1.0.79",
- "quote 1.0.35",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
  "syn 1.0.109",
 ]
 
-[[package]]
-name = "num_enum_derive"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96667db765a921f7b295ffee8b60472b686a51d4f21c2ee4ffdb94c7013b65a6"
-dependencies = [
- "proc-macro-crate 1.3.1",
- "proc-macro2 1.0.79",
- "quote 1.0.35",
- "syn 2.0.53",
-]
-
 [[package]]
 name = "num_enum_derive"
 version = "0.7.2"
@@ -4906,9 +5330,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "681030a937600a36906c185595136d26abfebb4aa9c65701cefcaf8578bb982b"
 dependencies = [
  "proc-macro-crate 3.1.0",
- "proc-macro2 1.0.79",
- "quote 1.0.35",
- "syn 2.0.53",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
 ]
 
 [[package]]
@@ -4918,49 +5342,216 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "915b1b472bc21c53464d6c8461c9d3af805ba1ef837e1cac254428f4a77177b1"
 dependencies = [
  "malloc_buf",
- "objc_exception",
 ]
 
 [[package]]
 name = "objc-sys"
-version = "0.2.0-beta.2"
+version = "0.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df3b9834c1e95694a05a828b59f55fa2afec6288359cda67146126b3f90a55d7"
+checksum = "cdb91bdd390c7ce1a8607f35f3ca7151b65afc0ff5ff3b34fa350f7d7c7e4310"
 
 [[package]]
 name = "objc2"
-version = "0.3.0-beta.3.patch-leaks.3"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e01640f9f2cb1220bbe80325e179e532cb3379ebcd1bf2279d703c19fe3a468"
+checksum = "46a785d4eeff09c14c487497c162e92766fbb3e4059a71840cecc03d9a50b804"
 dependencies = [
- "block2",
  "objc-sys",
  "objc2-encode",
 ]
 
+[[package]]
+name = "objc2-app-kit"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4e89ad9e3d7d297152b17d39ed92cd50ca8063a89a9fa569046d41568891eff"
+dependencies = [
+ "bitflags 2.6.0",
+ "block2",
+ "libc",
+ "objc2",
+ "objc2-core-data",
+ "objc2-core-image",
+ "objc2-foundation",
+ "objc2-quartz-core",
+]
+
+[[package]]
+name = "objc2-cloud-kit"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74dd3b56391c7a0596a295029734d3c1c5e7e510a4cb30245f8221ccea96b009"
+dependencies = [
+ "bitflags 2.6.0",
+ "block2",
+ "objc2",
+ "objc2-core-location",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-contacts"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5ff520e9c33812fd374d8deecef01d4a840e7b41862d849513de77e44aa4889"
+dependencies = [
+ "block2",
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-core-data"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "617fbf49e071c178c0b24c080767db52958f716d9eabdf0890523aeae54773ef"
+dependencies = [
+ "bitflags 2.6.0",
+ "block2",
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-core-image"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55260963a527c99f1819c4f8e3b47fe04f9650694ef348ffd2227e8196d34c80"
+dependencies = [
+ "block2",
+ "objc2",
+ "objc2-foundation",
+ "objc2-metal",
+]
+
+[[package]]
+name = "objc2-core-location"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "000cfee34e683244f284252ee206a27953279d370e309649dc3ee317b37e5781"
+dependencies = [
+ "block2",
+ "objc2",
+ "objc2-contacts",
+ "objc2-foundation",
+]
+
 [[package]]
 name = "objc2-encode"
-version = "2.0.0-pre.2"
+version = "4.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7891e71393cd1f227313c9379a26a584ff3d7e6e7159e988851f0934c993f0f8"
+
+[[package]]
+name = "objc2-foundation"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abfcac41015b00a120608fdaa6938c44cb983fee294351cc4bac7638b4e50512"
+checksum = "0ee638a5da3799329310ad4cfa62fbf045d5f56e3ef5ba4149e7452dcf89d5a8"
 dependencies = [
- "objc-sys",
+ "bitflags 2.6.0",
+ "block2",
+ "dispatch",
+ "libc",
+ "objc2",
 ]
 
 [[package]]
-name = "objc_exception"
-version = "0.1.2"
+name = "objc2-link-presentation"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad970fb455818ad6cba4c122ad012fae53ae8b4795f86378bce65e4f6bab2ca4"
+checksum = "a1a1ae721c5e35be65f01a03b6d2ac13a54cb4fa70d8a5da293d7b0020261398"
 dependencies = [
- "cc",
+ "block2",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-metal"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd0cba1276f6023976a406a14ffa85e1fdd19df6b0f737b063b95f6c8c7aadd6"
+dependencies = [
+ "bitflags 2.6.0",
+ "block2",
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-quartz-core"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e42bee7bff906b14b167da2bac5efe6b6a07e6f7c0a21a7308d40c960242dc7a"
+dependencies = [
+ "bitflags 2.6.0",
+ "block2",
+ "objc2",
+ "objc2-foundation",
+ "objc2-metal",
+]
+
+[[package]]
+name = "objc2-symbols"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a684efe3dec1b305badae1a28f6555f6ddd3bb2c2267896782858d5a78404dc"
+dependencies = [
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-ui-kit"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8bb46798b20cd6b91cbd113524c490f1686f4c4e8f49502431415f3512e2b6f"
+dependencies = [
+ "bitflags 2.6.0",
+ "block2",
+ "objc2",
+ "objc2-cloud-kit",
+ "objc2-core-data",
+ "objc2-core-image",
+ "objc2-core-location",
+ "objc2-foundation",
+ "objc2-link-presentation",
+ "objc2-quartz-core",
+ "objc2-symbols",
+ "objc2-uniform-type-identifiers",
+ "objc2-user-notifications",
+]
+
+[[package]]
+name = "objc2-uniform-type-identifiers"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44fa5f9748dbfe1ca6c0b79ad20725a11eca7c2218bceb4b005cb1be26273bfe"
+dependencies = [
+ "block2",
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-user-notifications"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76cfcbf642358e8689af64cee815d139339f3ed8ad05103ed5eaf73db8d84cb3"
+dependencies = [
+ "bitflags 2.6.0",
+ "block2",
+ "objc2",
+ "objc2-core-location",
+ "objc2-foundation",
 ]
 
 [[package]]
 name = "object"
-version = "0.32.2"
+version = "0.36.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441"
+checksum = "081b846d1d56ddfc18fdf1a922e4f6e07a11768ea1b92dec44e42b72712ccfce"
 dependencies = [
  "memchr",
 ]
@@ -4979,17 +5570,6 @@ dependencies = [
  "oboe-sys 0.4.5",
 ]
 
-[[package]]
-name = "oboe"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8868cc237ee02e2d9618539a23a8d228b9bb3fc2e7a5b11eed3831de77c395d0"
-dependencies = [
- "num-derive 0.3.3",
- "num-traits",
- "oboe-sys 0.5.0",
-]
-
 [[package]]
 name = "oboe"
 version = "0.6.1"
@@ -5013,15 +5593,6 @@ dependencies = [
  "cc",
 ]
 
-[[package]]
-name = "oboe-sys"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f44155e7fb718d3cfddcf70690b2b51ac4412f347cd9e4fbe511abe9cd7b5f2"
-dependencies = [
- "cc",
-]
-
 [[package]]
 name = "oboe-sys"
 version = "0.6.1"
@@ -5070,7 +5641,7 @@ version = "0.10.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "95a0481286a310808298130d22dd1fef0fa571e05a8f44ec801801e84b216b1f"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "cfg-if 1.0.0",
  "foreign-types 0.3.2",
  "libc",
@@ -5085,9 +5656,9 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
 dependencies = [
- "proc-macro2 1.0.79",
- "quote 1.0.35",
- "syn 2.0.53",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
 ]
 
 [[package]]
@@ -5098,9 +5669,9 @@ checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
 
 [[package]]
 name = "openssl-sys"
-version = "0.9.101"
+version = "0.9.102"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dda2b0f344e78efc2facf7d195d098df0dd72151b26ab98da807afc26c198dff"
+checksum = "c597637d56fbc83893a35eb0dd04b2b8e7a50c91e64e9493e398b5df4fb45fa2"
 dependencies = [
  "cc",
  "libc",
@@ -5127,41 +5698,18 @@ dependencies = [
 ]
 
 [[package]]
-name = "overload"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
-
-[[package]]
-name = "owned_ttf_parser"
-version = "0.20.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4586edfe4c648c71797a74c84bacb32b52b212eff5dfe2bb9f2c599844023e7"
-dependencies = [
- "ttf-parser",
-]
-
-[[package]]
-name = "palette"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a05c0334468e62a4dfbda34b29110aa7d70d58c7fdb2c9857b5874dd9827cc59"
-dependencies = [
- "approx 0.3.2",
- "num-traits",
- "palette_derive",
- "serde",
-]
+name = "overload"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
 
 [[package]]
-name = "palette_derive"
-version = "0.5.0"
+name = "owned_ttf_parser"
+version = "0.24.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b4b5f600e60dd3a147fb57b4547033d382d1979eb087af310e91cb45a63b1f4"
+checksum = "490d3a563d3122bf7c911a59b0add9389e5ec0f5f0c3ac6b91ff235a0e6a7f90"
 dependencies = [
- "proc-macro2 1.0.79",
- "quote 1.0.35",
- "syn 1.0.109",
+ "ttf-parser",
 ]
 
 [[package]]
@@ -5188,18 +5736,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7d17b78036a60663b797adeaee46f5c9dfebb86948d1255007a1d6be0271ff99"
 dependencies = [
  "instant",
- "lock_api 0.4.11",
+ "lock_api 0.4.12",
  "parking_lot_core 0.8.6",
 ]
 
 [[package]]
 name = "parking_lot"
-version = "0.12.1"
+version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f"
+checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27"
 dependencies = [
- "lock_api 0.4.11",
- "parking_lot_core 0.9.9",
+ "lock_api 0.4.12",
+ "parking_lot_core 0.9.10",
 ]
 
 [[package]]
@@ -5233,15 +5781,15 @@ dependencies = [
 
 [[package]]
 name = "parking_lot_core"
-version = "0.9.9"
+version = "0.9.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c42a9226546d68acdd9c0a280d17ce19bfe27a46bf68784e4066115788d008e"
+checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8"
 dependencies = [
  "cfg-if 1.0.0",
  "libc",
- "redox_syscall 0.4.1",
+ "redox_syscall 0.5.2",
  "smallvec 1.13.2",
- "windows-targets 0.48.5",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -5250,14 +5798,14 @@ version = "4.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "905787a434a2c721408e7c9a252e85f3d93ca0f118a5283022636c0e05a7ea49"
 dependencies = [
- "nom",
+ "nom 7.1.3",
 ]
 
 [[package]]
 name = "paste"
-version = "1.0.14"
+version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de3145af08024dea9fa9914f381a17b8fc6034dfb00f3a84013f7ff43f29ed4c"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
 
 [[package]]
 name = "pennereq"
@@ -5292,12 +5840,14 @@ dependencies = [
 
 [[package]]
 name = "petgraph"
-version = "0.6.4"
+version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1d3afd2628e69da2be385eb6f2fd57c8ac7977ceeff6dc166ff1657b0e386a9"
+checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db"
 dependencies = [
  "fixedbitset 0.4.2",
- "indexmap 2.2.5",
+ "indexmap 2.2.6",
+ "serde",
+ "serde_derive",
 ]
 
 [[package]]
@@ -5318,11 +5868,31 @@ dependencies = [
  "siphasher",
 ]
 
+[[package]]
+name = "pin-project"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6bf43b791c5b9e34c3d182969b4abb522f9343702850a2e57f460d00d09b4b3"
+dependencies = [
+ "pin-project-internal",
+]
+
+[[package]]
+name = "pin-project-internal"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f38a4412a78282e09a2cf38d195ea5420d15ba0602cb375210efbc877243965"
+dependencies = [
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
+]
+
 [[package]]
 name = "pin-project-lite"
-version = "0.2.13"
+version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8afb450f006bf6385ca15ef45d71d2288452bc3683ce2e2cacc0d18e4be60b58"
+checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02"
 
 [[package]]
 name = "pin-utils"
@@ -5332,12 +5902,12 @@ checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
 [[package]]
 name = "piper"
-version = "0.2.1"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "668d31b1c4eba19242f2088b2bf3316b82ca31082a8335764db4e083db7485d4"
+checksum = "ae1d5c74c9876f070d3e8fd503d748c7d974c3e48da8f41350fa5222ef9b4391"
 dependencies = [
  "atomic-waker",
- "fastrand 2.0.1",
+ "fastrand",
  "futures-io",
 ]
 
@@ -5380,7 +5950,7 @@ dependencies = [
  "crc32fast",
  "fdeflate",
  "flate2",
- "miniz_oxide 0.7.2",
+ "miniz_oxide 0.7.4",
 ]
 
 [[package]]
@@ -5389,6 +5959,21 @@ version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b18befed8bc2b61abc79a457295e7e838417326da1586050b919414073977f19"
 
+[[package]]
+name = "polling"
+version = "3.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3ed00ed3fbf728b5816498ecd316d1716eecaced9c0c8d2c5a6740ca214985b"
+dependencies = [
+ "cfg-if 1.0.0",
+ "concurrent-queue",
+ "hermit-abi 0.4.0",
+ "pin-project-lite",
+ "rustix",
+ "tracing",
+ "windows-sys 0.52.0",
+]
+
 [[package]]
 name = "pp-rs"
 version = "0.2.1"
@@ -5404,14 +5989,26 @@ version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
 
+[[package]]
+name = "presser"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8cf8e6a8aa66ce33f63993ffc4ea4271eb5b0530a9002db8455ea6050c77bfa"
+
+[[package]]
+name = "pretty-type-name"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0f73cdaf19b52e6143685c3606206e114a4dfa969d6b14ec3894c88eb38bd4b"
+
 [[package]]
 name = "prettyplease"
-version = "0.2.16"
+version = "0.2.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a41cf62165e97c7f814d2221421dbb9afcbcdb0a88068e5ea206e19951c2cbb5"
+checksum = "5f12335488a2f3b0a83b14edad48dca9879ce89b2edd10e80237e4e852dd645e"
 dependencies = [
- "proc-macro2 1.0.79",
- "syn 2.0.53",
+ "proc-macro2 1.0.86",
+ "syn 2.0.69",
 ]
 
 [[package]]
@@ -5444,9 +6041,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.79"
+version = "1.0.86"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e835ff2298f5721608eb1a980ecaee1aef2c132bf95ecc026a11b7bf3c01c02e"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
 dependencies = [
  "unicode-ident",
 ]
@@ -5456,6 +6053,19 @@ name = "profiling"
 version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "43d84d1d7a6ac92673717f9f6d1518374ef257669c24ebc5ac25d5033828be58"
+dependencies = [
+ "profiling-procmacros",
+]
+
+[[package]]
+name = "profiling-procmacros"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8021cf59c8ec9c432cfc2526ac6b8aa508ecaf29cd415f271b8406c1b851c3fd"
+dependencies = [
+ "quote 1.0.36",
+ "syn 2.0.69",
+]
 
 [[package]]
 name = "publicsuffix"
@@ -5464,16 +6074,27 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "95b4ce31ff0a27d93c8de1849cf58162283752f065a90d508f1105fa6c9a213f"
 dependencies = [
  "idna 0.2.3",
- "url 2.5.0",
+ "url 2.5.2",
 ]
 
 [[package]]
 name = "pulldown-cmark"
-version = "0.2.0"
+version = "0.9.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eef52fac62d0ea7b9b4dc7da092aa64ea7ec3d90af6679422d3d7e0e14b6ee15"
+checksum = "57206b407293d2bcd3af849ce869d52068623f19e1b5ff8e8778e3309439682b"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.6.0",
+ "memchr",
+ "unicase",
+]
+
+[[package]]
+name = "qoi"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f6d64c71eb498fe9eae14ce4ec935c555749aef511cca85b5568910d6e48001"
+dependencies = [
+ "bytemuck",
 ]
 
 [[package]]
@@ -5482,6 +6103,21 @@ version = "1.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
 
+[[package]]
+name = "quick-error"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
+
+[[package]]
+name = "quick-xml"
+version = "0.34.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f24d770aeca0eacb81ac29dfbc55ebcc09312fdd1f8bbecdc7e4a84e000e3b4"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "quote"
 version = "0.6.13"
@@ -5493,11 +6129,11 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.35"
+version = "1.0.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef"
+checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
 dependencies = [
- "proc-macro2 1.0.79",
+ "proc-macro2 1.0.86",
 ]
 
 [[package]]
@@ -5632,7 +6268,7 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 dependencies = [
- "getrandom 0.2.12",
+ "getrandom 0.2.15",
 ]
 
 [[package]]
@@ -5730,17 +6366,67 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c8a99fddc9f0ba0a85884b8d14e3592853e787d581ca1816c91349b10e4eeab"
 
+[[package]]
+name = "rav1e"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd87ce80a7665b1cce111f8a16c1f3929f6547ce91ade6addf4ec86a8dda5ce9"
+dependencies = [
+ "arbitrary",
+ "arg_enum_proc_macro",
+ "arrayvec 0.7.4",
+ "av1-grain",
+ "bitstream-io",
+ "built",
+ "cfg-if 1.0.0",
+ "interpolate_name",
+ "itertools",
+ "libc",
+ "libfuzzer-sys",
+ "log",
+ "maybe-rayon",
+ "new_debug_unreachable",
+ "noop_proc_macro",
+ "num-derive 0.4.2",
+ "num-traits",
+ "once_cell",
+ "paste",
+ "profiling",
+ "rand 0.8.5",
+ "rand_chacha 0.3.1",
+ "simd_helpers",
+ "system-deps",
+ "thiserror",
+ "v_frame",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "ravif"
+version = "0.11.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67376f469e7e7840d0040bbf4b9b3334005bb167f814621326e4c7ab8cd6e944"
+dependencies = [
+ "avif-serialize",
+ "imgref",
+ "loop9",
+ "quick-error 2.0.1",
+ "rav1e",
+ "rayon",
+ "rgb",
+]
+
 [[package]]
 name = "raw-window-handle"
-version = "0.5.2"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2ff9a1f06a88b01621b7ae906ef0211290d1c8a168a15542486a8f61c0833b9"
+checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539"
 
 [[package]]
 name = "rayon"
-version = "1.9.0"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4963ed1bc86e4f3ee217022bd855b297cef07fb9eac5dfa1f788b220b49b3bd"
+checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
 dependencies = [
  "either",
  "rayon-core",
@@ -5753,7 +6439,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
 dependencies = [
  "crossbeam-deque 0.8.5",
- "crossbeam-utils 0.8.19",
+ "crossbeam-utils 0.8.20",
 ]
 
 [[package]]
@@ -5803,32 +6489,32 @@ dependencies = [
 
 [[package]]
 name = "redox_syscall"
-version = "0.3.5"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29"
+checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
 dependencies = [
  "bitflags 1.3.2",
 ]
 
 [[package]]
 name = "redox_syscall"
-version = "0.4.1"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
+checksum = "c82cf8cff14456045f55ec4241383baeff27af886adb72ffb2162f99911de0fd"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.6.0",
 ]
 
 [[package]]
 name = "regex"
-version = "1.10.3"
+version = "1.10.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b62dbe01f0b06f9d8dc7d49e05a0785f153b00b2c227856282f671e0318c9b15"
+checksum = "b91213439dad192326a0d7c6ee3955910425f441d7038e0d6933b0aec5c4517f"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-automata 0.4.6",
- "regex-syntax 0.8.2",
+ "regex-automata 0.4.7",
+ "regex-syntax 0.8.4",
 ]
 
 [[package]]
@@ -5842,13 +6528,13 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.4.6"
+version = "0.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86b83b8b9847f9bf95ef68afb0b8e6cdb80f498442f5179a29fad448fcc1eaea"
+checksum = "38caf58cc5ef2fed281f89292ef23f6365465ed9a41b7a7754eb4e26496c92df"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-syntax 0.8.2",
+ "regex-syntax 0.8.4",
 ]
 
 [[package]]
@@ -5859,15 +6545,9 @@ checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
 
 [[package]]
 name = "regex-syntax"
-version = "0.7.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbb5fb1acd8a1a18b3dd5be62d25485eb770e05afb408a9627d14d451bae12da"
-
-[[package]]
-name = "regex-syntax"
-version = "0.8.2"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
+checksum = "7a66a03ae7c801facd77a29370b4faec201768915ac14a721ba36f20bc9c209b"
 
 [[package]]
 name = "remove_dir_all"
@@ -5931,6 +6611,15 @@ dependencies = [
  "rand 0.7.3",
 ]
 
+[[package]]
+name = "rgb"
+version = "0.8.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7439be6844e40133eda024efd85bf07f59d0dd2f59b10c00dd6cfb92cc5c741"
+dependencies = [
+ "bytemuck",
+]
+
 [[package]]
 name = "ringbuf"
 version = "0.2.8"
@@ -5948,12 +6637,13 @@ checksum = "3582f63211428f83597b51b2ddb88e2a91a9d52d12831f9d08f5e624e8977422"
 
 [[package]]
 name = "rodio"
-version = "0.17.3"
+version = "0.18.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b1bb7b48ee48471f55da122c0044fcc7600cfcc85db88240b89cb832935e611"
+checksum = "d1fceb9d127d515af1586d8d0cc601e1245bdb0af38e75c865a156290184f5b3"
 dependencies = [
  "cpal 0.15.3",
  "lewton 0.10.2",
+ "thiserror",
 ]
 
 [[package]]
@@ -5963,7 +6653,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b91f7eff05f748767f183df4320a63d6936e9c6107d97c9e6bdd9784f4289c94"
 dependencies = [
  "base64 0.21.7",
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "serde",
  "serde_derive",
 ]
@@ -5975,7 +6665,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b2e63d9e6b0d090be1485cf159b1e04c3973d2d3e1614963544ea2ff47a4a981"
 dependencies = [
  "byteorder",
- "nom",
+ "nom 7.1.3",
 ]
 
 [[package]]
@@ -6004,14 +6694,14 @@ dependencies = [
 name = "run_all_examples"
 version = "0.1.0"
 dependencies = [
- "toml",
+ "toml 0.5.11",
 ]
 
 [[package]]
 name = "rustc-demangle"
-version = "0.1.23"
+version = "0.1.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76"
+checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f"
 
 [[package]]
 name = "rustc-hash"
@@ -6037,7 +6727,7 @@ version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
 dependencies = [
- "semver",
+ "semver 0.9.0",
 ]
 
 [[package]]
@@ -6067,11 +6757,11 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "0.38.32"
+version = "0.38.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "65e04861e65f21776e67888bfbea442b3642beaa0138fdb1dd7a84a52dffdb89"
+checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "errno",
  "libc",
  "linux-raw-sys",
@@ -6094,22 +6784,27 @@ dependencies = [
  "stb_truetype",
 ]
 
+[[package]]
+name = "rustversion"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "955d28af4278de8121b7ebeb796b6a45735dc01436d898801014aced2773a3d6"
+
 [[package]]
 name = "ruzstd"
-version = "0.4.0"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac3ffab8f9715a0d455df4bbb9d21e91135aab3cd3ca187af0cd0c3c3f868fdc"
+checksum = "5022b253619b1ba797f243056276bed8ed1a73b0f5a7ce7225d524067644bf8f"
 dependencies = [
  "byteorder",
- "thiserror-core",
  "twox-hash",
 ]
 
 [[package]]
 name = "ryu"
-version = "1.0.17"
+version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e86697c916019a8588c99b5fac3cead74ec0b4b819707a682fd4d23fa0ce1ba1"
+checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
 
 [[package]]
 name = "safemem"
@@ -6155,9 +6850,9 @@ checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
 [[package]]
 name = "sctk-adwaita"
-version = "0.5.4"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cda4e97be1fd174ccc2aae81c8b694e803fa99b34e8fd0f057a9d70698e3ed09"
+checksum = "7555fcb4f753d095d734fdefebb0ad8c98478a21db500492d87c55913d3b0086"
 dependencies = [
  "ab_glyph",
  "log",
@@ -6168,11 +6863,11 @@ dependencies = [
 
 [[package]]
 name = "security-framework"
-version = "2.9.2"
+version = "2.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05b64fb303737d99b81884b2c63433e9ae28abebe5eb5045dcdd175dc2ecf4de"
+checksum = "c627723fd09706bacdb5cf41499e95098555af3c3c29d014dc3c458ef6be11c0"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.6.0",
  "core-foundation 0.9.4",
  "core-foundation-sys 0.8.6",
  "libc",
@@ -6181,9 +6876,9 @@ dependencies = [
 
 [[package]]
 name = "security-framework-sys"
-version = "2.9.1"
+version = "2.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e932934257d3b408ed8f30db49d85ea163bfe74961f017f405b025af298f0c7a"
+checksum = "317936bbbd05227752583946b9e66d7ce3b489f84e11a94a510b4437fef407d7"
 dependencies = [
  "core-foundation-sys 0.8.6",
  "libc",
@@ -6199,30 +6894,45 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "semver"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61697e0a1c7e512e84a621326239844a24d8207b4669b41bc18b32ea5cbf988b"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "semver-parser"
 version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
 
+[[package]]
+name = "send_wrapper"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd0b0ec5f1c1ca621c432a25813d8d60c88abe6d3e08a3eb9cf37d97a0fe3d73"
+
 [[package]]
 name = "serde"
-version = "1.0.197"
+version = "1.0.204"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fb1c873e1b9b056a4dc4c0c198b24c3ffa059243875552b2bd0933b1aee4ce2"
+checksum = "bc76f558e0cbb2a839d37354c575f1dc3fdc6546b5be373ba43d95f231bf7c12"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.197"
+version = "1.0.204"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7eb0b34b42edc17f6b7cac84a52a1c5f0e1bb2227e997ca9011ea3dd34e8610b"
+checksum = "e0cd7e117be63d3c3678776753929474f3b04a43a080c744d6b0ae2a8c28e222"
 dependencies = [
- "proc-macro2 1.0.79",
- "quote 1.0.35",
- "syn 2.0.53",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
 ]
 
 [[package]]
@@ -6236,15 +6946,24 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.114"
+version = "1.0.120"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5f09b1bd632ef549eaa9f60a1f8de742bdbc698e6cee2095fc84dde5f549ae0"
+checksum = "4e0d21c9a8cae1235ad58a00c11cb40d4b1e5c784f1ef2c537876ed6ffd8b7c5"
 dependencies = [
- "itoa 1.0.10",
+ "itoa 1.0.11",
  "ryu",
  "serde",
 ]
 
+[[package]]
+name = "serde_spanned"
+version = "0.6.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79e674e01f999af37c49f70a6ede167a8a60b2503e56c5599532a65baa5969a0"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "serde_urlencoded"
 version = "0.5.5"
@@ -6261,7 +6980,7 @@ dependencies = [
 name = "set_version"
 version = "0.1.0"
 dependencies = [
- "semver",
+ "semver 0.9.0",
  "toml_edit 0.1.5",
 ]
 
@@ -6286,20 +7005,11 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
-[[package]]
-name = "sid"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd5ac56c121948b4879bba9e519852c211bcdd8f014efff766441deff0b91bdb"
-dependencies = [
- "num-traits",
-]
-
 [[package]]
 name = "signal-hook-registry"
-version = "1.4.1"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8229b473baa5980ac72ef434c4415e70c4b5e71b423043adb4ba059f89c99a1"
+checksum = "a9e9e0b4211b72e7b8b6e85c807d36c212bdb33ea8587f7569562a84df5465b1"
 dependencies = [
  "libc",
 ]
@@ -6310,6 +7020,15 @@ version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe"
 
+[[package]]
+name = "simd_helpers"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95890f873bec569a0362c235787f3aca6e1e887302ba4840839bcc6459c42da6"
+dependencies = [
+ "quote 1.0.36",
+]
+
 [[package]]
 name = "simplecss"
 version = "0.1.0"
@@ -6334,15 +7053,16 @@ dependencies = [
 
 [[package]]
 name = "skeptic"
-version = "0.13.4"
-source = "git+https://github.com/mitchmindtree/rust-skeptic?branch=1.45-extern#52ac60f48a26659523ccb45bf75c8cfa7dbc3c19"
+version = "0.13.8"
+source = "git+https://github.com/Erk-/rust-skeptic?branch=fix-rust-1-77#3e6ce6a2ac3313f13723dfa2483042c6bcd812f2"
 dependencies = [
  "bytecount",
  "cargo_metadata",
  "error-chain",
  "glob",
  "pulldown-cmark",
- "tempdir",
+ "rustversion",
+ "tempfile",
  "walkdir",
 ]
 
@@ -6352,7 +7072,7 @@ version = "0.4.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
 dependencies = [
- "autocfg 1.1.0",
+ "autocfg 1.3.0",
 ]
 
 [[package]]
@@ -6378,48 +7098,60 @@ name = "smallvec"
 version = "1.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
-dependencies = [
- "serde",
-]
 
 [[package]]
 name = "smithay-client-toolkit"
-version = "0.16.1"
+version = "0.18.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "870427e30b8f2cbe64bf43ec4b86e88fe39b0a84b3f15efd9c9c2d020bc86eb9"
+checksum = "922fd3eeab3bd820d76537ce8f582b1cf951eceb5475c28500c7457d9d17f53a"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.6.0",
  "calloop",
- "dlib",
- "lazy_static",
+ "calloop-wayland-source",
+ "cursor-icon",
+ "libc",
  "log",
  "memmap2",
- "nix 0.24.3",
- "pkg-config",
+ "rustix",
+ "thiserror",
+ "wayland-backend",
  "wayland-client",
+ "wayland-csd-frame",
  "wayland-cursor",
  "wayland-protocols",
+ "wayland-protocols-wlr",
+ "wayland-scanner",
+ "xkeysym",
 ]
 
 [[package]]
 name = "smol_str"
-version = "0.2.1"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6845563ada680337a52d43bb0b29f396f2d911616f6573012645b9e3d048a49"
+checksum = "dd538fb6910ac1099850255cf94a94df6551fbdd602454387d0adb2d1ca6dead"
 dependencies = [
  "serde",
 ]
 
 [[package]]
 name = "socket2"
-version = "0.5.6"
+version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05ffd9c0a93b7543e062e759284fcf5f5e3b098501104bfbdde4d404db792871"
+checksum = "ce305eb0b4296696835b71df73eb912e0f1ffd2556a501fcede6e0c50349191c"
 dependencies = [
  "libc",
  "windows-sys 0.52.0",
 ]
 
+[[package]]
+name = "spin"
+version = "0.9.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
+dependencies = [
+ "lock_api 0.4.12",
+]
+
 [[package]]
 name = "spirv"
 version = "0.2.0+1.5.4"
@@ -6430,6 +7162,15 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "spirv"
+version = "0.3.0+sdk-1.3.268.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eda41003dc44290527a59b13432d4a0379379fa074b70174882adfbdfd917844"
+dependencies = [
+ "bitflags 2.6.0",
+]
+
 [[package]]
 name = "static_assertions"
 version = "1.1.0"
@@ -6495,9 +7236,9 @@ checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
 
 [[package]]
 name = "svg_fmt"
-version = "0.4.2"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f83ba502a3265efb76efb89b0a2f7782ad6f2675015d4ce37e4b547dda42b499"
+checksum = "20e16a0f46cf5fd675563ef54f26e83e20f2366bcf027bcb3cc3ed2b98aaf2ca"
 
 [[package]]
 name = "svgdom"
@@ -6539,19 +7280,19 @@ version = "1.0.109"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
 dependencies = [
- "proc-macro2 1.0.79",
- "quote 1.0.35",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
  "unicode-ident",
 ]
 
 [[package]]
 name = "syn"
-version = "2.0.53"
+version = "2.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7383cd0e49fff4b6b90ca5670bfd3e9d6a733b3f90c686605aa7eec8c4996032"
+checksum = "201fcda3845c23e8212cd466bfebf0bd20694490fc0356ae8e428e0824a915a6"
 dependencies = [
- "proc-macro2 1.0.79",
- "quote 1.0.35",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
  "unicode-ident",
 ]
 
@@ -6561,35 +7302,49 @@ version = "0.12.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f36bdaa60a83aca3921b5259d5400cbf5e90fc51931376a9bd4a0eb79aa7210f"
 dependencies = [
- "proc-macro2 1.0.79",
- "quote 1.0.35",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
  "syn 1.0.109",
  "unicode-xid 0.2.4",
 ]
 
 [[package]]
 name = "sysinfo"
-version = "0.29.11"
+version = "0.30.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd727fc423c2060f6c92d9534cef765c65a6ed3f428a03d7def74a8c4348e666"
+checksum = "732ffa00f53e6b2af46208fba5718d9662a421049204e156328b66791ffa15ae"
 dependencies = [
  "cfg-if 1.0.0",
  "core-foundation-sys 0.8.6",
  "libc",
  "ntapi",
  "once_cell",
- "winapi 0.3.9",
+ "windows 0.52.0",
+]
+
+[[package]]
+name = "system-deps"
+version = "6.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3e535eb8dded36d55ec13eddacd30dec501792ff23a0b1682c38601b8cf2349"
+dependencies = [
+ "cfg-expr",
+ "heck",
+ "pkg-config",
+ "toml 0.8.14",
+ "version-compare",
 ]
 
 [[package]]
 name = "taffy"
-version = "0.3.18"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c2287b6d7f721ada4cddf61ade5e760b2c6207df041cac9bfaa192897362fd3"
+checksum = "e8b61630cba2afd2c851821add2e1bb1b7851a2436e839ab73b56558b009035e"
 dependencies = [
  "arrayvec 0.7.4",
  "grid",
  "num-traits",
+ "serde",
  "slotmap",
 ]
 
@@ -6601,23 +7356,19 @@ checksum = "f764005d11ee5f36500a149ace24e00e3da98b0158b3e2d53a7495660d3f4d60"
 
 [[package]]
 name = "tar"
-version = "0.4.40"
+version = "0.4.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b16afcea1f22891c49a00c751c7b63b2233284064f11a200fc624137c51e2ddb"
+checksum = "cb797dad5fb5b76fcf519e702f4a589483b5ef06567f160c392832c1f5e44909"
 dependencies = [
  "filetime",
  "libc",
 ]
 
 [[package]]
-name = "tempdir"
-version = "0.3.7"
+name = "target-lexicon"
+version = "0.12.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15f2b5fb00ccdf689e0149d1b1b3c03fead81c2b37735d812fa8bddbbf41b6d8"
-dependencies = [
- "rand 0.4.6",
- "remove_dir_all",
-]
+checksum = "e1fc403891a21bcfb7c37834ba66a547a8f402146eba7265b5a6d88059c9ff2f"
 
 [[package]]
 name = "tempfile"
@@ -6626,7 +7377,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1"
 dependencies = [
  "cfg-if 1.0.0",
- "fastrand 2.0.1",
+ "fastrand",
  "rustix",
  "windows-sys 0.52.0",
 ]
@@ -6651,42 +7402,22 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "1.0.58"
+version = "1.0.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03468839009160513471e86a034bb2c5c0e4baae3b43f79ffc55c4a5427b3297"
+checksum = "c546c80d6be4bc6a00c0f01730c08df82eaa7a7a61f11d656526506112cc1709"
 dependencies = [
  "thiserror-impl",
 ]
 
-[[package]]
-name = "thiserror-core"
-version = "1.0.50"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c001ee18b7e5e3f62cbf58c7fe220119e68d902bb7443179c0c8aef30090e999"
-dependencies = [
- "thiserror-core-impl",
-]
-
-[[package]]
-name = "thiserror-core-impl"
-version = "1.0.50"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4c60d69f36615a077cc7663b9cb8e42275722d23e58a7fa3d2c7f2915d09d04"
-dependencies = [
- "proc-macro2 1.0.79",
- "quote 1.0.35",
- "syn 2.0.53",
-]
-
 [[package]]
 name = "thiserror-impl"
-version = "1.0.58"
+version = "1.0.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c61f3ba182994efc43764a46c018c347bc492c79f024e705f46567b418f6d4f7"
+checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533"
 dependencies = [
- "proc-macro2 1.0.79",
- "quote 1.0.35",
- "syn 2.0.53",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
 ]
 
 [[package]]
@@ -6700,22 +7431,24 @@ dependencies = [
 ]
 
 [[package]]
-name = "threadpool"
-version = "1.8.1"
+name = "tiff"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d050e60b33d41c19108b32cea32164033a9013fe3b46cbd4457559bfbf77afaa"
+checksum = "9a53f4706d65497df0c4349241deddf35f84cee19c87ed86ea8ca590f4464437"
 dependencies = [
- "num_cpus",
+ "jpeg-decoder 0.1.22",
+ "miniz_oxide 0.4.4",
+ "weezl",
 ]
 
 [[package]]
 name = "tiff"
-version = "0.6.1"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a53f4706d65497df0c4349241deddf35f84cee19c87ed86ea8ca590f4464437"
+checksum = "ba1310fcea54c6a9a4fd1aad794ecc02c31682f6bfbecdf460bf19533eed1e3e"
 dependencies = [
- "jpeg-decoder",
- "miniz_oxide 0.4.4",
+ "flate2",
+ "jpeg-decoder 0.3.1",
  "weezl",
 ]
 
@@ -6743,23 +7476,23 @@ dependencies = [
 
 [[package]]
 name = "tiny-skia"
-version = "0.8.4"
+version = "0.11.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df8493a203431061e901613751931f047d1971337153f96d0e5e363d6dbf6a67"
+checksum = "83d13394d44dae3207b52a326c0c85a8bf87f1541f23b0d143811088497b09ab"
 dependencies = [
  "arrayref",
  "arrayvec 0.7.4",
  "bytemuck",
  "cfg-if 1.0.0",
- "png 0.17.13",
+ "log",
  "tiny-skia-path",
 ]
 
 [[package]]
 name = "tiny-skia-path"
-version = "0.8.4"
+version = "0.11.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "adbfb5d3f3dd57a0e11d12f4f13d4ebbbc1b5c15b7ab0a156d030b21da5f677c"
+checksum = "9c9e7fc0c2e86a30b117d0462aa261b72b7a99b7ebd7deb3a14ceda95c5bdc93"
 dependencies = [
  "arrayref",
  "bytemuck",
@@ -6768,9 +7501,9 @@ dependencies = [
 
 [[package]]
 name = "tinyvec"
-version = "1.6.0"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50"
+checksum = "ce6b6a2fb3a985e99cebfaefa9faa3024743da73304ca1c683a36429613d3d22"
 dependencies = [
  "tinyvec_macros",
 ]
@@ -6802,16 +7535,16 @@ dependencies = [
 
 [[package]]
 name = "tokio"
-version = "1.36.0"
+version = "1.38.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61285f6515fa018fb2d1e46eb21223fff441ee8db5d0f1435e8ab4f5cdb80931"
+checksum = "ba4f4a02a7a80d6f274636f0aa95c7e383b912d41fe721a31f29e29698585a4a"
 dependencies = [
  "backtrace",
- "bytes 1.5.0",
+ "bytes 1.6.0",
  "libc",
  "mio 0.8.11",
  "num_cpus",
- "parking_lot 0.12.1",
+ "parking_lot 0.12.3",
  "pin-project-lite",
  "signal-hook-registry",
  "socket2",
@@ -6863,13 +7596,13 @@ dependencies = [
 
 [[package]]
 name = "tokio-macros"
-version = "2.2.0"
+version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b8a1e28f2deaa14e508979454cb3a223b10b938b45af148bc0986de36f1923b"
+checksum = "5f5ae998a069d4b5aba8ee9dad856af7d520c3699e6159b185c2acd48155d39a"
 dependencies = [
- "proc-macro2 1.0.79",
- "quote 1.0.35",
- "syn 2.0.53",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
 ]
 
 [[package]]
@@ -6946,18 +7679,33 @@ dependencies = [
 
 [[package]]
 name = "toml"
-version = "0.5.11"
+version = "0.5.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4f7f0dd8d50a853a531c426359045b1998f04219d88799810762cd4ad314234"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "toml"
+version = "0.8.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4f7f0dd8d50a853a531c426359045b1998f04219d88799810762cd4ad314234"
+checksum = "6f49eb2ab21d2f26bd6db7bf383edc527a7ebaee412d17af4d40fdccd442f335"
 dependencies = [
  "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_edit 0.22.14",
 ]
 
 [[package]]
 name = "toml_datetime"
-version = "0.6.5"
+version = "0.6.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3550f4e9685620ac18a50ed434eb3aec30db8ba93b0287467bca5826ea25baf1"
+checksum = "4badfd56924ae69bcc9039335b2e017639ce3f9b001c393c1b2d1ef846ce2cbf"
+dependencies = [
+ "serde",
+]
 
 [[package]]
 name = "toml_edit"
@@ -6976,31 +7724,33 @@ version = "0.19.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
 dependencies = [
- "indexmap 2.2.5",
+ "indexmap 2.2.6",
  "toml_datetime",
- "winnow",
+ "winnow 0.5.40",
 ]
 
 [[package]]
 name = "toml_edit"
-version = "0.20.7"
+version = "0.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70f427fce4d84c72b5b732388bf4a9f4531b53f74e2887e3ecb2481f68f66d81"
+checksum = "6a8534fd7f78b5405e860340ad6575217ce99f38d4d5c8f2442cb5ecb50090e1"
 dependencies = [
- "indexmap 2.2.5",
+ "indexmap 2.2.6",
  "toml_datetime",
- "winnow",
+ "winnow 0.5.40",
 ]
 
 [[package]]
 name = "toml_edit"
-version = "0.21.1"
+version = "0.22.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a8534fd7f78b5405e860340ad6575217ce99f38d4d5c8f2442cb5ecb50090e1"
+checksum = "f21c7aaf97f1bd9ca9d4f9e73b0a6c74bd5afef56f2bc931943a6e1c37e04e38"
 dependencies = [
- "indexmap 2.2.5",
+ "indexmap 2.2.6",
+ "serde",
+ "serde_spanned",
  "toml_datetime",
- "winnow",
+ "winnow 0.6.13",
 ]
 
 [[package]]
@@ -7020,9 +7770,9 @@ version = "0.1.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
 dependencies = [
- "proc-macro2 1.0.79",
- "quote 1.0.35",
- "syn 2.0.53",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
 ]
 
 [[package]]
@@ -7035,17 +7785,6 @@ dependencies = [
  "valuable",
 ]
 
-[[package]]
-name = "tracing-log"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f751112709b4e791d8ce53e32c4ed2d353565a795ce84da2285393f41557bdf2"
-dependencies = [
- "log",
- "once_cell",
- "tracing-core",
-]
-
 [[package]]
 name = "tracing-log"
 version = "0.2.0"
@@ -7072,7 +7811,7 @@ dependencies = [
  "thread_local",
  "tracing",
  "tracing-core",
- "tracing-log 0.2.0",
+ "tracing-log",
 ]
 
 [[package]]
@@ -7113,9 +7852,9 @@ dependencies = [
 
 [[package]]
 name = "ttf-parser"
-version = "0.20.0"
+version = "0.24.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17f77d76d837a7830fe1d4f12b7b4ba4192c1888001c7164257e4bc6d21d96b4"
+checksum = "8686b91785aff82828ed725225925b33b4fde44c4bb15876e5f7c832724c420a"
 
 [[package]]
 name = "twox-hash"
@@ -7128,13 +7867,10 @@ dependencies = [
 ]
 
 [[package]]
-name = "type-map"
-version = "0.5.0"
+name = "typeid"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "deb68604048ff8fa93347f02441e4487594adc20bb8a084f9e564d2b827a0a9f"
-dependencies = [
- "rustc-hash",
-]
+checksum = "059d83cc991e7a42fc37bd50941885db0888e34209f8cfd9aab07ddec03bc9cf"
 
 [[package]]
 name = "typenum"
@@ -7180,9 +7916,9 @@ checksum = "d4c87d22b6e3f4a18d4d40ef354e97c90fcb14dd91d7dc0aa9d8a1172ebf7202"
 
 [[package]]
 name = "unicode-width"
-version = "0.1.11"
+version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e51733f11c9c4f72aa0c160008246859e340b00807569a0da0e7a1079b27ba85"
+checksum = "0336d538f7abc86d282a4189614dfaa90810dfc2c6f6427eaf88e16311dd225d"
 
 [[package]]
 name = "unicode-xid"
@@ -7196,12 +7932,6 @@ version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
 
-[[package]]
-name = "unicode_names2"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "446c96c6dd42604779487f0a981060717156648c1706aa1f464677f03c6cc059"
-
 [[package]]
 name = "unreachable"
 version = "1.0.0"
@@ -7224,9 +7954,9 @@ dependencies = [
 
 [[package]]
 name = "url"
-version = "2.5.0"
+version = "2.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31e6302e3bb753d46e83516cae55ae196fc0c309407cf11ab35cc51a4c2a4633"
+checksum = "22784dbdf76fdde8af1aeda5622b546b422b6fc585325248a2bf9f5e41e94d6c"
 dependencies = [
  "form_urlencoded",
  "idna 0.5.0",
@@ -7250,9 +7980,9 @@ dependencies = [
 
 [[package]]
 name = "utf8parse"
-version = "0.2.1"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
 [[package]]
 name = "uuid"
@@ -7265,14 +7995,25 @@ dependencies = [
 
 [[package]]
 name = "uuid"
-version = "1.8.0"
+version = "1.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a183cf7feeba97b4dd1c0d46788634f6221d87fa961b305bed08c851829efcc0"
+checksum = "5de17fd2f7da591098415cff336e12965a28061ddace43b59cb3c430179c9439"
 dependencies = [
- "getrandom 0.2.12",
+ "getrandom 0.2.15",
  "serde",
 ]
 
+[[package]]
+name = "v_frame"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6f32aaa24bacd11e488aa9ba66369c7cd514885742c9fe08cfe85884db3e92b"
+dependencies = [
+ "aligned-vec",
+ "num-traits",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "valuable"
 version = "0.1.0"
@@ -7291,12 +8032,29 @@ version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
 
+[[package]]
+name = "version-compare"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "852e951cb7832cb45cb1169900d19760cfa39b82bc0ea9c0e5a14ae88411c98b"
+
 [[package]]
 name = "version_check"
 version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
 
+[[package]]
+name = "video-rs"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5d8155306a18fbe217e0d019018311fd4e82bcfe9ceff39638244dffcb0e411"
+dependencies = [
+ "ffmpeg-next",
+ "tracing",
+ "url 2.5.2",
+]
+
 [[package]]
 name = "void"
 version = "1.0.2"
@@ -7316,20 +8074,14 @@ dependencies = [
 
 [[package]]
 name = "vte_generate_state_changes"
-version = "0.1.1"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d257817081c7dffcdbab24b9e62d2def62e2ff7d00b1c20062551e6cccc145ff"
+checksum = "2e369bee1b05d510a7b4ed645f5faa90619e05437111783ea5848f28d97d3c2e"
 dependencies = [
- "proc-macro2 1.0.79",
- "quote 1.0.35",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
 ]
 
-[[package]]
-name = "waker-fn"
-version = "1.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3c4517f54858c779bbcbf228f4fca63d121bf85fbecb2dc578cdf4a39395690"
-
 [[package]]
 name = "walkdir"
 version = "2.5.0"
@@ -7388,9 +8140,9 @@ dependencies = [
  "bumpalo",
  "log",
  "once_cell",
- "proc-macro2 1.0.79",
- "quote 1.0.35",
- "syn 2.0.53",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
  "wasm-bindgen-shared",
 ]
 
@@ -7412,7 +8164,7 @@ version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
 dependencies = [
- "quote 1.0.35",
+ "quote 1.0.36",
  "wasm-bindgen-macro-support",
 ]
 
@@ -7422,9 +8174,9 @@ version = "0.2.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
 dependencies = [
- "proc-macro2 1.0.79",
- "quote 1.0.35",
- "syn 2.0.53",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
@@ -7436,75 +8188,111 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
 
 [[package]]
-name = "wayland-client"
-version = "0.29.5"
+name = "wayland-backend"
+version = "0.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f3b068c05a039c9f755f881dc50f01732214f5685e379829759088967c46715"
+checksum = "269c04f203640d0da2092d1b8d89a2d081714ae3ac2f1b53e99f205740517198"
 dependencies = [
- "bitflags 1.3.2",
+ "cc",
  "downcast-rs",
- "libc",
- "nix 0.24.3",
+ "rustix",
  "scoped-tls",
- "wayland-commons",
- "wayland-scanner",
+ "smallvec 1.13.2",
  "wayland-sys",
 ]
 
 [[package]]
-name = "wayland-commons"
-version = "0.29.5"
+name = "wayland-client"
+version = "0.31.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8691f134d584a33a6606d9d717b95c4fa20065605f798a3f350d78dced02a902"
+checksum = "08bd0f46c069d3382a36c8666c1b9ccef32b8b04f41667ca1fef06a1adcc2982"
 dependencies = [
- "nix 0.24.3",
- "once_cell",
- "smallvec 1.13.2",
- "wayland-sys",
+ "bitflags 2.6.0",
+ "rustix",
+ "wayland-backend",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-csd-frame"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "625c5029dbd43d25e6aa9615e88b829a5cad13b2819c4ae129fdbb7c31ab4c7e"
+dependencies = [
+ "bitflags 2.6.0",
+ "cursor-icon",
+ "wayland-backend",
 ]
 
 [[package]]
 name = "wayland-cursor"
-version = "0.29.5"
+version = "0.31.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6865c6b66f13d6257bef1cd40cbfe8ef2f150fb8ebbdb1e8e873455931377661"
+checksum = "09414bcf0fd8d9577d73e9ac4659ebc45bcc9cff1980a350543ad8e50ee263b2"
 dependencies = [
- "nix 0.24.3",
+ "rustix",
  "wayland-client",
  "xcursor",
 ]
 
 [[package]]
 name = "wayland-protocols"
-version = "0.29.5"
+version = "0.31.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b950621f9354b322ee817a23474e479b34be96c2e909c14f7bc0100e9a970bc6"
+checksum = "8f81f365b8b4a97f422ac0e8737c438024b5951734506b0e1d775c73030561f4"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.6.0",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-protocols-plasma"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23803551115ff9ea9bce586860c5c5a971e360825a0309264102a9495a5ff479"
+dependencies = [
+ "bitflags 2.6.0",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-protocols",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-protocols-wlr"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad1f61b76b6c2d8742e10f9ba5c3737f6530b4c243132c2a2ccc8aa96fe25cd6"
+dependencies = [
+ "bitflags 2.6.0",
+ "wayland-backend",
  "wayland-client",
- "wayland-commons",
+ "wayland-protocols",
  "wayland-scanner",
 ]
 
 [[package]]
 name = "wayland-scanner"
-version = "0.29.5"
+version = "0.31.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f4303d8fa22ab852f789e75a967f0a2cdc430a607751c0499bada3e451cbd53"
+checksum = "edf466fc49a4feb65a511ca403fec3601494d0dee85dbf37fff6fa0dd4eec3b6"
 dependencies = [
- "proc-macro2 1.0.79",
- "quote 1.0.35",
- "xml-rs",
+ "proc-macro2 1.0.86",
+ "quick-xml",
+ "quote 1.0.36",
 ]
 
 [[package]]
 name = "wayland-sys"
-version = "0.29.5"
+version = "0.31.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be12ce1a3c39ec7dba25594b97b42cb3195d54953ddb9d3d95a7c3902bc6e9d4"
+checksum = "4a6754825230fa5b27bafaa28c30b3c9e72c55530581220cef401fa422c0fae7"
 dependencies = [
  "dlib",
- "lazy_static",
+ "log",
+ "once_cell",
  "pkg-config",
 ]
 
@@ -7518,6 +8306,34 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "web-time"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "webbrowser"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "425ba64c1e13b1c6e8c5d2541c8fac10022ca584f33da781db01b5756aef1f4e"
+dependencies = [
+ "block2",
+ "core-foundation 0.9.4",
+ "home",
+ "jni 0.21.1",
+ "log",
+ "ndk-context",
+ "objc2",
+ "objc2-foundation",
+ "url 2.5.2",
+ "web-sys",
+]
+
 [[package]]
 name = "weezl"
 version = "0.1.8"
@@ -7526,19 +8342,20 @@ checksum = "53a85b86a771b1c87058196170769dd264f66c0782acf1ae6cc51bfd64b39082"
 
 [[package]]
 name = "wgpu"
-version = "0.17.2"
+version = "0.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "752e44d3998ef35f71830dd1ad3da513e628e2e4d4aedb0ab580f850827a0b41"
+checksum = "90e37c7b9921b75dfd26dd973fdcbce36f13dfa6e2dc82aece584e0ed48c355c"
 dependencies = [
  "arrayvec 0.7.4",
  "cfg-if 1.0.0",
+ "cfg_aliases 0.1.1",
+ "document-features",
  "js-sys",
  "log",
- "naga 0.13.0",
- "parking_lot 0.12.1",
+ "naga 0.20.0",
+ "parking_lot 0.12.3",
  "profiling",
  "raw-window-handle",
- "serde",
  "smallvec 1.13.2",
  "static_assertions",
  "wasm-bindgen",
@@ -7551,22 +8368,24 @@ dependencies = [
 
 [[package]]
 name = "wgpu-core"
-version = "0.17.1"
+version = "0.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f8a44dd301a30ceeed3c27d8c0090433d3da04d7b2a4042738095a424d12ae7"
+checksum = "d50819ab545b867d8a454d1d756b90cd5f15da1f2943334ca314af10583c9d39"
 dependencies = [
  "arrayvec 0.7.4",
  "bit-vec",
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
+ "cfg_aliases 0.1.1",
  "codespan-reporting",
+ "document-features",
+ "indexmap 2.2.6",
  "log",
- "naga 0.13.0",
- "parking_lot 0.12.1",
+ "naga 0.20.0",
+ "once_cell",
+ "parking_lot 0.12.3",
  "profiling",
  "raw-window-handle",
- "ron",
  "rustc-hash",
- "serde",
  "smallvec 1.13.2",
  "thiserror",
  "web-sys",
@@ -7576,19 +8395,21 @@ dependencies = [
 
 [[package]]
 name = "wgpu-hal"
-version = "0.17.2"
+version = "0.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a80bf0e3c77399bb52850cb0830af9bad073d5cfcb9dd8253bef8125c42db17"
+checksum = "172e490a87295564f3fcc0f165798d87386f6231b04d4548bca458cbbfd63222"
 dependencies = [
  "android_system_properties",
  "arrayvec 0.7.4",
  "ash",
  "bit-set",
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "block",
+ "cfg_aliases 0.1.1",
  "core-graphics-types",
  "d3d12",
  "glow",
+ "glutin_wgl_sys",
  "gpu-alloc",
  "gpu-allocator",
  "gpu-descriptor",
@@ -7596,12 +8417,14 @@ dependencies = [
  "js-sys",
  "khronos-egl",
  "libc",
- "libloading 0.8.3",
+ "libloading 0.8.4",
  "log",
  "metal",
- "naga 0.13.0",
+ "naga 0.20.0",
+ "ndk-sys 0.5.0+25.2.9519653",
  "objc",
- "parking_lot 0.12.1",
+ "once_cell",
+ "parking_lot 0.12.3",
  "profiling",
  "range-alloc",
  "raw-window-handle",
@@ -7617,13 +8440,12 @@ dependencies = [
 
 [[package]]
 name = "wgpu-types"
-version = "0.17.0"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee64d7398d0c2f9ca48922c902ef69c42d000c759f3db41e355f4a570b052b67"
+checksum = "1353d9a46bff7f955a680577f34c69122628cc2076e1d6f3a9be6ef00ae793ef"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "js-sys",
- "serde",
  "web-sys",
 ]
 
@@ -7641,9 +8463,9 @@ dependencies = [
 
 [[package]]
 name = "widestring"
-version = "1.0.2"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "653f141f39ec16bba3c5abe400a0c60da7468261cc2cbf36805022876bc721a8"
+checksum = "7219d36b6eac893fa81e84ebe06485e7dcbb616177469b142df14f1f4deb1311"
 
 [[package]]
 name = "wikipedia"
@@ -7687,11 +8509,11 @@ checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
 [[package]]
 name = "winapi-util"
-version = "0.1.6"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f29e6f9198ba0d26b4c9f07dbe6f9ed633e1f3d5b8b414090084349e46a52596"
+checksum = "4d4cc384e1e73b93bafa6fb4f1df8c41695c8a91cf9c4c64358067d15a7b6c6b"
 dependencies = [
- "winapi 0.3.9",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -7702,32 +8524,34 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
 name = "windows"
-version = "0.44.0"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e745dab35a0c4c77aa3ce42d595e13d2003d6902d6b08c9ef5fc326d08da12b"
+checksum = "e48a53791691ab099e5e2ad123536d0fff50652600abaf43bbf952894110d0be"
 dependencies = [
- "windows-targets 0.42.2",
+ "windows-core 0.52.0",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
 name = "windows"
-version = "0.48.0"
+version = "0.54.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e686886bc078bc1b0b600cac0147aadb815089b6e4da64016cbd754b6342700f"
+checksum = "9252e5725dbed82865af151df558e754e4a3c2c30818359eb17465f1346a1b49"
 dependencies = [
- "windows-implement",
- "windows-interface",
- "windows-targets 0.48.5",
+ "windows-core 0.54.0",
+ "windows-implement 0.53.0",
+ "windows-interface 0.53.0",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
 name = "windows"
-version = "0.54.0"
+version = "0.57.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9252e5725dbed82865af151df558e754e4a3c2c30818359eb17465f1346a1b49"
+checksum = "12342cb4d8e3b046f3d80effd474a7a02447231330ef77d71daa6fbc40681143"
 dependencies = [
- "windows-core 0.54.0",
- "windows-targets 0.52.4",
+ "windows-core 0.57.0",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -7736,7 +8560,7 @@ version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
 dependencies = [
- "windows-targets 0.52.4",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -7746,38 +8570,72 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "12661b9c89351d684a50a8a643ce5f608e20243b9fb84687800163429f161d65"
 dependencies = [
  "windows-result",
- "windows-targets 0.52.4",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.57.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2ed2439a290666cd67ecce2b0ffaad89c2a56b976b736e6ece670297897832d"
+dependencies = [
+ "windows-implement 0.57.0",
+ "windows-interface 0.57.0",
+ "windows-result",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
 name = "windows-implement"
-version = "0.48.0"
+version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e2ee588991b9e7e6c8338edf3333fbe4da35dc72092643958ebb43f0ab2c49c"
+checksum = "942ac266be9249c84ca862f0a164a39533dc2f6f33dc98ec89c8da99b82ea0bd"
 dependencies = [
- "proc-macro2 1.0.79",
- "quote 1.0.35",
- "syn 1.0.109",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.57.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9107ddc059d5b6fbfbffdfa7a7fe3e22a226def0b2608f72e9d552763d3e1ad7"
+dependencies = [
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
 ]
 
 [[package]]
 name = "windows-interface"
-version = "0.48.0"
+version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6fb8df20c9bcaa8ad6ab513f7b40104840c8867d5751126e4df3b08388d0cc7"
+checksum = "da33557140a288fae4e1d5f8873aaf9eb6613a9cf82c3e070223ff177f598b60"
 dependencies = [
- "proc-macro2 1.0.79",
- "quote 1.0.35",
- "syn 1.0.109",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.57.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29bee4b38ea3cde66011baa44dba677c432a78593e202392d1e9070cf2a7fca7"
+dependencies = [
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
 ]
 
 [[package]]
 name = "windows-result"
-version = "0.1.0"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd19df78e5168dfb0aedc343d1d1b8d422ab2db6756d2dc3fef75035402a3f64"
+checksum = "5e383302e8ec8515204254685643de10811af0ed97ea37210dc26fb0032647f8"
 dependencies = [
- "windows-targets 0.52.4",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -7804,7 +8662,7 @@ version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
 dependencies = [
- "windows-targets 0.52.4",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -7839,17 +8697,18 @@ dependencies = [
 
 [[package]]
 name = "windows-targets"
-version = "0.52.4"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7dd37b7e5ab9018759f893a1952c9420d060016fc19a472b4bb20d1bdd694d1b"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
 dependencies = [
- "windows_aarch64_gnullvm 0.52.4",
- "windows_aarch64_msvc 0.52.4",
- "windows_i686_gnu 0.52.4",
- "windows_i686_msvc 0.52.4",
- "windows_x86_64_gnu 0.52.4",
- "windows_x86_64_gnullvm 0.52.4",
- "windows_x86_64_msvc 0.52.4",
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
 ]
 
 [[package]]
@@ -7866,9 +8725,9 @@ checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
 
 [[package]]
 name = "windows_aarch64_gnullvm"
-version = "0.52.4"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bcf46cf4c365c6f2d1cc93ce535f2c8b244591df96ceee75d8e83deb70a9cac9"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
 [[package]]
 name = "windows_aarch64_msvc"
@@ -7884,9 +8743,9 @@ checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
 
 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.52.4"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da9f259dd3bcf6990b55bffd094c4f7235817ba4ceebde8e6d11cd0c5633b675"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
 [[package]]
 name = "windows_i686_gnu"
@@ -7902,9 +8761,15 @@ checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
 
 [[package]]
 name = "windows_i686_gnu"
-version = "0.52.4"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b474d8268f99e0995f25b9f095bc7434632601028cf86590aea5c8a5cb7801d3"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
 [[package]]
 name = "windows_i686_msvc"
@@ -7920,9 +8785,9 @@ checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
 
 [[package]]
 name = "windows_i686_msvc"
-version = "0.52.4"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1515e9a29e5bed743cb4415a9ecf5dfca648ce85ee42e15873c3cd8610ff8e02"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
 [[package]]
 name = "windows_x86_64_gnu"
@@ -7938,9 +8803,9 @@ checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
 
 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.52.4"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5eee091590e89cc02ad514ffe3ead9eb6b660aedca2183455434b93546371a03"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
@@ -7956,9 +8821,9 @@ checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
-version = "0.52.4"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77ca79f2451b49fa9e2af39f0747fe999fcda4f5e241b2898624dca97a1f2177"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
 [[package]]
 name = "windows_x86_64_msvc"
@@ -7974,43 +8839,60 @@ checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
 
 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.52.4"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32b752e52a2da0ddfbdbcc6fceadfeede4c939ed16d13e648833a61dfb611ed8"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
 [[package]]
 name = "winit"
-version = "0.28.7"
+version = "0.30.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9596d90b45384f5281384ab204224876e8e8bf7d58366d9b795ad99aa9894b94"
+checksum = "49f45a7b7e2de6af35448d7718dab6d95acec466eb3bb7a56f4d31d1af754004"
 dependencies = [
+ "ahash",
  "android-activity",
- "bitflags 1.3.2",
- "cfg_aliases",
+ "atomic-waker",
+ "bitflags 2.6.0",
+ "block2",
+ "bytemuck",
+ "calloop",
+ "cfg_aliases 0.2.1",
+ "concurrent-queue",
  "core-foundation 0.9.4",
  "core-graphics",
- "dispatch",
- "instant",
+ "cursor-icon",
+ "dpi",
+ "js-sys",
  "libc",
- "log",
- "mio 0.8.11",
- "ndk 0.7.0",
+ "memmap2",
+ "ndk 0.9.0",
  "objc2",
- "once_cell",
+ "objc2-app-kit",
+ "objc2-foundation",
+ "objc2-ui-kit",
  "orbclient",
  "percent-encoding 2.3.1",
+ "pin-project",
  "raw-window-handle",
- "redox_syscall 0.3.5",
+ "redox_syscall 0.4.1",
+ "rustix",
  "sctk-adwaita",
  "smithay-client-toolkit",
+ "smol_str",
+ "tracing",
+ "unicode-segmentation",
  "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "wayland-backend",
  "wayland-client",
- "wayland-commons",
  "wayland-protocols",
- "wayland-scanner",
+ "wayland-protocols-plasma",
  "web-sys",
- "windows-sys 0.45.0",
+ "web-time",
+ "windows-sys 0.52.0",
  "x11-dl",
+ "x11rb",
+ "xkbcommon-dl",
 ]
 
 [[package]]
@@ -8022,6 +8904,15 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "winnow"
+version = "0.6.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59b5e5f6c299a3c7890b876a2a587f3115162487e704907d9b6cd29473052ba1"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "winreg"
 version = "0.6.2"
@@ -8052,6 +8943,27 @@ dependencies = [
  "pkg-config",
 ]
 
+[[package]]
+name = "x11rb"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d91ffca73ee7f68ce055750bf9f6eca0780b8c85eff9bc046a3b0da41755e12"
+dependencies = [
+ "as-raw-xcb-connection",
+ "gethostname",
+ "libc",
+ "libloading 0.8.4",
+ "once_cell",
+ "rustix",
+ "x11rb-protocol",
+]
+
+[[package]]
+name = "x11rb-protocol"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec107c4503ea0b4a98ef47356329af139c0a4f7750e621cf2973cd3385ebcb3d"
+
 [[package]]
 name = "xcursor"
 version = "0.3.5"
@@ -8064,11 +8976,30 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a67300977d3dc3f8034dae89778f502b6ba20b269527b3223ba59c0cf393bb8a"
 
+[[package]]
+name = "xkbcommon-dl"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d039de8032a9a8856a6be89cea3e5d12fdd82306ab7c94d74e6deab2460651c5"
+dependencies = [
+ "bitflags 2.6.0",
+ "dlib",
+ "log",
+ "once_cell",
+ "xkeysym",
+]
+
+[[package]]
+name = "xkeysym"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9cc00251562a284751c9973bace760d86c0276c471b4be569fe6b068ee97a56"
+
 [[package]]
 name = "xml-rs"
-version = "0.8.19"
+version = "0.8.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fcb9cbac069e033553e8bb871be2fbdffcab578eb25bd0f7c508cedc6dcd75a"
+checksum = "791978798f0597cfc70478424c2b4fdc2b7a8024aaff78497ef00f24ef674193"
 
 [[package]]
 name = "xmlparser"
@@ -8088,11 +9019,11 @@ dependencies = [
 
 [[package]]
 name = "zerocopy"
-version = "0.7.32"
+version = "0.7.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74d4d3961e53fa4c9a25a8637fc2bfaf2595b3d3ae34875568a5cf64787716be"
+checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
 dependencies = [
- "zerocopy-derive 0.7.32",
+ "zerocopy-derive 0.7.35",
 ]
 
 [[package]]
@@ -8101,20 +9032,20 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d498dbd1fd7beb83c86709ae1c33ca50942889473473d287d56ce4770a18edfb"
 dependencies = [
- "proc-macro2 1.0.79",
+ "proc-macro2 1.0.86",
  "syn 1.0.109",
  "synstructure",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.7.32"
+version = "0.7.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6"
+checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
 dependencies = [
- "proc-macro2 1.0.79",
- "quote 1.0.35",
- "syn 2.0.53",
+ "proc-macro2 1.0.86",
+ "quote 1.0.36",
+ "syn 2.0.69",
 ]
 
 [[package]]
@@ -8129,3 +9060,27 @@ dependencies = [
  "podio",
  "time",
 ]
+
+[[package]]
+name = "zune-core"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f423a2c17029964870cfaabb1f13dfab7d092a62a29a89264f4d36990ca414a"
+
+[[package]]
+name = "zune-inflate"
+version = "0.2.54"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73ab332fe2f6680068f3582b16a24f90ad7096d5d39b974d1c0aff0125116f02"
+dependencies = [
+ "simd-adler32",
+]
+
+[[package]]
+name = "zune-jpeg"
+version = "0.4.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec866b44a2a1fd6133d363f073ca1b179f438f99e7e5bfb1e33f7181facfe448"
+dependencies = [
+ "zune-core",
+]
diff --git a/Cargo.toml b/Cargo.toml
index 5e0b6b6a8..466feb01c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,23 +2,18 @@
 members = [
     "bevy_nannou",
     "bevy_nannou_draw",
-    "bevy_nannou_render",
-    "bevy_nannou_wgpu",
+    "bevy_nannou_isf",
+    "bevy_nannou_video",
     "examples",
     "generative_design",
     "guide/book_tests",
     "nannou",
     "nannou_audio",
     "nannou_core",
-    "nannou_egui",
-    "nannou_egui_demo_app",
-    "nannou_isf",
     "nannou_laser",
-    "nannou_mesh",
     "nannou_new",
     "nannou_osc",
     "nannou_package",
-    "nannou_wgpu",
     "nature_of_code",
     "scripts/run_all_examples",
     "scripts/set_version",
@@ -28,4 +23,12 @@ members = [
 resolver = "2"
 
 [workspace.dependencies]
-bevy = "0.12"
+bevy = "0.14.0"
+bevy_egui = "0.28.0"
+bevy-inspector-egui = "0.25.0"
+rayon = "1.10"
+bevy_common_assets = "0.11.0"
+serde = "1"
+serde_json = "1"
+toml = "0.8"
+serde_yaml = "0.9"
\ No newline at end of file
diff --git a/bevy_nannou/Cargo.toml b/bevy_nannou/Cargo.toml
index dce7a3b20..9a73e61e5 100644
--- a/bevy_nannou/Cargo.toml
+++ b/bevy_nannou/Cargo.toml
@@ -5,5 +5,11 @@ edition = "2021"
 
 [dependencies]
 bevy = { workspace = true }
-bevy_nannou_render = { path = "../bevy_nannou_render" }
-bevy_nannou_draw = { path = "../bevy_nannou_draw" }
\ No newline at end of file
+bevy_nannou_draw = { path = "../bevy_nannou_draw" }
+bevy_nannou_isf = { path = "../bevy_nannou_isf", optional = true }
+bevy_nannou_video = { path = "../bevy_nannou_video", optional = true }
+
+[features]
+nightly = ["bevy_nannou_draw/nightly"]
+isf = ["bevy_nannou_isf"]
+video = ["bevy_nannou_video"]
\ No newline at end of file
diff --git a/bevy_nannou/src/lib.rs b/bevy_nannou/src/lib.rs
index 482548264..2657bff1a 100644
--- a/bevy_nannou/src/lib.rs
+++ b/bevy_nannou/src/lib.rs
@@ -1,12 +1,41 @@
 use bevy::prelude::*;
 
+pub mod prelude {
+    pub use bevy::color::palettes::css::*;
+    pub use bevy::color::*;
+    pub use bevy::core_pipeline::bloom::*;
+    pub use bevy::input::mouse::MouseWheel;
+    pub use bevy::prelude::*;
+    pub use bevy::render::render_asset::*;
+    pub use bevy::render::render_resource::*;
+    pub use bevy::winit::UpdateMode;
+
+    pub use bevy_nannou_draw::color::*;
+    pub use bevy_nannou_draw::draw::*;
+    pub use bevy_nannou_draw::render::blend::*;
+    pub use bevy_nannou_draw::render::NannouMaterialPlugin;
+    pub use bevy_nannou_draw::text::*;
+    pub use bevy_nannou_draw::*;
+
+    #[cfg(feature = "isf")]
+    pub use bevy_nannou_isf::prelude::*;
+    #[cfg(feature = "video")]
+    pub use bevy_nannou_video::prelude::*;
+}
+
 pub struct NannouPlugin;
 
 impl Plugin for NannouPlugin {
     fn build(&self, app: &mut App) {
-        app.add_plugins((
-            bevy_nannou_render::NannouRenderPlugin,
-            bevy_nannou_draw::NannouDrawPlugin,
-        ));
+        app.add_plugins((bevy_nannou_draw::NannouDrawPlugin,));
+        #[cfg(feature = "isf")]
+        {
+            app.add_plugins(bevy_nannou_isf::NannouIsfPlugin);
+        }
+        #[cfg(feature = "video")]
+        {
+            info!("Adding video plugin");
+            app.add_plugins(bevy_nannou_video::NannouVideoPlugin);
+        }
     }
 }
diff --git a/bevy_nannou/src/main.rs b/bevy_nannou/src/main.rs
deleted file mode 100644
index 36e77b18d..000000000
--- a/bevy_nannou/src/main.rs
+++ /dev/null
@@ -1,140 +0,0 @@
-use bevy::core_pipeline::bloom::{BloomCompositeMode, BloomPrefilterSettings, BloomSettings};
-use bevy::core_pipeline::clear_color::ClearColorConfig;
-use bevy::core_pipeline::tonemapping::Tonemapping;
-use bevy::prelude::shape::Torus;
-use bevy::prelude::*;
-use bevy_nannou::NannouPlugin;
-use bevy_nannou_draw::color::{RED, SALMON, SEAGREEN, SEASHELL, SKYBLUE};
-use bevy_nannou_render::NannouMesh;
-
-pub fn main() {
-    App::new()
-        .add_plugins((DefaultPlugins, NannouPlugin))
-        .insert_resource(Msaa::default())
-        .add_systems(Startup, startup)
-        .add_systems(Update, (update_draw, update_mesh))
-        .run();
-}
-
-#[derive(Resource, Deref, DerefMut)]
-struct MyTexture(Handle<Image>);
-
-fn startup(mut commands: Commands, assets: Res<AssetServer>, mut meshes: ResMut<Assets<Mesh>>) {
-    commands.insert_resource(AmbientLight {
-        color: Color::WHITE,
-        brightness: 1.0,
-    });
-
-    commands.spawn(PointLightBundle {
-        point_light: PointLight {
-            shadows_enabled: true,
-            intensity: 10_000_000_000.,
-            range: 100.0,
-            ..default()
-        },
-        transform: Transform::from_xyz(0.0, 500.0, 100.0),
-        ..default()
-    });
-    //
-    // commands.spawn(DirectionalLightBundle {
-    //     directional_light: DirectionalLight {
-    //         color: Color::rgb(1.0, 0.00, 0.00),
-    //         shadows_enabled: true,
-    //         ..default()
-    //     },
-    //     transform: Transform::from_xyz(100.0, 50.0, 100.0)
-    //         .looking_at(Vec3::new(-0.15, -0.05, 0.25), Vec3::Y),
-    //     ..default()
-    // });
-    //
-    // commands.spawn(DirectionalLightBundle {
-    //     directional_light: DirectionalLight {
-    //         color: Color::rgb(0.0, 0.00, 1.00),
-    //         shadows_enabled: true,
-    //         ..default()
-    //     },
-    //     transform: Transform::from_xyz(-100.0, -50.0, 100.0)
-    //         .looking_at(Vec3::new(-0.15, -0.05, 0.25), Vec3::Y),
-    //     ..default()
-    // });
-
-    commands.spawn(PbrBundle {
-        mesh: meshes.add(Mesh::from(Torus {
-            radius: 100.0,
-            ..default()
-        })),
-        transform: Transform::from_xyz(-200.0, -200.0, 0.0),
-        ..default()
-    });
-
-    commands.spawn((
-        Camera3dBundle {
-            camera: Camera {
-                hdr: true,
-                ..Default::default()
-            },
-            camera_3d: Camera3d {
-                // TODO: we should manage this in the nannou plugin as function of backgrond color
-                clear_color: ClearColorConfig::None,
-                ..Default::default()
-            },
-            transform: Transform::from_xyz(0.0, 0.0, -10.0).looking_at(Vec3::ZERO, Vec3::Z),
-            tonemapping: Tonemapping::TonyMcMapface, // 2. Using a tonemapper that desaturates to white is recommended
-            projection: OrthographicProjection {
-                scale: 1.0,
-                ..Default::default()
-            }
-            .into(),
-            ..Default::default()
-        },
-        BloomSettings {
-            intensity: 0.09,
-            low_frequency_boost: 0.7,
-            low_frequency_boost_curvature: 0.95,
-            high_pass_frequency: 1.0,
-            prefilter_settings: BloomPrefilterSettings {
-                threshold: 0.1,
-                threshold_softness: 0.4,
-            },
-            composite_mode: BloomCompositeMode::Additive,
-        },
-    ));
-
-    let handle = assets.load("images/nannou.png");
-    commands.insert_resource(MyTexture(handle));
-}
-
-fn update_mesh(mut handles: Query<(&Handle<Mesh>, &mut Transform), Without<NannouMesh>>) {
-    for (_, mut transform) in handles.iter_mut() {
-        transform.translation.x += 1.0;
-        transform.translation.y += 1.0;
-        transform.translation.z += 1.0;
-        transform.translation.z += 1.0;
-    }
-}
-
-fn update_draw(
-    draw: Query<&mut bevy_nannou_draw::Draw>,
-    texture_handle: Res<MyTexture>,
-    images: Res<Assets<Image>>,
-    time: Res<Time>,
-) {
-    let draw = draw.single();
-
-    let texture = match images.get(&**texture_handle) {
-        None => return,
-        Some(texture) => texture,
-    };
-
-    // TODO: why is the texture rotated?
-    // draw.texture(texture_handle.clone(), texture.clone());
-    draw.ellipse().w_h(100.0, 100.0).color(Color::SALMON);
-    draw.ellipse()
-        .x(100.0 + time.elapsed().as_millis() as f32 / 100.0)
-        .w_h(100.0, 100.0)
-        .color(Color::SEA_GREEN);
-    draw.ellipse()
-        .x(-100.0)
-        .w_h(100.0, 100.0)
-        .color(Color::BISQUE);
-}
diff --git a/bevy_nannou_draw/Cargo.toml b/bevy_nannou_draw/Cargo.toml
index c7598ca38..215a0554f 100644
--- a/bevy_nannou_draw/Cargo.toml
+++ b/bevy_nannou_draw/Cargo.toml
@@ -5,8 +5,13 @@ edition = "2021"
 
 [dependencies]
 bevy = { workspace = true }
-lyon = "0.17"
+lyon = "1.0"
 nannou_core = { path = "../nannou_core" }
-nannou_mesh = { path = "../nannou_mesh" }
 rusttype = { version = "0.8", features = ["gpu_cache"] }
-num-traits = "0.2"
\ No newline at end of file
+num-traits = "0.2"
+bytemuck = "1.15.0"
+rayon = { workspace = true }
+uuid = "1.8"
+
+[features]
+nightly = []
\ No newline at end of file
diff --git a/bevy_nannou_draw/src/color.rs b/bevy_nannou_draw/src/color.rs
new file mode 100644
index 000000000..1040bb9b7
--- /dev/null
+++ b/bevy_nannou_draw/src/color.rs
@@ -0,0 +1,9 @@
+use bevy::color::Color;
+
+pub trait ColorExt {
+    fn gray(value: f32) -> Color {
+        Color::srgb(value, value, value)
+    }
+}
+
+impl ColorExt for Color {}
diff --git a/bevy_nannou_draw/src/draw/background.rs b/bevy_nannou_draw/src/draw/background.rs
index 7c5ece20e..fe0b2ab3c 100644
--- a/bevy_nannou_draw/src/draw/background.rs
+++ b/bevy_nannou_draw/src/draw/background.rs
@@ -1,18 +1,27 @@
-use crate::draw::Draw;
-use bevy::prelude::Color;
-use nannou_core::color::{self, IntoColor, Srgb, Srgba};
+use bevy::prelude::{Color, Material};
+
+use crate::draw::{Draw, DrawCommand};
 
 /// A type used to update the background colour.
-pub struct Background<'a> {
-    draw: &'a Draw,
+pub struct Background<'a, M>
+where
+    M: Material + Default,
+{
+    draw: &'a Draw<M>,
 }
 
 /// Begin coloring the background.
-pub fn new<'a>(draw: &'a Draw) -> Background<'a> {
+pub fn new<M>(draw: &Draw<M>) -> Background<M>
+where
+    M: Material + Default,
+{
     Background { draw }
 }
 
-impl<'a> Background<'a> {
+impl<'a, M> Background<'a, M>
+where
+    M: Material + Default,
+{
     /// Clear the background with the given color.
     ///
     /// This method supports any color type that can be converted into RGBA.
@@ -24,18 +33,30 @@ impl<'a> Background<'a> {
     {
         if let Ok(mut state) = self.draw.state.try_write() {
             state.background_color = Some(color.into());
+            let color = state.background_color.unwrap();
+            state
+                .draw_commands
+                .push(Some(DrawCommand::BackgroundColor(color)));
         }
         self
     }
 
     /// Specify the color via red, green and blue channels.
-    pub fn rgb(self, r: f32, g: f32, b: f32) -> Self {
-        self.color(Color::rgb(r, g, b))
+    pub fn srgb(self, r: f32, g: f32, b: f32) -> Self {
+        self.color(Color::srgb(r, g, b))
     }
 
     /// Specify the color via red, green, blue and alpha channels.
-    pub fn rgba(self, r: f32, g: f32, b: f32, a: f32) -> Self {
-        self.color(Color::rgba(r, g, b, a))
+    pub fn srgba(self, r: f32, g: f32, b: f32, a: f32) -> Self {
+        self.color(Color::srgba(r, g, b, a))
+    }
+
+    pub fn linear_rgb(self, r: f32, g: f32, b: f32) -> Self {
+        self.color(Color::linear_rgb(r, g, b))
+    }
+
+    pub fn linear_rgba(self, r: f32, g: f32, b: f32, a: f32) -> Self {
+        self.color(Color::linear_rgba(r, g, b, a))
     }
 
     /// Specify the color via hue, saturation and luminance.
@@ -66,31 +87,81 @@ impl<'a> Background<'a> {
         self.color(Color::hsla(hue, s, l, a))
     }
 
-    // /// Specify the color via hue, saturation and *value* (brightness).
-    // ///
-    // /// This is sometimes also known as "hsb".
-    // ///
-    // /// The given hue expects a value between `0.0` and `1.0` where `0.0` is 0 degress and `1.0` is
-    // /// 360 degrees (or 2 PI radians).
-    // ///
-    // /// See the [wikipedia entry](https://en.wikipedia.org/wiki/HSL_and_HSV) for more details on
-    // /// this color space.
-    // pub fn hsv(self, h: f32, s: f32, v: f32) -> Self {
-    //     let hue = h * 360.0;
-    //     self.color(color::Hsv::new(hue, s, v))
-    // }
-    //
-    // /// Specify the color via hue, saturation, *value* (brightness) and an alpha channel.
-    // ///
-    // /// This is sometimes also known as "hsba".
-    // ///
-    // /// The given hue expects a value between `0.0` and `1.0` where `0.0` is 0 degress and `1.0` is
-    // /// 360 degrees (or 2 PI radians).
-    // ///
-    // /// See the [wikipedia entry](https://en.wikipedia.org/wiki/HSL_and_HSV) for more details on
-    // /// this color space.
-    // pub fn hsva(self, h: f32, s: f32, v: f32, a: f32) -> Self {
-    //     let hue = h * 360.0;
-    //     self.color(color::Hsva::new(hue, s, v, a))
-    // }
+    /// Specify the color via hue, saturation and *value* (brightness).
+    ///
+    /// This is sometimes also known as "hsb".
+    ///
+    /// The given hue expects a value between `0.0` and `1.0` where `0.0` is 0 degress and `1.0` is
+    /// 360 degrees (or 2 PI radians).
+    ///
+    /// See the [wikipedia entry](https://en.wikipedia.org/wiki/HSL_and_HSV) for more details on
+    /// this color space.
+    pub fn hsv(self, h: f32, s: f32, v: f32) -> Self {
+        let hue = h * 360.0;
+        self.color(Color::hsv(hue, s, v))
+    }
+
+    /// Specify the color via hue, saturation, *value* (brightness) and an alpha channel.
+    ///
+    /// This is sometimes also known as "hsba".
+    ///
+    /// The given hue expects a value between `0.0` and `1.0` where `0.0` is 0 degress and `1.0` is
+    /// 360 degrees (or 2 PI radians).
+    ///
+    /// See the [wikipedia entry](https://en.wikipedia.org/wiki/HSL_and_HSV) for more details on
+    /// this color space.
+    pub fn hsva(self, h: f32, s: f32, v: f32, a: f32) -> Self {
+        let hue = h * 360.0;
+        self.color(Color::hsva(hue, s, v, a))
+    }
+
+    pub fn hwb(self, h: f32, w: f32, b: f32) -> Self {
+        let hue = h * 360.0;
+        self.color(Color::hwb(hue, w, b))
+    }
+
+    pub fn hwba(self, h: f32, w: f32, b: f32, a: f32) -> Self {
+        let hue = h * 360.0;
+        self.color(Color::hwba(hue, w, b, a))
+    }
+
+    pub fn lab(self, l: f32, a: f32, b: f32) -> Self {
+        self.color(Color::lab(l, a, b))
+    }
+
+    pub fn laba(self, l: f32, a: f32, b: f32, alpha: f32) -> Self {
+        self.color(Color::laba(l, a, b, alpha))
+    }
+
+    pub fn lch(self, l: f32, c: f32, h: f32) -> Self {
+        self.color(Color::lch(l, c, h))
+    }
+
+    pub fn lcha(self, l: f32, c: f32, h: f32, alpha: f32) -> Self {
+        self.color(Color::lcha(l, c, h, alpha))
+    }
+
+    pub fn oklab(self, l: f32, a: f32, b: f32) -> Self {
+        self.color(Color::oklab(l, a, b))
+    }
+
+    pub fn oklaba(self, l: f32, a: f32, b: f32, alpha: f32) -> Self {
+        self.color(Color::oklaba(l, a, b, alpha))
+    }
+
+    pub fn oklch(self, l: f32, c: f32, h: f32) -> Self {
+        self.color(Color::oklch(l, c, h))
+    }
+
+    pub fn oklcha(self, l: f32, c: f32, h: f32, alpha: f32) -> Self {
+        self.color(Color::oklcha(l, c, h, alpha))
+    }
+
+    pub fn cie_xyz(self, x: f32, y: f32, z: f32) -> Self {
+        self.color(Color::xyz(x, y, z))
+    }
+
+    pub fn cie_xyza(self, x: f32, y: f32, z: f32, w: f32) -> Self {
+        self.color(Color::xyza(x, y, z, w))
+    }
 }
diff --git a/bevy_nannou_draw/src/draw/drawing.rs b/bevy_nannou_draw/src/draw/drawing.rs
index 75a2b8df6..1dc77e877 100644
--- a/bevy_nannou_draw/src/draw/drawing.rs
+++ b/bevy_nannou_draw/src/draw/drawing.rs
@@ -1,13 +1,19 @@
+use std::any::TypeId;
+use std::marker::PhantomData;
+
+use bevy::asset::{AsyncWriteExt, UntypedAssetId};
+use bevy::pbr::{ExtendedMaterial, MaterialExtension};
+use bevy::prelude::*;
+use lyon::path::PathEvent;
+use lyon::tessellation::{FillOptions, LineCap, LineJoin, StrokeOptions};
+use uuid::Uuid;
+
 use crate::draw::primitive::Primitive;
 use crate::draw::properties::{
     SetColor, SetDimensions, SetFill, SetOrientation, SetPosition, SetStroke,
 };
-use crate::draw::{self, Draw};
-use bevy::prelude::*;
-use lyon::path::PathEvent;
-use lyon::tessellation::{FillOptions, LineCap, LineJoin, StrokeOptions};
-use nannou_core::color::IntoColor;
-use std::marker::PhantomData;
+use crate::draw::{Draw, DrawCommand, DrawRef};
+use crate::render::{ExtendedNannouMaterial, NannouMaterial};
 
 /// A **Drawing** in progress.
 ///
@@ -19,13 +25,17 @@ use std::marker::PhantomData;
 /// inner **geom::Graph**. This ensures the correct instantiation order is maintained within the
 /// graph. As a result, each **Drawing** is associated with a single, unique node. Thus a
 /// **Drawing** can be thought of as a way of specifying properties for a node.
-#[derive(Debug)]
-pub struct Drawing<'a, T> {
+pub struct Drawing<'a, T, M>
+where
+    M: Material + Default,
+{
     // The `Draw` instance used to create this drawing.
-    draw: &'a Draw,
+    draw: DrawRef<'a, M>,
     // The draw command index of the primitive being drawn.
-    index: usize,
-    // Whether or not the **Drawing** should attempt to finish the drawing on drop.
+    pub(crate) index: usize,
+    // The draw command index of the material being used.
+    pub(crate) material_index: usize,
+    // Whether the **Drawing** should attempt to finish the drawing on drop.
     finish_on_drop: bool,
     // The node type currently being drawn.
     _ty: PhantomData<T>,
@@ -39,30 +49,36 @@ pub struct DrawingContext<'a> {
     pub mesh: &'a mut Mesh,
     /// A re-usable buffer for collecting path events.
     pub path_event_buffer: &'a mut Vec<PathEvent>,
-    /// A re-usable buffer for collecting colored polyline points.
-    pub path_points_colored_buffer: &'a mut Vec<(Vec2, Color)>,
-    /// A re-usable buffer for collecting textured polyline points.
-    pub path_points_textured_buffer: &'a mut Vec<(Vec2, Vec2)>,
+    /// A re-usable buffer for collecting polyline points vertex data.
+    pub path_points_vertex_buffer: &'a mut Vec<(Vec2, Color, Vec2)>,
     /// A re-usable buffer for collecting text.
     pub text_buffer: &'a mut String,
 }
 
 /// Construct a new **Drawing** instance.
-pub fn new<'a, T>(draw: &'a Draw, index: usize) -> Drawing<'a, T> {
+pub fn new<T, M: Material>(draw: &Draw<M>, index: usize, material_index: usize) -> Drawing<T, M>
+where
+    T: Into<Primitive>,
+    M: Material + Default,
+{
     let _ty = PhantomData;
     let finish_on_drop = true;
     Drawing {
-        draw,
+        draw: DrawRef::Borrowed(draw),
         index,
+        material_index,
         finish_on_drop,
         _ty,
     }
 }
 
-impl<'a, T> Drop for Drawing<'a, T> {
+impl<'a, T, M> Drop for Drawing<'a, T, M>
+where
+    M: Material + Default,
+{
     fn drop(&mut self) {
         if self.finish_on_drop {
-            self.finish_inner();
+            self.finish_inner()
         }
     }
 }
@@ -73,29 +89,47 @@ impl<'a> DrawingContext<'a> {
         let super::IntermediaryState {
             ref mut intermediary_mesh,
             ref mut path_event_buffer,
-            ref mut path_points_colored_buffer,
-            ref mut path_points_textured_buffer,
+            ref mut path_points_vertex_buffer,
             ref mut text_buffer,
         } = *state;
         DrawingContext {
             mesh: intermediary_mesh,
-            path_event_buffer: path_event_buffer,
-            path_points_colored_buffer: path_points_colored_buffer,
-            path_points_textured_buffer: path_points_textured_buffer,
-            text_buffer: text_buffer,
+            path_event_buffer,
+            path_points_vertex_buffer,
+            text_buffer,
         }
     }
 }
 
-impl<'a, T> Drawing<'a, T> {
+impl<'a, T, M> Drawing<'a, T, M>
+where
+    M: Material + Default,
+{
     // Shared between the **finish** method and the **Drawing**'s **Drop** implementation.
     //
     // 1. Create vertices based on node-specific position, points, etc.
     // 2. Insert edges into geom graph based on
     fn finish_inner(&mut self) {
-        match self.draw.state.try_write() {
+        match (*self.draw).state.try_write() {
             Err(err) => eprintln!("drawing failed to borrow state and finish: {}", err),
-            Ok(mut state) => state.finish_drawing(self.index),
+            Ok(mut state) => {
+                match &self.draw {
+                    // If we are "Owned", that means we mutated our material and so need to
+                    // spawn a new entity just for this primitive.
+                    DrawRef::Owned(draw) => {
+                        let id = draw.material.clone();
+                        let material_cmd = state
+                            .draw_commands
+                            .get_mut(self.material_index)
+                            .expect("Expected a valid material index");
+                        if let None = material_cmd {
+                            *material_cmd = Some(DrawCommand::Material(id));
+                        }
+                    }
+                    DrawRef::Borrowed(_) => (),
+                }
+                state.finish_drawing(self.index);
+            }
         }
     }
 
@@ -106,13 +140,108 @@ impl<'a, T> Drawing<'a, T> {
         self.finish_inner()
     }
 
+    /// Set the material's fragment shader for the drawing. Note: this shader must have
+    /// been initialized during application setup.
+    #[cfg(feature = "nightly")]
+    pub fn fragment_shader<const FS: &'static str>(
+        mut self,
+    ) -> Drawing<'a, T, ExtendedNannouMaterial<"", FS>> {
+        self.finish_on_drop = false;
+
+        let Drawing {
+            ref draw,
+            index,
+            material_index,
+            ..
+        } = self;
+
+        let state = draw.state.clone();
+        let new_id = UntypedAssetId::Uuid {
+            type_id: TypeId::of::<ExtendedNannouMaterial<"", FS>>(),
+            uuid: Uuid::new_v4(),
+        };
+
+        let material: ExtendedNannouMaterial<"", FS> = Default::default();
+        let mut state = state.write().unwrap();
+        state.materials.insert(new_id.clone(), Box::new(material));
+        // Mark the last material as the new material so that further drawings use the same material
+        // as the parent draw ref.
+        state.last_material = Some(new_id.clone());
+
+        let draw = Draw {
+            state: draw.state.clone(),
+            context: draw.context.clone(),
+            material: new_id.clone(),
+            window: draw.window,
+            _material: Default::default(),
+        };
+
+        Drawing::<'a, T, ExtendedMaterial<StandardMaterial, NannouMaterial<"", FS>>> {
+            draw: DrawRef::Owned(draw),
+            index,
+            material_index,
+            finish_on_drop: true,
+            _ty: PhantomData,
+        }
+    }
+
+    // Map the the parent's material to a new material type, taking ownership over the
+    // draw instance clone.
+    pub fn map_material<F>(mut self, map: F) -> Drawing<'a, T, M>
+    where
+        F: FnOnce(M) -> M,
+    {
+        self.finish_on_drop = false;
+
+        let Drawing {
+            ref draw,
+            index,
+            material_index,
+            ..
+        } = self;
+
+        let state = draw.state.clone();
+        let material = state.read().unwrap().materials[&self.draw.material]
+            .downcast_ref::<M>()
+            .unwrap()
+            .clone();
+
+        let new_id = UntypedAssetId::Uuid {
+            type_id: TypeId::of::<M>(),
+            uuid: Uuid::new_v4(),
+        };
+
+        let material = map(material.clone());
+        let mut state = state.write().unwrap();
+        state.materials.insert(new_id.clone(), Box::new(material));
+        // Mark the last material as the new material so that further drawings use the same material
+        // as the parent draw ref.
+        state.last_material = Some(new_id.clone());
+
+        let draw = Draw {
+            state: draw.state.clone(),
+            context: draw.context.clone(),
+            material: new_id.clone(),
+            window: draw.window,
+            _material: Default::default(),
+        };
+
+        Drawing {
+            draw: DrawRef::Owned(draw),
+            index,
+            material_index,
+            finish_on_drop: true,
+            _ty: PhantomData,
+        }
+    }
+
     // Map the given function onto the primitive stored within **Draw** at `index`.
     //
     // The functionn is only applied if the node has not yet been **Drawn**.
-    fn map_primitive<F, T2>(mut self, map: F) -> Drawing<'a, T2>
+    fn map_primitive<F, T2>(mut self, map: F) -> Drawing<'a, T2, M>
     where
         F: FnOnce(Primitive) -> Primitive,
-        T2: Into<Primitive>,
+        T2: Into<Primitive> + Clone,
     {
         if let Ok(mut state) = self.draw.state.try_write() {
             if let Some(mut primitive) = state.drawing.remove(&self.index) {
@@ -121,10 +250,16 @@ impl<'a, T> Drawing<'a, T> {
             }
         }
         self.finish_on_drop = false;
-        let Drawing { draw, index, .. } = self;
+        let Drawing {
+            ref draw,
+            index,
+            material_index,
+            ..
+        } = self;
         Drawing {
-            draw,
+            draw: draw.clone(),
             index,
+            material_index,
             finish_on_drop: true,
             _ty: PhantomData,
         }
@@ -133,18 +268,15 @@ impl<'a, T> Drawing<'a, T> {
     // The same as `map_primitive` but also passes a mutable reference to the vertex data to the
     // map function. This is useful for types that may have an unknown number of arbitrary
     // vertices.
-    fn map_primitive_with_context<F, T2>(mut self, map: F) -> Drawing<'a, T2>
+    fn map_primitive_with_context<F, T2>(mut self, map: F) -> Drawing<'a, T2, M>
     where
         F: FnOnce(Primitive, DrawingContext) -> Primitive,
-        T2: Into<Primitive>,
+        T2: Into<Primitive> + Clone,
     {
         if let Ok(mut state) = self.draw.state.try_write() {
             if let Some(mut primitive) = state.drawing.remove(&self.index) {
                 {
-                    let mut intermediary_state = state
-                        .intermediary_state
-                        .write()
-                        .expect("intermediary state lock poisoned");
+                    let mut intermediary_state = state.intermediary_state.write().unwrap();
                     let ctxt = DrawingContext::from_intermediary_state(&mut *intermediary_state);
                     primitive = map(primitive, ctxt);
                 }
@@ -152,10 +284,16 @@ impl<'a, T> Drawing<'a, T> {
             }
         }
         self.finish_on_drop = false;
-        let Drawing { draw, index, .. } = self;
+        let Drawing {
+            ref draw,
+            index,
+            material_index,
+            ..
+        } = self;
         Drawing {
-            draw,
+            draw: draw.clone(),
             index,
+            material_index,
             finish_on_drop: true,
             _ty: PhantomData,
         }
@@ -166,10 +304,10 @@ impl<'a, T> Drawing<'a, T> {
     /// The function is only applied if the node has not yet been **Drawn**.
     ///
     /// **Panics** if the primitive does not contain type **T**.
-    pub fn map_ty<F, T2>(self, map: F) -> Drawing<'a, T2>
+    pub fn map_ty<F, T2>(self, map: F) -> Drawing<'a, T2, M>
     where
         F: FnOnce(T) -> T2,
-        T2: Into<Primitive>,
+        T2: Into<Primitive> + Clone,
         Primitive: Into<Option<T>>,
     {
         self.map_primitive(|prim| {
@@ -185,10 +323,10 @@ impl<'a, T> Drawing<'a, T> {
     /// The function is only applied if the node has not yet been **Drawn**.
     ///
     /// **Panics** if the primitive does not contain type **T**.
-    pub(crate) fn map_ty_with_context<F, T2>(self, map: F) -> Drawing<'a, T2>
+    pub(crate) fn map_ty_with_context<F, T2>(self, map: F) -> Drawing<'a, T2, M>
     where
         F: FnOnce(T, DrawingContext) -> T2,
-        T2: Into<Primitive>,
+        T2: Into<Primitive> + Clone,
         Primitive: Into<Option<T>>,
     {
         self.map_primitive_with_context(|prim, ctxt| {
@@ -202,9 +340,10 @@ impl<'a, T> Drawing<'a, T> {
 
 // SetColor implementations.
 
-impl<'a, T> Drawing<'a, T>
+impl<'a, T, M> Drawing<'a, T, M>
 where
-    T: SetColor + Into<Primitive>,
+    T: SetColor + Into<Primitive> + Clone,
+    M: Material + Default,
     Primitive: Into<Option<T>>,
 {
     /// Specify a color.
@@ -220,23 +359,31 @@ where
     }
 
     /// Specify the color via red, green and blue channels.
-    pub fn rgb(self, r: f32, g: f32, b: f32) -> Self {
-        self.map_ty(|ty| SetColor::rgb(ty, r, g, b))
+    pub fn srgb(self, r: f32, g: f32, b: f32) -> Self {
+        self.map_ty(|ty| SetColor::srgb(ty, r, g, b))
     }
 
     /// Specify the color via red, green and blue channels as bytes
-    pub fn rgb8(self, r: u8, g: u8, b: u8) -> Self {
-        self.map_ty(|ty| SetColor::rgb8(ty, r, g, b))
+    pub fn srgb_u8(self, r: u8, g: u8, b: u8) -> Self {
+        self.map_ty(|ty| SetColor::srgb_u8(ty, r, g, b))
     }
 
     /// Specify the color via red, green, blue and alpha channels.
-    pub fn rgba(self, r: f32, g: f32, b: f32, a: f32) -> Self {
-        self.map_ty(|ty| SetColor::rgba(ty, r, g, b, a))
+    pub fn srgba(self, r: f32, g: f32, b: f32, a: f32) -> Self {
+        self.map_ty(|ty| SetColor::srgba(ty, r, g, b, a))
     }
 
     /// Specify the color via red, green, blue and alpha channels as bytes.
-    pub fn rgba8(self, r: u8, g: u8, b: u8, a: u8) -> Self {
-        self.map_ty(|ty| SetColor::rgba8(ty, r, g, b, a))
+    pub fn srgba_u8(self, r: u8, g: u8, b: u8, a: u8) -> Self {
+        self.map_ty(|ty| SetColor::srgba_u8(ty, r, g, b, a))
+    }
+
+    pub fn linear_rgb(self, r: f32, g: f32, b: f32) -> Self {
+        self.map_ty(|ty| SetColor::linear_rgb(ty, r, g, b))
+    }
+
+    pub fn linear_rgba(self, r: f32, g: f32, b: f32, a: f32) -> Self {
+        self.map_ty(|ty| SetColor::linear_rgba(ty, r, g, b, a))
     }
 
     /// Specify the color via hue, saturation and luminance.
@@ -265,31 +412,79 @@ where
         self.map_ty(|ty| SetColor::hsla(ty, h, s, l, a))
     }
 
-    // /// Specify the color via hue, saturation and *value* (brightness).
-    // ///
-    // /// This is sometimes also known as "hsb".
-    // ///
-    // /// The given hue expects a value between `0.0` and `1.0` where `0.0` is 0 degress and `1.0` is
-    // /// 360 degrees (or 2 PI radians).
-    // ///
-    // /// See the [wikipedia entry](https://en.wikipedia.org/wiki/HSL_and_HSV) for more details on
-    // /// this color space.
-    // pub fn hsv(self, h: f32, s: f32, v: f32) -> Self {
-    //     self.map_ty(|ty| SetColor::hsv(ty, h, s, v))
-    // }
-    //
-    // /// Specify the color via hue, saturation, *value* (brightness) and an alpha channel.
-    // ///
-    // /// This is sometimes also known as "hsba".
-    // ///
-    // /// The given hue expects a value between `0.0` and `1.0` where `0.0` is 0 degress and `1.0` is
-    // /// 360 degrees (or 2 PI radians).
-    // ///
-    // /// See the [wikipedia entry](https://en.wikipedia.org/wiki/HSL_and_HSV) for more details on
-    // /// this color space.
-    // pub fn hsva(self, h: f32, s: f32, v: f32, a: f32) -> Self {
-    //     self.map_ty(|ty| SetColor::hsva(ty, h, s, v, a))
-    // }
+    /// Specify the color via hue, saturation and *value* (brightness).
+    ///
+    /// This is sometimes also known as "hsb".
+    ///
+    /// The given hue expects a value between `0.0` and `1.0` where `0.0` is 0 degress and `1.0` is
+    /// 360 degrees (or 2 PI radians).
+    ///
+    /// See the [wikipedia entry](https://en.wikipedia.org/wiki/HSL_and_HSV) for more details on
+    /// this color space.
+    pub fn hsv(self, h: f32, s: f32, v: f32) -> Self {
+        self.map_ty(|ty| SetColor::hsv(ty, h, s, v))
+    }
+
+    /// Specify the color via hue, saturation, *value* (brightness) and an alpha channel.
+    ///
+    /// This is sometimes also known as "hsba".
+    ///
+    /// The given hue expects a value between `0.0` and `1.0` where `0.0` is 0 degress and `1.0` is
+    /// 360 degrees (or 2 PI radians).
+    ///
+    /// See the [wikipedia entry](https://en.wikipedia.org/wiki/HSL_and_HSV) for more details on
+    /// this color space.
+    pub fn hsva(self, h: f32, s: f32, v: f32, a: f32) -> Self {
+        self.map_ty(|ty| SetColor::hsva(ty, h, s, v, a))
+    }
+
+    pub fn hwb(self, h: f32, w: f32, b: f32) -> Self {
+        self.map_ty(|ty| SetColor::hwb(ty, h, w, b))
+    }
+
+    pub fn hwba(self, h: f32, w: f32, b: f32, a: f32) -> Self {
+        self.map_ty(|ty| SetColor::hwba(ty, h, w, b, a))
+    }
+
+    pub fn lab(self, l: f32, a: f32, b: f32) -> Self {
+        self.map_ty(|ty| SetColor::lab(ty, l, a, b))
+    }
+
+    pub fn laba(self, l: f32, a: f32, b: f32, alpha: f32) -> Self {
+        self.map_ty(|ty| SetColor::laba(ty, l, a, b, alpha))
+    }
+
+    pub fn lch(self, l: f32, c: f32, h: f32) -> Self {
+        self.map_ty(|ty| SetColor::lch(ty, l, c, h))
+    }
+
+    pub fn lcha(self, l: f32, c: f32, h: f32, alpha: f32) -> Self {
+        self.map_ty(|ty| SetColor::lcha(ty, l, c, h, alpha))
+    }
+
+    pub fn oklab(self, l: f32, a: f32, b: f32) -> Self {
+        self.map_ty(|ty| SetColor::oklab(ty, l, a, b))
+    }
+
+    pub fn oklaba(self, l: f32, a: f32, b: f32, alpha: f32) -> Self {
+        self.map_ty(|ty| SetColor::oklaba(ty, l, a, b, alpha))
+    }
+
+    pub fn oklch(self, l: f32, c: f32, h: f32) -> Self {
+        self.map_ty(|ty| SetColor::oklch(ty, l, c, h))
+    }
+
+    pub fn oklcha(self, l: f32, c: f32, h: f32, alpha: f32) -> Self {
+        self.map_ty(|ty| SetColor::oklcha(ty, l, c, h, alpha))
+    }
+
+    pub fn cie_xyz(self, x: f32, y: f32, z: f32) -> Self {
+        self.map_ty(|ty| SetColor::cie_xyz(ty, x, y, z))
+    }
+
+    pub fn cie_xyza(self, x: f32, y: f32, z: f32, alpha: f32) -> Self {
+        self.map_ty(|ty| SetColor::cie_xyza(ty, x, y, z, alpha))
+    }
 
     /// Specify the color as gray scale
     ///
@@ -301,9 +496,10 @@ where
 
 // SetDimensions implementations.
 
-impl<'a, T> Drawing<'a, T>
+impl<'a, T, M> Drawing<'a, T, M>
 where
-    T: SetDimensions + Into<Primitive>,
+    T: SetDimensions + Into<Primitive> + Clone,
+    M: Material + Default,
     Primitive: Into<Option<T>>,
 {
     /// Set the absolute width for the node.
@@ -359,9 +555,10 @@ where
 
 // SetPosition methods.
 
-impl<'a, T> Drawing<'a, T>
+impl<'a, T, M> Drawing<'a, T, M>
 where
-    T: SetPosition + Into<Primitive>,
+    T: SetPosition + Into<Primitive> + Clone,
+    M: Material + Default,
     Primitive: Into<Option<T>>,
 {
     /// Build with the given **Absolute** **Position** along the *x* axis.
@@ -402,9 +599,10 @@ where
 
 // SetOrientation methods.
 
-impl<'a, T> Drawing<'a, T>
+impl<'a, T, M> Drawing<'a, T, M>
 where
-    T: SetOrientation + Into<Primitive>,
+    T: SetOrientation + Into<Primitive> + Clone,
+    M: Material + Default,
     Primitive: Into<Option<T>>,
 {
     /// Describe orientation via the vector that points to the given target.
@@ -524,9 +722,10 @@ where
 
 // SetFill methods
 
-impl<'a, T> Drawing<'a, T>
+impl<'a, T, M> Drawing<'a, T, M>
 where
-    T: SetFill + Into<Primitive>,
+    T: SetFill + Into<Primitive> + Clone,
+    M: Material + Default,
     Primitive: Into<Option<T>>,
 {
     /// Specify the whole set of fill tessellation options.
@@ -567,9 +766,10 @@ where
 
 // SetStroke methods
 
-impl<'a, T> Drawing<'a, T>
+impl<'a, T, M> Drawing<'a, T, M>
 where
-    T: SetStroke + Into<Primitive>,
+    T: SetStroke + Into<Primitive> + Clone,
+    M: Material + Default,
     Primitive: Into<Option<T>>,
 {
     /// The start line cap as specified by the SVG spec.
@@ -707,3 +907,52 @@ where
         self.map_ty(|ty| ty.stroke_opts(opts))
     }
 }
+
+impl<'a, T, M> Drawing<'a, T, M>
+where
+    T: Into<Primitive> + Clone,
+    M: Material + Default,
+    Primitive: Into<Option<T>>,
+{
+}
+
+impl<'a, T, M> Drawing<'a, T, ExtendedMaterial<StandardMaterial, M>>
+where
+    T: Into<Primitive>,
+    M: MaterialExtension + Default,
+{
+    pub fn roughness(mut self, roughness: f32) -> Self {
+        self.map_material(|mut material| {
+            material.base.perceptual_roughness = roughness;
+            material
+        })
+    }
+
+    pub fn metallic(mut self, metallic: f32) -> Self {
+        self.map_material(|mut material| {
+            material.base.metallic = metallic;
+            material
+        })
+    }
+
+    pub fn base_color<C: Into<Color>>(mut self, color: C) -> Self {
+        self.map_material(|mut material| {
+            material.base.base_color = color.into();
+            material
+        })
+    }
+
+    pub fn emissive<C: Into<Color>>(mut self, color: C) -> Self {
+        self.map_material(|mut material| {
+            material.base.emissive = color.into().to_linear();
+            material
+        })
+    }
+
+    pub fn texture(mut self, texture: &Handle<Image>) -> Self {
+        self.map_material(|mut material| {
+            material.base.base_color_texture = Some(texture.clone());
+            material
+        })
+    }
+}
diff --git a/bevy_nannou_draw/src/draw/instanced.rs b/bevy_nannou_draw/src/draw/instanced.rs
new file mode 100644
index 000000000..5fa760626
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/instanced.rs
@@ -0,0 +1,326 @@
+//! A shader that renders a mesh multiple times in one draw call.
+
+use bevy::render::render_phase::ViewSortedRenderPhases;
+use bevy::{
+    core_pipeline::core_3d::Transparent3d,
+    ecs::{
+        query::QueryItem,
+        system::{lifetimeless::*, SystemParamItem},
+    },
+    pbr::{
+        MeshPipeline, MeshPipelineKey, RenderMeshInstances, SetMeshBindGroup, SetMeshViewBindGroup,
+    },
+    prelude::*,
+    render::{
+        extract_component::{ExtractComponent, ExtractComponentPlugin},
+        mesh::{GpuBufferInfo, GpuMesh, MeshVertexBufferLayoutRef},
+        render_asset::RenderAssets,
+        render_phase::{
+            AddRenderCommand, DrawFunctions, PhaseItem, PhaseItemExtraIndex, RenderCommand,
+            RenderCommandResult, SetItemPipeline, SortedRenderPhase, TrackedRenderPass,
+        },
+        render_resource::*,
+        renderer::RenderDevice,
+        view::ExtractedView,
+        Render, RenderApp, RenderSet,
+    },
+};
+use bytemuck::{Pod, Zeroable};
+use rayon::prelude::*;
+
+use crate::draw::drawing::Drawing;
+use crate::draw::primitive::Primitive;
+use crate::draw::{Draw, DrawCommand};
+
+static INSTANCING_RENDER: &str = include_str!("render/instancing.wgsl");
+
+const SHADER_HANDLE: Handle<Shader> = Handle::weak_from_u128(24560125337912185962);
+
+pub struct Instanced<'a, M>
+where
+    M: Material + Default,
+{
+    draw: &'a Draw<M>,
+    data: Option<(usize, InstanceMaterialData)>,
+}
+
+impl<'a, M> Drop for Instanced<'a, M>
+where
+    M: Material + Default,
+{
+    fn drop(&mut self) {
+        if let Some((index, data)) = self.data.take() {
+            self.insert_instanced_draw_command(index, data);
+        }
+    }
+}
+
+pub fn new<M>(draw: &Draw<M>) -> Instanced<M>
+where
+    M: Material + Default,
+{
+    Instanced { draw, data: None }
+}
+
+impl<'a, M> Instanced<'a, M>
+where
+    M: Material + Default,
+{
+    pub fn with<T, I, F>(
+        mut self,
+        drawing: Drawing<T, M>,
+        input: Vec<I>,
+        func: F,
+    ) -> Instanced<'a, M>
+    where
+        I: Send + Sync,
+        T: Into<Primitive>,
+        F: Fn(&I) -> InstanceData + Sync,
+    {
+        let data = input
+            .par_iter()
+            .map(|i| func(i))
+            .collect::<Vec<InstanceData>>();
+        let data = InstanceMaterialData(data);
+        self.draw
+            .state
+            .write()
+            .unwrap()
+            .instanced
+            .insert(drawing.index);
+        self.data = Some((drawing.index, data));
+        self
+    }
+
+    fn insert_instanced_draw_command(&self, index: usize, data: InstanceMaterialData) {
+        let mut state = self.draw.state.write().unwrap();
+        let primitive = state.drawing.remove(&index).unwrap();
+        state
+            .draw_commands
+            .push(Some(DrawCommand::Instanced(primitive, data)));
+    }
+}
+
+#[derive(Component, Deref, Clone, Debug)]
+pub struct InstanceMaterialData(pub Vec<InstanceData>);
+
+impl ExtractComponent for InstanceMaterialData {
+    type QueryData = &'static InstanceMaterialData;
+    type QueryFilter = ();
+    type Out = Self;
+
+    fn extract_component(item: QueryItem<'_, Self::QueryData>) -> Option<Self> {
+        Some(InstanceMaterialData(item.0.clone()))
+    }
+}
+
+pub struct InstancingPlugin;
+
+impl Plugin for InstancingPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_plugins(ExtractComponentPlugin::<InstanceMaterialData>::default());
+        app.sub_app_mut(RenderApp)
+            .add_render_command::<Transparent3d, DrawInstanced>()
+            .init_resource::<SpecializedMeshPipelines<InstancedDataPipeline>>()
+            .add_systems(
+                Render,
+                (
+                    queue_instanced.in_set(RenderSet::QueueMeshes),
+                    prepare_instance_buffers.in_set(RenderSet::PrepareResources),
+                ),
+            );
+    }
+
+    fn finish(&self, app: &mut App) {
+        app.world_mut()
+            .resource_mut::<Assets<Shader>>()
+            .get_or_insert_with(&SHADER_HANDLE, || {
+                Shader::from_wgsl(INSTANCING_RENDER, file!())
+            });
+
+        app.sub_app_mut(RenderApp)
+            .init_resource::<InstancedDataPipeline>();
+    }
+}
+
+#[derive(Debug, Clone, Copy, Pod, Zeroable)]
+#[repr(C)]
+pub struct InstanceData {
+    pub position: Vec3,
+    pub scale: f32,
+    pub color: [f32; 4],
+}
+
+#[allow(clippy::too_many_arguments)]
+fn queue_instanced(
+    transparent_3d_draw_functions: Res<DrawFunctions<Transparent3d>>,
+    custom_pipeline: Res<InstancedDataPipeline>,
+    msaa: Res<Msaa>,
+    mut pipelines: ResMut<SpecializedMeshPipelines<InstancedDataPipeline>>,
+    pipeline_cache: Res<PipelineCache>,
+    meshes: Res<RenderAssets<GpuMesh>>,
+    render_mesh_instances: Res<RenderMeshInstances>,
+    material_meshes: Query<Entity, With<InstanceMaterialData>>,
+    mut transparent_render_phases: ResMut<ViewSortedRenderPhases<Transparent3d>>,
+    mut views: Query<(Entity, &ExtractedView)>,
+) {
+    let draw_custom = transparent_3d_draw_functions.read().id::<DrawInstanced>();
+
+    let msaa_key = MeshPipelineKey::from_msaa_samples(msaa.samples());
+
+    for (view_entity, view) in &mut views {
+        let Some(transparent_phase) = transparent_render_phases.get_mut(&view_entity) else {
+            continue;
+        };
+
+        let view_key = msaa_key | MeshPipelineKey::from_hdr(view.hdr);
+        let rangefinder = view.rangefinder3d();
+        for entity in &material_meshes {
+            let Some(mesh_instance) = render_mesh_instances.render_mesh_queue_data(entity) else {
+                continue;
+            };
+            let Some(mesh) = meshes.get(mesh_instance.mesh_asset_id) else {
+                continue;
+            };
+            let key =
+                view_key | MeshPipelineKey::from_primitive_topology(mesh.primitive_topology());
+            let pipeline = pipelines
+                .specialize(&pipeline_cache, &custom_pipeline, key, &mesh.layout)
+                .unwrap();
+            transparent_phase.add(Transparent3d {
+                entity,
+                pipeline,
+                draw_function: draw_custom,
+                distance: rangefinder.distance_translation(&mesh_instance.translation),
+                batch_range: 0..1,
+                extra_index: PhaseItemExtraIndex::NONE,
+            });
+        }
+    }
+}
+
+#[derive(Component)]
+struct InstanceBuffer {
+    buffer: Buffer,
+    length: usize,
+}
+
+fn prepare_instance_buffers(
+    mut commands: Commands,
+    query: Query<(Entity, &InstanceMaterialData)>,
+    render_device: Res<RenderDevice>,
+) {
+    for (entity, instance_data) in &query {
+        let buffer = render_device.create_buffer_with_data(&BufferInitDescriptor {
+            label: Some("instance data buffer"),
+            contents: bytemuck::cast_slice(instance_data.as_slice()),
+            usage: BufferUsages::VERTEX | BufferUsages::COPY_DST,
+        });
+        commands.entity(entity).insert(InstanceBuffer {
+            buffer,
+            length: instance_data.len(),
+        });
+    }
+}
+
+#[derive(Resource)]
+struct InstancedDataPipeline {
+    shader: Handle<Shader>,
+    mesh_pipeline: MeshPipeline,
+}
+
+impl FromWorld for InstancedDataPipeline {
+    fn from_world(world: &mut World) -> Self {
+        let mesh_pipeline = world.resource::<MeshPipeline>();
+
+        InstancedDataPipeline {
+            shader: SHADER_HANDLE,
+            mesh_pipeline: mesh_pipeline.clone(),
+        }
+    }
+}
+
+impl SpecializedMeshPipeline for InstancedDataPipeline {
+    type Key = MeshPipelineKey;
+
+    fn specialize(
+        &self,
+        key: Self::Key,
+        layout: &MeshVertexBufferLayoutRef,
+    ) -> Result<RenderPipelineDescriptor, SpecializedMeshPipelineError> {
+        let mut descriptor = self.mesh_pipeline.specialize(key, layout)?;
+
+        descriptor.vertex.shader = self.shader.clone();
+        descriptor.vertex.buffers.push(VertexBufferLayout {
+            array_stride: std::mem::size_of::<InstanceData>() as u64,
+            step_mode: VertexStepMode::Instance,
+            attributes: vec![
+                VertexAttribute {
+                    format: VertexFormat::Float32x4,
+                    offset: 0,
+                    shader_location: 3, // shader locations 0-2 are taken up by Position, Normal and UV attributes
+                },
+                VertexAttribute {
+                    format: VertexFormat::Float32x4,
+                    offset: VertexFormat::Float32x4.size(),
+                    shader_location: 4,
+                },
+            ],
+        });
+        descriptor.fragment.as_mut().unwrap().shader = self.shader.clone();
+        Ok(descriptor)
+    }
+}
+
+type DrawInstanced = (
+    SetItemPipeline,
+    SetMeshViewBindGroup<0>,
+    SetMeshBindGroup<1>,
+    DrawMeshInstanced,
+);
+
+struct DrawMeshInstanced;
+
+impl<P: PhaseItem> RenderCommand<P> for DrawMeshInstanced {
+    type Param = (SRes<RenderAssets<GpuMesh>>, SRes<RenderMeshInstances>);
+    type ViewQuery = ();
+    type ItemQuery = Read<InstanceBuffer>;
+
+    #[inline]
+    fn render<'w>(
+        item: &P,
+        _view: (),
+        instance_buffer: Option<&'w InstanceBuffer>,
+        (meshes, render_mesh_instances): SystemParamItem<'w, '_, Self::Param>,
+        pass: &mut TrackedRenderPass<'w>,
+    ) -> RenderCommandResult {
+        let Some(mesh_instance) = render_mesh_instances.render_mesh_queue_data(item.entity())
+        else {
+            return RenderCommandResult::Failure;
+        };
+        let Some(gpu_mesh) = meshes.into_inner().get(mesh_instance.mesh_asset_id) else {
+            return RenderCommandResult::Failure;
+        };
+        let Some(instance_buffer) = instance_buffer else {
+            return RenderCommandResult::Failure;
+        };
+
+        pass.set_vertex_buffer(0, gpu_mesh.vertex_buffer.slice(..));
+        pass.set_vertex_buffer(1, instance_buffer.buffer.slice(..));
+
+        match &gpu_mesh.buffer_info {
+            GpuBufferInfo::Indexed {
+                buffer,
+                index_format,
+                count,
+            } => {
+                pass.set_index_buffer(buffer.slice(..), 0, *index_format);
+                pass.draw_indexed(0..*count, 0, 0..instance_buffer.length as u32);
+            }
+            GpuBufferInfo::NonIndexed => {
+                pass.draw(0..gpu_mesh.vertex_count, 0..instance_buffer.length as u32);
+            }
+        }
+        RenderCommandResult::Success
+    }
+}
diff --git a/bevy_nannou_draw/src/draw/mesh/builder.rs b/bevy_nannou_draw/src/draw/mesh/builder.rs
index d70c7b607..a1c6f9a1d 100644
--- a/bevy_nannou_draw/src/draw/mesh/builder.rs
+++ b/bevy_nannou_draw/src/draw/mesh/builder.rs
@@ -5,16 +5,14 @@
 //!
 //! Lyon tessellators assume `f32` data, so we do the same in the following implementations.
 
+use bevy::prelude::*;
+use lyon::tessellation::{FillVertex, GeometryBuilderError, StrokeVertex, VertexId};
 // use lyon::tessellation::{FillVertex, GeometryBuilderError, StrokeVertex, VertexId};
 use lyon::tessellation::geometry_builder::{
-    self, FillGeometryBuilder, GeometryBuilder, StrokeGeometryBuilder,
+    FillGeometryBuilder, GeometryBuilder, StrokeGeometryBuilder,
 };
-use lyon::tessellation::{FillVertex, GeometryBuilderError, StrokeVertex, VertexId};
 
 use crate::draw::mesh::MeshExt;
-use bevy::prelude::*;
-use bevy::render::mesh::Indices;
-use bevy::render::render_resource::encase::private::RuntimeSizedArray;
 
 pub struct MeshBuilder<'a, A> {
     /// The mesh that is to be extended.
@@ -30,8 +28,7 @@ pub struct MeshBuilder<'a, A> {
 }
 
 pub struct SingleColor(Color);
-pub struct ColorPerPoint;
-pub struct TexCoordsPerPoint;
+pub struct Vertex;
 
 impl<'a, A> MeshBuilder<'a, A> {
     /// Begin extending the mesh.
@@ -53,17 +50,10 @@ impl<'a> MeshBuilder<'a, SingleColor> {
     }
 }
 
-impl<'a> MeshBuilder<'a, ColorPerPoint> {
+impl<'a> MeshBuilder<'a, Vertex> {
     /// Begin extending a mesh where the path interpolates a unique color per point.
-    pub fn color_per_point(mesh: &'a mut Mesh, transform: Mat4) -> Self {
-        Self::new(mesh, transform, ColorPerPoint)
-    }
-}
-
-impl<'a> MeshBuilder<'a, TexCoordsPerPoint> {
-    /// Begin extending a mesh where the path interpolates a unique texture coordinates per point.
-    pub fn tex_coords_per_point(mesh: &'a mut Mesh, transform: Mat4) -> Self {
-        Self::new(mesh, transform, TexCoordsPerPoint)
+    pub fn vertex_per_point(mesh: &'a mut Mesh, transform: Mat4) -> Self {
+        Self::new(mesh, transform, Vertex)
     }
 }
 
@@ -73,29 +63,11 @@ impl<'a, A> GeometryBuilder for MeshBuilder<'a, A> {
         self.begin_index_count = self.mesh.count_indices() as u32;
     }
 
-    fn end_geometry(&mut self) -> geometry_builder::Count {
-        geometry_builder::Count {
-            vertices: self.mesh.count_vertices() as u32 - self.begin_vertex_count,
-            indices: self.mesh.count_indices() as u32 - self.begin_index_count,
-        }
-    }
-
     fn add_triangle(&mut self, a: VertexId, b: VertexId, c: VertexId) {
-        let indices = self.mesh.indices_mut();
-        if let Some(indices) = indices {
-            match indices {
-                Indices::U16(indices) => {
-                    indices.push(a.to_usize() as u16);
-                    indices.push(b.to_usize() as u16);
-                    indices.push(c.to_usize() as u16);
-                }
-                Indices::U32(indices) => {
-                    indices.push(a.to_usize() as u32);
-                    indices.push(b.to_usize() as u32);
-                    indices.push(c.to_usize() as u32);
-                }
-            }
-        }
+        // Wind the indices in the opposite order to ensure the normals are facing outwards.
+        self.mesh.push_index(c.to_usize() as u32);
+        self.mesh.push_index(b.to_usize() as u32);
+        self.mesh.push_index(a.to_usize() as u32);
     }
 
     fn abort_geometry(&mut self) {
@@ -104,53 +76,6 @@ impl<'a, A> GeometryBuilder for MeshBuilder<'a, A> {
 }
 
 impl<'a> FillGeometryBuilder for MeshBuilder<'a, SingleColor> {
-    fn add_fill_vertex(&mut self, vertex: FillVertex) -> Result<VertexId, GeometryBuilderError> {
-        // Retrieve the index.
-        let id = VertexId::from_usize(self.mesh.count_vertices());
-
-        let position = vertex.position();
-
-        // Construct and insert the point
-        let p = Vec2::new(position.x, position.y).extend(0.0);
-        let point = self.transform.transform_point3(p);
-        let SingleColor(color) = self.attributes;
-        let tex_coords = Vec2::ZERO;
-
-        self.mesh.points_mut().push(point.to_array());
-        self.mesh.colors_mut().push(color.as_linear_rgba_f32());
-        self.mesh.tex_coords_mut().push(tex_coords.to_array());
-
-        // Return the index.
-        Ok(id)
-    }
-}
-
-impl<'a> StrokeGeometryBuilder for MeshBuilder<'a, SingleColor> {
-    fn add_stroke_vertex(
-        &mut self,
-        vertex: StrokeVertex,
-    ) -> Result<VertexId, GeometryBuilderError> {
-        // Retrieve the index.
-        let id = VertexId::from_usize(self.mesh.count_vertices());
-
-        let position = vertex.position();
-
-        // Construct and insert the point
-        let p = Vec2::new(position.x, position.y).extend(0.0);
-        let point = self.transform.transform_point3(p);
-        let SingleColor(color) = self.attributes;
-        let tex_coords = Vec2::ZERO;
-
-        self.mesh.points_mut().push(point.to_array());
-        self.mesh.colors_mut().push(color.as_linear_rgba_f32());
-        self.mesh.tex_coords_mut().push(tex_coords.to_array());
-
-        // Return the index.
-        Ok(id)
-    }
-}
-
-impl<'a> FillGeometryBuilder for MeshBuilder<'a, ColorPerPoint> {
     fn add_fill_vertex(
         &mut self,
         mut vertex: FillVertex,
@@ -163,20 +88,28 @@ impl<'a> FillGeometryBuilder for MeshBuilder<'a, ColorPerPoint> {
         // Construct and insert the point
         let p = Vec2::new(position.x, position.y).extend(0.0);
         let point = self.transform.transform_point3(p);
-        let col = vertex.interpolated_attributes();
-        let color = Vec4::new(col[0], col[1], col[2], col[3]);
-        let tex_coords = Vec2::ZERO;
+        let SingleColor(color) = self.attributes;
+        let attr = vertex.interpolated_attributes();
+        let tex_coords = if attr.is_empty() {
+            // TODO: we should add dummy uv's at a higher level.
+            [0.0, 0.0]
+        } else {
+            [attr[0], attr[1]]
+        };
 
         self.mesh.points_mut().push(point.to_array());
-        self.mesh.colors_mut().push(color.to_array());
-        self.mesh.tex_coords_mut().push(tex_coords.to_array());
+        self.mesh
+            .colors_mut()
+            .push(color.to_linear().to_f32_array());
+        self.mesh.tex_coords_mut().push(tex_coords);
+        self.mesh.normals_mut().push([0.0, 0.0, 1.0]);
 
         // Return the index.
         Ok(id)
     }
 }
 
-impl<'a> StrokeGeometryBuilder for MeshBuilder<'a, ColorPerPoint> {
+impl<'a> StrokeGeometryBuilder for MeshBuilder<'a, SingleColor> {
     fn add_stroke_vertex(
         &mut self,
         mut vertex: StrokeVertex,
@@ -189,20 +122,28 @@ impl<'a> StrokeGeometryBuilder for MeshBuilder<'a, ColorPerPoint> {
         // Construct and insert the point
         let p = Vec2::new(position.x, position.y).extend(0.0);
         let point = self.transform.transform_point3(p);
-        let col = vertex.interpolated_attributes();
-        let color = Vec4::new(col[0], col[1], col[2], col[3]);
-        let tex_coords = Vec2::ZERO;
+        let SingleColor(color) = self.attributes;
+        let attr = vertex.interpolated_attributes();
+        let tex_coords = if attr.is_empty() {
+            // TODO: we should add dummy uv's at a higher level.
+            [0.0, 0.0]
+        } else {
+            [attr[0], attr[1]]
+        };
 
         self.mesh.points_mut().push(point.to_array());
-        self.mesh.colors_mut().push(color.to_array());
-        self.mesh.tex_coords_mut().push(tex_coords.to_array());
+        self.mesh
+            .colors_mut()
+            .push(color.to_linear().to_f32_array());
+        self.mesh.tex_coords_mut().push(tex_coords);
+        self.mesh.normals_mut().push([0.0, 0.0, 1.0]);
 
         // Return the index.
         Ok(id)
     }
 }
 
-impl<'a> FillGeometryBuilder for MeshBuilder<'a, TexCoordsPerPoint> {
+impl<'a> FillGeometryBuilder for MeshBuilder<'a, Vertex> {
     fn add_fill_vertex(
         &mut self,
         mut vertex: FillVertex,
@@ -215,20 +156,21 @@ impl<'a> FillGeometryBuilder for MeshBuilder<'a, TexCoordsPerPoint> {
         // Construct and insert the point
         let p = Vec2::new(position.x, position.y).extend(0.0);
         let point = self.transform.transform_point3(p);
-        let tc = vertex.interpolated_attributes();
-        let tex_coords = Vec2::new(tc[0], tc[1]);
-        let color = Color::default();
+        let attr = vertex.interpolated_attributes();
+        let color = Vec4::new(attr[0], attr[1], attr[2], attr[3]);
+        let tex_coords = Vec2::new(attr[4], attr[5]);
 
         self.mesh.points_mut().push(point.to_array());
-        self.mesh.colors_mut().push(color.as_linear_rgba_f32());
+        self.mesh.colors_mut().push(color.to_array());
         self.mesh.tex_coords_mut().push(tex_coords.to_array());
+        self.mesh.normals_mut().push([0.0, 0.0, 1.0]);
 
         // Return the index.
         Ok(id)
     }
 }
 
-impl<'a> StrokeGeometryBuilder for MeshBuilder<'a, TexCoordsPerPoint> {
+impl<'a> StrokeGeometryBuilder for MeshBuilder<'a, Vertex> {
     fn add_stroke_vertex(
         &mut self,
         mut vertex: StrokeVertex,
@@ -241,13 +183,14 @@ impl<'a> StrokeGeometryBuilder for MeshBuilder<'a, TexCoordsPerPoint> {
         // Construct and insert the point
         let p = Vec2::new(position.x, position.y).extend(0.0);
         let point = self.transform.transform_point3(p);
-        let tc = vertex.interpolated_attributes();
-        let tex_coords = Vec2::new(tc[0], tc[1]);
-        let color = Color::default();
+        let attr = vertex.interpolated_attributes();
+        let color = Vec4::new(attr[0], attr[1], attr[2], attr[3]);
+        let tex_coords = Vec2::new(attr[4], attr[5]);
 
         self.mesh.points_mut().push(point.to_array());
-        self.mesh.colors_mut().push(color.as_linear_rgba_f32());
+        self.mesh.colors_mut().push(color.to_array());
         self.mesh.tex_coords_mut().push(tex_coords.to_array());
+        self.mesh.normals_mut().push([0.0, 0.0, 1.0]);
 
         // Return the index.
         Ok(id)
diff --git a/bevy_nannou_draw/src/draw/mesh/mod.rs b/bevy_nannou_draw/src/draw/mesh/mod.rs
index a6d8e7b6a..825bf1ddb 100644
--- a/bevy_nannou_draw/src/draw/mesh/mod.rs
+++ b/bevy_nannou_draw/src/draw/mesh/mod.rs
@@ -1,14 +1,15 @@
 //! Items related to the custom mesh type used by the `Draw` API.
 
-use bevy::prelude::*;
-use bevy::render::mesh::{Indices, PrimitiveTopology, VertexAttributeValues};
-use nannou_mesh::{ClearIndices, ClearVertices};
 use std::ops::{Deref, DerefMut};
 
-pub mod builder;
+use bevy::prelude::*;
+use bevy::render::mesh::{Indices, PrimitiveTopology, VertexAttributeValues};
+use bevy::render::render_asset::RenderAssetUsages;
 
 pub use self::builder::MeshBuilder;
 
+pub mod builder;
+
 pub trait MeshExt {
     fn init() -> Mesh;
     fn init_with_topology(topology: PrimitiveTopology) -> Mesh;
@@ -19,6 +20,8 @@ pub trait MeshExt {
     fn colors_mut(&mut self) -> &mut Vec<[f32; 4]>;
     fn tex_coords(&self) -> &[[f32; 2]];
     fn tex_coords_mut(&mut self) -> &mut Vec<[f32; 2]>;
+    fn normals(&self) -> &[[f32; 3]];
+    fn normals_mut(&mut self) -> &mut Vec<[f32; 3]>;
     fn get_index(&self, index: usize) -> u32;
     fn count_indices(&self) -> usize;
     fn push_index(&mut self, index: u32);
@@ -30,15 +33,28 @@ impl MeshExt for Mesh {
     }
 
     fn init_with_topology(topology: PrimitiveTopology) -> Mesh {
-        let mesh = Mesh::new(topology);
+        let mesh = Mesh::new(topology, RenderAssetUsages::default());
         mesh.with_inserted_attribute(Mesh::ATTRIBUTE_POSITION, Vec::<[f32; 3]>::new())
             .with_inserted_attribute(Mesh::ATTRIBUTE_COLOR, Vec::<[f32; 4]>::new())
             .with_inserted_attribute(Mesh::ATTRIBUTE_UV_0, Vec::<[f32; 2]>::new())
-            .with_indices(Some(Indices::U32(vec![])))
+            .with_inserted_attribute(Mesh::ATTRIBUTE_NORMAL, Vec::<[f32; 3]>::new())
+            .with_inserted_indices(Indices::U32(vec![]))
     }
 
     fn clear(&mut self) {
-        *self = Self::init();
+        for (_, attribute) in self.attributes_mut().into_iter() {
+            match attribute {
+                VertexAttributeValues::Float32x2(attr) => attr.clear(),
+                VertexAttributeValues::Float32x3(attr) => attr.clear(),
+                VertexAttributeValues::Float32x4(attr) => attr.clear(),
+                _ => panic!("Unsupported attribute type"),
+            }
+        }
+
+        self.indices_mut().map(|indices| match indices {
+            Indices::U32(indices) => indices.clear(),
+            _ => panic!("Unsupported indices type"),
+        });
     }
 
     fn points(&self) -> &[[f32; 3]] {
@@ -107,6 +123,28 @@ impl MeshExt for Mesh {
         }
     }
 
+    fn normals(&self) -> &[[f32; 3]] {
+        let normals = self
+            .attribute(Mesh::ATTRIBUTE_NORMAL)
+            .expect("Mesh must have ATTRIBUTE_NORMAL attribute");
+
+        match normals {
+            VertexAttributeValues::Float32x3(normals) => normals,
+            _ => panic!("Mesh ATTRIBUTE_NORMAL attribute must be of type Float32x3"),
+        }
+    }
+
+    fn normals_mut(&mut self) -> &mut Vec<[f32; 3]> {
+        let normals = self
+            .attribute_mut(Mesh::ATTRIBUTE_NORMAL)
+            .expect("Mesh must have ATTRIBUTE_NORMAL attribute");
+
+        match normals {
+            VertexAttributeValues::Float32x3(normals) => normals,
+            _ => panic!("Mesh ATTRIBUTE_NORMAL attribute must be of type Float32x3"),
+        }
+    }
+
     fn get_index(&self, index: usize) -> u32 {
         match self.indices() {
             Some(Indices::U32(indices)) => indices[index],
diff --git a/bevy_nannou_draw/src/draw/mod.rs b/bevy_nannou_draw/src/draw/mod.rs
index c51440d1e..97a2a1a10 100644
--- a/bevy_nannou_draw/src/draw/mod.rs
+++ b/bevy_nannou_draw/src/draw/mod.rs
@@ -1,19 +1,25 @@
 //! A simple API for drawing 2D and 3D graphics.
 //!
-//! See the [**Draw** type](./struct.Draw.html) for more details.
+//! See the [Draw] for more details.
 
-use std::cell::RefCell;
-use std::collections::HashMap;
-use std::mem;
-use std::rc::Rc;
+use std::any::{Any, TypeId};
+use std::marker::PhantomData;
+use std::ops::{Deref, DerefMut};
 use std::sync::{Arc, RwLock};
 
-use crate::draw::mesh::MeshExt;
+use bevy::asset::UntypedAssetId;
+use bevy::ecs::world::Command;
 use bevy::prelude::*;
 use bevy::render::render_resource as wgpu;
+use bevy::render::render_resource::{BlendComponent, BlendState};
+use bevy::utils::{HashMap, HashSet};
 use lyon::path::PathEvent;
-use nannou_core::geom;
-use nannou_mesh::Clear;
+use uuid::Uuid;
+
+use crate::draw::instanced::{InstanceMaterialData, Instanced};
+use crate::draw::mesh::MeshExt;
+use crate::draw::render::RenderPrimitive;
+use crate::render::DefaultNannouMaterial;
 
 pub use self::background::Background;
 pub use self::drawing::{Drawing, DrawingContext};
@@ -22,101 +28,137 @@ pub use self::theme::Theme;
 
 pub mod background;
 mod drawing;
+pub mod instanced;
 pub mod mesh;
 pub mod primitive;
 pub mod properties;
-pub mod render;
+pub(crate) mod render;
 pub mod theme;
 
 /// A simple API for drawing 2D and 3D graphics.
 ///
-/// **Draw** provides a simple way to compose together geometry and text with custom colours and
+/// [Draw] provides a simple way to compose together geometry and text with custom colours and
 /// textures and draw them to the screen. A suite of methods have been provided for drawing
 /// polygons, paths, meshes, text and textures in an accessible-yet-efficient manner.
 ///
-/// **Draw** can also be used to create new **Draw** instances that refer to the same inner draw
+/// [Draw] can also be used to create new [Draw] instances that refer to the same inner draw
 /// state but are slightly different from one another. E.g. `draw.rotate(radians)` produces a new
-/// **Draw** instance where all drawings will be rotated by the given amount. `draw.x(x)` produces
-/// a new **Draw** instance where all drawings are translated along the *x* axis by the given
+/// [Draw] instance where all drawings will be rotated by the given amount. `draw.x(x)` produces
+/// a new [Draw] instance where all drawings are translated along the *x* axis by the given
 /// amount.
 ///
 /// See the [draw](https://github.com/nannou-org/nannou/blob/master/examples) examples for a
-/// variety of demonstrations of how the **Draw** type can be used!
-#[derive(Clone, Debug)]
-pub struct Draw {
-    /// The state of the **Draw**.
+/// variety of demonstrations of how the [Draw] type can be used!
+#[derive(Clone)]
+pub struct Draw<M = DefaultNannouMaterial>
+where
+    M: Material + Default,
+{
+    /// The state of the [Draw].
     ///
-    /// State is shared between this **Draw** instance and all other **Draw** instances that were
+    /// State is shared between this [Draw] instance and all other [Draw] instances that were
     /// produced by cloning or changing transform, scissor or blend mode.
     ///
     /// We use a `RefCell` in order to avoid requiring a `mut` handle to a `draw`. The primary
-    /// purpose of a **Draw** is to be an easy-as-possible, high-level API for drawing stuff. In
+    /// purpose of a [Draw] is to be an easy-as-possible, high-level API for drawing stuff. In
     /// order to be friendlier to new users, we want to avoid them having to think about mutability
     /// and focus on creativity. Rust-lang nuances can come later.
     pub state: Arc<RwLock<State>>,
-    /// The current context of this **Draw** instance.
-    context: Context,
+    /// The current context of this [Draw] instance.
+    context: DrawContext,
+    /// The current material of this [Draw] instance.
+    material: UntypedAssetId,
+    /// The window to which this [Draw] instance is associated.
+    pub(crate) window: Entity,
+    /// The type of material used by this [Draw] instance.
+    _material: PhantomData<M>,
+}
+
+/// A reference to a [Draw] instance that is either borrowed or owned.
+#[derive(Clone)]
+pub enum DrawRef<'a, M>
+where
+    M: Material + Default,
+{
+    Borrowed(&'a Draw<M>),
+    Owned(Draw<M>),
+}
+
+impl<'a, M> Deref for DrawRef<'a, M>
+where
+    M: Material + Default,
+{
+    type Target = Draw<M>;
+
+    fn deref(&self) -> &Self::Target {
+        match self {
+            DrawRef::Borrowed(draw) => *draw,
+            DrawRef::Owned(draw) => draw,
+        }
+    }
 }
 
-/// The current **Transform**, alpha **BlendState** and **Scissor** of a **Draw** instance.
+/// The current **Transform** of a [Draw] instance.
 #[derive(Clone, Debug, PartialEq)]
-pub struct Context {
+pub struct DrawContext {
+    // TODO: figure out how to fixup camera via transform
     pub transform: Mat4,
-    pub blend: wgpu::BlendState,
-    pub scissor: Scissor,
-    // TODO: Consider changing `PolygonMode` (added as of wgpu 0.7) rather than `PrimitiveTopology`
-    // here.
-    pub topology: wgpu::PrimitiveTopology,
 }
 
-/// Commands generated by drawings.
-///
-/// During rendering, the list of **DrawCommand**s are converted into a list of **RenderCommands**
-/// that are directly associated with encodable render pass commands.
+impl Default for DrawContext {
+    fn default() -> Self {
+        Self {
+            transform: Mat4::IDENTITY,
+        }
+    }
+}
+
+/// Commands generated by drawing that instruct how to create the meshes and materials that will be
+/// rendered.
 #[derive(Clone, Debug)]
 pub enum DrawCommand {
     /// Draw a primitive.
     Primitive(Primitive),
+    /// Draw an instanced primitive
+    Instanced(Primitive, InstanceMaterialData),
     /// A change in the rendering context occurred.
-    Context(Context),
-}
-
-/// The scissor for a **Draw**'s render context.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum Scissor {
-    /// The extent of the scissor matches the bounds of the target texture.
-    Full,
-    /// Crop the view to the given rect.
-    Rect(geom::Rect),
-    /// The scissor has no overlap with the previous window, resulting in nothing to draw.
-    NoOverlap,
+    Context(DrawContext),
+    /// A change in the material occurred.
+    Material(UntypedAssetId),
+    /// A change in the background color occurred.
+    BackgroundColor(Color),
 }
 
-/// The inner state of the **Draw** type.
+/// The inner state of the [Draw] type.
 ///
-/// The **Draw** type stores its **State** behind a **RefCell** - a type used for moving mutability
+/// The [Draw] type stores its [State] behind a [RwLock] - a type used for moving mutability
 /// checks from compile time to runtime. We do this in order to avoid requiring a `mut` handle to a
-/// `draw`. The primary purpose of a **Draw** is to be an easy-as-possible, high-level API for
+/// `draw`. The primary purpose of a [Draw] is to be an easy-as-possible, high-level API for
 /// drawing stuff. In order to be friendlier to new users, we want to avoid requiring them to think
 /// about mutability and instead focus on creativity. Rust-lang nuances can come later.
-#[derive(Clone, Debug)]
 pub struct State {
+    /// The last material used to draw an image, used to detect changes and emit commands for them.
+    last_material: Option<UntypedAssetId>,
     /// The last context used to draw an image, used to detect changes and emit commands for them.
-    last_draw_context: Option<Context>,
-    /// If `Some`, the **Draw** should first clear the frame's texture with the given color.
+    last_draw_context: Option<DrawContext>,
+    /// If `Some`, the [Draw] should first clear the frame's texture with the given color.
     background_color: Option<Color>,
     /// Primitives that are in the process of being drawn.
     ///
     /// Keys are indices into the `draw_commands` Vec.
     drawing: HashMap<usize, Primitive>,
+    /// A map of all type erased materials used by the draw.
+    pub(crate) materials: HashMap<UntypedAssetId, Box<dyn Any + Send + Sync>>,
+    /// A list of indices of primitives that are being drawn as instances and should not be drawn
+    instanced: HashSet<usize>,
     /// The list of recorded draw commands.
     ///
     /// An element may be `None` if it is a primitive in the process of being drawn.
-    draw_commands: Vec<Option<DrawCommand>>,
+    pub(crate) draw_commands: Vec<Option<DrawCommand>>,
     /// State made accessible via the `DrawingContext`.
-    pub intermediary_state: Arc<RwLock<IntermediaryState>>,
+    pub(crate) intermediary_state: Arc<RwLock<IntermediaryState>>,
     /// The theme containing default values.
-    pub theme: Theme,
+    pub(crate) theme: Theme,
 }
 
 /// State made accessible via the `DrawingContext`.
@@ -126,10 +168,8 @@ pub struct IntermediaryState {
     pub intermediary_mesh: Mesh,
     /// A re-usable buffer for collecting path events.
     pub path_event_buffer: Vec<PathEvent>,
-    /// A re-usable buffer for collecting colored polyline points.
-    pub path_points_colored_buffer: Vec<(Vec2, Color)>,
-    /// A re-usable buffer for collecting textured polyline points.
-    pub path_points_textured_buffer: Vec<(Vec2, Vec2)>,
+    /// A re-usable buffer for collecting polyline points vertex data.
+    pub path_points_vertex_buffer: Vec<(Vec2, Color, Vec2)>,
     /// A buffer containing all text.
     pub text_buffer: String,
 }
@@ -138,8 +178,7 @@ impl IntermediaryState {
     pub fn reset(&mut self) {
         self.intermediary_mesh.clear();
         self.path_event_buffer.clear();
-        self.path_points_colored_buffer.clear();
-        self.path_points_textured_buffer.clear();
+        self.path_points_vertex_buffer.clear();
         self.text_buffer.clear();
     }
 }
@@ -147,27 +186,31 @@ impl IntermediaryState {
 impl State {
     // Resets all state within the `Draw` instance.
     fn reset(&mut self) {
-        self.background_color = None;
+        self.last_material = None;
         self.last_draw_context = None;
+        self.background_color = None;
         self.drawing.clear();
+        self.materials.clear();
         self.draw_commands.clear();
-        self.intermediary_state
-            .write()
-            .expect("lock poisoned")
-            .reset();
+        self.intermediary_state.write().unwrap().reset();
     }
 
     // Drain any remaining `drawing`s and insert them as draw commands.
     fn finish_remaining_drawings(&mut self) {
-        let mut drawing = mem::replace(&mut self.drawing, Default::default());
+        let mut drawing = std::mem::replace(&mut self.drawing, Default::default());
         for (index, primitive) in drawing.drain() {
             self.insert_draw_command(index, primitive);
         }
-        mem::swap(&mut self.drawing, &mut drawing);
+        std::mem::swap(&mut self.drawing, &mut drawing);
     }
 
     // Finish the drawing at the given node index if it is not yet complete.
     pub(crate) fn finish_drawing(&mut self, index: usize) {
+        // Don't draw if the primitive is going to be instanced
+        if self.instanced.contains(&index) {
+            return;
+        }
+
         if let Some(primitive) = self.drawing.remove(&index) {
             self.insert_draw_command(index, primitive);
         }
@@ -181,24 +224,51 @@ impl State {
     }
 }
 
-impl Draw {
-    /// Create a new **Draw** instance.
-    ///
-    /// This is the same as calling **Draw::default**.
-    pub fn new() -> Self {
-        Self::default()
+impl<M> Draw<M>
+where
+    M: Material + Default,
+{
+    pub fn new(window: Entity) -> Self {
+        let mut state = State::default();
+        let context = DrawContext::default();
+        let material = M::default();
+        let material_id = UntypedAssetId::Uuid {
+            type_id: TypeId::of::<M>(),
+            uuid: Uuid::new_v4(),
+        };
+        state.materials.insert(material_id, Box::new(material));
+
+        Draw {
+            state: Arc::new(RwLock::new(state)),
+            context,
+            material: material_id,
+            window,
+            _material: PhantomData,
+        }
     }
 
     /// Resets all state within the `Draw` instance.
-    pub fn reset(&self) {
-        self.state.write().expect("lock poisoned").reset();
+    pub fn reset(&mut self) {
+        self.state.write().unwrap().reset();
+        self.insert_default_material();
+    }
+
+    fn insert_default_material(&mut self) {
+        let mut state = self.state.write().unwrap();
+        let material = M::default();
+        let material_id = UntypedAssetId::Uuid {
+            type_id: TypeId::of::<M>(),
+            uuid: Uuid::new_v4(),
+        };
+        state.materials.insert(material_id, Box::new(material));
+        self.material = material_id;
     }
 
     // Context changes.
 
-    /// Produce a new **Draw** instance transformed by the given transform matrix.
+    /// Produce a new [Draw] instance transformed by the given transform matrix.
     ///
-    /// The resulting **Draw** instance will be have a transform equal to the new transform applied
+    /// The resulting [Draw] instance will be have a transform equal to the new transform applied
     /// to the existing transform.
     pub fn transform(&self, transform_matrix: Mat4) -> Self {
         let mut context = self.context.clone();
@@ -248,30 +318,30 @@ impl Draw {
         self.x_y_z(0.0, 0.0, z)
     }
 
-    /// Produce a new **Draw** instance where the contents are scaled uniformly by the given value.
+    /// Produce a new [Draw] instance where the contents are scaled uniformly by the given value.
     pub fn scale(&self, s: f32) -> Self {
         self.scale_axes(Vec3::new(s, s, s))
     }
 
-    /// Produce a new **Draw** instance where the contents are scaled by the given amount across
+    /// Produce a new [Draw] instance where the contents are scaled by the given amount across
     /// each axis.
     pub fn scale_axes(&self, v: Vec3) -> Self {
         self.transform(Mat4::from_scale(v))
     }
 
-    /// Produce a new **Draw** instance where the contents are scaled by the given amount along the
+    /// Produce a new [Draw] instance where the contents are scaled by the given amount along the
     /// x axis
     pub fn scale_x(&self, s: f32) -> Self {
         self.scale_axes(Vec3::new(s, 1.0, 1.0))
     }
 
-    /// Produce a new **Draw** instance where the contents are scaled by the given amount along the
+    /// Produce a new [Draw] instance where the contents are scaled by the given amount along the
     /// y axis
     pub fn scale_y(&self, s: f32) -> Self {
         self.scale_axes(Vec3::new(1.0, s, 1.0))
     }
 
-    /// Produce a new **Draw** instance where the contents are scaled by the given amount along the
+    /// Produce a new [Draw] instance where the contents are scaled by the given amount along the
     /// z axis
     pub fn scale_z(&self, s: f32) -> Self {
         self.scale_axes(Vec3::new(1.0, 1.0, s))
@@ -383,116 +453,76 @@ impl Draw {
         self.z_radians(radians)
     }
 
-    /// Produce a new **Draw** instance that will draw with the given alpha blend descriptor.
-    pub fn alpha_blend(&self, blend_descriptor: wgpu::BlendComponent) -> Self {
-        let mut context = self.context.clone();
-        context.blend.alpha = blend_descriptor;
-        self.context(context)
-    }
-
-    /// Produce a new **Draw** instance that will draw with the given color blend descriptor.
-    pub fn color_blend(&self, blend_descriptor: wgpu::BlendComponent) -> Self {
-        let mut context = self.context.clone();
-        context.blend.color = blend_descriptor;
-        self.context(context)
+    /// Produce a new [Draw] instance with the given context.
+    fn context(&self, context: DrawContext) -> Draw<M> {
+        let state = self.state.clone();
+        let material = self.material.clone();
+        let window = self.window;
+        Draw {
+            state,
+            context,
+            material,
+            window,
+            _material: PhantomData,
+        }
     }
 
-    /// Short-hand for `color_blend`, the common use-case.
-    pub fn blend(&self, blend_descriptor: wgpu::BlendComponent) -> Self {
-        self.color_blend(blend_descriptor)
+    fn clone_material(&self) -> M {
+        let mut state = self.state.write().unwrap();
+        let material = state.materials.get_mut(&self.material).unwrap();
+        material
+            .downcast_ref::<M>()
+            .expect("Expected material to be of the correct type")
+            .clone()
     }
 
-    /// Produce a new **Draw** instance that will be cropped to the given rectangle.
-    ///
-    /// If the current **Draw** instance already contains a scissor, the result will be the overlap
-    /// between the original scissor and the new one.
-    pub fn scissor(&self, scissor: geom::Rect<f32>) -> Self {
-        let mut context = self.context.clone();
-        context.scissor = match context.scissor {
-            Scissor::Full => Scissor::Rect(scissor),
-            Scissor::Rect(rect) => rect
-                .overlap(scissor)
-                .map(Scissor::Rect)
-                .unwrap_or(Scissor::NoOverlap),
-            Scissor::NoOverlap => Scissor::NoOverlap,
+    /// Produce a new [Draw] instance with a new material type.
+    pub fn material<M2: Material + Default>(&self, material: M2) -> Draw<M2> {
+        let context = self.context.clone();
+        let DrawContext { transform, .. } = context;
+        let context = DrawContext { transform };
+        let state = self.state.clone();
+        let window = self.window;
+        let material_id = UntypedAssetId::Uuid {
+            type_id: TypeId::of::<M2>(),
+            uuid: Uuid::new_v4(),
         };
-        self.context(context)
-    }
-
-    /// Produce a new **Draw** instance.
-    ///
-    /// All drawing that occurs on the new instance will be rendered as a "wireframe" between all
-    /// vertices.
-    ///
-    /// This will cause the **draw::Renderer** to switch render pipelines in order to use the
-    /// **LineList** primitive topology. The switch will only occur if this topology was not
-    /// already enabled.
-    pub fn line_mode(&self) -> Self {
-        self.primitive_topology(wgpu::PrimitiveTopology::LineList)
-    }
 
-    /// Produce a new **Draw** instance.
-    ///
-    /// All drawing that occurs on the new instance will be rendered as points on the vertices.
-    ///
-    /// This will cause the **draw::Renderer** to switch render pipelines in order to use the
-    /// **PointList** primitive topology. The switch will only occur if this topology was not
-    /// already enabled.
-    pub fn point_mode(&self) -> Self {
-        self.primitive_topology(wgpu::PrimitiveTopology::PointList)
-    }
-
-    /// Produce a new **Draw** instance.
-    ///
-    /// All drawing that occurs on the new instance will be rendered as triangles on the vertices.
-    ///
-    /// This will cause the **draw::Renderer** to switch render pipelines in order to use the
-    /// **TriangleList** primitive topology. The switch will only occur if this topology was not
-    /// already enabled.
-    ///
-    /// This is the default primitive topology mode.
-    pub fn triangle_mode(&self) -> Self {
-        self.primitive_topology(wgpu::PrimitiveTopology::TriangleList)
-    }
-
-    // /// Produce a new **Draw** instance where all textures and textured vertices drawn will be
-    // /// sampled via a sampler of the given descriptor.
-    // pub fn sampler(&self, desc: wgpu::SamplerDescriptor<'static>) -> Self {
-    //     let mut context = self.context.clone();
-    //     context.sampler = desc;
-    //     self.context(context)
-    // }
-
-    /// Specify the primitive topology to use within the render pipeline.
-    ///
-    /// This method is shared between the `line_mode`, `point_mode` and `triangle_mode` methods.
-    fn primitive_topology(&self, topology: wgpu::PrimitiveTopology) -> Self {
-        let mut context = self.context.clone();
-        context.topology = topology;
-        self.context(context)
-    }
-
-    /// Produce a new **Draw** instance with the given context.
-    fn context(&self, context: Context) -> Self {
-        let state = self.state.clone();
-        Draw { state, context }
+        state
+            .write()
+            .unwrap()
+            .materials
+            .insert(material_id, Box::new(material));
+
+        Draw {
+            state,
+            context,
+            material: material_id,
+            window,
+            _material: PhantomData,
+        }
     }
 
     // Primitives.
 
     /// Specify a color with which the background should be cleared.
-    pub fn background(&self) -> Background {
+    pub fn background<'a>(&'a self) -> Background<'a, M> {
         background::new(self)
     }
 
+    /// Draw an instanced drawing
+    pub fn instanced<'a>(&'a self) -> Instanced<'a, M> {
+        instanced::new(self)
+    }
+
     /// Add the given type to be drawn.
-    pub fn a<T>(&self, primitive: T) -> Drawing<T>
+    pub fn a<T>(&self, primitive: T) -> Drawing<T, M>
     where
         T: Into<Primitive>,
         Primitive: Into<Option<T>>,
     {
-        let index = {
-            let mut state = self.state.write().expect("lock poisoned");
+        let (index, material_index) = {
+            let mut state = self.state.write().unwrap();
             // If drawing with a different context, insert the necessary command to update it.
             if state.last_draw_context.as_ref() != Some(&self.context) {
                 state
@@ -500,70 +530,83 @@ impl Draw {
                     .push(Some(DrawCommand::Context(self.context.clone())));
                 state.last_draw_context = Some(self.context.clone());
             }
+
+            let id = &self.material;
+            if state.last_material.as_ref() != Some(id) {
+                state
+                    .draw_commands
+                    .push(Some(DrawCommand::Material(id.clone())));
+                state.last_material = Some(id.clone());
+            }
+
+            // Insert a material slot to be used if the drawing switches materials.
+            let material_index = state.draw_commands.len();
+            state.draw_commands.push(None);
+
             // The primitive will be inserted in the next element.
             let index = state.draw_commands.len();
             let primitive: Primitive = primitive.into();
             state.draw_commands.push(None);
             state.drawing.insert(index, primitive);
-            index
+            (index, material_index)
         };
-        drawing::new(self, index)
+        drawing::new(self, index, material_index)
     }
 
     /// Begin drawing a **Path**.
-    pub fn path(&self) -> Drawing<primitive::PathInit> {
+    pub fn path(&self) -> Drawing<primitive::PathInit, M> {
         self.a(Default::default())
     }
 
     /// Begin drawing an **Ellipse**.
-    pub fn ellipse(&self) -> Drawing<primitive::Ellipse> {
+    pub fn ellipse(&self) -> Drawing<primitive::Ellipse, M> {
         self.a(Default::default())
     }
 
     /// Begin drawing a **Line**.
-    pub fn line(&self) -> Drawing<primitive::Line> {
+    pub fn line(&self) -> Drawing<primitive::Line, M> {
         self.a(Default::default())
     }
 
     /// Begin drawing an **Arrow**.
-    pub fn arrow(&self) -> Drawing<primitive::Arrow> {
+    pub fn arrow(&self) -> Drawing<primitive::Arrow, M> {
         self.a(Default::default())
     }
 
     /// Begin drawing a **Quad**.
-    pub fn quad(&self) -> Drawing<primitive::Quad> {
+    pub fn quad(&self) -> Drawing<primitive::Quad, M> {
         self.a(Default::default())
     }
 
     /// Begin drawing a **Rect**.
-    pub fn rect(&self) -> Drawing<primitive::Rect> {
+    pub fn rect(&self) -> Drawing<primitive::Rect, M> {
         self.a(Default::default())
     }
 
     /// Begin drawing a **Triangle**.
-    pub fn tri(&self) -> Drawing<primitive::Tri> {
+    pub fn tri(&self) -> Drawing<primitive::Tri, M> {
         self.a(Default::default())
     }
 
     /// Begin drawing a **Polygon**.
-    pub fn polygon(&self) -> Drawing<primitive::PolygonInit> {
+    pub fn polygon(&self) -> Drawing<primitive::PolygonInit, M> {
         self.a(Default::default())
     }
 
     /// Begin drawing a **Mesh**.
-    pub fn mesh(&self) -> Drawing<primitive::mesh::Vertexless> {
+    pub fn mesh(&self) -> Drawing<primitive::mesh::Vertexless, M> {
         self.a(Default::default())
     }
 
     /// Begin drawing a **Polyline**.
     ///
     /// Note that this is simply short-hand for `draw.path().stroke()`
-    pub fn polyline(&self) -> Drawing<primitive::PathStroke> {
+    pub fn polyline(&self) -> Drawing<primitive::PathStroke, M> {
         self.path().stroke()
     }
 
     /// Begin drawing a **Text**.
-    pub fn text(&self, s: &str) -> Drawing<primitive::Text> {
+    pub fn text(&self, s: &str) -> Drawing<primitive::Text, M> {
         let text = {
             let state = self.state.read().expect("lock poisoned");
             let mut intermediary_state = state.intermediary_state.write().expect("lock poisoned");
@@ -573,27 +616,12 @@ impl Draw {
         self.a(text)
     }
 
-    /// Begin drawing a **Texture**.
-    // TODO: this api sucks, because it requires the user to wait for the texture to load before
-    // they can draw it. We should provide a way to draw a texture without waiting for it to load.
-    // This is mostly due to the image size being unknown until the texture is loaded.
-    pub fn texture(
-        &self,
-        texture_handle: Handle<Image>,
-        texture: Image,
-    ) -> Drawing<primitive::Texture> {
-        self.a(primitive::Texture::new(texture_handle, texture))
-    }
-
     /// Finish any drawings-in-progress and produce an iterator draining the inner draw commands
     /// and yielding them by value.
     pub fn drain_commands(&self) -> impl Iterator<Item = DrawCommand> {
         self.finish_remaining_drawings();
         let cmds = {
-            let mut state = self
-                .state
-                .write()
-                .expect("failed to lock state for writing");
+            let mut state = self.state.write().unwrap();
             let empty = Vec::with_capacity(state.draw_commands.len());
             std::mem::replace(&mut state.draw_commands, empty)
         };
@@ -602,10 +630,44 @@ impl Draw {
 
     /// Drain any remaining `drawing`s and convert them to draw commands.
     pub fn finish_remaining_drawings(&self) {
-        self.state
-            .write()
-            .expect("lock poisoned")
-            .finish_remaining_drawings()
+        let mut state = self.state.write().unwrap();
+        state.finish_remaining_drawings()
+    }
+}
+
+impl Draw<DefaultNannouMaterial> {
+    /// Produce a new [Draw] instance that will draw with the given alpha blend descriptor.
+    pub fn alpha_blend(&self, blend_descriptor: wgpu::BlendComponent) -> Self {
+        // TODO: check if blend is already set and only update if necessary
+        let mut mat = self.clone_material().clone();
+        mat.extension.blend = Some(BlendState {
+            color: BlendComponent::REPLACE,
+            alpha: blend_descriptor,
+        });
+        self.material(mat)
+    }
+
+    /// Produce a new [Draw] instance that will draw with the given color blend descriptor.
+    pub fn color_blend(&self, blend_descriptor: wgpu::BlendComponent) -> Self {
+        // TODO: check if blend is already set and only update if necessary
+        let mut mat = self.clone_material().clone();
+        mat.extension.blend = Some(BlendState {
+            color: blend_descriptor,
+            alpha: BlendComponent::REPLACE,
+        });
+        self.material(mat)
+    }
+
+    /// Short-hand for `color_blend`, the common use-case.
+    pub fn blend(&self, blend_descriptor: wgpu::BlendComponent) -> Self {
+        self.color_blend(blend_descriptor)
+    }
+
+    /// Produce a new [Draw] instance that will use the given polygon mode.
+    pub fn polygon_mode(&self, polygon_mode: wgpu::PolygonMode) -> Self {
+        let mut mat = self.clone_material().clone();
+        mat.extension.polygon_mode = polygon_mode;
+        self.material(mat)
     }
 }
 
@@ -613,14 +675,12 @@ impl Default for IntermediaryState {
     fn default() -> Self {
         let intermediary_mesh = Mesh::init();
         let path_event_buffer = Default::default();
-        let path_points_colored_buffer = Default::default();
-        let path_points_textured_buffer = Default::default();
+        let path_points_vertex_buffer = Default::default();
         let text_buffer = Default::default();
         IntermediaryState {
             intermediary_mesh,
             path_event_buffer,
-            path_points_colored_buffer,
-            path_points_textured_buffer,
+            path_points_vertex_buffer,
             text_buffer,
         }
     }
@@ -628,49 +688,23 @@ impl Default for IntermediaryState {
 
 impl Default for State {
     fn default() -> Self {
+        let last_material = None;
         let last_draw_context = None;
         let background_color = Default::default();
         let draw_commands = Default::default();
         let drawing = Default::default();
-        let intermediary_state = Arc::new(RwLock::new(Default::default()));
+        let intermediary_state = Arc::new(Default::default());
         let theme = Default::default();
         State {
+            last_material,
             last_draw_context,
             draw_commands,
             drawing,
             intermediary_state,
             theme,
             background_color,
-        }
-    }
-}
-
-impl Default for Draw {
-    fn default() -> Self {
-        let state: Arc<RwLock<State>> = Arc::new(RwLock::new(Default::default()));
-        let context = Default::default();
-        Draw { state, context }
-    }
-}
-
-impl Default for Context {
-    fn default() -> Self {
-        Self {
-            transform: Mat4::IDENTITY,
-            blend: wgpu::BlendState {
-                color: wgpu::BlendComponent {
-                    src_factor: wgpu::BlendFactor::SrcAlpha,
-                    dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
-                    operation: wgpu::BlendOperation::Add,
-                },
-                alpha: wgpu::BlendComponent {
-                    src_factor: wgpu::BlendFactor::SrcAlpha,
-                    dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
-                    operation: wgpu::BlendOperation::Add,
-                },
-            },
-            scissor: Scissor::Full,
-            topology: wgpu::PrimitiveTopology::TriangleList,
+            instanced: Default::default(),
+            materials: Default::default(),
         }
     }
 }
diff --git a/bevy_nannou_draw/src/draw/primitive/arrow.rs b/bevy_nannou_draw/src/draw/primitive/arrow.rs
index e70dc5211..eb6bbf4cc 100644
--- a/bevy_nannou_draw/src/draw/primitive/arrow.rs
+++ b/bevy_nannou_draw/src/draw/primitive/arrow.rs
@@ -1,11 +1,12 @@
+use bevy::prelude::*;
+use lyon::tessellation::StrokeOptions;
+
 use crate::draw::primitive::path;
 use crate::draw::primitive::Line;
 use crate::draw::primitive::Primitive;
 use crate::draw::properties::spatial::{orientation, position};
 use crate::draw::properties::{SetColor, SetOrientation, SetPosition, SetStroke};
 use crate::draw::{self, Drawing};
-use bevy::prelude::*;
-use lyon::tessellation::StrokeOptions;
 
 /// A path containing only two points - a start and end.
 ///
@@ -18,7 +19,7 @@ pub struct Arrow {
 }
 
 /// The drawing context for a line.
-pub type DrawingArrow<'a> = Drawing<'a, Arrow>;
+pub type DrawingArrow<'a, M> = Drawing<'a, Arrow, M>;
 
 impl Arrow {
     /// Short-hand for the `stroke_weight` method.
@@ -83,7 +84,10 @@ impl Arrow {
     }
 }
 
-impl<'a> DrawingArrow<'a> {
+impl<'a, M> DrawingArrow<'a, M>
+where
+    M: Material + Default,
+{
     /// Short-hand for the `stroke_weight` method.
     pub fn weight(self, weight: f32) -> Self {
         self.map_ty(|ty| ty.weight(weight))
@@ -166,11 +170,7 @@ impl Into<Option<Arrow>> for Primitive {
 }
 
 impl draw::render::RenderPrimitive for Arrow {
-    fn render_primitive(
-        self,
-        mut ctxt: draw::render::RenderContext,
-        mesh: &mut Mesh,
-    ) -> draw::render::PrimitiveRender {
+    fn render_primitive(self, mut ctxt: draw::render::RenderContext, mesh: &mut Mesh) {
         let Arrow {
             line,
             head_length,
@@ -179,7 +179,7 @@ impl draw::render::RenderPrimitive for Arrow {
         let start = line.start.unwrap_or(Vec2::new(0.0, 0.0));
         let end = line.end.unwrap_or(Vec2::new(0.0, 0.0));
         if start == end {
-            return draw::render::PrimitiveRender::default();
+            return;
         }
 
         // Calculate the arrow head points.
@@ -209,11 +209,19 @@ impl draw::render::RenderPrimitive for Arrow {
 
         // Draw the tri.
         let tri_points = [tri_a, tri_b, tri_c];
-        let tri_points = tri_points.iter().cloned().map(|p| p.to_array().into());
+        let tri_tex_coords = [
+            Vec2::new(0.5, 1.0), // Tip of the arrowhead
+            Vec2::new(0.0, 0.0), // Left corner
+            Vec2::new(1.0, 0.0), // Right corner
+        ];
+        let tri_points = tri_points
+            .iter()
+            .cloned()
+            .zip(tri_tex_coords.iter().copied());
         let close_tri = true;
-        let tri_events = lyon::path::iterator::FromPolyline::new(close_tri, tri_points);
-        path::render_path_events(
-            tri_events,
+        path::render_path_points_themed(
+            tri_points,
+            close_tri,
             line.path.color,
             transform,
             path::Options::Fill(Default::default()),
@@ -227,11 +235,15 @@ impl draw::render::RenderPrimitive for Arrow {
         // Draw the line.
         if draw_line {
             let line_points = [line_start, line_end];
-            let line_points = line_points.iter().cloned().map(|p| p.to_array().into());
+            let line_tex_coords = [Vec2::new(0.0, 0.0), Vec2::new(1.0, 0.0)];
+            let line_points = line_points
+                .iter()
+                .cloned()
+                .zip(line_tex_coords.iter().copied());
             let close_line = false;
-            let line_events = lyon::path::iterator::FromPolyline::new(close_line, line_points);
-            path::render_path_events(
-                line_events,
+            path::render_path_points_themed(
+                line_points,
+                close_line,
                 line.path.color,
                 transform,
                 path::Options::Stroke(line.path.opts),
@@ -242,8 +254,6 @@ impl draw::render::RenderPrimitive for Arrow {
                 mesh,
             );
         }
-
-        draw::render::PrimitiveRender::default()
     }
 }
 
diff --git a/bevy_nannou_draw/src/draw/primitive/ellipse.rs b/bevy_nannou_draw/src/draw/primitive/ellipse.rs
index ee960e002..287989c78 100644
--- a/bevy_nannou_draw/src/draw/primitive/ellipse.rs
+++ b/bevy_nannou_draw/src/draw/primitive/ellipse.rs
@@ -1,3 +1,8 @@
+use bevy::prelude::*;
+use lyon::tessellation::StrokeOptions;
+
+use nannou_core::geom;
+
 use crate::draw;
 use crate::draw::primitive::polygon::{self, PolygonInit, PolygonOptions, SetPolygon};
 use crate::draw::primitive::Primitive;
@@ -6,9 +11,6 @@ use crate::draw::properties::{
     spatial, SetColor, SetDimensions, SetOrientation, SetPosition, SetStroke,
 };
 use crate::draw::Drawing;
-use bevy::prelude::*;
-use lyon::tessellation::StrokeOptions;
-use nannou_core::geom;
 
 /// Properties related to drawing an **Ellipse**.
 #[derive(Clone, Debug, Default)]
@@ -19,7 +21,7 @@ pub struct Ellipse {
 }
 
 /// The drawing context for an ellipse.
-pub type DrawingEllipse<'a> = Drawing<'a, Ellipse>;
+pub type DrawingEllipse<'a, M> = Drawing<'a, Ellipse, M>;
 
 // Ellipse-specific methods.
 
@@ -51,11 +53,7 @@ impl Ellipse {
 // Trait implementations.
 
 impl draw::render::RenderPrimitive for Ellipse {
-    fn render_primitive(
-        self,
-        ctxt: draw::render::RenderContext,
-        mesh: &mut Mesh,
-    ) -> draw::render::PrimitiveRender {
+    fn render_primitive(self, ctxt: draw::render::RenderContext, mesh: &mut Mesh) {
         let Ellipse {
             dimensions,
             polygon,
@@ -96,9 +94,27 @@ impl draw::render::RenderPrimitive for Ellipse {
             Some(resolution) => {
                 let rect = geom::Rect::from_w_h(w, h);
                 let ellipse = geom::Ellipse::new(rect, resolution);
-                let points = ellipse.circumference().map(Vec2::from);
+                let top_left = rect.top_left();
+                let bottom_right = rect.bottom_right();
+
+                let center = Vec2::new(
+                    (top_left.x + bottom_right.x) / 2.0,
+                    (top_left.y + bottom_right.y) / 2.0,
+                );
+                let radii = Vec2::new(
+                    (bottom_right.x - top_left.x) / 2.0,
+                    (bottom_right.y - top_left.y) / 2.0,
+                );
+
+                let points = ellipse.circumference().map(|p| {
+                    let p = Vec2::from(p);
+                    let tex_coords = calculate_tex_coords(&p, &center, &radii);
+                    (p, tex_coords)
+                });
+
                 polygon::render_points_themed(
                     polygon.opts,
+                    true,
                     points,
                     ctxt,
                     &draw::theme::Primitive::Ellipse,
@@ -106,11 +122,17 @@ impl draw::render::RenderPrimitive for Ellipse {
                 );
             }
         }
-
-        draw::render::PrimitiveRender::default()
     }
 }
 
+fn calculate_tex_coords(position: &Vec2, center: &Vec2, radius: &Vec2) -> Vec2 {
+    // Normalize the position to UV space (0, 1)
+    Vec2::new(
+        (position.x - center.x) / (2.0 * radius.x) + 0.5,
+        (position.y - center.y) / (2.0 * radius.y) + 0.5,
+    )
+}
+
 impl SetOrientation for Ellipse {
     fn properties(&mut self) -> &mut orientation::Properties {
         SetOrientation::properties(&mut self.polygon)
@@ -166,7 +188,10 @@ impl Into<Option<Ellipse>> for Primitive {
 
 // Drawing methods.
 
-impl<'a> DrawingEllipse<'a> {
+impl<'a, M> DrawingEllipse<'a, M>
+where
+    M: Material + Default,
+{
     /// Stroke the outline with the given color.
     pub fn stroke<C>(self, color: C) -> Self
     where
diff --git a/bevy_nannou_draw/src/draw/primitive/line.rs b/bevy_nannou_draw/src/draw/primitive/line.rs
index 418ef58d4..41248e915 100644
--- a/bevy_nannou_draw/src/draw/primitive/line.rs
+++ b/bevy_nannou_draw/src/draw/primitive/line.rs
@@ -1,10 +1,11 @@
+use bevy::prelude::*;
+use lyon::tessellation::StrokeOptions;
+
 use crate::draw::primitive::path;
 use crate::draw::primitive::{PathStroke, Primitive};
 use crate::draw::properties::spatial::{orientation, position};
 use crate::draw::properties::{SetColor, SetOrientation, SetPosition, SetStroke};
 use crate::draw::{self, Drawing};
-use bevy::prelude::*;
-use lyon::tessellation::StrokeOptions;
 
 /// A path containing only two points - a start and end.
 ///
@@ -18,7 +19,7 @@ pub struct Line {
 }
 
 /// The drawing context for a line.
-pub type DrawingLine<'a> = Drawing<'a, Line>;
+pub type DrawingLine<'a, M> = Drawing<'a, Line, M>;
 
 impl Line {
     /// Short-hand for the `stroke_weight` method.
@@ -59,7 +60,10 @@ impl Line {
     }
 }
 
-impl<'a> DrawingLine<'a> {
+impl<'a, M> DrawingLine<'a, M>
+where
+    M: Material + Default,
+{
     /// Short-hand for the `stroke_weight` method.
     pub fn weight(self, weight: f32) -> Self {
         self.map_ty(|ty| ty.weight(weight))
@@ -126,29 +130,26 @@ impl Into<Option<Line>> for Primitive {
 }
 
 impl draw::render::RenderPrimitive for Line {
-    fn render_primitive(
-        self,
-        mut ctxt: draw::render::RenderContext,
-        mesh: &mut Mesh,
-    ) -> draw::render::PrimitiveRender {
+    fn render_primitive(self, mut ctxt: draw::render::RenderContext, mesh: &mut Mesh) {
         let Line { path, start, end } = self;
         let start = start.unwrap_or(Vec2::new(0.0, 0.0));
         let end = end.unwrap_or(Vec2::new(0.0, 0.0));
         if start == end {
-            return draw::render::PrimitiveRender::default();
+            return;
         }
         let close = false;
         let points = [start, end];
-        let points = points.iter().cloned().map(|p| p.to_array().into());
-        let events = lyon::path::iterator::FromPolyline::new(close, points);
+        let tex_coords = [Vec2::new(0.0, 0.0), Vec2::new(1.0, 0.0)];
+        let points = points.iter().cloned().zip(tex_coords.iter().copied());
 
         // Determine the transform to apply to all points.
         let global_transform = *ctxt.transform;
         let local_transform = path.position.transform() * path.orientation.transform();
         let transform = global_transform * local_transform;
 
-        path::render_path_events(
-            events,
+        path::render_path_points_themed(
+            points,
+            close,
             path.color,
             transform,
             path::Options::Stroke(path.opts),
@@ -158,7 +159,5 @@ impl draw::render::RenderPrimitive for Line {
             &mut ctxt.stroke_tessellator,
             mesh,
         );
-
-        draw::render::PrimitiveRender::default()
     }
 }
diff --git a/bevy_nannou_draw/src/draw/primitive/mesh.rs b/bevy_nannou_draw/src/draw/primitive/mesh.rs
index 8be7a682e..1b96c25d1 100644
--- a/bevy_nannou_draw/src/draw/primitive/mesh.rs
+++ b/bevy_nannou_draw/src/draw/primitive/mesh.rs
@@ -1,12 +1,15 @@
+use std::ops;
+
+use bevy::prelude::*;
+
+use nannou_core::geom;
+
 use crate::draw::mesh::MeshExt;
 use crate::draw::primitive::{Primitive, Vertex};
 use crate::draw::properties::spatial::{orientation, position};
 use crate::draw::properties::{SetColor, SetOrientation, SetPosition};
 use crate::draw::{self, Drawing};
-use bevy::prelude::*;
-use bevy::render::mesh::Indices;
-use nannou_core::{color, geom};
-use std::ops;
+
 /// The mesh type prior to being initialised with vertices or indices.
 #[derive(Clone, Debug, Default)]
 pub struct Vertexless;
@@ -18,9 +21,7 @@ pub struct PrimitiveMesh {
     orientation: orientation::Properties,
     vertex_range: ops::Range<usize>,
     index_range: ops::Range<usize>,
-    vertex_mode: draw::render::VertexMode,
     fill_color: Option<FillColor>,
-    texture_handle: Option<Handle<Image>>,
 }
 
 #[derive(Clone, Debug, Default)]
@@ -34,7 +35,7 @@ struct FlattenIndices<I> {
     current: [usize; 3],
 }
 
-pub type DrawingMesh<'a> = Drawing<'a, PrimitiveMesh>;
+pub type DrawingMesh<'a, M> = Drawing<'a, PrimitiveMesh, M>;
 
 impl Vertexless {
     /// Describe the mesh with a sequence of textured points.
@@ -60,8 +61,7 @@ impl Vertexless {
             let tex_coords = t.into();
             (point, color, tex_coords)
         });
-        let vertex_mode = draw::render::VertexMode::Texture;
-        self.points_inner(inner_mesh, points, vertex_mode, Some(texture_handle))
+        self.points_inner(inner_mesh, points, Some(texture_handle))
     }
 
     /// Describe the mesh with a sequence of colored points.
@@ -81,8 +81,7 @@ impl Vertexless {
             let tex_coords = Vec2::ZERO;
             (point, color, tex_coords)
         });
-        let vertex_mode = draw::render::VertexMode::Color;
-        self.points_inner(inner_mesh, vertices, vertex_mode, None)
+        self.points_inner(inner_mesh, vertices, None)
     }
 
     /// Describe the mesh with a sequence of points.
@@ -103,8 +102,7 @@ impl Vertexless {
             let tex_coords = Vec2::ZERO;
             (point, color, tex_coords)
         });
-        let vertex_mode = draw::render::VertexMode::Color;
-        let mut mesh = self.points_inner(inner_mesh, vertices, vertex_mode, None);
+        let mut mesh = self.points_inner(inner_mesh, vertices, None);
         mesh.fill_color = Some(FillColor(None));
         mesh
     }
@@ -113,7 +111,6 @@ impl Vertexless {
         self,
         inner_mesh: &mut Mesh,
         vertices: I,
-        vertex_mode: draw::render::VertexMode,
         texture_handle: Option<Handle<Image>>,
     ) -> PrimitiveMesh
     where
@@ -123,13 +120,16 @@ impl Vertexless {
         let i_start = inner_mesh.count_indices();
         for (i, (point, color, tex_coords)) in vertices.enumerate() {
             inner_mesh.points_mut().push(point.to_array());
-            inner_mesh.colors_mut().push(color.as_linear_rgba_f32());
+            inner_mesh
+                .colors_mut()
+                .push(color.to_linear().to_f32_array());
             inner_mesh.tex_coords_mut().push(tex_coords.to_array());
+            inner_mesh.normals_mut().push([0.0, 0.0, 1.0]);
             inner_mesh.push_index(i as u32);
         }
         let v_end = inner_mesh.count_vertices();
         let i_end = inner_mesh.count_indices();
-        PrimitiveMesh::new(v_start..v_end, i_start..i_end, vertex_mode, texture_handle)
+        PrimitiveMesh::new(v_start..v_end, i_start..i_end, texture_handle)
     }
 
     /// Describe the mesh with a sequence of textured triangles.
@@ -221,14 +221,7 @@ impl Vertexless {
             let tex_coords = t.into();
             (point, color, tex_coords)
         });
-        let vertex_mode = draw::render::VertexMode::Texture;
-        self.indexed_inner(
-            inner_mesh,
-            vertices,
-            indices,
-            vertex_mode,
-            Some(texture_handle),
-        )
+        self.indexed_inner(inner_mesh, vertices, indices, Some(texture_handle))
     }
 
     /// Describe the mesh with the given indexed, colored points.
@@ -256,8 +249,7 @@ impl Vertexless {
             let tex_coords = Vec2::ZERO;
             (point, color, tex_coords)
         });
-        let vertex_mode = draw::render::VertexMode::Color;
-        self.indexed_inner(inner_mesh, vertices, indices, vertex_mode, None)
+        self.indexed_inner(inner_mesh, vertices, indices, None)
     }
 
     /// Describe the mesh with the given indexed points.
@@ -277,8 +269,7 @@ impl Vertexless {
             let tex_coords = Vec2::ZERO;
             (point, color, tex_coords)
         });
-        let vertex_mode = draw::render::VertexMode::Color;
-        let mut mesh = self.indexed_inner(inner_mesh, vertices, indices, vertex_mode, None);
+        let mut mesh = self.indexed_inner(inner_mesh, vertices, indices, None);
         mesh.fill_color = Some(FillColor(None));
         mesh
     }
@@ -288,7 +279,6 @@ impl Vertexless {
         inner_mesh: &mut Mesh,
         vertices: V,
         indices: I,
-        vertex_mode: draw::render::VertexMode,
         texture_handle: Option<Handle<Image>>,
     ) -> PrimitiveMesh
     where
@@ -300,8 +290,11 @@ impl Vertexless {
 
         for (point, color, tex_coords) in vertices.into_iter() {
             inner_mesh.points_mut().push(point.to_array());
-            inner_mesh.colors_mut().push(color.as_linear_rgba_f32());
+            inner_mesh
+                .colors_mut()
+                .push(color.to_linear().to_f32_array());
             inner_mesh.tex_coords_mut().push(tex_coords.to_array());
+            inner_mesh.normals_mut().push([0.0, 0.0, 1.0]);
         }
         for index in indices {
             inner_mesh.push_index(index as u32);
@@ -309,7 +302,7 @@ impl Vertexless {
 
         let v_end = inner_mesh.count_vertices();
         let i_end = inner_mesh.count_indices();
-        PrimitiveMesh::new(v_start..v_end, i_start..i_end, vertex_mode, texture_handle)
+        PrimitiveMesh::new(v_start..v_end, i_start..i_end, texture_handle)
     }
 }
 
@@ -318,7 +311,6 @@ impl PrimitiveMesh {
     fn new(
         vertex_range: ops::Range<usize>,
         index_range: ops::Range<usize>,
-        vertex_mode: draw::render::VertexMode,
         texture_handle: Option<Handle<Image>>,
     ) -> Self {
         let orientation = Default::default();
@@ -329,14 +321,15 @@ impl PrimitiveMesh {
             position,
             vertex_range,
             index_range,
-            vertex_mode,
             fill_color,
-            texture_handle: texture_handle,
         }
     }
 }
 
-impl<'a> Drawing<'a, Vertexless> {
+impl<'a, M> Drawing<'a, Vertexless, M>
+where
+    M: Material + Default,
+{
     /// Describe the mesh with a sequence of points.
     ///
     /// The given iterator may yield any type that can be converted directly into `Vec3`s.
@@ -344,7 +337,7 @@ impl<'a> Drawing<'a, Vertexless> {
     /// This method assumes that the entire mesh should be coloured with a single colour. If a
     /// colour is not specified via one of the builder methods, a default colour will be retrieved
     /// from the inner `Theme`.
-    pub fn points<I>(self, points: I) -> DrawingMesh<'a>
+    pub fn points<I>(self, points: I) -> DrawingMesh<'a, M>
     where
         I: IntoIterator,
         I::Item: Into<Vec3>,
@@ -357,7 +350,7 @@ impl<'a> Drawing<'a, Vertexless> {
     /// Each of the points must be represented as a tuple containing the point and the color in
     /// that order, e.g. `(point, color)`. `point` may be of any type that implements
     /// `Into<Vec3>` and `color` may be of any type that implements `IntoColor`.
-    pub fn points_colored<I, P, C>(self, points: I) -> DrawingMesh<'a>
+    pub fn points_colored<I, P, C>(self, points: I) -> DrawingMesh<'a, M>
     where
         I: IntoIterator<Item = (P, C)>,
         P: Into<Vec3>,
@@ -376,7 +369,7 @@ impl<'a> Drawing<'a, Vertexless> {
         self,
         texture_handle: Handle<Image>,
         points: I,
-    ) -> DrawingMesh<'a>
+    ) -> DrawingMesh<'a, M>
     where
         I: IntoIterator<Item = (P, T)>,
         P: Into<Vec3>,
@@ -393,7 +386,7 @@ impl<'a> Drawing<'a, Vertexless> {
     /// This method assumes that the entire mesh should be coloured with a single colour. If a
     /// colour is not specified via one of the builder methods, a default colour will be retrieved
     /// from the inner `Theme`.
-    pub fn tris<I, V>(self, tris: I) -> DrawingMesh<'a>
+    pub fn tris<I, V>(self, tris: I) -> DrawingMesh<'a, M>
     where
         I: IntoIterator<Item = geom::Tri<V>>,
         V: Into<Vec3>,
@@ -406,7 +399,7 @@ impl<'a> Drawing<'a, Vertexless> {
     /// Each of the vertices must be represented as a tuple containing the point and the color in
     /// that order, e.g. `(point, color)`. `point` may be of any type that implements `Into<Vec3>`
     /// and `color` may be of any type that implements `IntoColor`.
-    pub fn tris_colored<I, P, C>(self, tris: I) -> DrawingMesh<'a>
+    pub fn tris_colored<I, P, C>(self, tris: I) -> DrawingMesh<'a, M>
     where
         I: IntoIterator<Item = geom::Tri<(P, C)>>,
         P: Into<Vec3>,
@@ -421,7 +414,11 @@ impl<'a> Drawing<'a, Vertexless> {
     /// coordinates in that order, e.g. `(point, tex_coords)`. `point` may be of any type that
     /// implements `Into<Vec3>` and `tex_coords` may be of any type that implements
     /// `Into<Vec2>`.
-    pub fn tris_textured<I, P, T>(self, texture_handle: Handle<Image>, tris: I) -> DrawingMesh<'a>
+    pub fn tris_textured<I, P, T>(
+        self,
+        texture_handle: Handle<Image>,
+        tris: I,
+    ) -> DrawingMesh<'a, M>
     where
         I: IntoIterator<Item = geom::Tri<(P, T)>>,
         P: Into<Vec3>,
@@ -435,7 +432,7 @@ impl<'a> Drawing<'a, Vertexless> {
     /// Each trio of `indices` describes a single triangle made up of `points`.
     ///
     /// Each point may be any type that may be converted directly into the `Vec3` type.
-    pub fn indexed<V, I>(self, points: V, indices: I) -> DrawingMesh<'a>
+    pub fn indexed<V, I>(self, points: V, indices: I) -> DrawingMesh<'a, M>
     where
         V: IntoIterator,
         V::Item: Into<Vec3>,
@@ -451,7 +448,7 @@ impl<'a> Drawing<'a, Vertexless> {
     /// Each of the `points` must be represented as a tuple containing the point and the color in
     /// that order, e.g. `(point, color)`. `point` may be of any type that implements
     /// `Into<Vec3>` and `color` may be of any type that implements `IntoColor`.
-    pub fn indexed_colored<V, I, P, C>(self, points: V, indices: I) -> DrawingMesh<'a>
+    pub fn indexed_colored<V, I, P, C>(self, points: V, indices: I) -> DrawingMesh<'a, M>
     where
         V: IntoIterator<Item = (P, C)>,
         I: IntoIterator<Item = usize>,
@@ -474,7 +471,7 @@ impl<'a> Drawing<'a, Vertexless> {
         texture_handle: Handle<Image>,
         points: V,
         indices: I,
-    ) -> DrawingMesh<'a>
+    ) -> DrawingMesh<'a, M>
     where
         V: IntoIterator<Item = (P, T)>,
         I: IntoIterator<Item = usize>,
@@ -488,19 +485,13 @@ impl<'a> Drawing<'a, Vertexless> {
 }
 
 impl draw::render::RenderPrimitive for PrimitiveMesh {
-    fn render_primitive(
-        self,
-        ctxt: draw::render::RenderContext,
-        mesh: &mut Mesh,
-    ) -> draw::render::PrimitiveRender {
+    fn render_primitive(self, ctxt: draw::render::RenderContext, mesh: &mut Mesh) {
         let PrimitiveMesh {
             orientation,
             position,
             vertex_range,
             index_range,
-            vertex_mode,
             fill_color,
-            texture_handle: texture_handle,
         } = self;
 
         // Determine the transform to apply to vertices.
@@ -531,8 +522,9 @@ impl draw::render::RenderPrimitive for PrimitiveMesh {
 
                 for (point, color, tex_coords) in vertices {
                     mesh.points_mut().push(point.to_array());
-                    mesh.colors_mut().push(color.as_linear_rgba_f32());
+                    mesh.colors_mut().push(color.to_linear().to_f32_array());
                     mesh.tex_coords_mut().push(tex_coords.to_array());
+                    mesh.normals_mut().push([0.0, 0.0, 1.0]);
                 }
                 for index in indices {
                     mesh.push_index(index);
@@ -541,26 +533,23 @@ impl draw::render::RenderPrimitive for PrimitiveMesh {
             None => {
                 let vertices = vertex_range.map(|i| {
                     let point = transform_point(ctxt.intermediary_mesh.points()[i].into());
-                    let color: Color = ctxt.intermediary_mesh.colors()[i].into();
+                    let [r, g, b, a] = ctxt.intermediary_mesh.colors()[i];
+                    let color = Color::LinearRgba(LinearRgba::new(r, g, b, a));
                     let tex_coords: Vec2 = ctxt.intermediary_mesh.tex_coords()[i].into();
                     (point, color, tex_coords)
                 });
 
                 for (point, color, tex_coords) in vertices {
                     mesh.points_mut().push(point.to_array());
-                    mesh.colors_mut().push(color.into());
+                    mesh.colors_mut().push(color.to_linear().to_f32_array());
                     mesh.tex_coords_mut().push(tex_coords.to_array());
+                    mesh.normals_mut().push([0.0, 0.0, 1.0]);
                 }
                 for index in indices {
                     mesh.push_index(index);
                 }
             }
         }
-
-        draw::render::PrimitiveRender {
-            texture_handle,
-            vertex_mode,
-        }
     }
 }
 
diff --git a/bevy_nannou_draw/src/draw/primitive/mod.rs b/bevy_nannou_draw/src/draw/primitive/mod.rs
index f8dd32f0c..f06ff89c3 100644
--- a/bevy_nannou_draw/src/draw/primitive/mod.rs
+++ b/bevy_nannou_draw/src/draw/primitive/mod.rs
@@ -1,14 +1,6 @@
-pub mod arrow;
-pub mod ellipse;
-pub mod line;
-pub mod mesh;
-pub mod path;
-pub mod polygon;
-pub mod quad;
-pub mod rect;
-pub mod text;
-pub mod texture;
-pub mod tri;
+use bevy::prelude::{Color, Component};
+
+use nannou_core::geom::{Vec2, Vec3};
 
 pub use self::arrow::Arrow;
 pub use self::ellipse::Ellipse;
@@ -19,10 +11,18 @@ pub use self::polygon::{Polygon, PolygonInit};
 pub use self::quad::Quad;
 pub use self::rect::Rect;
 pub use self::text::Text;
-pub use self::texture::Texture;
 pub use self::tri::Tri;
-use bevy::prelude::Color;
-use nannou_core::geom::{Vec2, Vec3};
+
+pub mod arrow;
+pub mod ellipse;
+pub mod line;
+pub mod mesh;
+pub mod path;
+pub mod polygon;
+pub mod quad;
+pub mod rect;
+pub mod text;
+pub mod tri;
 
 type Vertex = (Vec3, Color, Vec2);
 
@@ -31,7 +31,7 @@ type Vertex = (Vec3, Color, Vec2);
 ///
 /// This also allows us to flush all pending drawings to the mesh if `Draw::to_frame` is called
 /// before their respective **Drawing** types are dropped.
-#[derive(Clone, Debug)]
+#[derive(Component, Clone, Debug)]
 pub enum Primitive {
     Arrow(Arrow),
     Ellipse(Ellipse),
@@ -47,6 +47,5 @@ pub enum Primitive {
     Quad(Quad),
     Rect(Rect),
     Text(Text),
-    Texture(Texture),
     Tri(Tri),
 }
diff --git a/bevy_nannou_draw/src/draw/primitive/path.rs b/bevy_nannou_draw/src/draw/primitive/path.rs
index 8884212ee..8a4d4467c 100644
--- a/bevy_nannou_draw/src/draw/primitive/path.rs
+++ b/bevy_nannou_draw/src/draw/primitive/path.rs
@@ -1,10 +1,11 @@
+use bevy::prelude::*;
+use lyon::path::PathEvent;
+use lyon::tessellation::{FillOptions, FillTessellator, StrokeOptions, StrokeTessellator};
+
 use crate::draw::primitive::Primitive;
 use crate::draw::properties::spatial::{orientation, position};
 use crate::draw::properties::{SetColor, SetFill, SetOrientation, SetPosition, SetStroke};
 use crate::draw::{self, Drawing, DrawingContext};
-use bevy::prelude::*;
-use lyon::path::PathEvent;
-use lyon::tessellation::{FillOptions, FillTessellator, StrokeOptions, StrokeTessellator};
 
 /// A set of path tessellation options (FillOptions or StrokeOptions).
 pub trait TessellationOptions {
@@ -18,26 +19,17 @@ pub trait TessellationOptions {
 pub(crate) enum PathEventSource {
     /// Fetch events from `path_events_buffer`.
     Buffered(std::ops::Range<usize>),
-    /// Generate events from the `path_points_colored_buffer`.
-    ColoredPoints {
-        range: std::ops::Range<usize>,
-        close: bool,
-    },
-    /// Generate events from the `path_points_textured_buffer`.
-    TexturedPoints {
+    /// Generate events from the `path_points_vertex_buffer`.
+    Vertex {
         range: std::ops::Range<usize>,
         close: bool,
     },
 }
 
 pub(crate) enum PathEventSourceIter<'a> {
-    Events(&'a mut dyn Iterator<Item = lyon::path::PathEvent>),
-    ColoredPoints {
-        points: &'a mut dyn Iterator<Item = (Vec2, Color)>,
-        close: bool,
-    },
-    TexturedPoints {
-        points: &'a mut dyn Iterator<Item = (Vec2, Vec2)>,
+    Events(&'a mut dyn Iterator<Item = PathEvent>),
+    Vertex {
+        points: &'a mut dyn Iterator<Item = (Vec2, Color, Vec2)>,
         close: bool,
     },
 }
@@ -76,24 +68,23 @@ pub struct Path {
     orientation: orientation::Properties,
     path_event_src: PathEventSource,
     options: Options,
-    vertex_mode: draw::render::VertexMode,
     texture_handle: Option<Handle<Image>>,
 }
 
 /// The initial drawing context for a path.
-pub type DrawingPathInit<'a> = Drawing<'a, PathInit>;
+pub type DrawingPathInit<'a, M> = Drawing<'a, PathInit, M>;
 
 /// The drawing context for a path in the tessellation options state.
-pub type DrawingPathOptions<'a, T> = Drawing<'a, PathOptions<T>>;
+pub type DrawingPathOptions<'a, T, M> = Drawing<'a, PathOptions<T>, M>;
 
 /// The drawing context for a stroked path, prior to path event submission.
-pub type DrawingPathStroke<'a> = Drawing<'a, PathStroke>;
+pub type DrawingPathStroke<'a, M> = Drawing<'a, PathStroke, M>;
 
 /// The drawing context for a filled path, prior to path event submission.
-pub type DrawingPathFill<'a> = Drawing<'a, PathFill>;
+pub type DrawingPathFill<'a, M> = Drawing<'a, PathFill, M>;
 
 /// The drawing context for a polyline whose vertices have been specified.
-pub type DrawingPath<'a> = Drawing<'a, Path>;
+pub type DrawingPath<'a, M> = Drawing<'a, Path, M>;
 
 /// Dynamically distinguish between fill and stroke tessellation options.
 #[derive(Clone, Debug)]
@@ -186,7 +177,6 @@ where
             self.color,
             PathEventSource::Buffered(start..end),
             self.opts.into_options(),
-            draw::render::VertexMode::Color,
             None,
         )
     }
@@ -212,53 +202,25 @@ where
     }
 
     /// Submit path events as a polyline of colored points.
-    pub fn points_colored<I, P, C>(self, ctxt: DrawingContext, points: I) -> Path
+    pub fn vertices<I, P, C, U>(self, ctxt: DrawingContext, points: I) -> Path
     where
-        I: IntoIterator<Item = (P, C)>,
+        I: IntoIterator<Item = (P, C, U)>,
         P: Into<Vec2>,
         C: Into<Color>,
+        U: Into<Vec2>,
     {
-        self.points_colored_inner(ctxt, false, points)
+        self.points_vertex_inner(ctxt, false, points)
     }
 
     /// Submit path events as a polyline of colored points.
-    pub fn points_colored_closed<I, P, C>(self, ctxt: DrawingContext, points: I) -> Path
+    pub fn vertices_closed<I, P, C, U>(self, ctxt: DrawingContext, points: I) -> Path
     where
-        I: IntoIterator<Item = (P, C)>,
+        I: IntoIterator<Item = (P, C, U)>,
         P: Into<Vec2>,
         C: Into<Color>,
+        U: Into<Vec2>,
     {
-        self.points_colored_inner(ctxt, true, points)
-    }
-
-    /// Submit path events as a polyline of textured points.
-    pub fn points_textured<I, P, TC>(
-        self,
-        ctxt: DrawingContext,
-        texture_handle: Handle<Image>,
-        points: I,
-    ) -> Path
-    where
-        I: IntoIterator<Item = (P, TC)>,
-        P: Into<Vec2>,
-        TC: Into<Vec2>,
-    {
-        self.points_textured_inner(ctxt, texture_handle, false, points)
-    }
-
-    /// Submit path events as a polyline of textured points.
-    pub fn points_textured_closed<I, P, TC>(
-        self,
-        ctxt: DrawingContext,
-        texture_handle: Handle<Image>,
-        points: I,
-    ) -> Path
-    where
-        I: IntoIterator<Item = (P, TC)>,
-        P: Into<Vec2>,
-        TC: Into<Vec2>,
-    {
-        self.points_textured_inner(ctxt, texture_handle, true, points)
+        self.points_vertex_inner(ctxt, true, points)
     }
 
     // Consumes an iterator of points and converts them to an iterator yielding events.
@@ -276,23 +238,26 @@ where
     }
 
     // Consumes an iterator of points and converts them to an iterator yielding events.
-    fn points_colored_inner<I, P, C>(self, ctxt: DrawingContext, close: bool, points: I) -> Path
+    fn points_vertex_inner<I, P, C, U>(self, ctxt: DrawingContext, close: bool, points: I) -> Path
     where
-        I: IntoIterator<Item = (P, C)>,
+        I: IntoIterator<Item = (P, C, U)>,
         P: Into<Vec2>,
         C: Into<Color>,
+        U: Into<Vec2>,
     {
         let DrawingContext {
-            path_points_colored_buffer,
+            path_points_vertex_buffer: path_points_colored_buffer,
             ..
         } = ctxt;
         let start = path_points_colored_buffer.len();
-        let points = points.into_iter().map(|(p, c)| (p.into(), c.into()));
+        let points = points
+            .into_iter()
+            .map(|(p, c, u)| (p.into(), c.into(), u.into()));
 
         path_points_colored_buffer.extend(points);
 
         let end = path_points_colored_buffer.len();
-        let path_event_src = PathEventSource::ColoredPoints {
+        let path_event_src = PathEventSource::Vertex {
             range: start..end,
             close,
         };
@@ -302,46 +267,9 @@ where
             self.color,
             path_event_src,
             self.opts.into_options(),
-            draw::render::VertexMode::Color,
             None,
         )
     }
-
-    // Consumes an iterator of textured points and buffers them for rendering.
-    fn points_textured_inner<I, P, TC>(
-        self,
-        ctxt: DrawingContext,
-        texture_handle: Handle<Image>,
-        close: bool,
-        points: I,
-    ) -> Path
-    where
-        I: IntoIterator<Item = (P, TC)>,
-        P: Into<Vec2>,
-        TC: Into<Vec2>,
-    {
-        let DrawingContext {
-            path_points_textured_buffer,
-            ..
-        } = ctxt;
-        let start = path_points_textured_buffer.len();
-        let points = points.into_iter().map(|(p, tc)| (p.into(), tc.into()));
-        path_points_textured_buffer.extend(points);
-        let end = path_points_textured_buffer.len();
-        let path_event_src = PathEventSource::TexturedPoints {
-            range: start..end,
-            close,
-        };
-        Path::new(
-            self.position,
-            self.orientation,
-            self.color,
-            path_event_src,
-            self.opts.into_options(),
-            draw::render::VertexMode::Texture,
-            Some(texture_handle),
-        )
-    }
 }
 
 pub(crate) fn render_path_events<I>(
@@ -374,63 +302,73 @@ pub(crate) fn render_path_events<I>(
     }
 }
 
-pub(crate) fn render_path_points_colored<I>(
-    points_colored: I,
+pub(crate) fn render_path_points_themed<I>(
+    points_themed: I,
     close: bool,
+    color: Option<Color>,
     transform: Mat4,
     options: Options,
+    theme: &draw::Theme,
+    theme_prim: &draw::theme::Primitive,
     fill_tessellator: &mut lyon::tessellation::FillTessellator,
     stroke_tessellator: &mut lyon::tessellation::StrokeTessellator,
     mesh: &mut Mesh,
 ) where
-    I: IntoIterator<Item = (Vec2, Color)>,
+    I: IntoIterator<Item = (Vec2, Vec2)>,
 {
-    let path = match points_colored_to_lyon_path(points_colored, close) {
+    let path = match points_themed_to_lyon_path(points_themed, close) {
         None => return,
         Some(p) => p,
     };
 
     // Extend the mesh with the built path.
-    let mut mesh_builder = draw::mesh::MeshBuilder::color_per_point(mesh, transform);
     let res = match options {
-        Options::Fill(options) => fill_tessellator.tessellate_with_ids(
-            path.id_iter(),
-            &path,
-            Some(&path),
-            &options,
-            &mut mesh_builder,
-        ),
-        Options::Stroke(options) => stroke_tessellator.tessellate_with_ids(
-            path.id_iter(),
-            &path,
-            Some(&path),
-            &options,
-            &mut mesh_builder,
-        ),
+        Options::Fill(options) => {
+            let color = color.unwrap_or_else(|| theme.fill(theme_prim));
+            let mut mesh_builder = draw::mesh::MeshBuilder::single_color(mesh, transform, color);
+            fill_tessellator.tessellate_with_ids(
+                path.id_iter(),
+                &path,
+                Some(&path),
+                &options,
+                &mut mesh_builder,
+            )
+        }
+        Options::Stroke(options) => {
+            let color = color.unwrap_or_else(|| theme.fill(theme_prim));
+            let mut mesh_builder = draw::mesh::MeshBuilder::single_color(mesh, transform, color);
+            stroke_tessellator.tessellate_with_ids(
+                path.id_iter(),
+                &path,
+                Some(&path),
+                &options,
+                &mut mesh_builder,
+            )
+        }
     };
     if let Err(err) = res {
         eprintln!("failed to tessellate path: {:?}", err);
     }
 }
 
-pub(crate) fn render_path_points_textured<I>(
-    points_textured: I,
+pub(crate) fn render_path_vertex<I>(
+    points_vertex: I,
     close: bool,
     transform: Mat4,
     options: Options,
-    fill_tessellator: &mut lyon::tessellation::FillTessellator,
-    stroke_tessellator: &mut lyon::tessellation::StrokeTessellator,
+    fill_tessellator: &mut FillTessellator,
+    stroke_tessellator: &mut StrokeTessellator,
     mesh: &mut Mesh,
 ) where
-    I: IntoIterator<Item = (Vec2, Vec2)>,
+    I: IntoIterator<Item = (Vec2, Color, Vec2)>,
 {
-    let path = match points_textured_to_lyon_path(points_textured, close) {
+    let path = match points_vertex_to_lyon_path(points_vertex, close) {
         None => return,
         Some(p) => p,
     };
 
     // Extend the mesh with the built path.
-    let mut mesh_builder = draw::mesh::MeshBuilder::tex_coords_per_point(mesh, transform);
+    let mut mesh_builder = draw::mesh::MeshBuilder::vertex_per_point(mesh, transform);
     let res = match options {
         Options::Fill(options) => fill_tessellator.tessellate_with_ids(
             path.id_iter(),
@@ -453,15 +391,14 @@ pub(crate) fn render_path_points_textured<I>(
 }
 
 pub(crate) fn render_path_source(
-    // TODO:
     path_src: PathEventSourceIter,
     color: Option<Color>,
     transform: Mat4,
     options: Options,
     theme: &draw::Theme,
     theme_prim: &draw::theme::Primitive,
-    fill_tessellator: &mut lyon::tessellation::FillTessellator,
-    stroke_tessellator: &mut lyon::tessellation::StrokeTessellator,
+    fill_tessellator: &mut FillTessellator,
+    stroke_tessellator: &mut StrokeTessellator,
     mesh: &mut Mesh,
 ) {
     match path_src {
@@ -476,16 +413,7 @@ pub(crate) fn render_path_source(
             stroke_tessellator,
             mesh,
         ),
-        PathEventSourceIter::ColoredPoints { points, close } => render_path_points_colored(
-            points,
-            close,
-            transform,
-            options,
-            fill_tessellator,
-            stroke_tessellator,
-            mesh,
-        ),
-        PathEventSourceIter::TexturedPoints { points, close } => render_path_points_textured(
+        PathEventSourceIter::Vertex { points, close } => render_path_vertex(
             points,
             close,
             transform,
@@ -498,19 +426,14 @@ pub(crate) fn render_path_source(
 }
 
 impl draw::render::RenderPrimitive for Path {
-    fn render_primitive(
-        self,
-        mut ctxt: draw::render::RenderContext,
-        mesh: &mut Mesh,
-    ) -> draw::render::PrimitiveRender {
+    fn render_primitive(self, mut ctxt: draw::render::RenderContext, mesh: &mut Mesh) {
         let Path {
             color,
             position,
             orientation,
             path_event_src,
             options,
-            vertex_mode,
-            texture_handle,
+            ..
         } = self;
 
         // Determine the transform to apply to all points.
@@ -548,9 +471,9 @@ impl draw::render::RenderPrimitive for Path {
                     &mut ctxt.stroke_tessellator,
                 );
             }
-            PathEventSource::ColoredPoints { range, close } => {
-                let mut points_colored = ctxt.path_points_colored_buffer[range].iter().cloned();
-                let src = PathEventSourceIter::ColoredPoints {
+            PathEventSource::Vertex { range, close } => {
+                let mut points_colored = ctxt.path_points_vertex_buffer[range].iter().cloned();
+                let src = PathEventSourceIter::Vertex {
                     points: &mut points_colored,
                     close,
                 };
@@ -561,47 +484,30 @@ impl draw::render::RenderPrimitive for Path {
                     &mut ctxt.stroke_tessellator,
                 );
             }
-            PathEventSource::TexturedPoints { range, close } => {
-                let mut points_textured = ctxt.path_points_textured_buffer[range].iter().cloned();
-                let src = PathEventSourceIter::TexturedPoints {
-                    points: &mut points_textured,
-                    close,
-                };
-                render(
-                    src,
-                    &ctxt.theme,
-                    &mut ctxt.fill_tessellator,
-                    &mut ctxt.stroke_tessellator,
-                );
-            }
-        }
-
-        draw::render::PrimitiveRender {
-            texture_handle,
-            vertex_mode,
         }
     }
 }
 
-/// Create a lyon path for the given iterator of colored points.
-pub fn points_colored_to_lyon_path<I>(points_colored: I, close: bool) -> Option<lyon::path::Path>
+pub fn points_themed_to_lyon_path<I>(points: I, close: bool) -> Option<lyon::path::Path>
 where
-    I: IntoIterator<Item = (Vec2, Color)>,
+    I: IntoIterator<Item = (Vec2, Vec2)>,
 {
-    // Build a path with a color attribute for each channel.
-    let channels = 4;
+    // Build a path with a uv attribute for each channel.
+    let channels = 2;
     let mut path_builder = lyon::path::Path::builder_with_attributes(channels);
 
     // Begin the path.
-    let mut iter = points_colored.into_iter();
-    let (first_point, first_color) = iter.next()?;
+    let mut iter = points.into_iter();
+    let (first_point, first_tex_coord) = iter.next()?;
     let p = first_point.to_array().into();
-    path_builder.begin(p, &first_color.as_linear_rgba_f32());
+    let [u, v] = first_tex_coord.to_array();
+    path_builder.begin(p, &[u, v]);
 
     // Add the lines, keeping track of the last
-    for (point, color) in iter {
+    for (point, text_coord) in iter {
         let p = point.to_array().into();
-        path_builder.line_to(p, &color.as_linear_rgba_f32());
+        let [u, v] = text_coord.to_array();
+        path_builder.line_to(p, &[u, v]);
     }
 
     // End the path, closing if necessary.
@@ -611,27 +517,29 @@ where
     Some(path_builder.build())
 }
 
-/// Create a lyon path for the given iterator of textured points.
-pub fn points_textured_to_lyon_path<I>(points_textured: I, close: bool) -> Option<lyon::path::Path>
+/// Create a lyon path for the given iterator of colored points.
+pub fn points_vertex_to_lyon_path<I>(points: I, close: bool) -> Option<lyon::path::Path>
 where
-    I: IntoIterator<Item = (Vec2, Vec2)>,
+    I: IntoIterator<Item = (Vec2, Color, Vec2)>,
 {
-    // Build a path with a texture coords attribute for each channel.
-    let channels = 2;
+    // Build a path with a color and uv attribute for each channel.
+    let channels = 6;
     let mut path_builder = lyon::path::Path::builder_with_attributes(channels);
 
     // Begin the path.
-    let mut iter = points_textured.into_iter();
-    let (first_point, first_tex_coords) = iter.next()?;
+    let mut iter = points.into_iter();
+    let (first_point, first_color, first_tex_coord) = iter.next()?;
     let p = first_point.to_array().into();
-    let (tc_x, tc_y) = first_tex_coords.into();
-    path_builder.begin(p, &[tc_x, tc_y]);
+    let [r, g, b, a] = first_color.to_linear().to_f32_array();
+    let [u, v] = first_tex_coord.to_array();
+    path_builder.begin(p, &[r, g, b, a, u, v]);
 
     // Add the lines, keeping track of the last
-    for (point, tex_coords) in iter {
+    for (point, color, text_coord) in iter {
         let p = point.to_array().into();
-        let (tc_x, tc_y) = tex_coords.into();
-        path_builder.line_to(p, &[tc_x, tc_y]);
+        let [r, g, b, a] = color.to_linear().to_f32_array();
+        let [u, v] = text_coord.to_array();
+        path_builder.line_to(p, &[r, g, b, a, u, v]);
     }
 
     // End the path, closing if necessary.
@@ -649,7 +557,6 @@ impl Path {
         color: Option<Color>,
         path_event_src: PathEventSource,
         options: Options,
-        vertex_mode: draw::render::VertexMode,
         texture_handle: Option<Handle<Image>>,
     ) -> Self {
         Path {
@@ -658,29 +565,34 @@ impl Path {
             position,
             path_event_src,
             options,
-            vertex_mode,
             texture_handle,
         }
     }
 }
 
-impl<'a> DrawingPathInit<'a> {
+impl<'a, M> DrawingPathInit<'a, M>
+where
+    M: Material + Default,
+{
     /// Specify that we want to use fill tessellation for the path.
     ///
     /// The returned building context allows for specifying the fill tessellation options.
-    pub fn fill(self) -> DrawingPathFill<'a> {
+    pub fn fill(self) -> DrawingPathFill<'a, M> {
         self.map_ty(|ty| ty.fill())
     }
 
     /// Specify that we want to use stroke tessellation for the path.
     ///
     /// The returned building context allows for specifying the stroke tessellation options.
-    pub fn stroke(self) -> DrawingPathStroke<'a> {
+    pub fn stroke(self) -> DrawingPathStroke<'a, M> {
         self.map_ty(|ty| ty.stroke())
     }
 }
 
-impl<'a> DrawingPathFill<'a> {
+impl<'a, M> DrawingPathFill<'a, M>
+where
+    M: Material + Default,
+{
     /// Maximum allowed distance to the path when building an approximation.
     pub fn tolerance(self, tolerance: f32) -> Self {
         self.map_ty(|ty| ty.tolerance(tolerance))
@@ -694,7 +606,10 @@ impl<'a> DrawingPathFill<'a> {
     }
 }
 
-impl<'a> DrawingPathStroke<'a> {
+impl<'a, M> DrawingPathStroke<'a, M>
+where
+    M: Material + Default,
+{
     /// Short-hand for the `stroke_weight` method.
     pub fn weight(self, weight: f32) -> Self {
         self.map_ty(|ty| ty.stroke_weight(weight))
@@ -706,14 +621,15 @@ impl<'a> DrawingPathStroke<'a> {
     }
 }
 
-impl<'a, T> DrawingPathOptions<'a, T>
+impl<'a, T, M> DrawingPathOptions<'a, T, M>
 where
     T: TessellationOptions,
-    PathOptions<T>: Into<Primitive>,
+    M: Material + Default,
+    PathOptions<T>: Into<Primitive> + Clone,
     Primitive: Into<Option<PathOptions<T>>>,
 {
     /// Submit the path events to be tessellated.
-    pub fn events<I>(self, events: I) -> DrawingPath<'a>
+    pub fn events<I>(self, events: I) -> DrawingPath<'a, M>
     where
         I: IntoIterator<Item = lyon::path::PathEvent>,
     {
@@ -721,7 +637,7 @@ where
     }
 
     /// Submit the path events as a polyline of points.
-    pub fn points<I>(self, points: I) -> DrawingPath<'a>
+    pub fn points<I>(self, points: I) -> DrawingPath<'a, M>
     where
         I: IntoIterator,
         I::Item: Into<Vec2>,
@@ -732,7 +648,7 @@ where
     /// Submit the path events as a polyline of points.
     ///
     /// An event will be generated that closes the start and end points.
-    pub fn points_closed<I>(self, points: I) -> DrawingPath<'a>
+    pub fn points_closed<I>(self, points: I) -> DrawingPath<'a, M>
     where
         I: IntoIterator,
         I::Item: Into<Vec2>,
@@ -740,56 +656,50 @@ where
         self.map_ty_with_context(|ty, ctxt| ty.points_closed(ctxt, points))
     }
 
-    /// Submit path events as a polyline of colored points.
-    pub fn points_colored<I, P, C>(self, points: I) -> DrawingPath<'a>
+    pub fn points_colored<I, P, C>(self, points: I) -> DrawingPath<'a, M>
     where
         I: IntoIterator<Item = (P, C)>,
         P: Into<Vec2>,
         C: Into<Color>,
     {
-        self.map_ty_with_context(|ty, ctxt| ty.points_colored(ctxt, points))
+        self.map_ty_with_context(|ty, ctxt| {
+            ty.vertices(ctxt, points.into_iter().map(|(p, c)| (p, c, Vec2::ZERO)))
+        })
     }
 
-    /// Submit path events as a polyline of colored points.
-    ///
-    /// The path with automatically close from the end point to the start point.
-    pub fn points_colored_closed<I, P, C>(self, points: I) -> DrawingPath<'a>
+    pub fn points_colored_closed<I, P, C>(self, points: I) -> DrawingPath<'a, M>
     where
         I: IntoIterator<Item = (P, C)>,
         P: Into<Vec2>,
         C: Into<Color>,
     {
-        self.map_ty_with_context(|ty, ctxt| ty.points_colored_closed(ctxt, points))
+        self.map_ty_with_context(|ty, ctxt| {
+            ty.vertices_closed(ctxt, points.into_iter().map(|(p, c)| (p, c, Vec2::ZERO)))
+        })
     }
 
-    /// Submit path events as a polyline of textured points.
-    pub fn points_textured<I, P, TC>(
-        self,
-        texture_handle: Handle<Image>,
-        points: I,
-    ) -> DrawingPath<'a>
+    /// Submit path events as a polyline of vertex points.
+    pub fn points_vertex<I, P, C, U>(self, points: I) -> DrawingPath<'a, M>
     where
-        I: IntoIterator<Item = (P, TC)>,
+        I: IntoIterator<Item = (P, C, U)>,
         P: Into<Vec2>,
-        TC: Into<Vec2>,
+        C: Into<Color>,
+        U: Into<Vec2>,
     {
-        self.map_ty_with_context(|ty, ctxt| ty.points_textured(ctxt, texture_handle, points))
+        self.map_ty_with_context(|ty, ctxt| ty.vertices(ctxt, points))
     }
 
-    /// Submit path events as a polyline of textured points.
+    /// Submit path events as a polyline of vertex points.
     ///
     /// The path with automatically close from the end point to the start point.
-    pub fn points_textured_closed<I, P, TC>(
-        self,
-        texture_handle: Handle<Image>,
-        points: I,
-    ) -> DrawingPath<'a>
+    pub fn points_vertex_closed<I, P, C, U>(self, points: I) -> DrawingPath<'a, M>
     where
-        I: IntoIterator<Item = (P, TC)>,
+        I: IntoIterator<Item = (P, C, U)>,
         P: Into<Vec2>,
-        TC: Into<Vec2>,
+        C: Into<Color>,
+        U: Into<Vec2>,
     {
-        self.map_ty_with_context(|ty, ctxt| ty.points_textured_closed(ctxt, texture_handle, points))
+        self.map_ty_with_context(|ty, ctxt| ty.vertices_closed(ctxt, points))
     }
 }
 
diff --git a/bevy_nannou_draw/src/draw/primitive/polygon.rs b/bevy_nannou_draw/src/draw/primitive/polygon.rs
index 7e33703eb..3d5a3cf02 100644
--- a/bevy_nannou_draw/src/draw/primitive/polygon.rs
+++ b/bevy_nannou_draw/src/draw/primitive/polygon.rs
@@ -1,12 +1,13 @@
+use bevy::prelude::*;
+use lyon::path::PathEvent;
+use lyon::tessellation::StrokeOptions;
+
 use crate::draw::drawing::DrawingContext;
 use crate::draw::primitive::path::{self, PathEventSource};
 use crate::draw::primitive::Primitive;
 use crate::draw::properties::spatial::{orientation, position};
 use crate::draw::properties::{SetColor, SetOrientation, SetPosition, SetStroke};
 use crate::draw::{self, Drawing};
-use bevy::prelude::*;
-use lyon::path::PathEvent;
-use lyon::tessellation::StrokeOptions;
 
 /// A trait implemented for all polygon draw primitives.
 pub trait SetPolygon: Sized {
@@ -60,14 +61,13 @@ pub struct PolygonOptions {
 pub struct Polygon {
     opts: PolygonOptions,
     path_event_src: PathEventSource,
-    texture_handle: Option<Handle<Image>>,
 }
 
 /// Initialised drawing state for a polygon.
-pub type DrawingPolygonInit<'a> = Drawing<'a, PolygonInit>;
+pub type DrawingPolygonInit<'a, M> = Drawing<'a, PolygonInit, M>;
 
 /// Initialised drawing state for a polygon.
-pub type DrawingPolygon<'a> = Drawing<'a, Polygon>;
+pub type DrawingPolygon<'a, M> = Drawing<'a, Polygon, M>;
 
 impl PolygonInit {
     /// Stroke the outline with the given color.
@@ -92,7 +92,6 @@ impl PolygonInit {
         Polygon {
             opts: self.opts,
             path_event_src: PathEventSource::Buffered(start..end),
-            texture_handle: None,
         }
     }
 
@@ -112,58 +111,30 @@ impl PolygonInit {
     }
 
     /// Consumes an iterator of points and converts them to an iterator yielding path events.
-    pub fn points_colored<I, P, C>(self, ctxt: DrawingContext, points: I) -> Polygon
+    pub fn points_vertex<I, P, C, U>(self, ctxt: DrawingContext, points: I) -> Polygon
     where
-        I: IntoIterator<Item = (P, C)>,
+        I: IntoIterator<Item = (P, C, U)>,
         P: Into<Vec2>,
         C: Into<Color>,
+        U: Into<Vec2>,
     {
         let DrawingContext {
-            path_points_colored_buffer,
+            path_points_vertex_buffer: path_points_colored_buffer,
             ..
         } = ctxt;
         let start = path_points_colored_buffer.len();
-        let points = points.into_iter().map(|(p, c)| (p.into(), c.into()));
+        let points = points
+            .into_iter()
+            .map(|(p, c, u)| (p.into(), c.into(), u.into()));
         path_points_colored_buffer.extend(points);
 
         let end = path_points_colored_buffer.len();
         Polygon {
             opts: self.opts,
-            path_event_src: PathEventSource::ColoredPoints {
+            path_event_src: PathEventSource::Vertex {
                 range: start..end,
                 close: true,
             },
-            texture_handle: None,
-        }
-    }
-
-    /// Consumes an iterator of points and converts them to an iterator yielding path events.
-    pub fn points_textured<I, P, T>(
-        self,
-        ctxt: DrawingContext,
-        texture_handle: Handle<Image>,
-        points: I,
-    ) -> Polygon
-    where
-        I: IntoIterator<Item = (P, T)>,
-        P: Into<Vec2>,
-        T: Into<Vec2>,
-    {
-        let DrawingContext {
-            path_points_textured_buffer,
-            ..
-        } = ctxt;
-        let start = path_points_textured_buffer.len();
-        let points = points.into_iter().map(|(p, c)| (p.into(), c.into()));
-        path_points_textured_buffer.extend(points);
-        let end = path_points_textured_buffer.len();
-        Polygon {
-            opts: self.opts,
-            path_event_src: PathEventSource::TexturedPoints {
-                range: start..end,
-                close: true,
-            },
-            texture_handle: Some(texture_handle),
         }
     }
 }
@@ -240,20 +211,73 @@ pub fn render_events_themed<F, I>(
 
 pub fn render_points_themed<I>(
     opts: PolygonOptions,
+    close: bool,
     points: I,
-    ctxt: draw::render::RenderContext,
+    mut ctxt: draw::render::RenderContext,
     theme_primitive: &draw::theme::Primitive,
     mesh: &mut Mesh,
 ) where
-    I: Clone + Iterator<Item = Vec2>,
+    I: Clone + Iterator<Item = (Vec2, Vec2)>,
 {
-    render_events_themed(
-        opts,
-        || lyon::path::iterator::FromPolyline::closed(points.clone().map(|p| p.to_array().into())),
-        ctxt,
-        theme_primitive,
-        mesh,
-    );
+    let PolygonOptions {
+        position,
+        orientation,
+        no_fill,
+        stroke_color,
+        color,
+        stroke,
+    } = opts;
+
+    // Determine the transform to apply to all points.
+    let global_transform = *ctxt.transform;
+    let local_transform = position.transform() * orientation.transform();
+    let transform = global_transform * local_transform;
+
+    // A function for rendering the path.
+    let mut render =
+        |opts: path::Options,
+         color: Option<Color>,
+         theme: &draw::Theme,
+         fill_tessellator: &mut lyon::tessellation::FillTessellator,
+         stroke_tessellator: &mut lyon::tessellation::StrokeTessellator| {
+            path::render_path_points_themed(
+                points.clone(),
+                close,
+                color,
+                transform,
+                opts,
+                theme,
+                theme_primitive,
+                fill_tessellator,
+                stroke_tessellator,
+                mesh,
+            )
+        };
+
+    // Do the fill tessellation first.
+    if !no_fill {
+        let opts = path::Options::Fill(lyon::tessellation::FillOptions::default());
+        render(
+            opts,
+            color,
+            &ctxt.theme,
+            &mut ctxt.fill_tessellator,
+            &mut ctxt.stroke_tessellator,
+        );
+    }
+
+    // Do the stroke tessellation on top.
+    if let Some(stroke_opts) = stroke {
+        let opts = path::Options::Stroke(stroke_opts);
+        let color = stroke_color;
+        render(
+            opts,
+            color,
+            &ctxt.theme,
+            &mut ctxt.fill_tessellator,
+            &mut ctxt.stroke_tessellator,
+        );
+    }
 }
 
 impl Polygon {
@@ -262,7 +286,7 @@ impl Polygon {
         ctxt: draw::render::RenderContext,
         mesh: &mut Mesh,
         theme_primitive: &draw::theme::Primitive,
-    ) -> draw::render::PrimitiveRender {
+    ) {
         let Polygon {
             path_event_src,
             opts:
@@ -274,14 +298,12 @@ impl Polygon {
                     color,
                     stroke,
                 },
-            texture_handle,
         } = self;
         let draw::render::RenderContext {
             fill_tessellator,
             stroke_tessellator,
             path_event_buffer,
-            path_points_colored_buffer,
-            path_points_textured_buffer,
+            path_points_vertex_buffer,
             transform,
             theme,
             ..
@@ -329,10 +351,10 @@ impl Polygon {
                         stroke_tessellator,
                     );
                 }
-                PathEventSource::ColoredPoints { ref range, close } => {
+                PathEventSource::Vertex { ref range, close } => {
                     let mut points_colored =
-                        path_points_colored_buffer[range.clone()].iter().cloned();
-                    let src = path::PathEventSourceIter::ColoredPoints {
+                        path_points_vertex_buffer[range.clone()].iter().cloned();
+                    let src = path::PathEventSourceIter::Vertex {
                         points: &mut points_colored,
                         close,
                     };
@@ -345,22 +367,6 @@ impl Polygon {
                         stroke_tessellator,
                     );
                 }
-                PathEventSource::TexturedPoints { ref range, close } => {
-                    let mut textured_points =
-                        path_points_textured_buffer[range.clone()].iter().cloned();
-                    let src = path::PathEventSourceIter::TexturedPoints {
-                        points: &mut textured_points,
-                        close,
-                    };
-                    render(
-                        src,
-                        opts,
-                        color,
-                        theme,
-                        fill_tessellator,
-                        stroke_tessellator,
-                    );
-                }
             }
         }
 
@@ -380,29 +386,14 @@ impl Polygon {
                         stroke_tessellator,
                     );
                 }
-                PathEventSource::ColoredPoints { range, close } => {
+                PathEventSource::Vertex { range, close } => {
                     let color = stroke_color.unwrap_or_else(|| theme.stroke(theme_primitive));
-                    let mut points_colored = path_points_colored_buffer[range]
+                    let mut points_vertex = path_points_vertex_buffer[range]
                         .iter()
                         .cloned()
-                        .map(|(point, _)| (point, color));
-                    let src = path::PathEventSourceIter::ColoredPoints {
-                        points: &mut points_colored,
-                        close,
-                    };
-                    render(
-                        src,
-                        opts,
-                        stroke_color,
-                        theme,
-                        fill_tessellator,
-                        stroke_tessellator,
-                    );
-                }
-                PathEventSource::TexturedPoints { range, close } => {
-                    let mut textured_points = path_points_textured_buffer[range].iter().cloned();
-                    let src = path::PathEventSourceIter::TexturedPoints {
-                        points: &mut textured_points,
+                        .map(|(point, _, tex_coord)| (point, color, tex_coord));
+                    let src = path::PathEventSourceIter::Vertex {
+                        points: &mut points_vertex,
                         close,
                     };
                     render(
@@ -416,30 +407,19 @@ impl Polygon {
                 }
             }
         }
-
-        match texture_handle {
-            None => draw::render::PrimitiveRender::default(),
-            Some(texture_handle) => draw::render::PrimitiveRender {
-                texture_handle: Some(texture_handle),
-                vertex_mode: draw::render::VertexMode::Texture,
-            },
-        }
     }
 }
 
 impl draw::render::RenderPrimitive for Polygon {
-    fn render_primitive(
-        self,
-        ctxt: draw::render::RenderContext,
-        mesh: &mut Mesh,
-    ) -> draw::render::PrimitiveRender {
+    fn render_primitive(self, ctxt: draw::render::RenderContext, mesh: &mut Mesh) {
         self.render_themed(ctxt, mesh, &draw::theme::Primitive::Polygon)
     }
 }
 
-impl<'a, T> Drawing<'a, T>
+impl<'a, T, M> Drawing<'a, T, M>
 where
-    T: SetPolygon + Into<Primitive>,
+    T: SetPolygon + Into<Primitive> + Clone,
+    M: Material + Default,
     Primitive: Into<Option<T>>,
 {
     /// Specify no fill color and in turn no fill tessellation for the polygon.
@@ -464,7 +444,10 @@ where
     }
 }
 
-impl<'a> DrawingPolygonInit<'a> {
+impl<'a, M> DrawingPolygonInit<'a, M>
+where
+    M: Material + Default,
+{
     /// Stroke the outline with the given color.
     pub fn stroke<C>(self, color: C) -> Self
     where
@@ -474,7 +457,7 @@ impl<'a> DrawingPolygonInit<'a> {
     }
 
     /// Describe the polygon with a sequence of path events.
-    pub fn events<I>(self, events: I) -> DrawingPolygon<'a>
+    pub fn events<I>(self, events: I) -> DrawingPolygon<'a, M>
     where
         I: IntoIterator<Item = PathEvent>,
     {
@@ -482,7 +465,7 @@ impl<'a> DrawingPolygonInit<'a> {
     }
 
     /// Describe the polygon with a sequence of points.
-    pub fn points<I>(self, points: I) -> DrawingPolygon<'a>
+    pub fn points<I>(self, points: I) -> DrawingPolygon<'a, M>
     where
         I: IntoIterator,
         I::Item: Into<Vec2>,
@@ -490,28 +473,26 @@ impl<'a> DrawingPolygonInit<'a> {
         self.map_ty_with_context(|ty, ctxt| ty.points(ctxt, points))
     }
 
-    /// Consumes an iterator of points and converts them to an iterator yielding path events.
-    pub fn points_colored<I, P, C>(self, points: I) -> DrawingPolygon<'a>
+    pub fn points_colored<I, P, C>(self, points: I) -> DrawingPolygon<'a, M>
     where
         I: IntoIterator<Item = (P, C)>,
         P: Into<Vec2>,
         C: Into<Color>,
     {
-        self.map_ty_with_context(|ty, ctxt| ty.points_colored(ctxt, points))
+        self.map_ty_with_context(|ty, ctxt| {
+            ty.points_vertex(ctxt, points.into_iter().map(|(p, c)| (p, c, Vec2::ZERO)))
+        })
     }
 
-    /// Describe the polygon with an iterator yielding textured poings.
-    pub fn points_textured<I, P, T>(
-        self,
-        texture_handle: Handle<Image>,
-        points: I,
-    ) -> DrawingPolygon<'a>
+    /// Consumes an iterator of points and converts them to an iterator yielding path events.
+    pub fn points_vertex<I, P, C, U>(self, points: I) -> DrawingPolygon<'a, M>
     where
-        I: IntoIterator<Item = (P, T)>,
+        I: IntoIterator<Item = (P, C, U)>,
         P: Into<Vec2>,
-        T: Into<Vec2>,
+        C: Into<Color>,
+        U: Into<Vec2>,
     {
-        self.map_ty_with_context(|ty, ctxt| ty.points_textured(ctxt, texture_handle, points))
+        self.map_ty_with_context(|ty, ctxt| ty.points_vertex(ctxt, points))
     }
 }
 
diff --git a/bevy_nannou_draw/src/draw/primitive/quad.rs b/bevy_nannou_draw/src/draw/primitive/quad.rs
index e09bca3a9..42593d59c 100644
--- a/bevy_nannou_draw/src/draw/primitive/quad.rs
+++ b/bevy_nannou_draw/src/draw/primitive/quad.rs
@@ -1,3 +1,8 @@
+use bevy::prelude::*;
+use lyon::tessellation::StrokeOptions;
+
+use nannou_core::geom;
+
 use crate::draw::primitive::polygon::{self, PolygonInit, PolygonOptions, SetPolygon};
 use crate::draw::primitive::Primitive;
 use crate::draw::properties::spatial::{dimension, orientation, position};
@@ -5,9 +10,6 @@ use crate::draw::properties::{
     spatial, SetColor, SetDimensions, SetOrientation, SetPosition, SetStroke,
 };
 use crate::draw::{self, Drawing};
-use bevy::prelude::*;
-use lyon::tessellation::StrokeOptions;
-use nannou_core::geom;
 
 /// Properties related to drawing a **Quad**.
 #[derive(Clone, Debug)]
@@ -18,7 +20,7 @@ pub struct Quad {
 }
 
 /// The drawing context for a `Quad`.
-pub type DrawingQuad<'a> = Drawing<'a, Quad>;
+pub type DrawingQuad<'a, M> = Drawing<'a, Quad, M>;
 
 // Quad-specific methods.
 
@@ -47,11 +49,7 @@ impl Quad {
 
 // Trait implementations.
 impl draw::render::RenderPrimitive for Quad {
-    fn render_primitive(
-        self,
-        ctxt: draw::render::RenderContext,
-        mesh: &mut Mesh,
-    ) -> draw::render::PrimitiveRender {
+    fn render_primitive(self, ctxt: draw::render::RenderContext, mesh: &mut Mesh) {
         let Quad {
             mut quad,
             polygon,
@@ -75,16 +73,22 @@ impl draw::render::RenderPrimitive for Quad {
             quad = geom::Quad([new_a, new_b, new_c, new_d]);
         }
 
-        let points = quad.vertices();
+        let tex_coords = [
+            Vec2::new(0.0, 0.0), // Bottom-left
+            Vec2::new(1.0, 0.0), // Bottom-right
+            Vec2::new(1.0, 1.0), // Top-right
+            Vec2::new(0.0, 1.0), // Top-left
+        ];
+
+        let points = quad.vertices().zip(tex_coords.iter().copied());
         polygon::render_points_themed(
             polygon.opts,
+            true,
             points,
             ctxt,
             &draw::theme::Primitive::Quad,
             mesh,
         );
-
-        draw::render::PrimitiveRender::default()
     }
 }
 
@@ -171,7 +175,10 @@ impl Into<Option<Quad>> for Primitive {
 
 // Drawing methods.
 
-impl<'a> DrawingQuad<'a> {
+impl<'a, M> DrawingQuad<'a, M>
+where
+    M: Material + Default,
+{
     /// Use the given points as the vertices (corners) of the quad.
     pub fn points<P>(self, a: P, b: P, c: P, d: P) -> Self
     where
diff --git a/bevy_nannou_draw/src/draw/primitive/rect.rs b/bevy_nannou_draw/src/draw/primitive/rect.rs
index c3359e57a..271b371b0 100644
--- a/bevy_nannou_draw/src/draw/primitive/rect.rs
+++ b/bevy_nannou_draw/src/draw/primitive/rect.rs
@@ -1,21 +1,25 @@
+use bevy::prelude::*;
+use lyon::tessellation::StrokeOptions;
+
+use nannou_core::geom;
+
 use crate::draw::primitive::polygon::{self, PolygonInit, PolygonOptions, SetPolygon};
 use crate::draw::primitive::Primitive;
 use crate::draw::properties::spatial::{dimension, orientation, position};
+use crate::draw::properties::tex_coords::SetTexCoords;
 use crate::draw::properties::{SetColor, SetDimensions, SetOrientation, SetPosition, SetStroke};
 use crate::draw::{self, Drawing};
-use bevy::prelude::*;
-use lyon::tessellation::StrokeOptions;
-use nannou_core::geom;
 
 /// Properties related to drawing a **Rect**.
 #[derive(Clone, Debug)]
 pub struct Rect {
     dimensions: dimension::Properties,
+    tex_coords: Option<geom::Rect>,
     polygon: PolygonInit,
 }
 
 /// The drawing context for a Rect.
-pub type DrawingRect<'a> = Drawing<'a, Rect>;
+pub type DrawingRect<'a, M> = Drawing<'a, Rect, M>;
 
 // Trait implementations.
 
@@ -29,7 +33,10 @@ impl Rect {
     }
 }
 
-impl<'a> DrawingRect<'a> {
+impl<'a, M> DrawingRect<'a, M>
+where
+    M: Material + Default,
+{
     /// Stroke the outline with the given color.
     pub fn stroke<C>(self, color: C) -> Self
     where
@@ -37,15 +44,16 @@ impl<'a> DrawingRect<'a> {
     {
         self.map_ty(|ty| ty.stroke(color))
     }
+
+    pub fn area(self, area: geom::Rect) -> Self {
+        self.map_ty(|ty| ty.area(area))
+    }
 }
 
 impl draw::render::RenderPrimitive for Rect {
-    fn render_primitive(
-        self,
-        ctxt: draw::render::RenderContext,
-        mesh: &mut Mesh,
-    ) -> draw::render::PrimitiveRender {
+    fn render_primitive(self, ctxt: draw::render::RenderContext, mesh: &mut Mesh) {
         let Rect {
+            tex_coords,
             polygon,
             dimensions,
         } = self;
@@ -59,16 +67,37 @@ impl draw::render::RenderPrimitive for Rect {
         let w = maybe_x.unwrap_or(100.0);
         let h = maybe_y.unwrap_or(100.0);
         let rect = geom::Rect::from_wh([w, h].into());
-        let points = rect.corners().vertices().map(Vec2::from);
+
+        let tex_coords = tex_coords
+            .map(|area| {
+                [
+                    area.bottom_left(),
+                    area.bottom_right(),
+                    area.top_right(),
+                    area.top_left(),
+                ]
+            })
+            .unwrap_or([
+                Vec2::new(0.0, 0.0), // Bottom-left
+                Vec2::new(1.0, 0.0), // Bottom-right
+                Vec2::new(1.0, 1.0), // Top-right
+                Vec2::new(0.0, 1.0), // Top-left
+            ]);
+
+        let points = rect
+            .corners()
+            .vertices()
+            .map(Vec2::from)
+            .zip(tex_coords.iter().copied());
+
         polygon::render_points_themed(
             polygon.opts,
+            true,
             points,
             ctxt,
             &draw::theme::Primitive::Rect,
             mesh,
         );
-
-        draw::render::PrimitiveRender::default()
     }
 }
 
@@ -85,6 +114,7 @@ impl Default for Rect {
         let polygon = <_>::default();
         Rect {
             dimensions,
+            tex_coords: None,
             polygon,
         }
     }
@@ -126,6 +156,12 @@ impl SetPolygon for Rect {
     }
 }
 
+impl SetTexCoords for Rect {
+    fn tex_coords_mut(&mut self) -> &mut Option<geom::Rect> {
+        SetTexCoords::tex_coords_mut(&mut self.tex_coords)
+    }
+}
+
 // Primitive conversions.
 
 impl From<Rect> for Primitive {
diff --git a/bevy_nannou_draw/src/draw/primitive/text.rs b/bevy_nannou_draw/src/draw/primitive/text.rs
index 71f05fa24..b2de7080f 100644
--- a/bevy_nannou_draw/src/draw/primitive/text.rs
+++ b/bevy_nannou_draw/src/draw/primitive/text.rs
@@ -1,12 +1,11 @@
+use bevy::prelude::*;
+
 use crate::draw::drawing::DrawingContext;
-use crate::draw::mesh::MeshExt;
-use crate::draw::primitive::{Primitive, Vertex};
+use crate::draw::primitive::Primitive;
 use crate::draw::properties::spatial::{self, dimension, orientation, position};
 use crate::draw::properties::{SetColor, SetDimensions, SetOrientation, SetPosition};
-use crate::draw::{self, theme, Drawing};
+use crate::draw::{self, Drawing};
 use crate::text::{self, Align, Font, FontSize, Justify, Layout, Scalar, Wrap};
-use bevy::prelude::*;
-use nannou_core::geom;
 
 /// Properties related to drawing the **Text** primitive.
 #[derive(Clone, Debug)]
@@ -26,7 +25,7 @@ pub struct Style {
 }
 
 /// The drawing context for the **Text** primitive.
-pub type DrawingText<'a> = Drawing<'a, Text>;
+pub type DrawingText<'a, M> = Drawing<'a, Text, M>;
 
 impl Text {
     /// Begin drawing some text.
@@ -157,7 +156,10 @@ impl Text {
     }
 }
 
-impl<'a> DrawingText<'a> {
+impl<'a, M> DrawingText<'a, M>
+where
+    M: Material + Default,
+{
     /// The font size to use for the text.
     pub fn font_size(self, size: text::FontSize) -> Self {
         self.map_ty(|ty| ty.font_size(size))
@@ -256,160 +258,8 @@ impl<'a> DrawingText<'a> {
 }
 
 impl draw::render::RenderPrimitive for Text {
-    fn render_primitive(
-        self,
-        ctxt: draw::render::RenderContext,
-        mesh: &mut Mesh,
-    ) -> draw::render::PrimitiveRender {
-        let Text {
-            spatial,
-            style,
-            text,
-        } = self;
-        let Style {
-            color,
-            glyph_colors,
-            layout,
-        } = style;
-        let layout = layout.build();
-        let (maybe_x, maybe_y, maybe_z) = (
-            spatial.dimensions.x,
-            spatial.dimensions.y,
-            spatial.dimensions.z,
-        );
-        assert!(
-            maybe_z.is_none(),
-            "z dimension support for text is unimplemented"
-        );
-        let w = maybe_x.unwrap_or(200.0);
-        let h = maybe_y.unwrap_or(200.0);
-        let rect: geom::Rect = geom::Rect::from_wh([w, h].into());
-        let color = color.unwrap_or_else(|| ctxt.theme.fill(&theme::Primitive::Text));
-
-        let text_str = &ctxt.text_buffer[text.clone()];
-        let text = text::text(text_str).layout(&layout).build(rect);
-
-        // Queue the glyphs to be cached
-        let font_id = text::font::id(text.font());
-        let positioned_glyphs: Vec<_> = text
-            .rt_glyphs(
-                ctxt.output_attachment_size,
-                ctxt.output_attachment_scale_factor,
-            )
-            .collect();
-        for glyph in positioned_glyphs.iter() {
-            ctxt.glyph_cache.queue_glyph(font_id.index(), glyph.clone());
-        }
-
-        // Cache the enqueued glyphs within the pixel buffer.
-        let (glyph_cache_w, _) = ctxt.glyph_cache.dimensions();
-        {
-            let draw::render::RenderContext {
-                glyph_cache:
-                    &mut draw::render::GlyphCache {
-                        ref mut cache,
-                        ref mut pixel_buffer,
-                        ref mut requires_upload,
-                        ..
-                    },
-                ..
-            } = ctxt;
-            let glyph_cache_w = glyph_cache_w as usize;
-            let res = cache.cache_queued(|rect, data| {
-                let width = (rect.max.x - rect.min.x) as usize;
-                let height = (rect.max.y - rect.min.y) as usize;
-                let mut dst_ix = rect.min.y as usize * glyph_cache_w + rect.min.x as usize;
-                let mut src_ix = 0;
-                for _ in 0..height {
-                    let dst_range = dst_ix..dst_ix + width;
-                    let src_range = src_ix..src_ix + width;
-                    let dst_slice = &mut pixel_buffer[dst_range];
-                    let src_slice = &data[src_range];
-                    dst_slice.copy_from_slice(src_slice);
-                    dst_ix += glyph_cache_w;
-                    src_ix += width;
-                }
-                *requires_upload = true;
-            });
-            if let Err(err) = res {
-                eprintln!("failed to cache queued glyphs: {}", err);
-            }
-        }
-
-        // Determine the transform to apply to all points.
-        let global_transform = *ctxt.transform;
-        let local_transform = spatial.position.transform() * spatial.orientation.transform();
-        let transform = global_transform * local_transform;
-
-        // A function for converting RustType rects to nannou rects.
-        let scale_factor = ctxt.output_attachment_scale_factor;
-        let (out_w, out_h) = ctxt.output_attachment_size.into();
-        let [half_out_w, half_out_h] = [out_w as f32 / 2.0, out_h as f32 / 2.0];
-        let to_nannou_rect = |screen_rect: text::rt::Rect<i32>| {
-            let l = screen_rect.min.x as f32 / scale_factor - half_out_w;
-            let r = screen_rect.max.x as f32 / scale_factor - half_out_w;
-            let t = -(screen_rect.min.y as f32 / scale_factor - half_out_h);
-            let b = -(screen_rect.max.y as f32 / scale_factor - half_out_h);
-            geom::Rect::from_corners([l, b].into(), [r, t].into())
-        };
-
-        // Skips non-rendered colors (e.g. due to line breaks),
-        //   assuming LineInfos are ordered by ascending character position.
-        let glyph_colors_iter = text
-            .line_infos()
-            .iter()
-            .flat_map(|li| li.char_range())
-            .take_while(|&i| i < glyph_colors.len())
-            .map(|i| &glyph_colors[i])
-            // Repeat `color` if more glyphs than glyph_colors
-            .chain(std::iter::repeat(&color));
-
-        // Extend the mesh with a rect for each displayed glyph.
-        for (g, g_color) in positioned_glyphs.iter().zip(glyph_colors_iter) {
-            if let Ok(Some((uv_rect, screen_rect))) = ctxt.glyph_cache.rect_for(font_id.index(), &g)
-            {
-                let rect = to_nannou_rect(screen_rect);
-
-                // Create a mesh-compatible vertex from the position and tex_coords.
-                let v = |p: Vec2, tex_coords: [f32; 2]| -> Vertex {
-                    let point = transform.transform_point3([p.x, p.y, 0.0].into());
-                    (point, g_color.to_owned(), tex_coords.into())
-                };
-
-                // The sides of the UV rect.
-                let uv_l = uv_rect.min.x;
-                let uv_t = uv_rect.min.y;
-                let uv_r = uv_rect.max.x;
-                let uv_b = uv_rect.max.y;
-
-                // Insert the vertices.
-                let bottom_left = v(rect.bottom_left(), [uv_l, uv_b]);
-                let bottom_right = v(rect.bottom_right(), [uv_r, uv_b]);
-                let top_left = v(rect.top_left(), [uv_l, uv_t]);
-                let top_right = v(rect.top_right(), [uv_r, uv_t]);
-                let start_ix = mesh.count_vertices() as u32;
-
-                for (point, color, uv) in [top_left, bottom_left, bottom_right, top_right] {
-                    mesh.points_mut().push(point.to_array());
-                    mesh.colors_mut().push(color.as_linear_rgba_f32());
-                    mesh.tex_coords_mut().push(uv.to_array());
-                }
-
-                // Now the indices.
-                let tl_ix = start_ix;
-                let bl_ix = start_ix + 1;
-                let br_ix = start_ix + 2;
-                let tr_ix = start_ix + 3;
-                mesh.push_index(tl_ix);
-                mesh.push_index(bl_ix);
-                mesh.push_index(br_ix);
-                mesh.push_index(tl_ix);
-                mesh.push_index(br_ix);
-                mesh.push_index(tr_ix);
-            }
-        }
-
-        draw::render::PrimitiveRender::text()
+    fn render_primitive(self, _ctxt: draw::render::RenderContext, _mesh: &mut Mesh) {
+        todo!()
     }
 }
 
diff --git a/bevy_nannou_draw/src/draw/primitive/texture.rs b/bevy_nannou_draw/src/draw/primitive/texture.rs
deleted file mode 100644
index 458293153..000000000
--- a/bevy_nannou_draw/src/draw/primitive/texture.rs
+++ /dev/null
@@ -1,161 +0,0 @@
-use crate::draw::primitive::path;
-use crate::draw::primitive::Primitive;
-use crate::draw::properties::spatial::{self, dimension, orientation, position};
-use crate::draw::properties::{SetDimensions, SetOrientation, SetPosition};
-use crate::draw::{self, Drawing};
-use bevy::prelude::*;
-use nannou_core::geom;
-
-/// Properties related to drawing a **Rect**.
-#[derive(Clone, Debug)]
-pub struct Texture {
-    texture_handle: Handle<Image>,
-    spatial: spatial::Properties,
-    area: geom::Rect,
-}
-
-/// The drawing context for a Rect.
-pub type DrawingTexture<'a> = Drawing<'a, Texture>;
-
-// Trait implementations.
-
-impl Texture {
-    pub(crate) fn new(texture_handle: Handle<Image>, texture: Image) -> Self {
-        let w = texture.width() as f32;
-        let h = texture.height() as f32;
-        let spatial = spatial::Properties::default().w_h(w, h);
-        let x = geom::Range {
-            start: 0.0,
-            end: 1.0,
-        };
-        let y = geom::Range {
-            start: 0.0,
-            end: 1.0,
-        };
-        let area = geom::Rect { x, y };
-        Self {
-            texture_handle,
-            spatial,
-            area,
-        }
-    }
-}
-
-impl Texture {
-    /// Specify the area of the texture to draw.
-    ///
-    /// The bounds of the rectangle should represent the desired area as texture coordinates of the
-    /// underlying texture.
-    ///
-    /// Texture coordinates range from (0.0, 0.0) in the bottom left of the texture, to (1.0, 1.0)
-    /// in the top right of the texture.
-    ///
-    /// By default, the area represents the full extent of the texture.
-    pub fn area(mut self, rect: geom::Rect) -> Self {
-        self.area = rect;
-        self
-    }
-}
-
-impl<'a> DrawingTexture<'a> {
-    /// Specify the area of the texture to draw.
-    ///
-    /// The bounds of the rectangle should represent the desired area as texture coordinates of the
-    /// underlying texture.
-    ///
-    /// Texture coordinates range from (0.0, 0.0) in the bottom left of the texture, to (1.0, 1.0)
-    /// in the top right of the texture.
-    ///
-    /// By default, the area represents the full extent of the texture.
-    pub fn area(self, rect: geom::Rect) -> Self {
-        self.map_ty(|ty| ty.area(rect))
-    }
-}
-
-impl draw::render::RenderPrimitive for Texture {
-    fn render_primitive(
-        self,
-        mut ctxt: draw::render::RenderContext,
-        mesh: &mut Mesh,
-    ) -> draw::render::PrimitiveRender {
-        let Texture {
-            texture_handle,
-            spatial,
-            area,
-        } = self;
-        let spatial::Properties {
-            dimensions,
-            position,
-            orientation,
-        } = spatial;
-
-        // If dimensions were specified, scale the points to those dimensions.
-        let (maybe_x, maybe_y, maybe_z) = (dimensions.x, dimensions.y, dimensions.z);
-        assert!(
-            maybe_z.is_none(),
-            "z dimension support for rect is unimplemented"
-        );
-        let w = maybe_x.unwrap_or(100.0);
-        let h = maybe_y.unwrap_or(100.0);
-        let rect = geom::Rect::from_w_h(w, h);
-
-        // Determine the transform to apply to all points.
-        let global_transform = *ctxt.transform;
-        let local_transform = position.transform() * orientation.transform();
-        let transform = global_transform * local_transform;
-
-        // Create an iterator yielding texture points.
-        let points_textured = rect
-            .corners()
-            .vertices()
-            .map(Vec2::from)
-            .zip(area.invert_y().corners().vertices().map(Vec2::from));
-
-        path::render_path_points_textured(
-            points_textured,
-            true,
-            transform,
-            path::Options::Fill(Default::default()),
-            &mut ctxt.fill_tessellator,
-            &mut ctxt.stroke_tessellator,
-            mesh,
-        );
-
-        draw::render::PrimitiveRender::texture(texture_handle)
-    }
-}
-
-impl SetOrientation for Texture {
-    fn properties(&mut self) -> &mut orientation::Properties {
-        SetOrientation::properties(&mut self.spatial)
-    }
-}
-
-impl SetPosition for Texture {
-    fn properties(&mut self) -> &mut position::Properties {
-        SetPosition::properties(&mut self.spatial)
-    }
-}
-
-impl SetDimensions for Texture {
-    fn properties(&mut self) -> &mut dimension::Properties {
-        SetDimensions::properties(&mut self.spatial)
-    }
-}
-
-// Primitive conversions.
-
-impl From<Texture> for Primitive {
-    fn from(prim: Texture) -> Self {
-        Primitive::Texture(prim)
-    }
-}
-
-impl Into<Option<Texture>> for Primitive {
-    fn into(self) -> Option<Texture> {
-        match self {
-            Primitive::Texture(prim) => Some(prim),
-            _ => None,
-        }
-    }
-}
diff --git a/bevy_nannou_draw/src/draw/primitive/tri.rs b/bevy_nannou_draw/src/draw/primitive/tri.rs
index 30f122299..6217044f3 100644
--- a/bevy_nannou_draw/src/draw/primitive/tri.rs
+++ b/bevy_nannou_draw/src/draw/primitive/tri.rs
@@ -1,11 +1,13 @@
+use bevy::prelude::*;
+use lyon::tessellation::StrokeOptions;
+
+use nannou_core::geom;
+
 use crate::draw::primitive::polygon::{self, PolygonInit, PolygonOptions, SetPolygon};
 use crate::draw::primitive::Primitive;
 use crate::draw::properties::spatial::{dimension, orientation, position};
 use crate::draw::properties::{SetColor, SetDimensions, SetOrientation, SetPosition, SetStroke};
 use crate::draw::{self, Drawing};
-use bevy::prelude::*;
-use lyon::tessellation::StrokeOptions;
-use nannou_core::geom;
 
 /// Properties related to drawing a **Tri**.
 #[derive(Clone, Debug)]
@@ -16,7 +18,7 @@ pub struct Tri {
 }
 
 /// The drawing context for a `Tri`.
-pub type DrawingTri<'a> = Drawing<'a, Tri>;
+pub type DrawingTri<'a, M> = Drawing<'a, Tri, M>;
 
 // Tri-specific methods.
 
@@ -44,7 +46,10 @@ impl Tri {
 
 // Drawing methods.
 
-impl<'a> DrawingTri<'a> {
+impl<'a, M> DrawingTri<'a, M>
+where
+    M: Material + Default,
+{
     /// Stroke the outline with the given color.
     pub fn stroke<C>(self, color: C) -> Self
     where
@@ -65,11 +70,7 @@ impl<'a> DrawingTri<'a> {
 // Trait implementations.
 
 impl draw::render::RenderPrimitive for Tri {
-    fn render_primitive(
-        self,
-        ctxt: draw::render::RenderContext,
-        mesh: &mut Mesh,
-    ) -> draw::render::PrimitiveRender {
+    fn render_primitive(self, ctxt: draw::render::RenderContext, mesh: &mut Mesh) {
         let Tri {
             mut tri,
             dimensions,
@@ -90,16 +91,23 @@ impl draw::render::RenderPrimitive for Tri {
             let new_c = translate(c);
             tri = geom::Tri([new_a, new_b, new_c]);
         }
-        let points = tri.vertices();
+
+        let tex_coords = [
+            Vec2::new(0.0, 0.0), // Vertex A
+            Vec2::new(1.0, 0.0), // Vertex B
+            Vec2::new(0.5, 1.0), // Vertex C
+        ];
+
+        let points = tri.vertices().zip(tex_coords.iter().copied());
+
         polygon::render_points_themed(
             polygon.opts,
+            true,
             points,
             ctxt,
             &draw::theme::Primitive::Tri,
             mesh,
         );
-
-        draw::render::PrimitiveRender::default()
     }
 }
 
diff --git a/bevy_nannou_draw/src/draw/properties/color.rs b/bevy_nannou_draw/src/draw/properties/color.rs
index f4a2d0fca..d84ce2c48 100644
--- a/bevy_nannou_draw/src/draw/properties/color.rs
+++ b/bevy_nannou_draw/src/draw/properties/color.rs
@@ -1,5 +1,4 @@
 use bevy::prelude::Color;
-use num_traits::Float;
 
 /// Nodes that support setting colors.
 pub trait SetColor: Sized {
@@ -20,23 +19,31 @@ pub trait SetColor: Sized {
     }
 
     /// Specify the color via red, green and blue channels.
-    fn rgb(self, r: f32, g: f32, b: f32) -> Self {
-        self.color(Color::rgb(r, g, b))
+    fn srgb(self, r: f32, g: f32, b: f32) -> Self {
+        self.color(Color::srgb(r, g, b))
     }
 
     /// Specify the color via red, green and blue channels as bytes
-    fn rgb8(self, r: u8, g: u8, b: u8) -> Self {
-        self.color(Color::rgb_u8(r, g, b))
+    fn srgb_u8(self, r: u8, g: u8, b: u8) -> Self {
+        self.color(Color::srgb_u8(r, g, b))
     }
 
     /// Specify the color via red, green, blue and alpha channels.
-    fn rgba(self, r: f32, g: f32, b: f32, a: f32) -> Self {
-        self.color(Color::rgba(r, g, b, a))
+    fn srgba(self, r: f32, g: f32, b: f32, a: f32) -> Self {
+        self.color(Color::srgba(r, g, b, a))
     }
 
     /// Specify the color via red, green, blue and alpha channels as bytes
-    fn rgba8(self, r: u8, g: u8, b: u8, a: u8) -> Self {
-        self.color(Color::rgba_u8(r, g, b, a))
+    fn srgba_u8(self, r: u8, g: u8, b: u8, a: u8) -> Self {
+        self.color(Color::srgba_u8(r, g, b, a))
+    }
+
+    fn linear_rgb(self, r: f32, g: f32, b: f32) -> Self {
+        self.color(Color::linear_rgb(r, g, b))
+    }
+
+    fn linear_rgba(self, r: f32, g: f32, b: f32, a: f32) -> Self {
+        self.color(Color::linear_rgba(r, g, b, a))
     }
 
     /// Specify the color via hue, saturation and luminance.
@@ -67,36 +74,83 @@ pub trait SetColor: Sized {
         self.color(Color::hsla(hue, s, l, a))
     }
 
-    // /// Specify the color via hue, saturation and *value* (brightness).
-    // ///
-    // /// This is sometimes also known as "hsb".
-    // ///
-    // /// The given hue expects a value between `0.0` and `1.0` where `0.0` is 0 degress and `1.0` is
-    // /// 360 degrees (or 2 PI radians).
-    // ///
-    // /// See the [wikipedia entry](https://en.wikipedia.org/wiki/HSL_and_HSV) for more details on
-    // /// this color space.
-    // fn hsv(self, h: f32, s: f32, v: f32) -> Self {
-    //     let hue = h * 360.0;
-    //     self.color(Color:: (hue, s, v))
-    // }
-
-    // /// Specify the color via hue, saturation, *value* (brightness) and an alpha channel.
-    // ///
-    // /// This is sometimes also known as "hsba".
-    // ///
-    // /// The given hue expects a value between `0.0` and `1.0` where `0.0` is 0 degress and `1.0` is
-    // /// 360 degrees (or 2 PI radians).
-    // ///
-    // /// See the [wikipedia entry](https://en.wikipedia.org/wiki/HSL_and_HSV) for more details on
-    // /// this color space.
-    // fn hsva(self, h: S, s: S, v: S, a: S) -> Self
-    // where
-    //     S: Float,
-    // {
-    //     let hue = color::RgbHue::from_degrees(h * S::from(360.0).unwrap());
-    //     self.color(color::Hsva::new(hue, s, v, a))
-    // }
+    /// Specify the color via hue, saturation and *value* (brightness).
+    ///
+    /// This is sometimes also known as "hsb".
+    ///
+    /// The given hue expects a value between `0.0` and `1.0` where `0.0` is 0 degress and `1.0` is
+    /// 360 degrees (or 2 PI radians).
+    ///
+    /// See the [wikipedia entry](https://en.wikipedia.org/wiki/HSL_and_HSV) for more details on
+    /// this color space.
+    fn hsv(self, h: f32, s: f32, v: f32) -> Self {
+        let hue = h * 360.0;
+        self.color(Color::hsv(hue, s, v))
+    }
+
+    /// Specify the color via hue, saturation, *value* (brightness) and an alpha channel.
+    ///
+    /// This is sometimes also known as "hsba".
+    ///
+    /// The given hue expects a value between `0.0` and `1.0` where `0.0` is 0 degress and `1.0` is
+    /// 360 degrees (or 2 PI radians).
+    ///
+    /// See the [wikipedia entry](https://en.wikipedia.org/wiki/HSL_and_HSV) for more details on
+    /// this color space.
+    fn hsva(self, h: f32, s: f32, v: f32, a: f32) -> Self {
+        let hue = h * 360.0;
+        self.color(Color::hsva(hue, s, v, a))
+    }
+
+    fn hwb(self, h: f32, w: f32, b: f32) -> Self {
+        let hue = h * 360.0;
+        self.color(Color::hwb(hue, w, b))
+    }
+
+    fn hwba(self, h: f32, w: f32, b: f32, a: f32) -> Self {
+        let hue = h * 360.0;
+        self.color(Color::hwba(hue, w, b, a))
+    }
+
+    fn lab(self, l: f32, a: f32, b: f32) -> Self {
+        self.color(Color::lab(l, a, b))
+    }
+
+    fn laba(self, l: f32, a: f32, b: f32, alpha: f32) -> Self {
+        self.color(Color::laba(l, a, b, alpha))
+    }
+
+    fn lch(self, l: f32, c: f32, h: f32) -> Self {
+        self.color(Color::lch(l, c, h))
+    }
+
+    fn lcha(self, l: f32, c: f32, h: f32, alpha: f32) -> Self {
+        self.color(Color::lcha(l, c, h, alpha))
+    }
+
+    fn oklab(self, l: f32, a: f32, b: f32) -> Self {
+        self.color(Color::oklab(l, a, b))
+    }
+
+    fn oklaba(self, l: f32, a: f32, b: f32, alpha: f32) -> Self {
+        self.color(Color::oklaba(l, a, b, alpha))
+    }
+
+    fn oklch(self, l: f32, c: f32, h: f32) -> Self {
+        self.color(Color::oklch(l, c, h))
+    }
+
+    fn oklcha(self, l: f32, c: f32, h: f32, alpha: f32) -> Self {
+        self.color(Color::oklcha(l, c, h, alpha))
+    }
+
+    fn cie_xyz(self, x: f32, y: f32, z: f32) -> Self {
+        self.color(Color::xyz(x, y, z))
+    }
+
+    fn cie_xyza(self, x: f32, y: f32, z: f32, alpha: f32) -> Self {
+        self.color(Color::xyza(x, y, z, alpha))
+    }
 
     /// Specify the color as gray scale
     ///
diff --git a/bevy_nannou_draw/src/draw/properties/mod.rs b/bevy_nannou_draw/src/draw/properties/mod.rs
index dc566a22d..69ddecb2f 100644
--- a/bevy_nannou_draw/src/draw/properties/mod.rs
+++ b/bevy_nannou_draw/src/draw/properties/mod.rs
@@ -6,14 +6,15 @@
 //! Each **Drawing** instance is associated with a specific **Node** in the geometry graph and has
 //! a unique **node::Index** to simplify this.
 
-pub mod color;
-pub mod fill;
-pub mod spatial;
-pub mod stroke;
-
 pub use self::color::SetColor;
 pub use self::fill::SetFill;
 pub use self::spatial::dimension::SetDimensions;
 pub use self::spatial::orientation::SetOrientation;
 pub use self::spatial::position::SetPosition;
 pub use self::stroke::SetStroke;
+
+pub mod color;
+pub mod fill;
+pub mod spatial;
+pub mod stroke;
+pub mod tex_coords;
diff --git a/bevy_nannou_draw/src/draw/properties/spatial/dimension.rs b/bevy_nannou_draw/src/draw/properties/spatial/dimension.rs
index a9486c5fe..c0bc04982 100644
--- a/bevy_nannou_draw/src/draw/properties/spatial/dimension.rs
+++ b/bevy_nannou_draw/src/draw/properties/spatial/dimension.rs
@@ -1,4 +1,5 @@
 use bevy::prelude::*;
+
 /// Dimension properties for **Drawing** a **Primitive**.
 #[derive(Copy, Clone, Debug, Default, PartialEq)]
 pub struct Properties {
diff --git a/bevy_nannou_draw/src/draw/properties/spatial/mod.rs b/bevy_nannou_draw/src/draw/properties/spatial/mod.rs
index d7aa8fa57..199cca37d 100644
--- a/bevy_nannou_draw/src/draw/properties/spatial/mod.rs
+++ b/bevy_nannou_draw/src/draw/properties/spatial/mod.rs
@@ -1,11 +1,11 @@
-pub mod dimension;
-pub mod orientation;
-pub mod position;
-
 pub use self::dimension::SetDimensions;
 pub use self::orientation::SetOrientation;
 pub use self::position::SetPosition;
 
+pub mod dimension;
+pub mod orientation;
+pub mod position;
+
 /// Types that may be positioned, sized and oriented within 3D space.
 pub trait SetSpatial: SetDimensions + SetPosition + SetOrientation {}
 
diff --git a/bevy_nannou_draw/src/draw/properties/tex_coords.rs b/bevy_nannou_draw/src/draw/properties/tex_coords.rs
new file mode 100644
index 000000000..d58316b1b
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/properties/tex_coords.rs
@@ -0,0 +1,16 @@
+use nannou_core::geom;
+
+pub trait SetTexCoords: Sized {
+    fn tex_coords_mut(&mut self) -> &mut Option<geom::Rect>;
+
+    fn area(mut self, area: geom::Rect) -> Self {
+        *self.tex_coords_mut() = Some(area);
+        self
+    }
+}
+
+impl SetTexCoords for Option<geom::Rect> {
+    fn tex_coords_mut(&mut self) -> &mut Option<geom::Rect> {
+        self
+    }
+}
diff --git a/bevy_nannou_draw/src/draw/render/instancing.wgsl b/bevy_nannou_draw/src/draw/render/instancing.wgsl
new file mode 100644
index 000000000..856022536
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/render/instancing.wgsl
@@ -0,0 +1,36 @@
+#import bevy_pbr::mesh_functions::{get_model_matrix, mesh_position_local_to_clip}
+
+struct Vertex {
+    @location(0) position: vec3<f32>,
+    @location(1) normal: vec3<f32>,
+    @location(2) uv: vec2<f32>,
+
+    @location(3) i_pos_scale: vec4<f32>,
+    @location(4) i_color: vec4<f32>,
+};
+
+struct VertexOutput {
+    @builtin(position) clip_position: vec4<f32>,
+    @location(0) color: vec4<f32>,
+};
+
+@vertex
+fn vertex(vertex: Vertex) -> VertexOutput {
+    let position = vertex.position * vertex.i_pos_scale.w + vertex.i_pos_scale.xyz;
+    var out: VertexOutput;
+    // NOTE: Passing 0 as the instance_index to get_model_matrix() is a hack
+    // for this example as the instance_index builtin would map to the wrong
+    // index in the Mesh array. This index could be passed in via another
+    // uniform instead but it's unnecessary for the example.
+    out.clip_position = mesh_position_local_to_clip(
+        get_model_matrix(0u),
+        vec4<f32>(position, 1.0)
+    );
+    out.color = vec4(1.0, 0.0, 0.0, 1.0);
+    return out;
+}
+
+@fragment
+fn fragment(in: VertexOutput) -> @location(0) vec4<f32> {
+    return in.color;
+}
diff --git a/bevy_nannou_draw/src/draw/render/mod.rs b/bevy_nannou_draw/src/draw/render/mod.rs
index 267439492..c51abf8ed 100644
--- a/bevy_nannou_draw/src/draw/render/mod.rs
+++ b/bevy_nannou_draw/src/draw/render/mod.rs
@@ -1,27 +1,15 @@
-use crate::{draw, text};
+use std::hash::Hash;
+
 use bevy::prelude::*;
 use lyon::path::PathEvent;
 use lyon::tessellation::{FillTessellator, StrokeTessellator};
-use std::fmt;
-use std::hash::{Hash, Hasher};
-use std::ops::{Deref, DerefMut};
+
+use crate::draw;
 
 /// Draw API primitives that may be rendered via the **Renderer** type.
 pub trait RenderPrimitive {
     /// Render self into the given mesh.
-    fn render_primitive(self, ctxt: RenderContext, mesh: &mut Mesh) -> PrimitiveRender;
-}
-
-/// Information about the way in which a primitive was rendered.
-pub struct PrimitiveRender {
-    /// Whether or not a specific texture must be available when this primitive is drawn.
-    ///
-    /// If `Some` and the given texture is different than the currently set texture, a render
-    /// command will be encoded that switches from the previous texture's bind group to the new
-    /// one.
-    pub texture_handle: Option<Handle<Image>>,
-    /// The way in which vertices should be coloured in the fragment shader.
-    pub vertex_mode: VertexMode,
+    fn render_primitive(self, ctxt: RenderContext, mesh: &mut Mesh);
 }
 
 /// The context provided to primitives to assist with the rendering process.
@@ -29,53 +17,15 @@ pub struct RenderContext<'a> {
     pub transform: &'a Mat4,
     pub intermediary_mesh: &'a Mesh,
     pub path_event_buffer: &'a [PathEvent],
-    pub path_points_colored_buffer: &'a [(Vec2, Color)],
-    pub path_points_textured_buffer: &'a [(Vec2, Vec2)],
+    pub path_points_vertex_buffer: &'a [(Vec2, Color, Vec2)],
     pub text_buffer: &'a str,
     pub theme: &'a draw::Theme,
-    pub glyph_cache: &'a mut GlyphCache,
     pub fill_tessellator: &'a mut FillTessellator,
     pub stroke_tessellator: &'a mut StrokeTessellator,
     pub output_attachment_size: Vec2, // logical coords
     pub output_attachment_scale_factor: f32,
 }
 
-#[derive(Resource)]
-pub struct GlyphCache {
-    /// Tracks glyphs and their location within the cache.
-    pub cache: text::GlyphCache<'static>,
-    /// The buffer used to store the pixels of the glyphs.
-    pub pixel_buffer: Vec<u8>,
-    /// Will be set to `true` after the cache has been updated if the texture requires re-uploading.
-    pub requires_upload: bool,
-}
-
-impl Deref for GlyphCache {
-    type Target = text::GlyphCache<'static>;
-    fn deref(&self) -> &Self::Target {
-        &self.cache
-    }
-}
-
-impl DerefMut for GlyphCache {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.cache
-    }
-}
-
-/// A top-level indicator of whether or not
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
-#[repr(u32)]
-pub enum VertexMode {
-    /// Use the color values and ignore the texture coordinates.
-    Color = 0,
-    /// Use the texture color and ignore the color values.
-    Texture = 1,
-    /// A special mode used by the text primitive.
-    ///
-    /// Uses the color values, but multiplies the alpha by the glyph cache texture's red value.
-    Text = 2,
-}
 /// The position and dimensions of the scissor.
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub struct Scissor {
@@ -85,14 +35,8 @@ pub struct Scissor {
     pub height: u32,
 }
 
-impl Default for PrimitiveRender {
-    fn default() -> Self {
-        Self::color()
-    }
-}
-
 impl RenderPrimitive for draw::Primitive {
-    fn render_primitive(self, ctxt: RenderContext, mesh: &mut Mesh) -> PrimitiveRender {
+    fn render_primitive(self, ctxt: RenderContext, mesh: &mut Mesh) {
         match self {
             draw::Primitive::Arrow(prim) => prim.render_primitive(ctxt, mesh),
             draw::Primitive::Mesh(prim) => prim.render_primitive(ctxt, mesh),
@@ -104,62 +48,7 @@ impl RenderPrimitive for draw::Primitive {
             draw::Primitive::Rect(prim) => prim.render_primitive(ctxt, mesh),
             draw::Primitive::Line(prim) => prim.render_primitive(ctxt, mesh),
             draw::Primitive::Text(prim) => prim.render_primitive(ctxt, mesh),
-            draw::Primitive::Texture(prim) => prim.render_primitive(ctxt, mesh),
-            _ => PrimitiveRender::default(),
-        }
-    }
-}
-
-impl fmt::Debug for GlyphCache {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("GlyphCache")
-            .field("cache", &self.cache.dimensions())
-            .field("pixel_buffer", &self.pixel_buffer.len())
-            .field("requires_upload", &self.requires_upload)
-            .finish()
-    }
-}
-
-impl PrimitiveRender {
-    /// Specify a vertex mode for the primitive render.
-    pub fn vertex_mode(vertex_mode: VertexMode) -> Self {
-        PrimitiveRender {
-            texture_handle: None,
-            vertex_mode,
-        }
-    }
-
-    pub fn color() -> Self {
-        Self::vertex_mode(VertexMode::Color)
-    }
-
-    pub fn texture(texture_handle: Handle<Image>) -> Self {
-        PrimitiveRender {
-            vertex_mode: VertexMode::Texture,
-            texture_handle: Some(texture_handle),
-        }
-    }
-
-    pub fn text() -> Self {
-        Self::vertex_mode(VertexMode::Text)
-    }
-}
-
-impl GlyphCache {
-    pub fn new(size: [u32; 2], scale_tolerance: f32, position_tolerance: f32) -> Self {
-        let [w, h] = size;
-        let cache = text::GlyphCache::builder()
-            .dimensions(w, h)
-            .scale_tolerance(scale_tolerance)
-            .position_tolerance(position_tolerance)
-            .build()
-            .into();
-        let pixel_buffer = vec![0u8; w as usize * h as usize];
-        let requires_upload = false;
-        GlyphCache {
-            cache,
-            pixel_buffer,
-            requires_upload,
+            _ => {}
         }
     }
 }
diff --git a/bevy_nannou_draw/src/draw/theme.rs b/bevy_nannou_draw/src/draw/theme.rs
index 3a7a521d2..46557e2b6 100644
--- a/bevy_nannou_draw/src/draw/theme.rs
+++ b/bevy_nannou_draw/src/draw/theme.rs
@@ -1,6 +1,7 @@
-use bevy::prelude::Color;
 use std::collections::HashMap;
 
+use bevy::prelude::Color;
+
 /// A set of styling defaults used for coloring texturing geometric primitives that have no entry
 /// within the **Draw**'s inner **ColorMap**.
 #[derive(Clone, Debug)]
@@ -60,8 +61,8 @@ impl Theme {
 impl Default for Theme {
     fn default() -> Self {
         // TODO: This should be pub const.
-        let default_fill = Color::rgba(1.0, 1.0, 1.0, 1.0);
-        let default_stroke = Color::rgba(0.0, 0.0, 0.0, 1.0);
+        let default_fill = Color::srgba(1.0, 1.0, 1.0, 1.0);
+        let default_stroke = Color::srgba(0.0, 0.0, 0.0, 1.0);
 
         let fill_color = ThemeColor {
             default: default_fill,
diff --git a/bevy_nannou_draw/src/lib.rs b/bevy_nannou_draw/src/lib.rs
index bf3dd5250..a6dabaa52 100644
--- a/bevy_nannou_draw/src/lib.rs
+++ b/bevy_nannou_draw/src/lib.rs
@@ -1,24 +1,36 @@
+#![cfg_attr(feature = "nightly", feature(adt_const_params))]
+
 use bevy::prelude::*;
-use bevy::render::extract_component::ExtractComponent;
 
-pub use nannou_core::color;
+use crate::render::NannouRenderPlugin;
 
+pub mod color;
 pub mod draw;
+pub mod render;
 pub mod text;
 
 pub struct NannouDrawPlugin;
 
 impl Plugin for NannouDrawPlugin {
     fn build(&self, app: &mut App) {
-        app.add_systems(PreUpdate, spawn_draw);
+        app.add_plugins(NannouRenderPlugin)
+            .add_systems(First, (spawn_draw, reset_draw).chain());
+    }
+}
+
+fn reset_draw(mut draw_q: Query<&mut DrawHolder>) {
+    for mut draw in draw_q.iter_mut() {
+        draw.reset();
     }
 }
 
-fn spawn_draw(mut commands: Commands, query: Query<Entity, Added<Camera>>) {
+fn spawn_draw(mut commands: Commands, query: Query<Entity, Added<Window>>) {
     for entity in query.iter() {
-        commands.entity(entity).insert(Draw(draw::Draw::new()));
+        commands
+            .entity(entity)
+            .insert(DrawHolder(draw::Draw::new(entity)));
     }
 }
 
-#[derive(Component, Clone, Deref, DerefMut, ExtractComponent)]
-pub struct Draw(pub draw::Draw);
+#[derive(Component, Clone, Deref, DerefMut)]
+pub struct DrawHolder(pub draw::Draw);
diff --git a/bevy_nannou_draw/src/render.rs b/bevy_nannou_draw/src/render.rs
new file mode 100644
index 000000000..ebc5c40bf
--- /dev/null
+++ b/bevy_nannou_draw/src/render.rs
@@ -0,0 +1,449 @@
+use std::any::TypeId;
+use std::hash::Hash;
+use std::ops::{Deref, DerefMut};
+
+use bevy::asset::UntypedAssetId;
+use bevy::pbr::MaterialExtension;
+use bevy::prelude::*;
+use bevy::render::camera::RenderTarget;
+use bevy::render::extract_component::{ExtractComponent, ExtractComponentPlugin};
+use bevy::render::extract_resource::{ExtractResource, ExtractResourcePlugin};
+use bevy::render::render_resource as wgpu;
+use bevy::render::render_resource::{AsBindGroup, BlendState, PolygonMode};
+use bevy::render::view::{NoFrustumCulling, RenderLayers};
+use bevy::window::WindowRef;
+use lyon::lyon_tessellation::{FillTessellator, StrokeTessellator};
+
+#[cfg(feature = "nightly")]
+pub use nightly::*;
+#[cfg(not(feature = "nightly"))]
+pub use stable::*;
+
+use crate::draw::instanced::InstancingPlugin;
+use crate::draw::mesh::MeshExt;
+use crate::draw::render::{RenderContext, RenderPrimitive};
+use crate::draw::{DrawCommand, DrawContext};
+use crate::DrawHolder;
+
+pub struct NannouRenderPlugin;
+
+impl Plugin for NannouRenderPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_systems(Startup, setup_default_texture)
+            .add_plugins((
+                ExtractComponentPlugin::<NannouTextureHandle>::default(),
+                NannouMaterialPlugin::<DefaultNannouMaterial>::default(),
+                InstancingPlugin,
+            ))
+            .add_plugins(ExtractResourcePlugin::<DefaultTextureHandle>::default())
+            .add_systems(Update, texture_event_handler)
+            .add_systems(PostUpdate, update_draw_mesh);
+    }
+}
+
+#[derive(Default)]
+pub struct NannouMaterialPlugin<M: Material>(std::marker::PhantomData<M>);
+
+impl<M: Material> Plugin for NannouMaterialPlugin<M>
+where
+    M::Data: PartialEq + Eq + Hash + Clone,
+{
+    fn build(&self, app: &mut App) {
+        app.add_plugins(MaterialPlugin::<M>::default())
+            .add_systems(PostUpdate, update_material::<M>.after(update_draw_mesh));
+    }
+}
+
+// ----------------------------------------------------------------------------
+// Components and Resources
+// ----------------------------------------------------------------------------
+
+#[cfg(feature = "nightly")]
+mod nightly {
+    use bevy::asset::Asset;
+    use bevy::pbr::{
+        ExtendedMaterial, MaterialExtension, MaterialExtensionKey, MaterialExtensionPipeline,
+        StandardMaterial,
+    };
+    use bevy::prelude::TypePath;
+    use bevy::render::mesh::MeshVertexBufferLayoutRef;
+    use bevy::render::render_resource::{
+        AsBindGroup, BlendState, PolygonMode, RenderPipelineDescriptor, ShaderRef,
+        SpecializedMeshPipelineError,
+    };
+
+    pub type DefaultNannouMaterial = ExtendedMaterial<StandardMaterial, NannouMaterial<"", "">>;
+
+    pub type ExtendedNannouMaterial<const VS: &'static str, const FS: &'static str> =
+        ExtendedMaterial<StandardMaterial, NannouMaterial<VS, FS>>;
+
+    #[derive(Asset, AsBindGroup, TypePath, Debug, Clone, Default)]
+    #[bind_group_data(NannouMaterialKey)]
+    pub struct NannouMaterial<const VS: &'static str, const FS: &'static str> {
+        pub polygon_mode: PolygonMode,
+        pub blend: Option<BlendState>,
+    }
+
+    #[derive(Eq, PartialEq, Hash, Clone)]
+    pub struct NannouMaterialKey {
+        polygon_mode: PolygonMode,
+        blend: Option<BlendState>,
+    }
+
+    impl<const VS: &'static str, const FS: &'static str> From<&NannouMaterial<VS, FS>>
+        for NannouMaterialKey
+    {
+        fn from(material: &NannouMaterial<VS, FS>) -> Self {
+            Self {
+                polygon_mode: material.polygon_mode,
+                blend: material.blend,
+            }
+        }
+    }
+
+    impl<const VS: &'static str, const FS: &'static str> MaterialExtension for NannouMaterial<VS, FS> {
+        fn vertex_shader() -> ShaderRef {
+            if !VS.is_empty() {
+                VS.into()
+            } else {
+                ShaderRef::Default
+            }
+        }
+
+        fn fragment_shader() -> ShaderRef {
+            if !FS.is_empty() {
+                FS.into()
+            } else {
+                ShaderRef::Default
+            }
+        }
+
+        fn specialize(
+            _pipeline: &MaterialExtensionPipeline,
+            descriptor: &mut RenderPipelineDescriptor,
+            _layout: &MeshVertexBufferLayoutRef,
+            key: MaterialExtensionKey<Self>,
+        ) -> Result<(), SpecializedMeshPipelineError> {
+            if let Some(blend) = key.bind_group_data.blend {
+                let fragment = descriptor.fragment.as_mut().unwrap();
+                fragment.targets.iter_mut().for_each(|target| {
+                    if let Some(target) = target {
+                        target.blend = Some(blend);
+                    }
+                });
+            }
+
+            descriptor.primitive.polygon_mode = key.bind_group_data.polygon_mode;
+            Ok(())
+        }
+    }
+}
+
+#[cfg(not(feature = "nightly"))]
+mod stable {
+    use bevy::asset::Asset;
+    use bevy::pbr::{
+        ExtendedMaterial, MaterialExtension, MaterialExtensionKey, MaterialExtensionPipeline,
+        StandardMaterial,
+    };
+    use bevy::prelude::TypePath;
+    use bevy::render::mesh::MeshVertexBufferLayoutRef;
+    use bevy::render::render_resource::{
+        AsBindGroup, BlendState, PolygonMode, RenderPipelineDescriptor, ShaderRef,
+        SpecializedMeshPipelineError,
+    };
+
+    pub type DefaultNannouMaterial = ExtendedMaterial<StandardMaterial, NannouMaterial>;
+
+    pub type ExtendedNannouMaterial = ExtendedMaterial<StandardMaterial, NannouMaterial>;
+
+    #[derive(Asset, AsBindGroup, TypePath, Debug, Clone, Default)]
+    #[bind_group_data(NannouMaterialKey)]
+    pub struct NannouMaterial {
+        pub polygon_mode: PolygonMode,
+        pub blend: Option<BlendState>,
+    }
+
+    #[derive(Eq, PartialEq, Hash, Clone)]
+    pub struct NannouMaterialKey {
+        polygon_mode: PolygonMode,
+        blend: Option<BlendState>,
+    }
+
+    impl From<&NannouMaterial> for NannouMaterialKey {
+        fn from(material: &NannouMaterial) -> Self {
+            Self {
+                polygon_mode: material.polygon_mode,
+                blend: material.blend,
+            }
+        }
+    }
+
+    impl MaterialExtension for NannouMaterial {
+        fn specialize(
+            _pipeline: &MaterialExtensionPipeline,
+            descriptor: &mut RenderPipelineDescriptor,
+            _layout: &MeshVertexBufferLayoutRef,
+            key: MaterialExtensionKey<Self>,
+        ) -> Result<(), SpecializedMeshPipelineError> {
+            if let Some(blend) = key.bind_group_data.blend {
+                let fragment = descriptor.fragment.as_mut().unwrap();
+                fragment.targets.iter_mut().for_each(|target| {
+                    if let Some(target) = target {
+                        target.blend = Some(blend);
+                    }
+                });
+            }
+
+            descriptor.primitive.polygon_mode = key.bind_group_data.polygon_mode;
+            Ok(())
+        }
+    }
+
+    impl From<&NannouMaterial> for crate::render::NannouMaterialKey {
+        fn from(material: &NannouMaterial) -> Self {
+            Self {
+                polygon_mode: material.polygon_mode,
+                blend: material.blend,
+            }
+        }
+    }
+}
+
+#[derive(Eq, PartialEq, Hash, Clone)]
+pub struct NannouMaterialKey {
+    polygon_mode: PolygonMode,
+    blend: Option<BlendState>,
+}
+
+#[derive(Resource, Deref, DerefMut, ExtractResource, Clone)]
+pub struct DefaultTextureHandle(Handle<Image>);
+
+#[derive(Component, Deref, DerefMut, ExtractComponent, Clone)]
+pub struct NannouTextureHandle(Handle<Image>);
+
+fn texture_event_handler(
+    mut commands: Commands,
+    mut ev_asset: EventReader<AssetEvent<Image>>,
+    assets: Res<Assets<Image>>,
+) {
+    for ev in ev_asset.read() {
+        match ev {
+            AssetEvent::Added { .. } | AssetEvent::Modified { .. } | AssetEvent::Removed { .. } => {
+                // TODO: handle these events
+            }
+            AssetEvent::LoadedWithDependencies { id } => {
+                let handle = Handle::Weak(*id);
+                let image = assets.get(&handle).unwrap();
+                // TODO hack to only handle 2D textures for now
+                // We should maybe require users to spawn a NannouTextureHandle themselves
+                if image.texture_descriptor.dimension == wgpu::TextureDimension::D2 {
+                    commands.spawn(NannouTextureHandle(handle));
+                }
+            }
+            _ => {}
+        }
+    }
+}
+
+fn setup_default_texture(mut commands: Commands, mut images: ResMut<Assets<Image>>) {
+    let texture = images.add(Image::default());
+    commands.insert_resource(DefaultTextureHandle(texture));
+}
+
+#[derive(Component, Deref)]
+pub struct UntypedMaterialId(UntypedAssetId);
+
+fn update_material<M>(
+    draw_q: Query<&DrawHolder>,
+    mut commands: Commands,
+    mut materials: ResMut<Assets<M>>,
+    materials_q: Query<(Entity, &UntypedMaterialId)>,
+) where
+    M: Material,
+{
+    for draw in draw_q.iter() {
+        let state = draw.state.write().unwrap();
+        state.materials.iter().for_each(|(id, material)| {
+            if id.type_id() == TypeId::of::<M>() {
+                let material = material.downcast_ref::<M>().unwrap();
+                materials.insert(id.typed(), material.clone());
+            }
+        });
+    }
+
+    for (entity, UntypedMaterialId(id)) in materials_q.iter() {
+        if id.type_id() == TypeId::of::<M>() {
+            commands
+                .entity(entity)
+                .insert(Handle::Weak(id.typed::<M>()));
+        }
+    }
+}
+
+fn update_draw_mesh(
+    mut commands: Commands,
+    draw_q: Query<&DrawHolder>,
+    mut cameras_q: Query<(&mut Camera, &RenderLayers), With<NannouCamera>>,
+    windows: Query<&Window>,
+    mut meshes: ResMut<Assets<Mesh>>,
+) {
+    for draw in draw_q.iter() {
+        let Some((mut window_camera, window_layers)) = cameras_q.iter_mut().find(|(camera, _)| {
+            if let RenderTarget::Window(WindowRef::Entity(window)) = camera.target {
+                if window == draw.window {
+                    return true;
+                }
+            }
+
+            false
+        }) else {
+            warn!("No camera found for window {:?}", draw.window);
+            continue;
+        };
+
+        // Reset the clear color each frame.
+        window_camera.clear_color = ClearColorConfig::None;
+
+        // The window we are rendering to.
+        let window = windows.get(draw.window).unwrap();
+
+        let mut fill_tessellator = FillTessellator::new();
+        let mut stroke_tessellator = StrokeTessellator::new();
+
+        let mut mesh = meshes.add(Mesh::init());
+        let mut curr_ctx: DrawContext = Default::default();
+
+        let draw_cmds = draw.drain_commands();
+        let mut draw_state = draw.state.read().unwrap();
+        let intermediary_state = draw_state.intermediary_state.read().unwrap();
+
+        for cmd in draw_cmds {
+            match cmd {
+                DrawCommand::Primitive(prim) => {
+                    // Info required during rendering.
+                    let ctxt = RenderContext {
+                        intermediary_mesh: &intermediary_state.intermediary_mesh,
+                        path_event_buffer: &intermediary_state.path_event_buffer,
+                        path_points_vertex_buffer: &intermediary_state.path_points_vertex_buffer,
+                        text_buffer: &intermediary_state.text_buffer,
+                        theme: &draw_state.theme,
+                        transform: &curr_ctx.transform,
+                        fill_tessellator: &mut fill_tessellator,
+                        stroke_tessellator: &mut stroke_tessellator,
+                        output_attachment_size: Vec2::new(window.width(), window.height()),
+                        output_attachment_scale_factor: window.scale_factor(),
+                    };
+
+                    // Render the primitive.
+                    let mut mesh = meshes.get_mut(&mesh).unwrap();
+                    prim.render_primitive(ctxt, &mut mesh);
+                }
+                DrawCommand::Instanced(prim, instance_data) => {
+                    let ctxt = RenderContext {
+                        intermediary_mesh: &intermediary_state.intermediary_mesh,
+                        path_event_buffer: &intermediary_state.path_event_buffer,
+                        path_points_vertex_buffer: &intermediary_state.path_points_vertex_buffer,
+                        text_buffer: &intermediary_state.text_buffer,
+                        theme: &draw_state.theme,
+                        transform: &curr_ctx.transform,
+                        fill_tessellator: &mut fill_tessellator,
+                        stroke_tessellator: &mut stroke_tessellator,
+                        output_attachment_size: Vec2::new(window.width(), window.height()),
+                        output_attachment_scale_factor: window.scale_factor(),
+                    };
+
+                    // Render the primitive.
+                    let mut mesh = Mesh::init();
+                    prim.render_primitive(ctxt, &mut mesh);
+                    mesh = mesh.with_removed_attribute(Mesh::ATTRIBUTE_COLOR);
+                    let mesh = meshes.add(mesh);
+                    commands.spawn((
+                        NannouMesh,
+                        mesh,
+                        SpatialBundle::INHERITED_IDENTITY,
+                        instance_data,
+                        NoFrustumCulling,
+                        window_layers.clone(),
+                    ));
+                }
+                DrawCommand::Context(ctx) => {
+                    curr_ctx = ctx;
+                }
+                DrawCommand::Material(mat_id) => {
+                    // We switched materials, so start rendering into a new mesh
+                    mesh = meshes.add(Mesh::init());
+                    commands.spawn((
+                        UntypedMaterialId(mat_id),
+                        mesh.clone(),
+                        Transform::default(),
+                        GlobalTransform::default(),
+                        Visibility::default(),
+                        InheritedVisibility::default(),
+                        ViewVisibility::default(),
+                        NannouMesh,
+                        NoFrustumCulling,
+                        window_layers.clone(),
+                    ));
+                }
+                DrawCommand::BackgroundColor(color) => {
+                    window_camera.clear_color = ClearColorConfig::Custom(color);
+                }
+            }
+        }
+    }
+}
+
+#[derive(Component)]
+pub struct NannouMesh;
+
+#[derive(Resource)]
+pub struct NannouRender {
+    pub mesh: Handle<Mesh>,
+    pub entity: Entity,
+    pub draw_context: DrawContext,
+}
+
+// BLEND
+pub mod blend {
+    use bevy::render::render_resource as wgpu;
+
+    pub const BLEND_NORMAL: wgpu::BlendComponent = wgpu::BlendComponent {
+        src_factor: wgpu::BlendFactor::SrcAlpha,
+        dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
+        operation: wgpu::BlendOperation::Add,
+    };
+
+    pub const BLEND_ADD: wgpu::BlendComponent = wgpu::BlendComponent {
+        src_factor: wgpu::BlendFactor::Src,
+        dst_factor: wgpu::BlendFactor::Dst,
+        operation: wgpu::BlendOperation::Add,
+    };
+
+    pub const BLEND_SUBTRACT: wgpu::BlendComponent = wgpu::BlendComponent {
+        src_factor: wgpu::BlendFactor::Src,
+        dst_factor: wgpu::BlendFactor::Dst,
+        operation: wgpu::BlendOperation::Subtract,
+    };
+
+    pub const BLEND_REVERSE_SUBTRACT: wgpu::BlendComponent = wgpu::BlendComponent {
+        src_factor: wgpu::BlendFactor::Src,
+        dst_factor: wgpu::BlendFactor::Dst,
+        operation: wgpu::BlendOperation::ReverseSubtract,
+    };
+
+    pub const BLEND_DARKEST: wgpu::BlendComponent = wgpu::BlendComponent {
+        src_factor: wgpu::BlendFactor::One,
+        dst_factor: wgpu::BlendFactor::One,
+        operation: wgpu::BlendOperation::Min,
+    };
+
+    pub const BLEND_LIGHTEST: wgpu::BlendComponent = wgpu::BlendComponent {
+        src_factor: wgpu::BlendFactor::One,
+        dst_factor: wgpu::BlendFactor::One,
+        operation: wgpu::BlendOperation::Max,
+    };
+}
+
+#[derive(Component)]
+pub struct NannouCamera;
diff --git a/bevy_nannou_draw/src/text/cursor.rs b/bevy_nannou_draw/src/text/cursor.rs
index b75b58b82..53e2a8048 100644
--- a/bevy_nannou_draw/src/text/cursor.rs
+++ b/bevy_nannou_draw/src/text/cursor.rs
@@ -1,8 +1,9 @@
 //! Logic related to the positioning of the cursor within text.
 
-use crate::text::{self, FontSize, Point, Scalar};
 use nannou_core::geom::{Range, Rect};
 
+use crate::text::{self, FontSize, Point, Scalar};
+
 /// An index representing the position of a cursor within some text.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Index {
diff --git a/bevy_nannou_draw/src/text/font.rs b/bevy_nannou_draw/src/text/font.rs
index f2c62fdcc..6226d230d 100644
--- a/bevy_nannou_draw/src/text/font.rs
+++ b/bevy_nannou_draw/src/text/font.rs
@@ -1,10 +1,11 @@
 //! The `font::Id` and `font::Map` types.
 
-use crate::text::{Font, FontCollection};
 use std::collections::HashMap;
 use std::hash::{Hash, Hasher};
 use std::path::{Path, PathBuf};
 
+use crate::text::{Font, FontCollection};
+
 /// A type-safe wrapper around the `FontId`.
 ///
 /// This is used as both:
diff --git a/bevy_nannou_draw/src/text/glyph.rs b/bevy_nannou_draw/src/text/glyph.rs
index d531476b1..662cc95c3 100644
--- a/bevy_nannou_draw/src/text/glyph.rs
+++ b/bevy_nannou_draw/src/text/glyph.rs
@@ -1,8 +1,10 @@
 //! Logic and types specific to individual glyph layout.
 
-use crate::text::{self, FontSize, Scalar, ScaledGlyph};
+use nannou_core::geom;
 use nannou_core::geom::{Range, Rect};
 
+use crate::text::{self, FontSize, Scalar, ScaledGlyph};
+
 /// Some position along the X axis (used within `CharXs`).
 pub type X = Scalar;
 
@@ -73,7 +75,7 @@ impl<'a, 'b> Iterator for Rects<'a, 'b> {
                 });
             let x = Range::new(left, right);
             let y = Range::new(y.start, y.start + height);
-            let r = Rect { x: x, y: y };
+            let r = geom::Rect { x: x, y: y };
             let g = g.into_unpositioned();
             (g, r)
         })
diff --git a/bevy_nannou_draw/src/text/line.rs b/bevy_nannou_draw/src/text/line.rs
index 697c241dc..d33c70e16 100644
--- a/bevy_nannou_draw/src/text/line.rs
+++ b/bevy_nannou_draw/src/text/line.rs
@@ -2,9 +2,10 @@
 //!
 //! This module is the core of multi-line text handling.
 
-use crate::text::{self, FontSize, Scalar, Wrap};
 use nannou_core::geom::{Range, Rect};
 
+use crate::text::{self, FontSize, Scalar, Wrap};
+
 /// The two types of **Break** indices returned by the **WrapIndicesBy** iterators.
 #[derive(Copy, Clone, Debug, PartialEq)]
 pub enum Break {
diff --git a/bevy_nannou_draw/src/text/mod.rs b/bevy_nannou_draw/src/text/mod.rs
index 59a8520d8..173e9993b 100644
--- a/bevy_nannou_draw/src/text/mod.rs
+++ b/bevy_nannou_draw/src/text/mod.rs
@@ -3,6 +3,17 @@
 //! Currently, this crate is used primarily by the `draw.text()` API but will also play an
 //! important role in future GUI work.
 
+use std::borrow::Cow;
+
+use bevy::prelude::*;
+pub use rusttype::gpu_cache::Cache as GlyphCache;
+pub use rusttype::{Glyph, GlyphId, GlyphIter, LayoutIter, Scale, ScaledGlyph};
+
+use nannou_core::geom;
+
+// Re-export all relevant rusttype types here.
+pub use self::layout::Layout;
+
 pub mod cursor;
 pub mod font;
 pub mod glyph;
@@ -13,15 +24,6 @@ pub mod rt {
     pub use rusttype::{gpu_cache, point, vector, Point, Rect, Vector};
 }
 
-// Re-export all relevant rusttype types here.
-pub use self::layout::Layout;
-pub use rusttype::gpu_cache::Cache as GlyphCache;
-pub use rusttype::{Glyph, GlyphId, GlyphIter, LayoutIter, Scale, ScaledGlyph};
-
-use bevy::prelude::*;
-use nannou_core::geom;
-use std::borrow::Cow;
-
 /// The RustType `FontCollection` type used by nannou.
 pub type FontCollection = rusttype::FontCollection<'static>;
 /// The RustType `Font` type used by nannou.
diff --git a/bevy_nannou_isf/Cargo.toml b/bevy_nannou_isf/Cargo.toml
new file mode 100644
index 000000000..4a6fef37a
--- /dev/null
+++ b/bevy_nannou_isf/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+name = "bevy_nannou_isf"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+bevy = { workspace = true, features = ["shader_format_glsl"] }
+bevy_egui = { workspace = true }
+bevy-inspector-egui = { workspace = true, features = ["bevy_render"] }
+isf = "0.1.0"
+thiserror = "1"
+bytemuck = "1"
+meval = "0.2"
diff --git a/nannou_isf/src/lib.rs b/bevy_nannou_isf/src/asset.rs
similarity index 63%
rename from nannou_isf/src/lib.rs
rename to bevy_nannou_isf/src/asset.rs
index 92770e540..b78fe0145 100644
--- a/nannou_isf/src/lib.rs
+++ b/bevy_nannou_isf/src/asset.rs
@@ -1,16 +1,110 @@
-//! A crate aimed at making it easy to set up an ISF hot-loading environment with nannou.
+use bevy::asset::io::Reader;
+use bevy::asset::{AssetLoader, AsyncReadExt, LoadContext, LoadedAsset};
+use bevy::ecs::system::SystemParamItem;
+use bevy::prelude::*;
+use bevy::render::render_asset::{
+    PrepareAssetError, RenderAsset, RenderAssetPlugin, RenderAssetUsages,
+};
+use bevy::render::render_resource::{AsBindGroup, ShaderRef, ShaderStage};
+use bevy::utils::ConditionalSendFuture;
+use std::collections::BTreeMap;
+use std::io::BufReader;
+use thiserror::Error;
 
-pub use crate::pipeline::{IsfPipeline, IsfTime};
-use std::path::Path;
+// 1. ISF Asset
+#[derive(Asset, TypePath, Debug, Clone)]
+pub struct Isf {
+    pub isf: isf::Isf,
+    pub shader: Handle<Shader>,
+    pub imported_images: BTreeMap<String, Handle<Image>>,
+}
 
-mod pipeline;
+impl Isf {
+    pub fn num_images(&self) -> usize {
+        let mut image_count = self.imported_images.len();
+        let inputs = &self.isf.inputs;
+        for input in inputs {
+            match input.ty {
+                isf::InputType::Image { .. }
+                | isf::InputType::Audio(_)
+                | isf::InputType::AudioFft(_) => image_count += 1,
+                _ => {}
+            }
+        }
+        for pass in &self.isf.passes {
+            if let Some(ref target) = pass.target {
+                image_count += 1;
+            }
+        }
+        image_count
+    }
+}
 
-/// Read the ISF from the shader file at the given path.
-///
-/// Assumes the given path contains a shader.
-pub fn isf_from_shader_path(path: &Path) -> Result<isf::Isf, isf::ParseError> {
-    let glsl_string = std::fs::read_to_string(path).expect("failed to read shader to string");
-    isf::parse(&glsl_string)
+// 2. ISF Asset Loader
+#[derive(Default)]
+pub struct IsfLoader;
+
+#[derive(Debug, Error)]
+pub enum IsfAssetLoaderError {
+    #[error("Failed to load ISF file")]
+    Io(#[from] std::io::Error),
+    #[error("Failed to parse ISF")]
+    Parse(#[from] isf::ParseError),
+}
+
+impl AssetLoader for IsfLoader {
+    type Asset = Isf;
+    type Settings = ();
+    type Error = IsfAssetLoaderError;
+
+    async fn load<'a>(
+        &'a self,
+        reader: &'a mut Reader<'_>,
+        settings: &'a Self::Settings,
+        load_context: &'a mut LoadContext<'_>,
+    ) -> Result<Self::Asset, Self::Error> {
+        let mut bytes = Vec::new();
+        reader.read_to_end(&mut bytes).await?;
+        let glsl_src = std::str::from_utf8(&bytes).map_err(|_| {
+            IsfAssetLoaderError::Io(std::io::Error::new(
+                std::io::ErrorKind::InvalidData,
+                "Invalid UTF-8",
+            ))
+        })?;
+
+        let isf = isf::parse(glsl_src).map_err(|e| IsfAssetLoaderError::Parse(e))?;
+        let glsl = glsl_string_from_isf(&isf);
+        let glsl = prefix_isf_glsl_str(&glsl, glsl_src.to_string());
+        info!("GLSL: {}", glsl);
+        let shader = Shader::from_glsl(glsl, ShaderStage::Fragment, file!());
+        let shader = load_context.add_labeled_asset(String::from("shader"), shader);
+
+        let mut imported_images = BTreeMap::new();
+        for (name, import) in &isf.imported {
+            let image = load_context.load::<Image>(import.path.clone());
+            imported_images.insert(name.clone(), image);
+        }
+        Ok(Isf {
+            isf,
+            shader,
+            imported_images,
+        })
+    }
+
+    fn extensions(&self) -> &[&str] {
+        &["fs", "isf"]
+    }
+}
+
+// 4. Plugin to register the asset loader and material
+pub struct IsfAssetPlugin;
+
+impl Plugin for IsfAssetPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_plugins(RenderAssetPlugin::<GpuIsf>::default())
+            .init_asset::<Isf>()
+            .init_asset_loader::<IsfLoader>();
+    }
 }
 
 /// Generate the necessary GLSL declarations from the given ISF to be prefixed to the GLSL string
@@ -27,11 +121,25 @@ pub fn glsl_string_from_isf(isf: &isf::Isf) -> String {
     let isf_data_str = "
         layout(set = 0, binding = 0) uniform IsfData {
             int PASSINDEX;
+            int _pad0;
+            int _pad1;
+            int _pad2;
             vec2 RENDERSIZE;
+            int _pad3;
+            int _pad4;
             float TIME;
+            int _pad5;
+            int _pad6;
+            int _pad7;
             float TIMEDELTA;
+            int _pad8;
+            int _pad9;
+            int _pad10;
             vec4 DATE;
             int FRAMEINDEX;
+            int _pad11;
+            int _pad12;
+            int _pad13;
         };
     ";
 
@@ -44,18 +152,24 @@ pub fn glsl_string_from_isf(isf: &isf::Isf) -> String {
                 layout(set = 1, binding = 0) uniform IsfDataInputs {\n
             "
             .to_string();
+
             for input in &isf.inputs {
-                let ty_str = match input.ty {
-                    isf::InputType::Event | isf::InputType::Bool(_) => "bool",
-                    isf::InputType::Long(_) => "int",
-                    isf::InputType::Float(_) => "float",
-                    isf::InputType::Point2d(_) => "vec2",
-                    isf::InputType::Color(_) => "vec4",
+                let (ty_str, padding) = match input.ty {
+                    isf::InputType::Event | isf::InputType::Bool(_) => ("bool", 3),
+                    isf::InputType::Long(_) => ("int", 3),
+                    isf::InputType::Float(_) => ("float", 3),
+                    isf::InputType::Point2d(_) => ("vec2", 2),
+                    isf::InputType::Color(_) => ("vec4", 0),
                     isf::InputType::Image
                     | isf::InputType::Audio(_)
                     | isf::InputType::AudioFft(_) => continue,
                 };
                 isf_data_input_string.push_str(&format!("{} {};\n", ty_str, input.name));
+                if padding > 0 {
+                    for i in 0..padding {
+                        isf_data_input_string.push_str(&format!("float _pad{};\n", i));
+                    }
+                }
             }
             isf_data_input_string.push_str("};\n");
             Some(isf_data_input_string)
@@ -152,6 +266,19 @@ pub fn glsl_string_from_isf(isf: &isf::Isf) -> String {
     s
 }
 
+// Check whether or not any of the given list of isf inputs would require the `IsfDataInputs`
+// uniform.
+fn inputs_require_isf_data_input(inputs: &[isf::Input]) -> bool {
+    for input in inputs {
+        match input.ty {
+            isf::InputType::Image | isf::InputType::Audio(_) | isf::InputType::AudioFft(_) => (),
+            _ => return true,
+        }
+    }
+    false
+}
+pub const FRAGCOLOR_OUT_DECL_STR: &str = "layout(location = 0) out vec4 FragColor;";
+
 /// Check to see if the `gl_FragColor` variable from old GLSL versions exist and if there's no out
 /// variable for it. If so, create a variable for it.
 ///
@@ -161,10 +288,6 @@ pub fn glfragcolor_exists_and_no_out(glsl_str: &str) -> bool {
     glsl_str.contains("gl_FragColor") && !glsl_str.contains("out vec4 gl_FragColor")
 }
 
-/// We can't create allow a `gl_FragColor` out, so in the case we have to rename it we create the
-/// out decl for it here.
-pub const FRAGCOLOR_OUT_DECL_STR: &str = "layout(location = 0) out vec4 FragColor;";
-
 /// Inserts the ISF into the beginning of the shader, returning the resulting glsl source.
 pub fn prefix_isf_glsl_str(isf_glsl_str: &str, mut shader_string: String) -> String {
     // Check to see if we need to declare the `gl_FragCoord` output.
@@ -221,14 +344,18 @@ pub fn prefix_isf_glsl_str(isf_glsl_str: &str, mut shader_string: String) -> Str
     output
 }
 
-// Check whether or not any of the given list of isf inputs would require the `IsfDataInputs`
-// uniform.
-fn inputs_require_isf_data_input(inputs: &[isf::Input]) -> bool {
-    for input in inputs {
-        match input.ty {
-            isf::InputType::Image | isf::InputType::Audio(_) | isf::InputType::AudioFft(_) => (),
-            _ => return true,
-        }
+pub struct GpuIsf {
+    pub isf: Isf,
+}
+
+impl RenderAsset for GpuIsf {
+    type SourceAsset = Isf;
+    type Param = ();
+
+    fn prepare_asset(
+        isf: Self::SourceAsset,
+        param: &mut SystemParamItem<Self::Param>,
+    ) -> Result<Self, PrepareAssetError<Self::SourceAsset>> {
+        Ok(GpuIsf { isf })
     }
-    false
 }
diff --git a/bevy_nannou_isf/src/fullscreen.vert b/bevy_nannou_isf/src/fullscreen.vert
new file mode 100644
index 000000000..1b085d965
--- /dev/null
+++ b/bevy_nannou_isf/src/fullscreen.vert
@@ -0,0 +1,14 @@
+#version 450
+
+layout(location = 0) out vec2 isf_FragNormCoord;
+
+void main() {
+    uint vertex_index = gl_VertexIndex;
+
+    // Calculate UV coordinates
+    isf_FragNormCoord = vec2(float(vertex_index >> 1), float(vertex_index & 1)) * 2.0;
+
+    // Calculate clip position
+    vec2 clip_position = isf_FragNormCoord * vec2(2.0, -2.0) + vec2(-1.0, 1.0);
+    gl_Position = vec4(clip_position, 0.0, 1.0);
+}
\ No newline at end of file
diff --git a/bevy_nannou_isf/src/inputs.rs b/bevy_nannou_isf/src/inputs.rs
new file mode 100644
index 000000000..6cf3f4c5f
--- /dev/null
+++ b/bevy_nannou_isf/src/inputs.rs
@@ -0,0 +1,413 @@
+use crate::render::IsfInputsUniform;
+use bevy::prelude::*;
+use bevy::reflect::utility::NonGenericTypeInfoCell;
+use bevy::reflect::{
+    ApplyError, DynamicStruct, FieldIter, FromType, GetTypeRegistration, NamedField,
+    ReflectFromPtr, ReflectKind, ReflectMut, ReflectOwned, ReflectRef, StructInfo, TypeInfo,
+    TypeRegistration, Typed,
+};
+use bevy::render::extract_component::ExtractComponent;
+use bevy::render::extract_resource::ExtractResource;
+use bevy::render::render_resource::encase::private::Metadata;
+use bevy::render::render_resource::encase::UniformBuffer;
+use bevy::render::render_resource::{AsBindGroupShaderType, ShaderType};
+use bevy_inspector_egui::inspector_options::InspectorOptionsType;
+use bevy_inspector_egui::prelude::ReflectInspectorOptions;
+use bevy_inspector_egui::InspectorOptions;
+use bytemuck::{Pod, Zeroable};
+use std::any::Any;
+use std::collections::BTreeMap;
+use std::fmt::Formatter;
+use std::ops::Deref;
+
+#[derive(Resource, ExtractResource, TypePath, Deref, DerefMut, Debug, Clone, Default)]
+pub struct IsfInputs(BTreeMap<String, IsfInputValue>);
+
+#[repr(C)]
+#[derive(Copy, Clone, Pod, Zeroable)]
+struct GpuBool {
+    value: u32,
+    _padding: [u32; 3], // Padding to make up 16 bytes
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Pod, Zeroable)]
+struct GpuFloat {
+    value: f32,
+    _padding: [f32; 3], // Padding to make up 16 bytes
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Pod, Zeroable)]
+struct GpuLong {
+    value: i32,
+    _padding: [i32; 3], // Padding to make up 16 bytes
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Pod, Zeroable)]
+struct GpuPoint2d {
+    x: f32,
+    y: f32,
+    _padding: [f32; 2], // Padding to make up 16 bytes
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, Pod, Zeroable)]
+struct GpuColor {
+    r: f32,
+    g: f32,
+    b: f32,
+    a: f32, // No padding needed, already 16 bytes
+}
+
+impl IsfInputs {
+    pub(crate) fn to_uniform(&self) -> IsfInputsUniform {
+        let mut uniform = IsfInputsUniform(self.serialize_values());
+        uniform
+    }
+
+    pub(crate) fn uniform_size(&self) -> usize {
+        let size = self
+            .iter()
+            .map(|(_, v)| match v {
+                IsfInputValue::Bool(_) => std::mem::size_of::<GpuBool>(),
+                IsfInputValue::Float(_) => std::mem::size_of::<GpuFloat>(),
+                IsfInputValue::Long(_) => std::mem::size_of::<GpuLong>(),
+                IsfInputValue::Point2d(_) => std::mem::size_of::<GpuPoint2d>(),
+                IsfInputValue::Color(_) => std::mem::size_of::<GpuColor>(),
+                _ => 0,
+            })
+            .sum();
+        if size < 40 {
+            40
+        } else {
+            size
+        }
+    }
+
+    fn serialize_values(&self) -> Vec<u8> {
+        let mut buffer = Vec::new();
+        for (_, value) in self.deref() {
+            match value {
+                IsfInputValue::Bool(b) => {
+                    let gpu_value = GpuBool {
+                        value: *b as u32,
+                        _padding: [0; 3],
+                    };
+                    buffer.extend_from_slice(bytemuck::bytes_of(&gpu_value));
+                }
+                IsfInputValue::Float(f) => {
+                    let gpu_value = GpuFloat {
+                        value: *f,
+                        _padding: [0.0; 3],
+                    };
+                    buffer.extend_from_slice(bytemuck::bytes_of(&gpu_value));
+                }
+                IsfInputValue::Long(l) => {
+                    let gpu_value = GpuLong {
+                        value: *l,
+                        _padding: [0; 3],
+                    };
+                    buffer.extend_from_slice(bytemuck::bytes_of(&gpu_value));
+                }
+                IsfInputValue::Point2d(v) => {
+                    let gpu_value = GpuPoint2d {
+                        x: v.x,
+                        y: v.y,
+                        _padding: [0.0; 2],
+                    };
+                    buffer.extend_from_slice(bytemuck::bytes_of(&gpu_value));
+                }
+                IsfInputValue::Color(c) => {
+                    let [r, g, b, a] = c.to_linear().to_f32_array();
+                    let gpu_value = GpuColor { r, g, b, a };
+                    buffer.extend_from_slice(bytemuck::bytes_of(&gpu_value));
+                }
+                _ => {}
+            }
+        }
+
+        if buffer.len() < 40 {
+            buffer.resize(40, 0);
+        }
+
+        buffer
+    }
+}
+
+#[derive(Debug, Reflect, Clone)]
+pub enum IsfInputValue {
+    Event(bool),
+    Bool(bool),
+    Long(i32),
+    Float(f32),
+    Point2d(Vec2),
+    Color(Color),
+    Image(Handle<Image>),
+    Audio(Vec<f32>),
+    AudioFft(Vec<f32>),
+}
+
+impl IsfInputs {
+    pub fn from_isf(isf: &isf::Isf) -> Self {
+        let mut values = BTreeMap::new();
+        for input in &isf.inputs {
+            let value = match &input.ty {
+                isf::InputType::Event => IsfInputValue::Event(false),
+                isf::InputType::Bool(b) => IsfInputValue::Bool(b.default.unwrap_or_default()),
+                isf::InputType::Long(l) => IsfInputValue::Long(l.default.unwrap_or_default()),
+                isf::InputType::Float(f) => IsfInputValue::Float(f.default.unwrap_or_default()),
+                isf::InputType::Point2d(p) => {
+                    let [x, y] = p.default.unwrap_or_default();
+                    IsfInputValue::Point2d(Vec2::new(x, y))
+                }
+                isf::InputType::Color(c) => {
+                    let rgba = c
+                        .default
+                        .clone()
+                        .unwrap_or_else(|| vec![0.0, 0.0, 0.0, 1.0]);
+                    IsfInputValue::Color(Color::srgba(
+                        rgba[0],
+                        rgba[1],
+                        rgba[2],
+                        *rgba.get(4).unwrap_or(&1.0f32),
+                    ))
+                }
+                isf::InputType::Image => IsfInputValue::Image(Handle::default()),
+                isf::InputType::Audio(_) => IsfInputValue::Audio(Vec::new()),
+                isf::InputType::AudioFft(_) => IsfInputValue::AudioFft(Vec::new()),
+            };
+            values.insert(input.name.clone(), value);
+        }
+        Self(values)
+    }
+}
+
+impl Typed for IsfInputs {
+    fn type_info() -> &'static TypeInfo {
+        static CELL: NonGenericTypeInfoCell = NonGenericTypeInfoCell::new();
+        CELL.get_or_set(|| {
+            let fields = [NamedField::new::<BTreeMap<String, IsfInputValue>>("values")];
+            let info = StructInfo::new::<Self>(&fields);
+            TypeInfo::Struct(info)
+        })
+    }
+}
+
+impl GetTypeRegistration for IsfInputs {
+    fn get_type_registration() -> TypeRegistration {
+        let mut type_registration = TypeRegistration::of::<IsfInputs>();
+        type_registration.insert::<ReflectFromPtr>(FromType::<IsfInputs>::from_type());
+        // type_registration.insert::<ReflectInspectorOptions>(FromType::<IsfInputs>::from_type());
+        type_registration
+    }
+}
+
+impl Struct for IsfInputs {
+    fn field(&self, name: &str) -> Option<&dyn Reflect> {
+        self.get(name).map(|v| match v {
+            IsfInputValue::Event(b) => b as &dyn Reflect,
+            IsfInputValue::Bool(b) => b as &dyn Reflect,
+            IsfInputValue::Long(l) => l as &dyn Reflect,
+            IsfInputValue::Float(f) => f as &dyn Reflect,
+            IsfInputValue::Point2d(v) => v as &dyn Reflect,
+            IsfInputValue::Color(c) => c as &dyn Reflect,
+            IsfInputValue::Image(h) => h as &dyn Reflect,
+            IsfInputValue::Audio(a) => a as &dyn Reflect,
+            IsfInputValue::AudioFft(a) => a as &dyn Reflect,
+        })
+    }
+
+    fn field_mut(&mut self, name: &str) -> Option<&mut dyn Reflect> {
+        self.get_mut(name).map(|v| match v {
+            IsfInputValue::Event(b) => b as &mut dyn Reflect,
+            IsfInputValue::Bool(b) => b as &mut dyn Reflect,
+            IsfInputValue::Long(l) => l as &mut dyn Reflect,
+            IsfInputValue::Float(f) => f as &mut dyn Reflect,
+            IsfInputValue::Point2d(v) => v as &mut dyn Reflect,
+            IsfInputValue::Color(c) => c as &mut dyn Reflect,
+            IsfInputValue::Image(h) => h as &mut dyn Reflect,
+            IsfInputValue::Audio(a) => a as &mut dyn Reflect,
+            IsfInputValue::AudioFft(a) => a as &mut dyn Reflect,
+        })
+    }
+
+    fn field_at(&self, index: usize) -> Option<&dyn Reflect> {
+        self.values().nth(index).map(|v| match v {
+            IsfInputValue::Event(b) => b as &dyn Reflect,
+            IsfInputValue::Bool(b) => b as &dyn Reflect,
+            IsfInputValue::Long(l) => l as &dyn Reflect,
+            IsfInputValue::Float(f) => f as &dyn Reflect,
+            IsfInputValue::Point2d(v) => v as &dyn Reflect,
+            IsfInputValue::Color(c) => c as &dyn Reflect,
+            IsfInputValue::Image(h) => h as &dyn Reflect,
+            IsfInputValue::Audio(a) => a as &dyn Reflect,
+            IsfInputValue::AudioFft(a) => a as &dyn Reflect,
+        })
+    }
+
+    fn field_at_mut(&mut self, index: usize) -> Option<&mut dyn Reflect> {
+        self.values_mut().nth(index).map(|v| match v {
+            IsfInputValue::Event(b) => b as &mut dyn Reflect,
+            IsfInputValue::Bool(b) => b as &mut dyn Reflect,
+            IsfInputValue::Long(l) => l as &mut dyn Reflect,
+            IsfInputValue::Float(f) => f as &mut dyn Reflect,
+            IsfInputValue::Point2d(v) => v as &mut dyn Reflect,
+            IsfInputValue::Color(c) => c as &mut dyn Reflect,
+            IsfInputValue::Image(h) => h as &mut dyn Reflect,
+            IsfInputValue::Audio(a) => a as &mut dyn Reflect,
+            IsfInputValue::AudioFft(a) => a as &mut dyn Reflect,
+        })
+    }
+
+    fn name_at(&self, index: usize) -> Option<&str> {
+        self.keys().nth(index).map(|s| s.as_str())
+    }
+
+    fn field_len(&self) -> usize {
+        self.len()
+    }
+
+    fn iter_fields(&self) -> FieldIter {
+        FieldIter::new(self)
+    }
+
+    fn clone_dynamic(&self) -> DynamicStruct {
+        let mut dynamic_struct = DynamicStruct::default();
+        for (name, value) in self.deref() {
+            dynamic_struct.insert(name, value.clone());
+        }
+        dynamic_struct
+    }
+}
+
+impl Reflect for IsfInputs {
+    #[inline]
+    fn get_represented_type_info(&self) -> Option<&'static TypeInfo> {
+        Some(Self::type_info())
+    }
+
+    #[inline]
+    fn into_any(self: Box<Self>) -> Box<dyn Any> {
+        self
+    }
+
+    #[inline]
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    #[inline]
+    fn as_any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+
+    #[inline]
+    fn into_reflect(self: Box<Self>) -> Box<dyn Reflect> {
+        self
+    }
+
+    #[inline]
+    fn as_reflect(&self) -> &dyn Reflect {
+        self
+    }
+
+    #[inline]
+    fn as_reflect_mut(&mut self) -> &mut dyn Reflect {
+        self
+    }
+
+    fn try_apply(&mut self, value: &dyn Reflect) -> Result<(), ApplyError> {
+        if let ReflectRef::Struct(struct_value) = value.reflect_ref() {
+            for (i, value) in struct_value.iter_fields().enumerate() {
+                let name = struct_value.name_at(i).unwrap();
+                if let Some(v) = self.field_mut(name) {
+                    v.try_apply(value)?;
+                }
+            }
+        } else {
+            return Err(ApplyError::MismatchedKinds {
+                from_kind: value.reflect_kind(),
+                to_kind: ReflectKind::Struct,
+            });
+        }
+        Ok(())
+    }
+
+    #[inline]
+    fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>> {
+        *self = value.take()?;
+        Ok(())
+    }
+
+    #[inline]
+    fn reflect_kind(&self) -> ReflectKind {
+        ReflectKind::Struct
+    }
+
+    #[inline]
+    fn reflect_ref(&self) -> ReflectRef {
+        ReflectRef::Struct(self)
+    }
+
+    #[inline]
+    fn reflect_mut(&mut self) -> ReflectMut {
+        ReflectMut::Struct(self)
+    }
+
+    #[inline]
+    fn reflect_owned(self: Box<Self>) -> ReflectOwned {
+        ReflectOwned::Struct(self)
+    }
+
+    #[inline]
+    fn clone_value(&self) -> Box<dyn Reflect> {
+        Box::new(self.clone_dynamic())
+    }
+
+    fn reflect_partial_eq(&self, value: &dyn Reflect) -> Option<bool> {
+        struct_partial_eq(self, value)
+    }
+
+    fn debug(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, " IsfInputs(")?;
+        for (i, (name, value)) in self.iter().enumerate() {
+            if i != 0 {
+                write!(f, ", ")?;
+            }
+            write!(f, "{}: {:?}", name, value)?;
+        }
+        write!(f, ")")
+    }
+
+    #[inline]
+    fn is_dynamic(&self) -> bool {
+        true
+    }
+}
+
+#[inline]
+pub fn struct_partial_eq(a: &IsfInputs, b: &dyn Reflect) -> Option<bool> {
+    let ReflectRef::Struct(struct_value) = b.reflect_ref() else {
+        return Some(false);
+    };
+
+    if a.len() != struct_value.field_len() {
+        return Some(false);
+    }
+
+    for (i, value) in struct_value.iter_fields().enumerate() {
+        let name = struct_value.name_at(i).unwrap();
+        if let Some(field_value) = a.get(name) {
+            let eq_result = field_value.reflect_partial_eq(value);
+            if let failed @ (Some(false) | None) = eq_result {
+                return failed;
+            }
+        } else {
+            return Some(false);
+        }
+    }
+
+    Some(true)
+}
diff --git a/bevy_nannou_isf/src/lib.rs b/bevy_nannou_isf/src/lib.rs
new file mode 100644
index 000000000..5e4e1a83e
--- /dev/null
+++ b/bevy_nannou_isf/src/lib.rs
@@ -0,0 +1,73 @@
+use crate::asset::{Isf, IsfAssetPlugin};
+use crate::inputs::{IsfInputValue, IsfInputs};
+use crate::render::{IsfRenderPlugin, IsfRenderTargets};
+use bevy::asset::embedded_asset;
+use bevy::prelude::*;
+use bevy::render::extract_component::ExtractComponentPlugin;
+use bevy::render::extract_resource::ExtractResourcePlugin;
+use bevy::render::view;
+use bevy::render::view::{NoFrustumCulling, VisibilitySystems};
+use bevy::window::PrimaryWindow;
+use bevy_egui::{egui, EguiContext};
+use bevy_inspector_egui::inspector_egui_impls::InspectorEguiImpl;
+use bevy_inspector_egui::quick::ResourceInspectorPlugin;
+use bevy_inspector_egui::DefaultInspectorConfigPlugin;
+use std::any::TypeId;
+
+mod asset;
+mod inputs;
+mod render;
+
+pub mod prelude {
+    pub use crate::asset::Isf;
+    pub use crate::inputs::{IsfInputValue, IsfInputs};
+}
+
+pub struct NannouIsfPlugin;
+impl Plugin for NannouIsfPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_systems(First, asset_event_handler)
+            .add_plugins((
+                IsfRenderPlugin,
+                IsfAssetPlugin,
+                ResourceInspectorPlugin::<IsfInputs>::default(),
+                ExtractComponentPlugin::<Handle<Isf>>::default(),
+                ExtractResourcePlugin::<IsfInputs>::default(),
+                ExtractResourcePlugin::<IsfRenderTargets>::default(),
+            ))
+            .init_resource::<IsfRenderTargets>()
+            .init_resource::<IsfInputs>()
+            .register_type::<IsfInputs>()
+            .register_type::<IsfInputValue>()
+            .register_asset_reflect::<Image>();
+
+        let type_registry = app.world().resource::<AppTypeRegistry>();
+        let mut type_registry = type_registry.write();
+        type_registry.register_type_data::<Handle<Image>, InspectorEguiImpl>();
+    }
+}
+
+fn asset_event_handler(
+    mut commands: Commands,
+    mut ev_asset: EventReader<AssetEvent<Isf>>,
+    mut isf_inputs: ResMut<IsfInputs>,
+    mut cameras: Query<Entity, With<Camera>>,
+    assets: Res<Assets<Isf>>,
+) {
+    for ev in ev_asset.read() {
+        match ev {
+            AssetEvent::Added { .. } | AssetEvent::Modified { .. } | AssetEvent::Removed { .. } => {
+                // TODO: handle these events
+            }
+            AssetEvent::LoadedWithDependencies { id } => {
+                let handle = Handle::Weak(*id);
+                let isf = assets.get(&handle).unwrap();
+                *isf_inputs = IsfInputs::from_isf(&isf.isf);
+                for camera in cameras.iter() {
+                    commands.entity(camera).insert(handle.clone());
+                }
+            }
+            _ => {}
+        }
+    }
+}
diff --git a/bevy_nannou_isf/src/render.rs b/bevy_nannou_isf/src/render.rs
new file mode 100644
index 000000000..f766ca1d9
--- /dev/null
+++ b/bevy_nannou_isf/src/render.rs
@@ -0,0 +1,640 @@
+use bevy::asset::embedded_asset;
+use bevy::core_pipeline::core_3d::graph::{Core3d, Node3d};
+use bevy::core_pipeline::core_3d::{Opaque3d, Opaque3dBinKey, CORE_3D_DEPTH_FORMAT};
+use bevy::core_pipeline::fullscreen_vertex_shader::{
+    fullscreen_shader_vertex_state, FULLSCREEN_SHADER_HANDLE,
+};
+use bevy::ecs::entity::EntityHashMap;
+use bevy::ecs::query::{QueryItem, ROQueryItem};
+use bevy::ecs::system::lifetimeless::SRes;
+use bevy::ecs::system::SystemParamItem;
+use bevy::prelude::*;
+use bevy::render::camera::RenderTarget;
+use bevy::render::extract_component::DynamicUniformIndex;
+use bevy::render::extract_resource::ExtractResource;
+use bevy::render::render_asset::{PrepareAssetError, RenderAsset, RenderAssets};
+use bevy::render::render_graph::{
+    NodeRunError, RenderGraphApp, RenderGraphContext, RenderLabel, ViewNode, ViewNodeRunner,
+};
+use bevy::render::render_phase::{
+    BinnedRenderPhaseType, DrawFunctions, PhaseItem, RenderCommand, RenderCommandResult,
+    SetItemPipeline, TrackedRenderPass, ViewBinnedRenderPhases,
+};
+use bevy::render::render_resource::binding_types::{
+    sampler, texture_2d, uniform_buffer, uniform_buffer_sized,
+};
+use bevy::render::render_resource::*;
+use bevy::render::renderer::{RenderContext, RenderDevice, RenderQueue};
+use bevy::render::texture::{BevyDefault, DefaultImageSampler, GpuImage};
+use bevy::render::view::{ExtractedView, ViewTarget, VisibleEntities};
+use bevy::render::{Extract, Render, RenderApp, RenderSet};
+use bevy::utils::HashMap;
+use bevy::window::{PrimaryWindow, WindowRef};
+use std::num::{NonZero, NonZeroU64};
+use std::ops::Deref;
+
+use crate::asset::{GpuIsf, Isf};
+use crate::inputs::{IsfInputValue, IsfInputs};
+
+pub struct IsfRenderPlugin;
+
+impl Plugin for IsfRenderPlugin {
+    fn build(&self, app: &mut App) {
+        embedded_asset!(app, "src/", "fullscreen.vert");
+        app.add_systems(Update, update_render_targets);
+        let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
+            return;
+        };
+
+        render_app
+            .add_systems(
+                Render,
+                (
+                    queue_isf.in_set(RenderSet::Queue),
+                    prepare_isf_bind_groups.in_set(RenderSet::PrepareBindGroups),
+                ),
+            )
+            .init_resource::<SpecializedRenderPipelines<IsfPipeline>>()
+            .add_render_graph_node::<ViewNodeRunner<IsfNode>>(Core3d, IsfLabel)
+            .add_render_graph_edges(
+                Core3d,
+                (Node3d::StartMainPass, IsfLabel, Node3d::EndMainPass),
+            );
+    }
+
+    fn finish(&self, app: &mut App) {
+        let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
+            return;
+        };
+
+        render_app.init_resource::<IsfPipeline>();
+    }
+}
+
+#[derive(Resource, ExtractResource, Deref, DerefMut, Clone, Debug, Default)]
+pub struct IsfRenderTargets(Vec<Option<IsfPass>>);
+
+#[derive(Clone, Debug)]
+pub struct IsfPass {
+    size: UVec2,
+    target: Handle<Image>,
+    format: TextureFormat,
+    clear: bool,
+}
+
+fn update_render_targets(
+    cameras_q: Query<(&Camera, &Handle<Isf>)>,
+    windows_q: Query<(&Window, Option<&PrimaryWindow>)>,
+    mut render_targets: ResMut<IsfRenderTargets>,
+    mut images: ResMut<Assets<Image>>,
+    isfs: Res<Assets<Isf>>,
+) {
+    let Ok((camera, isf)) = cameras_q.get_single() else {
+        return;
+    };
+    let resolution = match &camera.target {
+        RenderTarget::Window(window) => match window {
+            WindowRef::Primary => windows_q
+                .iter()
+                .filter(|(_, primary)| primary.is_some())
+                .map(|(window, _)| window.resolution.physical_size())
+                .next()
+                .expect("Primary window not found"),
+            WindowRef::Entity(window) => windows_q
+                .get(*window)
+                .map(|(window, _)| window.resolution.physical_size())
+                .expect(&format!("Window not found: {:?}", window)),
+        },
+        RenderTarget::Image(image) => images
+            .get(image)
+            .map(|image| image.size())
+            .expect(&format!("Image not found: {:?}", image)),
+        RenderTarget::TextureView(_) => {
+            todo!("implement texture view")
+        }
+    };
+
+    let isf = isfs.get(isf).expect("Isf not found");
+    render_targets.resize(isf.isf.passes.len(), None);
+    for (pass_idx, pass) in isf.isf.passes.iter().enumerate() {
+        if let None = pass.target {
+            render_targets[pass_idx] = None;
+            continue;
+        }
+
+        let UVec2 { x, y } = resolution;
+        let width = pass
+            .width
+            .as_ref()
+            .map(|expr| {
+                let result = meval::eval_str(
+                    expr.replace("$WIDTH", &x.to_string())
+                        .replace("$HEIGHT", &y.to_string()),
+                )
+                .expect(&format!("Failed to evaluate expression: {:?}", expr));
+                result as u32
+            })
+            .unwrap_or(x);
+        let height = pass
+            .height
+            .as_ref()
+            .map(|expr| {
+                let result = meval::eval_str(
+                    expr.replace("$WIDTH", &x.to_string())
+                        .replace("$HEIGHT", &y.to_string()),
+                )
+                .expect(&format!("Failed to evaluate expression: {:?}", expr));
+                result as u32
+            })
+            .unwrap_or(y);
+
+        if let Some(Some(IsfPass { size, .. })) = render_targets.get(pass_idx) {
+            if size.x == width && size.y == height {
+                continue;
+            }
+        }
+
+        let mut target = Image::default();
+        let format = if pass.float {
+            TextureFormat::Rgba32Float
+        } else {
+            TextureFormat::Rgba8UnormSrgb
+        };
+        target.texture_descriptor.format = format;
+        target.texture_descriptor.usage = TextureUsages::RENDER_ATTACHMENT
+            | TextureUsages::TEXTURE_BINDING
+            | TextureUsages::COPY_DST;
+        let size = Extent3d {
+            width,
+            height,
+            ..default()
+        };
+        target.resize(size);
+        let target = images.add(target);
+
+        render_targets[pass_idx] = Some(IsfPass {
+            size: UVec2::new(width, height),
+            target,
+            format,
+            clear: !pass.persistent,
+        });
+    }
+
+    if render_targets.is_empty() {
+        render_targets.push(None);
+    }
+}
+
+#[derive(Component, Deref, DerefMut, Default)]
+pub struct IsfPipelineIds(Vec<CachedRenderPipelineId>);
+
+fn queue_isf(
+    mut commands: Commands,
+    mut render_device: ResMut<RenderDevice>,
+    pipeline_cache: Res<PipelineCache>,
+    mut isf_pipeline: ResMut<IsfPipeline>,
+    isf_assets: Res<RenderAssets<GpuIsf>>,
+    msaa: Res<Msaa>,
+    isf_inputs: Res<IsfInputs>,
+    isf_render_targets: Res<IsfRenderTargets>,
+    mut specialized_render_pipelines: ResMut<SpecializedRenderPipelines<IsfPipeline>>,
+    views: Query<(Entity, &ExtractedView, &Handle<Isf>)>,
+) {
+    for (view_entity, extracted_view, isf) in views.iter() {
+        let isf = isf_assets.get(isf).unwrap();
+
+        // Prepare any new layouts
+        if let None = isf_pipeline
+            .isf_input_uniforms_layouts
+            .get(&isf_inputs.uniform_size())
+        {
+            isf_pipeline.isf_input_uniforms_layouts.insert(
+                isf_inputs.uniform_size(),
+                render_device.create_bind_group_layout(
+                    "isf_input_uniforms_layout",
+                    &BindGroupLayoutEntries::single(
+                        ShaderStages::FRAGMENT,
+                        uniform_buffer_sized(false, NonZero::new(isf_inputs.uniform_size() as u64)),
+                    ),
+                ),
+            );
+        }
+
+        let image_count = isf.isf.num_images();
+        if let None = isf_pipeline
+            .isf_textures_bind_group_layouts
+            .get(&image_count)
+        {
+            isf_pipeline
+                .isf_textures_bind_group_layouts
+                .insert(image_count, {
+                    let mut entries = vec![];
+                    entries.push(
+                        sampler(SamplerBindingType::Filtering).build(0, ShaderStages::FRAGMENT),
+                    );
+                    for i in 0..image_count {
+                        entries.push(
+                            texture_2d(TextureSampleType::Float { filterable: true })
+                                .build((i + 1) as u32, ShaderStages::FRAGMENT),
+                        );
+                    }
+
+                    render_device
+                        .create_bind_group_layout("isf_textures_bind_group_layout", &entries)
+                });
+        }
+
+        let mut pipeline_ids = IsfPipelineIds::default();
+
+        for pass in isf_render_targets.iter() {
+            let (format, samples) = match pass {
+                None => (
+                    if extracted_view.hdr {
+                        TextureFormat::Rgba32Float
+                    } else {
+                        TextureFormat::Rgba8UnormSrgb
+                    },
+                    msaa.samples(),
+                ),
+                Some(pass) => (pass.format, 1),
+            };
+
+            let pipeline_id = specialized_render_pipelines.specialize(
+                &pipeline_cache,
+                &isf_pipeline,
+                IsfPipelineKey {
+                    shader: isf.isf.shader.clone(),
+                    format,
+                    size: isf_inputs.uniform_size(),
+                    textures: isf.isf.num_images(),
+                    samples,
+                },
+            );
+
+            pipeline_ids.push(pipeline_id);
+        }
+
+        commands.entity(view_entity).insert(pipeline_ids);
+    }
+}
+
+#[derive(Component)]
+pub struct IsfBindGroups {
+    isf_inputs_bind_group: BindGroup,
+    isf_textures_bind_groups: Vec<BindGroup>,
+}
+
+fn prepare_isf_bind_groups(
+    mut commands: Commands,
+    pipeline: Res<IsfPipeline>,
+    sampler: Res<DefaultImageSampler>,
+    isf_inputs: Res<IsfInputs>,
+    views: Query<(Entity, &Handle<Isf>)>,
+    render_device: Res<RenderDevice>,
+    isf_render_targets: Res<IsfRenderTargets>,
+    isf_assets: Res<RenderAssets<GpuIsf>>,
+    gpu_images: Res<RenderAssets<GpuImage>>,
+) {
+    for (entity, isf) in views.iter() {
+        let gpu_isf = isf_assets.get(isf).unwrap();
+
+        let isf_inputs_uniform_buffer =
+            render_device.create_buffer_with_data(&BufferInitDescriptor {
+                label: None,
+                contents: &bytemuck::cast_slice(&isf_inputs.to_uniform()),
+                usage: BufferUsages::UNIFORM | BufferUsages::COPY_DST,
+            });
+
+        let inputs_bind_group = render_device.create_bind_group(
+            "isf_inputs_bind_group",
+            &pipeline.isf_input_uniforms_layouts[&isf_inputs.uniform_size()],
+            &[BindGroupEntry {
+                binding: 0,
+                resource: isf_inputs_uniform_buffer.as_entire_binding(),
+            }],
+        );
+
+        let mut bindings = vec![BindGroupEntry {
+            binding: 0,
+            resource: sampler.into_binding(),
+        }];
+
+        let mut binding = 1;
+
+        // Imported images
+        for (_name, image) in gpu_isf.isf.imported_images.iter() {
+            let gpu_image = gpu_images.get(image).unwrap();
+            bindings.push(BindGroupEntry {
+                binding,
+                resource: gpu_image.texture_view.into_binding(),
+            });
+            binding += 1;
+        }
+
+        // Inputs
+        for input in &gpu_isf.isf.isf.inputs {
+            match input.ty {
+                isf::InputType::Image { .. }
+                | isf::InputType::Audio(_)
+                | isf::InputType::AudioFft(_) => {
+                    let input_value = &isf_inputs[&input.name];
+                    match input_value {
+                        IsfInputValue::Image(image) => {
+                            let gpu_image = gpu_images.get(image).unwrap();
+                            bindings.push(BindGroupEntry {
+                                binding,
+                                resource: gpu_image.texture_view.into_binding(),
+                            });
+                            binding += 1;
+                        }
+                        IsfInputValue::Audio(_) => todo!("implement audio"),
+                        IsfInputValue::AudioFft(_) => todo!("implement audio fft"),
+                        _ => {}
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        let num_images = gpu_isf.isf.num_images();
+        let mut textures_bind_groups = vec![];
+        let dummy_image = gpu_images.get(&Handle::<Image>::default()).unwrap();
+        // Passes
+        for pass in isf_render_targets.iter() {
+            let mut pass_bindings = bindings.clone();
+            let Some(pass) = pass else {
+                let textures_bind_group = render_device.create_bind_group(
+                    "isf_textures_bind_group",
+                    &pipeline.isf_textures_bind_group_layouts[&num_images],
+                    &pass_bindings,
+                );
+                textures_bind_groups.push(textures_bind_group);
+                continue;
+            };
+            let Some(gpu_image) = gpu_images.get(&pass.target) else {
+                return;
+            };
+            pass_bindings.push(BindGroupEntry {
+                binding,
+                resource: dummy_image.texture_view.into_binding(),
+            });
+            let textures_bind_group = render_device.create_bind_group(
+                "isf_textures_bind_group",
+                &pipeline.isf_textures_bind_group_layouts[&num_images],
+                &pass_bindings,
+            );
+            textures_bind_groups.push(textures_bind_group);
+            // Make our texture available for the next pass
+            bindings.push(BindGroupEntry {
+                binding,
+                resource: gpu_image.texture_view.into_binding(),
+            });
+            binding += 1;
+        }
+
+        commands.entity(entity).insert(IsfBindGroups {
+            isf_inputs_bind_group: inputs_bind_group,
+            isf_textures_bind_groups: textures_bind_groups,
+        });
+    }
+}
+
+#[derive(Debug, Hash, PartialEq, Eq, Clone, RenderLabel)]
+struct IsfLabel;
+
+#[derive(Default)]
+struct IsfNode;
+
+impl ViewNode for IsfNode {
+    type ViewQuery = (
+        &'static ViewTarget,
+        &'static IsfBindGroups,
+        &'static IsfPipelineIds,
+    );
+
+    fn run(
+        &self,
+        _graph: &mut RenderGraphContext,
+        render_context: &mut RenderContext,
+        (view_target, bind_groups, pipeline_ids): QueryItem<Self::ViewQuery>,
+        world: &World,
+    ) -> Result<(), NodeRunError> {
+        let pipeline = world.resource::<IsfPipeline>();
+        let gpu_images = world.resource::<RenderAssets<GpuImage>>();
+
+        let isf_render_targets = world.resource::<IsfRenderTargets>();
+        for (pass_index, pass) in isf_render_targets.iter().enumerate() {
+            let uniform = IsfUniform {
+                pass_index: pass_index as i32,
+                render_size: [0.0; 2],
+                time: 0.0,
+                time_delta: 0.0,
+                date: [0.0; 4],
+                frame_index: 0,
+                ..default()
+            };
+
+            let isf_uniform_buffer =
+                render_context
+                    .render_device()
+                    .create_buffer_with_data(&BufferInitDescriptor {
+                        label: None,
+                        contents: &bytemuck::cast_slice(&[uniform]),
+                        usage: BufferUsages::UNIFORM | BufferUsages::COPY_DST,
+                    });
+
+            let uniform_bind_group = render_context.render_device().create_bind_group(
+                "isf_inputs_bind_group",
+                &pipeline.isf_uniforms_layout,
+                &[BindGroupEntry {
+                    binding: 0,
+                    resource: isf_uniform_buffer.as_entire_binding(),
+                }],
+            );
+
+            let pipeline_cache = world.resource::<PipelineCache>();
+            let Some(pipeline) = pipeline_cache.get_render_pipeline(pipeline_ids[pass_index])
+            else {
+                warn!("Failed to get render pipeline");
+                return Ok(());
+            };
+
+            let color_attachment = match pass {
+                Some(pass) => RenderPassColorAttachment {
+                    view: &gpu_images.get(&pass.target).unwrap().texture_view,
+                    resolve_target: None,
+                    ops: if pass.clear {
+                        Operations {
+                            load: LoadOp::Load,
+                            store: StoreOp::Store,
+                        }
+                    } else {
+                        Operations {
+                            load: LoadOp::Load,
+                            store: StoreOp::Store,
+                        }
+                    },
+                },
+                None => view_target.get_color_attachment(),
+            };
+            let mut render_pass = render_context.begin_tracked_render_pass(RenderPassDescriptor {
+                label: Some("isf_pass"),
+                color_attachments: &[Some(color_attachment)],
+                depth_stencil_attachment: None,
+                timestamp_writes: None,
+                occlusion_query_set: None,
+            });
+
+            render_pass.set_render_pipeline(pipeline);
+            render_pass.set_bind_group(0, &uniform_bind_group, &[]);
+            render_pass.set_bind_group(1, &bind_groups.isf_inputs_bind_group, &[]);
+            render_pass.set_bind_group(2, &bind_groups.isf_textures_bind_groups[pass_index], &[]);
+            render_pass.draw(0..3, 0..1);
+        }
+
+        Ok(())
+    }
+}
+
+struct DrawIsf;
+
+impl<P> RenderCommand<P> for DrawIsf
+where
+    P: PhaseItem,
+{
+    type Param = SRes<IsfBuffers>;
+
+    type ViewQuery = ();
+
+    type ItemQuery = ();
+
+    fn render<'w>(
+        _: &P,
+        _: ROQueryItem<'w, Self::ViewQuery>,
+        _: Option<ROQueryItem<'w, Self::ItemQuery>>,
+        custom_phase_item_buffers: SystemParamItem<'w, '_, Self::Param>,
+        pass: &mut TrackedRenderPass<'w>,
+    ) -> RenderCommandResult {
+        // Borrow check workaround.
+        let custom_phase_item_buffers = custom_phase_item_buffers.into_inner();
+
+        pass.draw(0..3, 0..1);
+
+        RenderCommandResult::Success
+    }
+}
+
+#[derive(Resource)]
+struct IsfBuffers {}
+
+#[derive(Component)]
+pub struct ExtractedIsf {
+    inputs: IsfInputs,
+    images: Vec<Handle<Image>>,
+}
+
+#[derive(Resource)]
+pub struct IsfPipeline {
+    isf_uniforms_layout: BindGroupLayout,
+    isf_input_uniforms_layouts: HashMap<usize, BindGroupLayout>,
+    isf_textures_bind_group_layouts: HashMap<usize, BindGroupLayout>,
+    fullscreen_shader: Handle<Shader>,
+}
+
+impl FromWorld for IsfPipeline {
+    fn from_world(world: &mut World) -> Self {
+        let render_device = world.resource::<RenderDevice>();
+
+        let isf_uniforms_layout = render_device.create_bind_group_layout(
+            "isf_uniforms_layout",
+            &BindGroupLayoutEntries::single(
+                ShaderStages::FRAGMENT,
+                uniform_buffer::<IsfUniform>(false),
+            ),
+        );
+        Self {
+            isf_uniforms_layout,
+            isf_input_uniforms_layouts: default(),
+            isf_textures_bind_group_layouts: default(),
+            fullscreen_shader: world
+                .resource_mut::<AssetServer>()
+                .load("embedded://bevy_nannou_isf/fullscreen.vert"),
+        }
+    }
+}
+
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+pub struct IsfPipelineKey {
+    shader: Handle<Shader>,
+    format: TextureFormat,
+    size: usize,
+    textures: usize,
+    samples: u32,
+}
+
+impl SpecializedRenderPipeline for IsfPipeline {
+    type Key = IsfPipelineKey;
+
+    fn specialize(&self, key: Self::Key) -> RenderPipelineDescriptor {
+        RenderPipelineDescriptor {
+            label: Some("isf_pipeline".into()),
+            layout: vec![
+                self.isf_uniforms_layout.clone(),
+                self.isf_input_uniforms_layouts[&key.size].clone(),
+                self.isf_textures_bind_group_layouts[&key.textures].clone(),
+            ],
+            push_constant_ranges: vec![],
+            vertex: VertexState {
+                shader: self.fullscreen_shader.clone(),
+                shader_defs: Vec::new(),
+                entry_point: "main".into(),
+                buffers: vec![],
+            },
+            fragment: Some(FragmentState {
+                shader: key.shader,
+                shader_defs: vec![],
+                entry_point: "main".into(),
+                targets: vec![Some(ColorTargetState {
+                    format: key.format,
+                    blend: None,
+                    write_mask: ColorWrites::ALL,
+                })],
+            }),
+            primitive: PrimitiveState::default(),
+            depth_stencil: None,
+            multisample: MultisampleState {
+                count: key.samples,
+                mask: !0,
+                alpha_to_coverage_enabled: false,
+            },
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(ShaderType, Copy, Clone, Debug, Default, bytemuck::Pod, bytemuck::Zeroable)]
+struct IsfUniform {
+    pass_index: i32,
+    _pad0: i32,
+    _pad1: i32,
+    _pad2: i32,
+    render_size: [f32; 2],
+    _pad4: i32,
+    _pad5: i32,
+    time: f32,
+    _pad6: i32,
+    _pad7: i32,
+    _pad8: i32,
+    time_delta: f32,
+    _pad9: i32,
+    _pad10: i32,
+    _pad11: i32,
+    date: [f32; 4],
+    frame_index: i32,
+    _pad12: i32,
+    _pad13: i32,
+    _pad14: i32,
+}
+
+#[derive(Component, Deref, DerefMut)]
+pub struct IsfInputsUniform(pub Vec<u8>);
diff --git a/bevy_nannou_render/Cargo.toml b/bevy_nannou_render/Cargo.toml
deleted file mode 100644
index eea5aa563..000000000
--- a/bevy_nannou_render/Cargo.toml
+++ /dev/null
@@ -1,12 +0,0 @@
-[package]
-name = "bevy_nannou_render"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-bevy = { workspace = true }
-bevy_nannou_wgpu = { path = "../bevy_nannou_wgpu" }
-bevy_nannou_draw = { path = "../bevy_nannou_draw" }
-nannou_core = { path = "../nannou_core" }
-lyon = "0.17"
-wgpu-types = "0.17"
diff --git a/bevy_nannou_render/src/lib.rs b/bevy_nannou_render/src/lib.rs
deleted file mode 100644
index 88a53ca7a..000000000
--- a/bevy_nannou_render/src/lib.rs
+++ /dev/null
@@ -1,235 +0,0 @@
-use std::collections::HashMap;
-use std::ops::{Deref, Range};
-
-use bevy::asset::load_internal_asset;
-use bevy::core::cast_slice;
-use bevy::core_pipeline::core_3d;
-use bevy::core_pipeline::core_3d::{Transparent3d, CORE_3D};
-use bevy::ecs::system::lifetimeless::SRes;
-use bevy::ecs::system::SystemParamItem;
-use bevy::prelude::shape::Cube;
-use bevy::prelude::*;
-use bevy::render::camera::{ExtractedCamera, NormalizedRenderTarget, RenderTarget};
-use bevy::render::extract_component::{
-    ComponentUniforms, ExtractComponent, ExtractComponentPlugin, UniformComponentPlugin,
-};
-use bevy::render::extract_resource::{ExtractResource, ExtractResourcePlugin};
-use bevy::render::mesh::Indices;
-use bevy::render::primitives::Sphere;
-use bevy::render::render_asset::{PrepareAssetError, RenderAsset, RenderAssetPlugin, RenderAssets};
-use bevy::render::render_graph::{RenderGraphApp, ViewNode, ViewNodeRunner};
-use bevy::render::render_phase::{AddRenderCommand, DrawFunctions, RenderPhase};
-use bevy::render::render_resource::{
-    BindGroupLayout, BufferInitDescriptor, CachedRenderPipelineId, PipelineCache, ShaderType,
-    SpecializedRenderPipeline, SpecializedRenderPipelines,
-};
-use bevy::render::renderer::RenderDevice;
-use bevy::render::texture::BevyDefault;
-use bevy::render::view::{
-    ExtractedView, ExtractedWindow, ExtractedWindows, ViewDepthTexture, ViewTarget, ViewUniforms,
-};
-use bevy::render::{render_resource as wgpu, Extract, RenderSet};
-use bevy::render::{Render, RenderApp};
-use bevy::window::{PrimaryWindow, WindowRef};
-use lyon::lyon_tessellation::{FillTessellator, StrokeTessellator};
-use wgpu_types::PrimitiveTopology;
-
-use bevy_nannou_draw::draw::mesh::MeshExt;
-use bevy_nannou_draw::draw::render::{
-    GlyphCache, RenderContext, RenderPrimitive, Scissor, VertexMode,
-};
-use bevy_nannou_draw::{draw, Draw};
-use nannou_core::geom;
-use nannou_core::math::map_range;
-
-pub struct NannouRenderPlugin;
-
-pub const NANNOU_SHADER_HANDLE: Handle<Shader> = Handle::weak_from_u128(43700360588854283521);
-
-impl Plugin for NannouRenderPlugin {
-    fn build(&self, app: &mut App) {
-        load_internal_asset!(
-            app,
-            NANNOU_SHADER_HANDLE,
-            "shaders/nannou.wgsl",
-            Shader::from_wgsl
-        );
-
-        app.add_systems(Startup, setup_default_texture)
-            .add_plugins((
-                ExtractComponentPlugin::<Draw>::default(),
-                ExtractComponentPlugin::<NannouTextureHandle>::default(),
-            ))
-            .add_plugins(ExtractResourcePlugin::<DefaultTextureHandle>::default())
-            .insert_resource(GlyphCache::new([1024; 2], 0.1, 0.1))
-            .add_systems(Update, texture_event_handler)
-            .add_systems(Last, update_draw_mesh.chain());
-    }
-}
-
-// ----------------------------------------------------------------------------
-// Components and Resources
-// ----------------------------------------------------------------------------
-
-#[derive(Resource, Deref, DerefMut, ExtractResource, Clone)]
-pub struct DefaultTextureHandle(Handle<Image>);
-
-#[derive(Component, Deref, DerefMut, ExtractComponent, Clone)]
-pub struct NannouTextureHandle(Handle<Image>);
-
-fn texture_event_handler(
-    mut commands: Commands,
-    mut ev_asset: EventReader<AssetEvent<Image>>,
-    assets: Res<Assets<Image>>,
-) {
-    for ev in ev_asset.read() {
-        match ev {
-            AssetEvent::Added { .. } | AssetEvent::Modified { .. } | AssetEvent::Removed { .. } => {
-                // TODO: handle these events
-            }
-            AssetEvent::LoadedWithDependencies { id } => {
-                let handle = Handle::Weak(*id);
-                let image = assets.get(&handle).unwrap();
-                // TODO hack to only handle 2D textures for now
-                // We should maybe require users to spawn a NannouTextureHandle themselves
-                if image.texture_descriptor.dimension == wgpu::TextureDimension::D2 {
-                    commands.spawn(NannouTextureHandle(handle));
-                }
-            }
-            _ => {}
-        }
-    }
-}
-
-fn setup_default_texture(mut commands: Commands, mut images: ResMut<Assets<Image>>) {
-    let texture = images.add(Image::default());
-    commands.insert_resource(DefaultTextureHandle(texture));
-}
-
-// Prepare our mesh for rendering
-fn update_draw_mesh(
-    mut commands: Commands,
-    mut glyph_cache: ResMut<GlyphCache>,
-    windows: Query<(&Window, Has<PrimaryWindow>)>,
-    mut meshes: ResMut<Assets<Mesh>>,
-    mut materials: ResMut<Assets<StandardMaterial>>,
-    draw: Query<(&Draw, &Camera)>,
-    mesh_q: Query<(&Handle<Mesh>, &Handle<StandardMaterial>), With<NannouMesh>>,
-) {
-    for (draw, camera) in &draw {
-        let window = if let RenderTarget::Window(window_ref) = camera.target {
-            match window_ref {
-                WindowRef::Primary => {
-                    let mut primary_window = None;
-                    for (window, is_primary) in windows.iter() {
-                        if is_primary {
-                            primary_window = Some(window);
-                            break;
-                        }
-                    }
-                    if let Some(primary_window) = primary_window {
-                        primary_window
-                    } else {
-                        warn!("No primary window found");
-                        continue;
-                    }
-                }
-                WindowRef::Entity(entity) => windows.get(entity).unwrap().0,
-            }
-        } else {
-            // TODO: handle other render targets
-            // For now, we only support rendering to a window
-            warn!("Unsupported render target");
-            continue;
-        };
-
-        // TODO: Unclear if we need to track this, or if the physical size is enough.
-        let scale_factor = 1.0;
-        let [w_px, h_px] = [window.physical_width(), window.physical_height()];
-
-        // Converting between pixels and points.
-        let px_to_pt = |s: u32| s as f32 / scale_factor;
-        let pt_to_px = |s: f32| (s * scale_factor).round() as u32;
-        let full_rect = nannou_core::geom::Rect::from_w_h(px_to_pt(w_px), px_to_pt(h_px));
-
-        let window_to_scissor = |v: nannou_core::geom::Vec2| -> [u32; 2] {
-            let x = map_range(v.x, full_rect.left(), full_rect.right(), 0u32, w_px);
-            let y = map_range(v.y, full_rect.bottom(), full_rect.top(), 0u32, h_px);
-            [x, y]
-        };
-
-        // TODO: Store these in `Renderer`.
-        let mut fill_tessellator = FillTessellator::new();
-        let mut stroke_tessellator = StrokeTessellator::new();
-
-        // Keep track of context changes.
-        let mut curr_ctxt = draw::Context::default();
-
-        // Collect all draw commands to avoid borrow errors.
-        let draw_cmds: Vec<_> = draw.drain_commands().collect();
-        let draw_state = draw.state.write().expect("failed to lock draw state");
-        let intermediary_state = draw_state
-            .intermediary_state
-            .read()
-            .expect("failed to lock intermediary state");
-        for (i, cmd) in draw_cmds.into_iter().enumerate() {
-            match cmd {
-                draw::DrawCommand::Context(ctxt) => curr_ctxt = ctxt,
-                draw::DrawCommand::Primitive(prim) => {
-                    // Info required during rendering.
-                    let ctxt = RenderContext {
-                        intermediary_mesh: &intermediary_state.intermediary_mesh,
-                        path_event_buffer: &intermediary_state.path_event_buffer,
-                        path_points_colored_buffer: &intermediary_state.path_points_colored_buffer,
-                        path_points_textured_buffer: &intermediary_state
-                            .path_points_textured_buffer,
-                        text_buffer: &intermediary_state.text_buffer,
-                        theme: &draw_state.theme,
-                        transform: &curr_ctxt.transform,
-                        fill_tessellator: &mut fill_tessellator,
-                        stroke_tessellator: &mut stroke_tessellator,
-                        glyph_cache: &mut glyph_cache,
-                        output_attachment_size: Vec2::new(px_to_pt(w_px), px_to_pt(h_px)),
-                        output_attachment_scale_factor: scale_factor,
-                    };
-
-                    // Get or spawn the mesh and material.
-                    let (mesh, material) = match mesh_q.iter().nth(i) {
-                        // We already have a mesh and material for this index.
-                        Some((mesh, material)) => (mesh.clone(), material.clone()),
-                        // We need to spawn a new mesh and material for this index.
-                        None => {
-                            let mesh = Mesh::init_with_topology(curr_ctxt.topology);
-                            let mesh = meshes.add(mesh);
-                            let material = materials.add(StandardMaterial::default());
-
-                            commands.spawn((
-                                NannouMesh,
-                                PbrBundle {
-                                    mesh: mesh.clone(),
-                                    material: material.clone(),
-                                    ..default()
-                                },
-                            ));
-
-                            (mesh, material)
-                        }
-                    };
-
-                    // Fetch the mesh and material.
-                    let (mesh, material) = (
-                        meshes.get_mut(&mesh).unwrap(),
-                        materials.get_mut(&material).unwrap(),
-                    );
-
-                    // Render the primitive.
-                    let render = prim.render_primitive(ctxt, mesh);
-                    material.base_color_texture = render.texture_handle;
-                }
-            }
-        }
-    }
-}
-
-#[derive(Component)]
-pub struct NannouMesh;
diff --git a/bevy_nannou_render/src/shaders/nannou.wgsl b/bevy_nannou_render/src/shaders/nannou.wgsl
deleted file mode 100644
index 2e14c04df..000000000
--- a/bevy_nannou_render/src/shaders/nannou.wgsl
+++ /dev/null
@@ -1,72 +0,0 @@
-#import bevy_render::view::View
-
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ VERTEX ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
-
-struct DrawMeshUniform {
-    mode: u32,
-};
-
-@group(0) @binding(0) var<uniform> view: View;
-@group(1) @binding(0) var<uniform> mesh: DrawMeshUniform;
-
-struct VertexInput {
-    @location(0) position: vec3<f32>,
-    @location(1) color: vec4<f32>,
-    @location(2) tex_coords: vec2<f32>,
-};
-
-struct VertexOutput {
-    @location(0) color: vec4<f32>,
-    @location(1) tex_coords: vec2<f32>,
-    @location(2) mode: u32,
-    @builtin(position) pos: vec4<f32>,
-};
-
-@vertex
-fn vertex(
-    input: VertexInput,
-) -> VertexOutput {
-    let out_pos: vec4<f32> = view.view_proj * vec4<f32>(input.position, 1.0);
-    return VertexOutput(input.color, input.tex_coords, mesh.mode, out_pos);
-}
-
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ FRAGMENT ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
-
-struct FragmentInput {
-    @location(0) color: vec4<f32>,
-    @location(1) tex_coords: vec2<f32>,
-    @location(2) mode: u32,
-}
-
-struct FragmentOutput {
-    @location(0) color: vec4<f32>,
-};
-
-@group(2) @binding(0) var text_sampler: sampler;
-@group(2) @binding(1) var text: texture_2d<f32>;
-@group(3) @binding(0) var texture_sampler: sampler;
-@group(3) @binding(1) var texture: texture_2d<f32>;
-
-@fragment
-fn fragment(
-    input: FragmentInput,
-) -> FragmentOutput {
-    let texture_color: vec4<f32> = textureSample(texture, texture_sampler, input.tex_coords);
-    let text_color: vec4<f32> = textureSample(text, text_sampler, input.tex_coords);
-    let text_alpha: f32 = text_color.x;
-    var out_color: vec4<f32>;
-    if (input.mode == u32(0)) {
-        out_color = input.color;
-    } else {
-        if (input.mode == u32(1)) {
-            out_color = texture_color;
-        } else {
-            if (input.mode == u32(2)) {
-                out_color = vec4<f32>(input.color.xyz, input.color.w * text_alpha);
-            } else {
-                out_color = vec4<f32>(1.0, 0.0, 0.0, 1.0);
-            }
-        }
-    }
-    return FragmentOutput(out_color);
-}
diff --git a/bevy_nannou_video/Cargo.toml b/bevy_nannou_video/Cargo.toml
new file mode 100644
index 000000000..a5c050c0e
--- /dev/null
+++ b/bevy_nannou_video/Cargo.toml
@@ -0,0 +1,11 @@
+[package]
+name = "bevy_nannou_video"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+bevy = { workspace = true }
+video-rs = "0.8.1"
+thiserror = "1"
+rayon = { workspace = true }
+serde = { version = "1.0.204", features = ["derive"] }
diff --git a/bevy_nannou_video/src/asset.rs b/bevy_nannou_video/src/asset.rs
new file mode 100644
index 000000000..37700e0f3
--- /dev/null
+++ b/bevy_nannou_video/src/asset.rs
@@ -0,0 +1,157 @@
+use bevy::asset::io::file::FileAssetReader;
+use bevy::asset::io::{AssetReader, AssetReaderError, AssetSource, PathStream, Reader};
+use bevy::asset::{AssetLoader, LoadContext};
+use bevy::prelude::*;
+use bevy::render::render_asset::RenderAssetUsages;
+use bevy::render::render_resource::{Extent3d, TextureFormat};
+use bevy::utils::HashMap;
+use rayon::prelude::*;
+use serde::{Deserialize, Serialize};
+use std::ops::{Deref, DerefMut};
+use std::path::Path;
+use thiserror::Error;
+use video_rs::hwaccel::HardwareAccelerationDeviceType;
+use video_rs::{Decoder, DecoderBuilder};
+
+pub struct VideoAssetPlugin;
+
+impl Plugin for VideoAssetPlugin {
+    fn build(&self, app: &mut App) {
+        info!("Adding video asset plugin");
+        app.init_asset::<Video>()
+            .init_asset_loader::<VideoLoader>()
+            .add_systems(Update, load_next_frame);
+    }
+}
+
+fn load_next_frame(
+    mut videos: ResMut<Assets<Video>>,
+    mut images: ResMut<Assets<Image>>,
+    time: Res<Time>,
+) {
+    for (_, video) in videos.iter_mut() {
+        let current_time = time.elapsed_seconds_f64();
+        if current_time - video.last_update < video.frame_duration {
+            continue; // Not time for next frame yet
+        }
+        video.last_update = current_time;
+        if let Some(next_texture) = video.next_texture() {
+            video.texture = images.add(next_texture);
+        }
+    }
+}
+
+#[derive(Asset, TypePath)]
+pub struct Video {
+    last_update: f64,
+    frame_duration: f64,
+    pub decoder: Decoder,
+    pub texture: Handle<Image>,
+}
+
+impl Video {
+    fn next_texture(&mut self) -> Option<Image> {
+        let (width, height) = self.decoder.size();
+        if let Some(Ok(frame)) = self.decoder.decode_raw_iter().next() {
+            // TODO: Handle other formats
+            let rgba = frame
+                .data(0)
+                .par_iter()
+                .chunks(3)
+                .flat_map(|chunk| {
+                    let r = chunk[0];
+                    let g = chunk[1];
+                    let b = chunk[2];
+                    [*r, *g, *b, 255]
+                })
+                .collect::<Vec<u8>>();
+
+            let mut image = Image::default();
+            image.texture_descriptor.format = TextureFormat::Rgba8UnormSrgb;
+            image.resize(Extent3d {
+                width,
+                height,
+                ..default()
+            });
+            image.data = rgba;
+            image.asset_usage = RenderAssetUsages::RENDER_WORLD;
+            return Some(image);
+        }
+        None
+    }
+}
+
+impl Deref for Video {
+    type Target = Decoder;
+
+    fn deref(&self) -> &Self::Target {
+        &self.decoder
+    }
+}
+
+impl DerefMut for Video {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.decoder
+    }
+}
+
+#[derive(Default)]
+struct VideoLoader;
+
+#[derive(Default, Serialize, Deserialize)]
+pub struct VideoLoaderSettings {
+    pub options: std::collections::HashMap<String, String>,
+}
+
+impl AssetLoader for VideoLoader {
+    type Asset = Video;
+    type Settings = VideoLoaderSettings;
+    type Error = VideoAssetLoaderError;
+
+    async fn load<'a>(
+        &'a self,
+        _reader: &'a mut Reader<'_>,
+        settings: &'a Self::Settings,
+        load_context: &'a mut LoadContext<'_>,
+    ) -> Result<Self::Asset, Self::Error> {
+        let path = load_context.asset_path().path();
+        // TODO: support web loading
+        let base_path = FileAssetReader::get_base_path().join("assets");
+        let path = base_path.join(path);
+        let options = settings.options.clone();
+        let options = options.into();
+        let decoder = DecoderBuilder::new(path)
+            .with_options(&options)
+            .build()
+            .map_err(|e| VideoAssetLoaderError::Decoder(e))?;
+        let (width, height) = decoder.size();
+        let mut image = Image::default();
+        image.texture_descriptor.format = TextureFormat::Rgba8UnormSrgb;
+        image.resize(Extent3d {
+            width,
+            height,
+            ..default()
+        });
+        image.asset_usage = RenderAssetUsages::RENDER_WORLD;
+        let texture = load_context.add_labeled_asset(String::from("video_texture"), image);
+        let fps = decoder.frame_rate() as f64;
+        Ok(Video {
+            last_update: 0.0,
+            frame_duration: 1.0 / fps,
+            decoder,
+            texture,
+        })
+    }
+
+    fn extensions(&self) -> &[&str] {
+        &["mp4"]
+    }
+}
+
+#[derive(Debug, Error)]
+pub enum VideoAssetLoaderError {
+    #[error("Failed to construct video decoder {0}")]
+    Decoder(#[from] video_rs::Error),
+    #[error("Failed to load video file")]
+    Io(#[from] std::io::Error),
+}
diff --git a/bevy_nannou_video/src/lib.rs b/bevy_nannou_video/src/lib.rs
new file mode 100644
index 000000000..83d84567f
--- /dev/null
+++ b/bevy_nannou_video/src/lib.rs
@@ -0,0 +1,16 @@
+use crate::asset::VideoAssetPlugin;
+use bevy::app::{App, Plugin};
+
+mod asset;
+
+pub mod prelude {
+    pub use crate::asset::{Video, VideoLoaderSettings};
+}
+
+pub struct NannouVideoPlugin;
+
+impl Plugin for NannouVideoPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_plugins(VideoAssetPlugin);
+    }
+}
diff --git a/bevy_nannou_wgpu/Cargo.toml b/bevy_nannou_wgpu/Cargo.toml
deleted file mode 100644
index 939489a4d..000000000
--- a/bevy_nannou_wgpu/Cargo.toml
+++ /dev/null
@@ -1,9 +0,0 @@
-[package]
-name = "bevy_nannou_wgpu"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-bevy = { workspace = true }
-# We use bevy's mirrored wgpu types almost always, but in a few rare cases, we need to use wgpu types directly
-wgpu-types = "0.17"
\ No newline at end of file
diff --git a/bevy_nannou_wgpu/src/bind_group_builder.rs b/bevy_nannou_wgpu/src/bind_group_builder.rs
deleted file mode 100644
index 7a93998db..000000000
--- a/bevy_nannou_wgpu/src/bind_group_builder.rs
+++ /dev/null
@@ -1,223 +0,0 @@
-use bevy::prelude::*;
-use bevy::render::render_resource as wgpu;
-use bevy::render::render_resource::ShaderType;
-use bevy::render::renderer::RenderDevice;
-
-/// A type aimed at simplifying the creation of a bind group layout.
-#[derive(Debug, Default)]
-pub struct BindGroupLayoutBuilder {
-    bindings: Vec<(wgpu::ShaderStages, wgpu::BindingType)>,
-}
-
-/// Simplified creation of a bind group.
-#[derive(Debug, Default)]
-pub struct BindGroupBuilder<'a> {
-    resources: Vec<wgpu::BindingResource<'a>>,
-}
-
-impl BindGroupLayoutBuilder {
-    /// Begin building the bind group layout.
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Specify a new binding.
-    ///
-    /// The `binding` position of each binding will be inferred as the index within the order that
-    /// they are added to this builder type. If you require manually specifying the binding
-    /// location, you may be better off not using the `BindGroupLayoutBuilder` and instead
-    /// constructing the `BindGroupLayout` and `BindGroup` manually.
-    pub fn binding(mut self, visibility: wgpu::ShaderStages, ty: wgpu::BindingType) -> Self {
-        self.bindings.push((visibility, ty));
-        self
-    }
-
-    /// Add a uniform buffer binding to the layout.
-    pub fn uniform_buffer<T: ShaderType>(
-        self,
-        visibility: wgpu::ShaderStages,
-        has_dynamic_offset: bool,
-    ) -> Self {
-        let ty = wgpu::BindingType::Buffer {
-            ty: wgpu::BufferBindingType::Uniform,
-            has_dynamic_offset,
-            min_binding_size: Some(T::min_size()),
-        };
-        self.binding(visibility, ty)
-    }
-
-    /// Add a storage buffer binding to the layout.
-    pub fn storage_buffer(
-        self,
-        visibility: wgpu::ShaderStages,
-        has_dynamic_offset: bool,
-        read_only: bool,
-    ) -> Self {
-        let ty = wgpu::BindingType::Buffer {
-            ty: wgpu::BufferBindingType::Storage { read_only },
-            has_dynamic_offset,
-            // wgpu 0.5-0.6 TODO: potential perf hit, investigate this field
-            min_binding_size: None,
-        };
-        self.binding(visibility, ty)
-    }
-
-    /// Add a sampler binding to the layout.
-    pub fn sampler(self, visibility: wgpu::ShaderStages, filtering: bool) -> Self {
-        let ty = wgpu::BindingType::Sampler(if filtering {
-            wgpu::SamplerBindingType::Filtering
-        } else {
-            wgpu::SamplerBindingType::NonFiltering
-        });
-        self.binding(visibility, ty)
-    }
-
-    /// Add a sampler binding to the layout.
-    pub fn comparison_sampler(self, visibility: wgpu::ShaderStages) -> Self {
-        let ty = wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Comparison);
-        self.binding(visibility, ty)
-    }
-
-    /// Add a texture binding to the layout.
-    pub fn texture(
-        self,
-        visibility: wgpu::ShaderStages,
-        multisampled: bool,
-        view_dimension: wgpu::TextureViewDimension,
-        sample_type: wgpu::TextureSampleType,
-    ) -> Self {
-        // fix sample type in certain scenarios (constraint given by wgpu)
-        let sample_type = if multisampled
-            && matches!(
-                sample_type,
-                wgpu::TextureSampleType::Float { filterable: true }
-            ) {
-            wgpu::TextureSampleType::Float { filterable: false }
-        } else {
-            sample_type
-        };
-        let ty = wgpu::BindingType::Texture {
-            multisampled,
-            view_dimension,
-            sample_type,
-        };
-        self.binding(visibility, ty)
-    }
-
-    /// Add a storage texture binding to the layout.
-    pub fn storage_texture(
-        self,
-        visibility: wgpu::ShaderStages,
-        format: wgpu::TextureFormat,
-        view_dimension: wgpu::TextureViewDimension,
-        access: wgpu::StorageTextureAccess,
-    ) -> Self {
-        let ty = wgpu::BindingType::StorageTexture {
-            view_dimension,
-            format,
-            access,
-        };
-        self.binding(visibility, ty)
-    }
-
-    /// Build the bind group layout from the specified parameters.
-    pub fn build(self, device: &RenderDevice) -> wgpu::BindGroupLayout {
-        let mut entries = Vec::with_capacity(self.bindings.len());
-        for (i, (visibility, ty)) in self.bindings.into_iter().enumerate() {
-            let layout_binding = wgpu::BindGroupLayoutEntry {
-                binding: i as u32,
-                visibility,
-                ty,
-                count: None,
-            };
-            entries.push(layout_binding);
-        }
-
-        let label = Some("nannou bind group layout");
-        let desc = wgpu::BindGroupLayoutDescriptor {
-            label,
-            entries: &entries,
-        };
-        device.create_bind_group_layout(&desc)
-    }
-}
-
-impl<'a> BindGroupBuilder<'a> {
-    /// Begin building the bind group.
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Specify a new binding.
-    ///
-    /// The `binding` position of each binding will be inferred as the index within the order that
-    /// they are added to this builder type. If you require manually specifying the binding
-    /// location, you may be better off not using the `BindGroupBuilder` and instead constructing
-    /// the `BindGroupLayout` and `BindGroup` manually.
-    pub fn binding(mut self, resource: wgpu::BindingResource<'a>) -> Self {
-        self.resources.push(resource);
-        self
-    }
-
-    /// Specify a slice of a buffer to be bound.
-    ///
-    /// The given `range` represents the start and end point of the buffer to be bound in bytes.
-    pub fn buffer_bytes(
-        self,
-        buffer: &'a wgpu::Buffer,
-        offset: wgpu::BufferAddress,
-        size: Option<wgpu::BufferSize>,
-    ) -> Self {
-        let resource = wgpu::BindingResource::Buffer(wgpu::BufferBinding {
-            buffer,
-            offset,
-            size,
-        });
-        self.binding(resource)
-    }
-
-    /// Specify a slice of a buffer of elements of type `T` to be bound.
-    ///
-    /// This method is similar to `buffer_bytes`, but expects a range of **elements** rather than a
-    /// range of **bytes**.
-    ///
-    /// Type `T` *must* be either `#[repr(C)]` or `#[repr(transparent)]`.
-    // NOTE: We might want to change this to match the wgpu API by using a NonZeroU64 for size.
-    pub fn buffer<T>(self, buffer: &'a wgpu::Buffer, range: std::ops::Range<usize>) -> Self
-// TODO: why was this necessary?
-    // where
-    //     T: Copy,
-    {
-        let size_bytes = std::mem::size_of::<T>() as wgpu::BufferAddress;
-        let start = range.start as wgpu::BufferAddress * size_bytes;
-        let end = range.end as wgpu::BufferAddress * size_bytes;
-        let size = std::num::NonZeroU64::new(end - start).expect("buffer slice must not be empty");
-        self.buffer_bytes(buffer, start, Some(size))
-    }
-
-    /// Specify a sampler to be bound.
-    pub fn sampler(self, sampler: &'a wgpu::Sampler) -> Self {
-        let resource = wgpu::BindingResource::Sampler(sampler);
-        self.binding(resource)
-    }
-
-    /// Specify a texture view to be bound.
-    pub fn texture_view(self, view: &'a wgpu::TextureView) -> Self {
-        let resource = wgpu::BindingResource::TextureView(view);
-        self.binding(resource)
-    }
-
-    /// Build the bind group with the specified resources.
-    pub fn build(self, device: &RenderDevice, layout: &wgpu::BindGroupLayout) -> wgpu::BindGroup {
-        let mut entries = Vec::with_capacity(self.resources.len());
-        for (i, resource) in self.resources.into_iter().enumerate() {
-            let binding = wgpu::BindGroupEntry {
-                binding: i as u32,
-                resource,
-            };
-            entries.push(binding);
-        }
-        let label = Some("nannou bind group");
-        device.create_bind_group(label, &layout, &entries)
-    }
-}
diff --git a/bevy_nannou_wgpu/src/lib.rs b/bevy_nannou_wgpu/src/lib.rs
deleted file mode 100644
index dff61894c..000000000
--- a/bevy_nannou_wgpu/src/lib.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-mod bind_group_builder;
-mod render_pass;
-mod render_pipeline_builder;
-mod sampler_builder;
-mod texture;
-
-pub use bind_group_builder::{BindGroupBuilder, BindGroupLayoutBuilder};
-pub use render_pass::{
-    ColorAttachmentDescriptorBuilder, DepthStencilAttachmentDescriptorBuilder, RenderPassBuilder,
-};
-pub use render_pipeline_builder::RenderPipelineBuilder;
-pub use sampler_builder::SamplerBuilder;
-pub use texture::TextureBuilder;
-
-use bevy::prelude::*;
-use bevy::render::render_resource as wgpu;
-
-/// Whether or not the sampler descriptor describes a sampler that might perform linear filtering.
-///
-/// This is used to determine the `filtering` field for the sampler binding type variant which
-/// assists wgpu with validation.
-pub fn sampler_filtering(desc: &wgpu::SamplerDescriptor) -> bool {
-    match (desc.mag_filter, desc.min_filter, desc.mipmap_filter) {
-        (wgpu::FilterMode::Nearest, wgpu::FilterMode::Nearest, wgpu::FilterMode::Nearest) => false,
-        _ => true,
-    }
-}
-
-//TODO: Does this need to be a plugin to inject anything into the ECS? Or just utils?
-struct NannouWgpuPlugin;
-
-impl Plugin for NannouWgpuPlugin {
-    fn build(&self, app: &mut App) {}
-}
diff --git a/bevy_nannou_wgpu/src/render_pass.rs b/bevy_nannou_wgpu/src/render_pass.rs
deleted file mode 100644
index 71f85f5a7..000000000
--- a/bevy_nannou_wgpu/src/render_pass.rs
+++ /dev/null
@@ -1,225 +0,0 @@
-use bevy::prelude::*;
-use bevy::render::render_phase::TrackedRenderPass;
-use bevy::render::render_resource as wgpu;
-use bevy::render::renderer::RenderContext;
-use wgpu_types::Color;
-
-/// A builder type to simplify the process of creating a render pass descriptor.
-#[derive(Debug, Default)]
-pub struct RenderPassBuilder<'a> {
-    color_attachments: Vec<Option<wgpu::RenderPassColorAttachment<'a>>>,
-    depth_stencil_attachment: Option<wgpu::RenderPassDepthStencilAttachment<'a>>,
-}
-
-/// A builder type to simplify the process of creating a render pass descriptor.
-#[derive(Debug)]
-pub struct ColorAttachmentDescriptorBuilder<'a> {
-    descriptor: wgpu::RenderPassColorAttachment<'a>,
-}
-
-/// A builder type to simplify the process of creating a render pass descriptor.
-#[derive(Debug)]
-pub struct DepthStencilAttachmentDescriptorBuilder<'a> {
-    descriptor: wgpu::RenderPassDepthStencilAttachment<'a>,
-}
-
-impl<'a> ColorAttachmentDescriptorBuilder<'a> {
-    pub const DEFAULT_CLEAR_COLOR: Color = Color::TRANSPARENT;
-    pub const DEFAULT_LOAD_OP: wgpu::LoadOp<Color> = wgpu::LoadOp::Clear(Self::DEFAULT_CLEAR_COLOR);
-    pub const DEFAULT_STORE_OP: bool = true;
-
-    /// Begin building a new render pass color attachment descriptor.
-    fn new(attachment: &'a wgpu::TextureView) -> Self {
-        ColorAttachmentDescriptorBuilder {
-            descriptor: wgpu::RenderPassColorAttachment {
-                view: attachment,
-                resolve_target: None,
-                ops: wgpu::Operations {
-                    load: wgpu::LoadOp::Clear(Color::TRANSPARENT),
-                    store: true,
-                },
-            },
-        }
-    }
-
-    /// Specify the resolve target for this render pass color attachment.
-    pub fn resolve_target(mut self, target: Option<&'a wgpu::TextureView>) -> Self {
-        self.descriptor.resolve_target = target.map(|t| &**t);
-        self
-    }
-    //
-    // /// Specify the resolve target for this render pass color attachment.
-    // pub fn resolve_target_handle(mut self, target: Option<&'a wgpu::TextureView>) -> Self {
-    //     self.descriptor.resolve_target = target;
-    //     self
-    // }
-
-    /// The beginning-of-pass load operation for this color attachment.
-    pub fn load_op(mut self, load_op: wgpu::LoadOp<Color>) -> Self {
-        self.descriptor.ops.load = load_op;
-        self
-    }
-
-    // /// The end-of-pass store operation for this color attachment.
-    // pub fn store_op(mut self, store_op: bool::Store) -> Self {
-    //     self.descriptor.ops.store = store_op;
-    //     self
-    // }
-}
-
-impl<'a> DepthStencilAttachmentDescriptorBuilder<'a> {
-    pub const DEFAULT_DEPTH_LOAD_OP: wgpu::LoadOp<f32> =
-        wgpu::LoadOp::Clear(Self::DEFAULT_CLEAR_DEPTH);
-    pub const DEFAULT_DEPTH_STORE_OP: bool = true;
-    pub const DEFAULT_CLEAR_DEPTH: f32 = 1.0;
-    pub const DEFAULT_STENCIL_LOAD_OP: wgpu::LoadOp<u32> =
-        wgpu::LoadOp::Clear(Self::DEFAULT_CLEAR_STENCIL);
-    pub const DEFAULT_STENCIL_STORE_OP: bool = true;
-    pub const DEFAULT_CLEAR_STENCIL: u32 = 0;
-
-    fn new(attachment: &'a wgpu::TextureView) -> Self {
-        DepthStencilAttachmentDescriptorBuilder {
-            descriptor: wgpu::RenderPassDepthStencilAttachment {
-                view: attachment,
-                depth_ops: Some(wgpu::Operations {
-                    load: Self::DEFAULT_DEPTH_LOAD_OP,
-                    store: Self::DEFAULT_DEPTH_STORE_OP,
-                }),
-                stencil_ops: Some(wgpu::Operations {
-                    load: Self::DEFAULT_STENCIL_LOAD_OP,
-                    store: Self::DEFAULT_STENCIL_STORE_OP,
-                }),
-            },
-        }
-    }
-
-    /// The beginning-of-pass load operation for this depth attachment.
-    pub fn depth_load_op(mut self, load: wgpu::LoadOp<f32>) -> Self {
-        self.descriptor.depth_ops = Some(wgpu::Operations {
-            load,
-            store: self.descriptor.depth_ops.expect("no depth ops field").store,
-        });
-        self
-    }
-
-    /// The end-of-pass store operation for this depth attachment.
-    pub fn depth_store_op(mut self, store: bool) -> Self {
-        self.descriptor.depth_ops = Some(wgpu::Operations {
-            load: self.descriptor.depth_ops.expect("no depth ops field").load,
-            store,
-        });
-        self
-    }
-
-    /// The beginning-of-pass load operation for this stencil attachment.
-    pub fn stencil_load_op(mut self, load: wgpu::LoadOp<u32>) -> Self {
-        self.descriptor.stencil_ops = Some(wgpu::Operations {
-            load,
-            store: self
-                .descriptor
-                .stencil_ops
-                .expect("no stencil ops field")
-                .store,
-        });
-        self
-    }
-
-    /// The end-of-pass store operation for this stencil attachment.
-    pub fn stencil_store_op(mut self, store: bool) -> Self {
-        self.descriptor.stencil_ops = Some(wgpu::Operations {
-            load: self
-                .descriptor
-                .stencil_ops
-                .expect("no stencil ops field")
-                .load,
-            store,
-        });
-        self
-    }
-}
-
-impl<'a> RenderPassBuilder<'a> {
-    pub const DEFAULT_COLOR_LOAD_OP: wgpu::LoadOp<Color> =
-        ColorAttachmentDescriptorBuilder::DEFAULT_LOAD_OP;
-    pub const DEFAULT_COLOR_STORE_OP: bool = ColorAttachmentDescriptorBuilder::DEFAULT_STORE_OP;
-    pub const DEFAULT_CLEAR_COLOR: Color = ColorAttachmentDescriptorBuilder::DEFAULT_CLEAR_COLOR;
-    pub const DEFAULT_DEPTH_LOAD_OP: wgpu::LoadOp<f32> =
-        DepthStencilAttachmentDescriptorBuilder::DEFAULT_DEPTH_LOAD_OP;
-    pub const DEFAULT_DEPTH_STORE_OP: bool =
-        DepthStencilAttachmentDescriptorBuilder::DEFAULT_DEPTH_STORE_OP;
-    pub const DEFAULT_CLEAR_DEPTH: f32 =
-        DepthStencilAttachmentDescriptorBuilder::DEFAULT_CLEAR_DEPTH;
-    pub const DEFAULT_STENCIL_LOAD_OP: wgpu::LoadOp<u32> =
-        DepthStencilAttachmentDescriptorBuilder::DEFAULT_STENCIL_LOAD_OP;
-    pub const DEFAULT_STENCIL_STORE_OP: bool =
-        DepthStencilAttachmentDescriptorBuilder::DEFAULT_STENCIL_STORE_OP;
-    pub const DEFAULT_CLEAR_STENCIL: u32 =
-        DepthStencilAttachmentDescriptorBuilder::DEFAULT_CLEAR_STENCIL;
-
-    /// Begin building a new render pass descriptor.
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Add a single color attachment descriptor to the render pass descriptor.
-    ///
-    /// Call this multiple times in succession to add multiple color attachments.
-    pub fn color_attachment<F>(
-        mut self,
-        attachment: &'a wgpu::TextureView,
-        color_builder: F,
-    ) -> Self
-    where
-        F: FnOnce(ColorAttachmentDescriptorBuilder<'a>) -> ColorAttachmentDescriptorBuilder<'a>,
-    {
-        let builder = ColorAttachmentDescriptorBuilder::new(attachment);
-        let descriptor = color_builder(builder).descriptor;
-        self.color_attachments.push(Some(descriptor));
-        self
-    }
-
-    /// Add a depth stencil attachment to the render pass.
-    ///
-    /// This should only be called once, as only a single depth stencil attachment is valid. Only
-    /// the attachment submitted last will be used.
-    pub fn depth_stencil_attachment<F>(
-        mut self,
-        attachment: &'a wgpu::TextureView,
-        depth_stencil_builder: F,
-    ) -> Self
-    where
-        F: FnOnce(
-            DepthStencilAttachmentDescriptorBuilder<'a>,
-        ) -> DepthStencilAttachmentDescriptorBuilder<'a>,
-    {
-        let builder = DepthStencilAttachmentDescriptorBuilder::new(attachment);
-        let descriptor = depth_stencil_builder(builder).descriptor;
-        self.depth_stencil_attachment = Some(descriptor);
-        self
-    }
-
-    /// Return the built color and depth attachments.
-    pub fn into_inner(
-        self,
-    ) -> (
-        Vec<Option<wgpu::RenderPassColorAttachment<'a>>>,
-        Option<wgpu::RenderPassDepthStencilAttachment<'a>>,
-    ) {
-        let RenderPassBuilder {
-            color_attachments,
-            depth_stencil_attachment,
-        } = self;
-        (color_attachments, depth_stencil_attachment)
-    }
-
-    /// Begin a render pass with the specified parameters on the given encoder.
-    pub fn begin(self, render_context: &'a mut RenderContext) -> TrackedRenderPass<'a> {
-        let (color_attachments, depth_stencil_attachment) = self.into_inner();
-        let descriptor = wgpu::RenderPassDescriptor {
-            label: Some("nannou_render_pass"),
-            color_attachments: &color_attachments,
-            depth_stencil_attachment,
-        };
-        render_context.begin_tracked_render_pass(descriptor)
-    }
-}
diff --git a/bevy_nannou_wgpu/src/render_pipeline_builder.rs b/bevy_nannou_wgpu/src/render_pipeline_builder.rs
deleted file mode 100644
index 0a187a928..000000000
--- a/bevy_nannou_wgpu/src/render_pipeline_builder.rs
+++ /dev/null
@@ -1,509 +0,0 @@
-//! Items aimed at easing the contruction of a render pipeline.
-//!
-//! Creating a `RenderPipeline` tends to involve a lot of boilerplate that we don't always want to
-//! have to consider when writing graphics code. Here we definGe a set of helpers that allow us to
-//! simplify the process and fall back to a set of reasonable defaults.
-use bevy::prelude::*;
-use bevy::render::render_resource as wgpu;
-use std::borrow::Cow;
-
-/// Types that may be directly converted into a pipeline layout descriptor.
-
-pub trait IntoPipelineLayoutDescriptor<'a> {
-    /// Convert the type into a pipeline layout descriptor.
-    fn into_pipeline_layout_descriptor(self) -> wgpu::PipelineLayoutDescriptor<'a>;
-}
-
-/// A builder type to help simplify the construction of a **RenderPipeline**.
-///
-/// We've attempted to provide a suite of reasonable defaults in the case that none are provided.
-#[derive(Debug)]
-pub struct RenderPipelineBuilder<'a> {
-    layout: &'a [wgpu::BindGroupLayout],
-    vs_mod: Handle<Shader>,
-    fs_mod: Option<Handle<Shader>>,
-    vs_entry_point: &'a str,
-    fs_entry_point: &'a str,
-    primitive: wgpu::PrimitiveState,
-    color_state: Option<wgpu::ColorTargetState>,
-    color_states: &'a [Option<wgpu::ColorTargetState>],
-    depth_stencil: Option<wgpu::DepthStencilState>,
-    vertex_buffers: Vec<wgpu::VertexBufferLayout>,
-    multisample: wgpu::MultisampleState,
-}
-
-impl<'a> RenderPipelineBuilder<'a> {
-    // The default entry point used for shaders when unspecified.
-    pub const DEFAULT_SHADER_ENTRY_POINT: &'static str = "main";
-
-    // Primitive state.
-    pub const DEFAULT_FRONT_FACE: wgpu::FrontFace = wgpu::FrontFace::Ccw;
-    pub const DEFAULT_CULL_MODE: Option<wgpu::Face> = None;
-    pub const DEFAULT_POLYGON_MODE: wgpu::PolygonMode = wgpu::PolygonMode::Fill;
-    pub const DEFAULT_PRIMITIVE_TOPOLOGY: wgpu::PrimitiveTopology =
-        wgpu::PrimitiveTopology::TriangleList;
-    pub const DEFAULT_PRIMITIVE: wgpu::PrimitiveState = wgpu::PrimitiveState {
-        topology: Self::DEFAULT_PRIMITIVE_TOPOLOGY,
-        strip_index_format: None,
-        front_face: Self::DEFAULT_FRONT_FACE,
-        cull_mode: Self::DEFAULT_CULL_MODE,
-        polygon_mode: Self::DEFAULT_POLYGON_MODE,
-        unclipped_depth: Self::DEFAULT_UNCLIPPED_DEPTH,
-        conservative: false,
-    };
-
-    // Color state defaults.
-    pub const DEFAULT_COLOR_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba16Float;
-    pub const DEFAULT_COLOR_BLEND: wgpu::BlendComponent = wgpu::BlendComponent {
-        src_factor: wgpu::BlendFactor::SrcAlpha,
-        dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
-        operation: wgpu::BlendOperation::Add,
-    };
-    pub const DEFAULT_ALPHA_BLEND: wgpu::BlendComponent = wgpu::BlendComponent {
-        src_factor: wgpu::BlendFactor::One,
-        dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
-        operation: wgpu::BlendOperation::Add,
-    };
-    pub const DEFAULT_COLOR_WRITE: wgpu::ColorWrites = wgpu::ColorWrites::ALL;
-    pub const DEFAULT_BLEND_STATE: wgpu::BlendState = wgpu::BlendState {
-        color: Self::DEFAULT_COLOR_BLEND,
-        alpha: Self::DEFAULT_ALPHA_BLEND,
-    };
-    pub const DEFAULT_COLOR_STATE: wgpu::ColorTargetState = wgpu::ColorTargetState {
-        format: Self::DEFAULT_COLOR_FORMAT,
-        blend: Some(Self::DEFAULT_BLEND_STATE),
-        write_mask: Self::DEFAULT_COLOR_WRITE,
-    };
-
-    // Depth state defaults.
-    pub const DEFAULT_DEPTH_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Depth32Float;
-    pub const DEFAULT_DEPTH_WRITE_ENABLED: bool = true;
-    pub const DEFAULT_DEPTH_COMPARE: wgpu::CompareFunction = wgpu::CompareFunction::GreaterEqual;
-    pub const DEFAULT_STENCIL_FRONT: wgpu::StencilFaceState = wgpu::StencilFaceState::IGNORE;
-    pub const DEFAULT_STENCIL_BACK: wgpu::StencilFaceState = wgpu::StencilFaceState::IGNORE;
-    pub const DEFAULT_STENCIL_READ_MASK: u32 = 0;
-    pub const DEFAULT_STENCIL_WRITE_MASK: u32 = 0;
-    pub const DEFAULT_STENCIL: wgpu::StencilState = wgpu::StencilState {
-        front: Self::DEFAULT_STENCIL_FRONT,
-        back: Self::DEFAULT_STENCIL_BACK,
-        read_mask: Self::DEFAULT_STENCIL_READ_MASK,
-        write_mask: Self::DEFAULT_STENCIL_WRITE_MASK,
-    };
-    pub const DEFAULT_DEPTH_BIAS_CONSTANT: i32 = 0;
-    pub const DEFAULT_DEPTH_BIAS_SLOPE_SCALE: f32 = 0.0;
-    pub const DEFAULT_DEPTH_BIAS_CLAMP: f32 = 0.0;
-    pub const DEFAULT_DEPTH_BIAS: wgpu::DepthBiasState = wgpu::DepthBiasState {
-        constant: Self::DEFAULT_DEPTH_BIAS_CONSTANT,
-        slope_scale: Self::DEFAULT_DEPTH_BIAS_SLOPE_SCALE,
-        clamp: Self::DEFAULT_DEPTH_BIAS_CLAMP,
-    };
-    pub const DEFAULT_UNCLIPPED_DEPTH: bool = false;
-    pub const DEFAULT_DEPTH_STENCIL: wgpu::DepthStencilState = wgpu::DepthStencilState {
-        format: Self::DEFAULT_DEPTH_FORMAT,
-        depth_write_enabled: Self::DEFAULT_DEPTH_WRITE_ENABLED,
-        depth_compare: Self::DEFAULT_DEPTH_COMPARE,
-        stencil: Self::DEFAULT_STENCIL,
-        bias: Self::DEFAULT_DEPTH_BIAS,
-    };
-
-    // Multisample state.
-    pub const DEFAULT_SAMPLE_COUNT: u32 = 1;
-    pub const DEFAULT_SAMPLE_MASK: u64 = !0;
-    pub const DEFAULT_ALPHA_TO_COVERAGE_ENABLED: bool = false;
-    pub const DEFAULT_MULTISAMPLE: wgpu::MultisampleState = wgpu::MultisampleState {
-        count: Self::DEFAULT_SAMPLE_COUNT,
-        mask: Self::DEFAULT_SAMPLE_MASK,
-        alpha_to_coverage_enabled: Self::DEFAULT_ALPHA_TO_COVERAGE_ENABLED,
-    };
-
-    // Constructors
-
-    pub fn from_layout(layout: &'a [wgpu::BindGroupLayout], vs_mod: Handle<Shader>) -> Self {
-        Self::new_inner(layout, vs_mod)
-    }
-
-    // Shared between constructors.
-    fn new_inner(layout: &'a [wgpu::BindGroupLayout], vs_mod: Handle<Shader>) -> Self {
-        RenderPipelineBuilder {
-            layout,
-            vs_mod,
-            fs_mod: None,
-            vs_entry_point: Self::DEFAULT_SHADER_ENTRY_POINT,
-            fs_entry_point: Self::DEFAULT_SHADER_ENTRY_POINT,
-            color_state: None,
-            color_states: &[],
-            primitive: Self::DEFAULT_PRIMITIVE,
-            depth_stencil: None,
-            vertex_buffers: vec![],
-            multisample: Self::DEFAULT_MULTISAMPLE,
-        }
-    }
-
-    // Builders
-
-    /// The name of the entry point in the compiled shader.
-    ///
-    /// There must be a function that returns void with this name in the shader.
-    pub fn vertex_entry_point(mut self, entry_point: &'a str) -> Self {
-        self.vs_entry_point = entry_point;
-        self
-    }
-
-    /// The name of the entry point in the compiled shader.
-    ///
-    /// There must be a function that returns void with this name in the shader.
-    pub fn fragment_entry_point(mut self, entry_point: &'a str) -> Self {
-        self.fs_entry_point = entry_point;
-        self
-    }
-
-    /// Specify a compiled fragment shader for the render pipeline.
-    pub fn fragment_shader(mut self, fs_mod: Handle<Shader>) -> Self {
-        self.fs_mod = Some(fs_mod);
-        self
-    }
-
-    // Primitive state.
-
-    /// Specify the full primitive state.
-    ///
-    /// Describes the state of primitive assembly and rasterization in a render pipeline.
-    pub fn primitive(mut self, p: wgpu::PrimitiveState) -> Self {
-        self.primitive = p;
-        self
-    }
-
-    /// The face to consider the front for the purpose of culling and stencil operations.
-    pub fn front_face(mut self, front_face: wgpu::FrontFace) -> Self {
-        self.primitive.front_face = front_face;
-        self
-    }
-
-    /// The face culling mode.
-    pub fn cull_mode(mut self, cull_mode: Option<wgpu::Face>) -> Self {
-        self.primitive.cull_mode = cull_mode;
-        self
-    }
-
-    /// Specify the primitive topology.
-    ///
-    /// This represents the way vertices will be read from the **VertexBuffer**.
-    pub fn primitive_topology(mut self, topology: wgpu::PrimitiveTopology) -> Self {
-        self.primitive.topology = topology;
-        self
-    }
-
-    /// Controls the way each polygon is rasterized. Can be either `Fill` (default), `Line` or
-    /// `Point`.
-    ///
-    /// Setting this to something other than `Fill` requires `Features::NON_FILL_POLYGON_MODE` to
-    /// be enabled.
-    pub fn polygon_mode(mut self, mode: wgpu::PolygonMode) -> Self {
-        self.primitive.polygon_mode = mode;
-        self
-    }
-
-    // Color state.
-
-    /// Specify the full color state for drawing to the output attachment.
-    ///
-    /// If you have multiple output attachments, see the `color_states` method.
-    pub fn color_state(mut self, state: wgpu::ColorTargetState) -> Self {
-        self.color_state = Some(state);
-        self
-    }
-
-    /// The texture formrat of the image that this pipelinew ill render to.
-    ///
-    /// Must match the format of the corresponding color attachment.
-    pub fn color_format(mut self, format: wgpu::TextureFormat) -> Self {
-        let state = self.color_state.get_or_insert(Self::DEFAULT_COLOR_STATE);
-        state.format = format;
-        self
-    }
-
-    /// The color blending used for this pipeline.
-    pub fn color_blend(mut self, color_blend: wgpu::BlendComponent) -> Self {
-        let state = self.color_state.get_or_insert(Self::DEFAULT_COLOR_STATE);
-        let blend = state.blend.get_or_insert(Self::DEFAULT_BLEND_STATE);
-        blend.color = color_blend;
-
-        self
-    }
-
-    /// The alpha blending used for this pipeline.
-    pub fn alpha_blend(mut self, alpha_blend: wgpu::BlendComponent) -> Self {
-        let state = self.color_state.get_or_insert(Self::DEFAULT_COLOR_STATE);
-        let blend = state.blend.get_or_insert(Self::DEFAULT_BLEND_STATE);
-        blend.alpha = alpha_blend;
-
-        self
-    }
-
-    /// Mask which enables/disables writes to different color/alpha channel.
-    pub fn write_mask(mut self, mask: wgpu::ColorWrites) -> Self {
-        let state = self.color_state.get_or_insert(Self::DEFAULT_COLOR_STATE);
-        state.write_mask = mask;
-        self
-    }
-
-    // Depth / Stencil state
-
-    /// Specify the full depth stencil state.
-    pub fn depth_stencil(mut self, state: wgpu::DepthStencilState) -> Self {
-        self.depth_stencil = Some(state);
-        self
-    }
-
-    /// Format of the depth/stencil buffer. Must be one of the depth formats. Must match the format
-    /// of the depth/stencil attachment.
-    pub fn depth_format(mut self, format: wgpu::TextureFormat) -> Self {
-        let state = self
-            .depth_stencil
-            .get_or_insert(Self::DEFAULT_DEPTH_STENCIL);
-        state.format = format;
-        self
-    }
-
-    pub fn depth_write_enabled(mut self, enabled: bool) -> Self {
-        let state = self
-            .depth_stencil
-            .get_or_insert(Self::DEFAULT_DEPTH_STENCIL);
-        state.depth_write_enabled = enabled;
-        self
-    }
-
-    /// Comparison function used to compare depth values in the depth test.
-    pub fn depth_compare(mut self, compare: wgpu::CompareFunction) -> Self {
-        let state = self
-            .depth_stencil
-            .get_or_insert(Self::DEFAULT_DEPTH_STENCIL);
-        state.depth_compare = compare;
-        self
-    }
-
-    /// Specify the full set of stencil parameters.
-    pub fn stencil(mut self, stencil: wgpu::StencilState) -> Self {
-        let state = self
-            .depth_stencil
-            .get_or_insert(Self::DEFAULT_DEPTH_STENCIL);
-        state.stencil = stencil;
-        self
-    }
-
-    /// Front face mode.
-    pub fn stencil_front(mut self, stencil: wgpu::StencilFaceState) -> Self {
-        let state = self
-            .depth_stencil
-            .get_or_insert(Self::DEFAULT_DEPTH_STENCIL);
-        state.stencil.front = stencil;
-        self
-    }
-
-    /// Back face mode.
-    pub fn stencil_back(mut self, stencil: wgpu::StencilFaceState) -> Self {
-        let state = self
-            .depth_stencil
-            .get_or_insert(Self::DEFAULT_DEPTH_STENCIL);
-        state.stencil.back = stencil;
-        self
-    }
-
-    /// Stencil values are AND'd with this mask when reading and writing from the stencil buffer.
-    /// Only low 8 bits are used.
-    pub fn stencil_read_mask(mut self, mask: u32) -> Self {
-        let state = self
-            .depth_stencil
-            .get_or_insert(Self::DEFAULT_DEPTH_STENCIL);
-        state.stencil.read_mask = mask;
-        self
-    }
-
-    /// Stencil values are AND'd with this mask when writing to the stencil buffer.
-    /// Only low 8 bits are used.
-    pub fn stencil_write_mask(mut self, mask: u32) -> Self {
-        let state = self
-            .depth_stencil
-            .get_or_insert(Self::DEFAULT_DEPTH_STENCIL);
-        state.stencil.write_mask = mask;
-        self
-    }
-
-    /// Specify the full set of depth bias parameters.
-    ///
-    /// Describes the biasing setting for the depth target.
-    pub fn depth_bias(mut self, bias: wgpu::DepthBiasState) -> Self {
-        let state = self
-            .depth_stencil
-            .get_or_insert(Self::DEFAULT_DEPTH_STENCIL);
-        state.bias = bias;
-        self
-    }
-
-    /// Constant depth biasing factor, in basic units of the depth format.
-    pub fn depth_bias_constant(mut self, constant: i32) -> Self {
-        let state = self
-            .depth_stencil
-            .get_or_insert(Self::DEFAULT_DEPTH_STENCIL);
-        state.bias.constant = constant;
-        self
-    }
-
-    /// Slope depth biasing factor.
-    pub fn depth_bias_slope_scale(mut self, scale: f32) -> Self {
-        let state = self
-            .depth_stencil
-            .get_or_insert(Self::DEFAULT_DEPTH_STENCIL);
-        state.bias.slope_scale = scale;
-        self
-    }
-
-    /// Depth bias clamp value (absolute).
-    pub fn depth_bias_clamp(mut self, clamp: f32) -> Self {
-        let state = self
-            .depth_stencil
-            .get_or_insert(Self::DEFAULT_DEPTH_STENCIL);
-        state.bias.clamp = clamp;
-        self
-    }
-
-    /// If enabled polygon depth is clamped to 0-1 range instead of being clipped.
-    ///
-    /// Requires `Features::DEPTH_CLIP_CONTROL` enabled.
-    pub fn unclipped_depth(mut self, b: bool) -> Self {
-        self.primitive.unclipped_depth = b;
-        self
-    }
-
-    // Vertex buffer methods.
-
-    /// Add a new vertex buffer descriptor to the render pipeline.
-    pub fn add_vertex_buffer_layout(mut self, d: wgpu::VertexBufferLayout) -> Self {
-        self.vertex_buffers.push(d);
-        self
-    }
-
-    /// Short-hand for adding a descriptor to the render pipeline describing a buffer of vertices
-    /// of the given vertex type.
-    ///
-    /// The vertex stride is assumed to be equal to `size_of::<V>()`. If this is not the case,
-    /// consider using `add_vertex_buffer_layout` instead.
-    pub fn add_vertex_buffer<V>(self, attrs: &'static [wgpu::VertexAttribute]) -> Self {
-        let array_stride = std::mem::size_of::<V>() as wgpu::BufferAddress;
-        let step_mode = wgpu::VertexStepMode::Vertex;
-        let descriptor = wgpu::VertexBufferLayout {
-            array_stride,
-            step_mode,
-            attributes: Vec::from(attrs),
-        };
-        self.add_vertex_buffer_layout(descriptor)
-    }
-
-    /// Short-hand for adding a descriptor to the render pipeline describing a buffer of instances
-    /// of the given vertex type.
-    pub fn add_instance_buffer<I>(self, attrs: &'static [wgpu::VertexAttribute]) -> Self {
-        let array_stride = std::mem::size_of::<I>() as wgpu::BufferAddress;
-        let step_mode = wgpu::VertexStepMode::Instance;
-        let descriptor = wgpu::VertexBufferLayout {
-            array_stride,
-            step_mode,
-            attributes: Vec::from(attrs),
-        };
-        self.add_vertex_buffer_layout(descriptor)
-    }
-
-    // Multisample state.
-
-    /// Specify the full multisample state.
-    pub fn multisample(mut self, multisample: wgpu::MultisampleState) -> Self {
-        self.multisample = multisample;
-        self
-    }
-
-    /// The number of samples calculated per pixel (for MSAA).
-    ///
-    /// For non-multisampled textures, this should be 1 (the default).
-    pub fn sample_count(mut self, sample_count: u32) -> Self {
-        self.multisample.count = sample_count;
-        self
-    }
-
-    /// Bitmask that restricts the samples of a pixel modified by this pipeline. All samples can be
-    /// enabled using the value !0 (the default).
-    pub fn sample_mask(mut self, sample_mask: u64) -> Self {
-        self.multisample.mask = sample_mask;
-        self
-    }
-
-    /// When enabled, produces another sample mask per pixel based on the alpha output value, that
-    /// is ANDed with the sample_mask and the primitive coverage to restrict the set of samples
-    /// affected by a primitive.
-    ///
-    /// The implicit mask produced for alpha of zero is guaranteed to be zero, and for alpha of one
-    /// is guaranteed to be all 1-s.
-    ///
-    /// Disabled by default.
-    pub fn alpha_to_coverage_enabled(mut self, b: bool) -> Self {
-        self.multisample.alpha_to_coverage_enabled = b;
-        self
-    }
-
-    pub fn build(self) -> wgpu::RenderPipelineDescriptor {
-        let RenderPipelineBuilder {
-            layout,
-            vs_mod,
-            fs_mod,
-            vs_entry_point,
-            fs_entry_point,
-            primitive,
-            color_state,
-            color_states,
-            depth_stencil,
-            multisample,
-            vertex_buffers,
-        } = self;
-
-        let vertex = wgpu::VertexState {
-            shader: vs_mod,
-            entry_point: vs_entry_point.to_string().into(),
-            buffers: Vec::from(&vertex_buffers[..]),
-            shader_defs: vec![],
-        };
-
-        let mut single_color_state = [Some(RenderPipelineBuilder::DEFAULT_COLOR_STATE)];
-        let color_states = match (fs_mod.is_some(), color_states.is_empty()) {
-            (true, true) => {
-                if let cs @ Some(_) = color_state {
-                    single_color_state[0] = cs;
-                }
-                &single_color_state[..]
-            }
-            (true, false) => color_states,
-            (false, true) => panic!("specified color states but no fragment shader"),
-            (false, false) => match color_state.is_some() {
-                true => panic!("specified color state fields but no fragment shader"),
-                false => &[],
-            },
-        };
-        let fragment = match (fs_mod, color_states.is_empty()) {
-            (Some(fs_mod), false) => Some(wgpu::FragmentState {
-                shader: fs_mod,
-                entry_point: fs_entry_point.to_string().into(),
-                targets: Vec::from(color_states),
-                shader_defs: vec![],
-            }),
-            _ => None,
-        };
-
-        wgpu::RenderPipelineDescriptor {
-            label: Some(Cow::from("nannou render pipeline")),
-            layout: Vec::from(&layout[..]),
-            push_constant_ranges: vec![],
-            vertex,
-            primitive,
-            depth_stencil,
-            multisample,
-            fragment,
-        }
-    }
-}
diff --git a/bevy_nannou_wgpu/src/sampler_builder.rs b/bevy_nannou_wgpu/src/sampler_builder.rs
deleted file mode 100644
index f787c1b10..000000000
--- a/bevy_nannou_wgpu/src/sampler_builder.rs
+++ /dev/null
@@ -1,153 +0,0 @@
-use bevy::prelude::*;
-use bevy::render::render_resource as wgpu;
-use bevy::render::renderer::RenderDevice;
-/// Simplifies the construction of a `Sampler` with a set of reasonable defaults.
-#[derive(Debug)]
-pub struct SamplerBuilder {
-    pub descriptor: wgpu::SamplerDescriptor<'static>,
-}
-
-impl<'b> SamplerBuilder {
-    pub const DEFAULT_ADDRESS_MODE_U: wgpu::AddressMode = wgpu::AddressMode::ClampToEdge;
-    pub const DEFAULT_ADDRESS_MODE_V: wgpu::AddressMode = wgpu::AddressMode::ClampToEdge;
-    pub const DEFAULT_ADDRESS_MODE_W: wgpu::AddressMode = wgpu::AddressMode::ClampToEdge;
-    pub const DEFAULT_MAG_FILTER: wgpu::FilterMode = wgpu::FilterMode::Linear;
-    pub const DEFAULT_MIN_FILTER: wgpu::FilterMode = wgpu::FilterMode::Linear;
-    pub const DEFAULT_MIPMAP_FILTER: wgpu::FilterMode = wgpu::FilterMode::Nearest;
-    pub const DEFAULT_LOD_MIN_CLAMP: f32 = 0.0;
-    pub const DEFAULT_LOD_MAX_CLAMP: f32 = 100.0;
-    pub const DEFAULT_COMPARE: Option<wgpu::CompareFunction> = None;
-    pub const DEFAULT_ANISOTROPY_CLAMP: u16 = 1;
-    pub const DEFAULT_LABEL: &'static str = "nannou-sampler";
-    pub const DEFAULT_BORDER_COLOR: Option<wgpu_types::SamplerBorderColor> = None;
-    pub const DEFAULT_DESCRIPTOR: wgpu::SamplerDescriptor<'static> = wgpu::SamplerDescriptor {
-        address_mode_u: Self::DEFAULT_ADDRESS_MODE_U,
-        address_mode_v: Self::DEFAULT_ADDRESS_MODE_V,
-        address_mode_w: Self::DEFAULT_ADDRESS_MODE_W,
-        mag_filter: Self::DEFAULT_MAG_FILTER,
-        min_filter: Self::DEFAULT_MIN_FILTER,
-        mipmap_filter: Self::DEFAULT_MIPMAP_FILTER,
-        lod_min_clamp: Self::DEFAULT_LOD_MIN_CLAMP,
-        lod_max_clamp: Self::DEFAULT_LOD_MAX_CLAMP,
-        compare: Self::DEFAULT_COMPARE,
-        anisotropy_clamp: Self::DEFAULT_ANISOTROPY_CLAMP,
-        label: Some(Self::DEFAULT_LABEL),
-        border_color: Self::DEFAULT_BORDER_COLOR,
-    };
-
-    /// Begin building a `Sampler`, starting with the `Default` parameters.
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// How the implementation should behave when sampling outside of the texture coordinates range
-    /// [0.0, 1.0].
-    pub fn address_mode_u(mut self, mode: wgpu::AddressMode) -> Self {
-        self.descriptor.address_mode_u = mode;
-        self
-    }
-
-    /// How the implementation should behave when sampling outside of the texture coordinates range
-    /// [0.0, 1.0].
-    pub fn address_mode_v(mut self, mode: wgpu::AddressMode) -> Self {
-        self.descriptor.address_mode_v = mode;
-        self
-    }
-
-    /// How the implementation should behave when sampling outside of the texture coordinates range
-    /// [0.0, 1.0].
-    pub fn address_mode_w(mut self, mode: wgpu::AddressMode) -> Self {
-        self.descriptor.address_mode_w = mode;
-        self
-    }
-
-    /// How the implementation should behave when sampling outside of the texture coordinates range
-    /// [0.0, 1.0].
-    ///
-    /// Applies the same address mode to all axes.
-    pub fn address_mode(self, mode: wgpu::AddressMode) -> Self {
-        self.address_mode_u(mode)
-            .address_mode_v(mode)
-            .address_mode_w(mode)
-    }
-
-    /// How the implementation should sample from the image when it is respectively larger than the
-    /// original.
-    pub fn mag_filter(mut self, filter: wgpu::FilterMode) -> Self {
-        self.descriptor.mag_filter = filter;
-        self
-    }
-
-    /// How the implementation should sample from the image when it is respectively smaller than
-    /// the original.
-    pub fn min_filter(mut self, filter: wgpu::FilterMode) -> Self {
-        self.descriptor.min_filter = filter;
-        self
-    }
-
-    /// How the implementation should choose which mipmap to use.
-    pub fn mipmap_filter(mut self, filter: wgpu::FilterMode) -> Self {
-        self.descriptor.mipmap_filter = filter;
-        self
-    }
-
-    /// The minimum mipmap level to use.
-    pub fn lod_min_clamp(mut self, min: f32) -> Self {
-        self.descriptor.lod_min_clamp = min;
-        self
-    }
-
-    /// The maximum mipmap level to use.
-    pub fn lod_max_clamp(mut self, max: f32) -> Self {
-        self.descriptor.lod_max_clamp = max;
-        self
-    }
-
-    /// The comparison function to use, if any.
-    pub fn compare(mut self, f: Option<wgpu::CompareFunction>) -> Self {
-        self.descriptor.compare = f;
-        self
-    }
-
-    /// The anisotropy level to clamp to, if any.
-    pub fn anisotropy_clamp(mut self, clamp: u16) -> Self {
-        self.descriptor.anisotropy_clamp = clamp;
-        self
-    }
-
-    /// The label to use, if any.
-    pub fn label(mut self, label: Option<&'static str>) -> Self {
-        self.descriptor.label = label;
-        self
-    }
-
-    /// Calls `device.create_sampler(&self.descriptor)` internally.
-    pub fn build(&self, device: &RenderDevice) -> wgpu::Sampler {
-        device.create_sampler(&self.descriptor)
-    }
-
-    /// Consume the builder and produce the inner `SamplerDescriptor`.
-    pub fn into_descriptor(self) -> wgpu::SamplerDescriptor<'static> {
-        self.into()
-    }
-}
-
-impl Default for SamplerBuilder {
-    fn default() -> Self {
-        SamplerBuilder {
-            descriptor: Self::DEFAULT_DESCRIPTOR,
-        }
-    }
-}
-
-impl Into<wgpu::SamplerDescriptor<'static>> for SamplerBuilder {
-    fn into(self) -> wgpu::SamplerDescriptor<'static> {
-        self.descriptor
-    }
-}
-
-impl From<wgpu::SamplerDescriptor<'static>> for SamplerBuilder {
-    fn from(descriptor: wgpu::SamplerDescriptor<'static>) -> Self {
-        SamplerBuilder { descriptor }
-    }
-}
diff --git a/bevy_nannou_wgpu/src/texture.rs b/bevy_nannou_wgpu/src/texture.rs
deleted file mode 100644
index b21924ba0..000000000
--- a/bevy_nannou_wgpu/src/texture.rs
+++ /dev/null
@@ -1,203 +0,0 @@
-use bevy::render::render_resource as wgpu;
-use bevy::render::renderer::RenderDevice;
-
-/// A type aimed at simplifying the construction of a **Texture**.
-///
-/// The builder assumes a set of defaults describing a 128x128, non-multisampled, single-layer,
-/// non-linear sRGBA-8 texture. A suite of builder methods may be used to specify the exact
-/// properties desired.
-#[derive(Debug)]
-pub struct TextureBuilder {
-    descriptor: wgpu::TextureDescriptor<'static>,
-}
-
-impl TextureBuilder {
-    pub const DEFAULT_SIDE: u32 = 128;
-    pub const DEFAULT_DEPTH: u32 = 1;
-    pub const DEFAULT_SIZE: wgpu::Extent3d = wgpu::Extent3d {
-        width: Self::DEFAULT_SIDE,
-        height: Self::DEFAULT_SIDE,
-        depth_or_array_layers: Self::DEFAULT_DEPTH,
-    };
-    pub const DEFAULT_ARRAY_LAYER_COUNT: u32 = 1;
-    pub const DEFAULT_MIP_LEVEL_COUNT: u32 = 1;
-    pub const DEFAULT_SAMPLE_COUNT: u32 = 1;
-    pub const DEFAULT_DIMENSION: wgpu::TextureDimension = wgpu::TextureDimension::D2;
-    pub const DEFAULT_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm;
-    pub const DEFAULT_USAGE: wgpu::TextureUsages = wgpu::TextureUsages::all(); // TODO: is this the right choice?
-    pub const DEFAULT_DESCRIPTOR: wgpu::TextureDescriptor<'static> = wgpu::TextureDescriptor {
-        label: Some("nannou Texture"),
-        size: Self::DEFAULT_SIZE,
-        mip_level_count: Self::DEFAULT_MIP_LEVEL_COUNT,
-        sample_count: Self::DEFAULT_SAMPLE_COUNT,
-        dimension: Self::DEFAULT_DIMENSION,
-        format: Self::DEFAULT_FORMAT,
-        usage: Self::DEFAULT_USAGE,
-        view_formats: &[],
-    };
-
-    /// Creates a new `Default` builder
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Specify the width and height of the texture.
-    ///
-    /// Note: On calls to `size`, `depth` and `extent` the `Builder` will attempt to infer the
-    /// `wgpu::TextureDimension` of its inner `wgpu::TextureDescriptor` by examining its `size`
-    /// field. Use `TextureBuilder::dimension()` to override this behavior.
-    pub fn size(mut self, [width, height]: [u32; 2]) -> Self {
-        self.descriptor.size.width = width;
-        self.descriptor.size.height = height;
-        self.infer_dimension_from_size();
-        self
-    }
-
-    /// Specify the depth of the texture.
-    ///
-    /// Note: On calls to `size`, `depth` and `extent` the `Builder` will attempt to infer the
-    /// `wgpu::TextureDimension` of its inner `wgpu::TextureDescriptor` by examining its `size`
-    /// field. Use `TextureBuilder::dimension()` to override this behavior.
-    pub fn depth(mut self, depth: u32) -> Self {
-        self.descriptor.size.depth_or_array_layers = depth;
-        self.infer_dimension_from_size();
-        self
-    }
-
-    /// Specify the width, height and depth of the texture.
-    ///
-    /// Note: On calls to `size`, `depth` and `extent` the `Builder` will attempt to infer the
-    /// `wgpu::TextureDimension` of its inner `wgpu::TextureDescriptor` by examining its `size`
-    /// field. Use `TextureBuilder::dimension()` to override this behavior.
-    pub fn extent(mut self, extent: wgpu::Extent3d) -> Self {
-        self.descriptor.size = extent;
-        self.infer_dimension_from_size();
-        self
-    }
-
-    /// Specify the dimension of the texture, overriding inferred dimension.
-    ///
-    /// Mainly useful for creating 2d texture arrays -- override dimension with
-    /// `wgpu::TextureDimension::D2` on a texture with `extent.depth > 1` in order to create a
-    /// texture array (/ cubemap / cubemap array) instead of a 3d texture.
-    pub fn dimension(mut self, dimension: wgpu::TextureDimension) -> Self {
-        self.descriptor.dimension = dimension;
-        self
-    }
-
-    /// Specify the number of mip levels of the texture.
-    pub fn mip_level_count(mut self, count: u32) -> Self {
-        self.descriptor.mip_level_count = count;
-        self
-    }
-
-    /// Specify the number of samples per pixel in the case that the texture is multisampled.
-    pub fn sample_count(mut self, count: u32) -> Self {
-        self.descriptor.sample_count = count;
-        self
-    }
-
-    /// Specify the texture format.
-    pub fn format(mut self, format: wgpu::TextureFormat) -> Self {
-        self.descriptor.format = format;
-        self
-    }
-
-    /// Describes to the implementation how the texture is to be used.
-    ///
-    /// It is important that the set of usage bits reflects the
-    pub fn usage(mut self, usage: wgpu::TextureUsages) -> Self {
-        self.descriptor.usage = usage;
-        self
-    }
-
-    // If `depth` is greater than `1` then `D3` is assumed, otherwise if `height` is greater than
-    // `1` then `D2` is assumed, otherwise `D1` is assumed.
-    fn infer_dimension_from_size(&mut self) {
-        if self.descriptor.size.depth_or_array_layers > 1 {
-            self.descriptor.dimension = wgpu::TextureDimension::D3;
-        } else if self.descriptor.size.height > 1 {
-            self.descriptor.dimension = wgpu::TextureDimension::D2;
-        } else {
-            self.descriptor.dimension = wgpu::TextureDimension::D1;
-        }
-    }
-
-    /// Build the texture resulting from the specified parameters with the given device.
-    pub fn build(self, device: &RenderDevice) -> wgpu::Texture {
-        device.create_texture(&self.descriptor)
-    }
-
-    /// Consumes the builder and returns the resulting `wgpu::TextureDescriptor`.
-    pub fn into_descriptor(self) -> wgpu::TextureDescriptor<'static> {
-        self.into()
-    }
-}
-
-impl Default for TextureBuilder {
-    fn default() -> Self {
-        Self {
-            descriptor: Self::DEFAULT_DESCRIPTOR,
-        }
-    }
-}
-
-impl From<wgpu::TextureDescriptor<'static>> for TextureBuilder {
-    fn from(descriptor: wgpu::TextureDescriptor<'static>) -> Self {
-        Self { descriptor }
-    }
-}
-
-impl Into<wgpu::TextureDescriptor<'static>> for TextureBuilder {
-    fn into(self) -> wgpu::TextureDescriptor<'static> {
-        self.descriptor
-    }
-}
-
-/// The size of the texture data in bytes as described by the given descriptor.
-pub fn data_size_bytes(desc: &wgpu::TextureDescriptor) -> usize {
-    desc.size.width as usize
-        * desc.size.height as usize
-        * desc.size.depth_or_array_layers as usize
-        * format_size_bytes(desc.format) as usize
-}
-
-/// Return the size of the given texture format in bytes.
-pub fn format_size_bytes(format: wgpu::TextureFormat) -> u32 {
-    format
-        .block_size(None)
-        .expect("Expected the format to have a block size") as u32
-}
-
-/// Returns `true` if the given `wgpu::Extent3d`s are equal.
-pub fn extent_3d_eq(a: &wgpu::Extent3d, b: &wgpu::Extent3d) -> bool {
-    a.width == b.width && a.height == b.height && a.depth_or_array_layers == b.depth_or_array_layers
-}
-
-/// Returns `true` if the given texture descriptors are equal.
-pub fn descriptor_eq(a: &wgpu::TextureDescriptor, b: &wgpu::TextureDescriptor) -> bool {
-    extent_3d_eq(&a.size, &b.size)
-        && a.mip_level_count == b.mip_level_count
-        && a.sample_count == b.sample_count
-        && a.dimension == b.dimension
-        && a.format == b.format
-        && a.usage == b.usage
-}
-
-/// Used to infer the `TextureAspect` for a `TextureView` from a specific `TextureFormat`.
-///
-/// Does the following:
-///
-/// - If the format is `Depth32Float` or `Depth24Plus`, `TextureAspect::DepthOnly` is assumed.
-/// - Otherwise, `TextureAspect::All` is assumed.
-///
-/// Please note that `wgpu::TextureAspect::StencilOnly` can never be inferred with this function.
-/// If you require using a `TextureView` as a stencil, consider explicitly specify the
-/// `TextureAspect` you require.
-pub fn infer_aspect_from_format(format: wgpu::TextureFormat) -> wgpu::TextureAspect {
-    use wgpu::TextureFormat::*;
-    match format {
-        Depth32Float | Depth24Plus => wgpu::TextureAspect::DepthOnly,
-        _ => wgpu::TextureAspect::All,
-    }
-}
diff --git a/default.nix b/default.nix
index 0ae958cbb..e139e11f2 100644
--- a/default.nix
+++ b/default.nix
@@ -1,7 +1,9 @@
 { alsaLib
 , darwin
+, ffmpeg
 , jq
 , lib
+, llvmPackages
 , libiconv
 , makeWrapper
 , pkg-config
@@ -22,8 +24,7 @@ rustPlatform.buildRustPackage rec {
   cargoLock = {
     lockFile = ./Cargo.lock;
     outputHashes = {
-      "isf-0.1.0" = "sha256-utexaXpZZgpRunVAQyD2JAwvabhZGzeorC4pRFIumAc=";
-      "skeptic-0.13.4" = "sha256-EZFtWIPfsfbpGBD8NwsVtMzRM10kVdg+djoV00dhT4Y=";
+      "skeptic-0.13.8" = "sha256-LLVrpuyQsMdbp8OYcHN0nq+uKC8xgJzpNy+gyXxTYbo=";
     };
   };
 
@@ -32,6 +33,7 @@ rustPlatform.buildRustPackage rec {
 
   nativeBuildInputs = [
     makeWrapper
+    llvmPackages.clang
     pkg-config
   ];
 
@@ -40,9 +42,12 @@ rustPlatform.buildRustPackage rec {
     jq
     # `nannou-new` needs this because of `cargo` dep. See #606.
     openssl
+    ffmpeg
   ] ++ lib.optionals stdenv.isLinux [
     alsaLib
     udev
+    llvmPackages.bintools
+    llvmPackages.libclang
     vulkan-loader
     vulkan-validation-layers
     xorg.libX11
@@ -63,6 +68,7 @@ rustPlatform.buildRustPackage rec {
       inherit XCURSOR_THEME;
       LD_LIBRARY_PATH = "${lib.makeLibraryPath buildInputs}";
       ALSA_LIB_DEV = "${alsaLib.dev}";
+      LIBCLANG_PATH = "${llvmPackages.libclang.lib}/lib";
     } // lib.optionalAttrs stdenv.isDarwin {
     COREAUDIO_SDK_PATH = "${darwin.apple_sdk.frameworks.CoreAudio}/Library/Frameworks/CoreAudio.framework";
   });
diff --git a/examples/Cargo.toml b/examples/Cargo.toml
index 149c6589c..4e8493452 100644
--- a/examples/Cargo.toml
+++ b/examples/Cargo.toml
@@ -19,8 +19,6 @@ hotglsl = "0.2"
 hrtf = "0.2"
 nannou = { version ="0.19.0", path = "../nannou" }
 nannou_audio = { version ="0.19.0", path = "../nannou_audio" }
-nannou_egui = { version ="0.19.0", path = "../nannou_egui" }
-nannou_isf = { version ="0.1.0", path = "../nannou_isf" }
 nannou_laser = { version ="0.19.0", features = ["ffi", "ilda-idtf"], path = "../nannou_laser" }
 nannou_osc = { version ="0.19.0", path = "../nannou_osc" }
 pitch_calc = { version = "0.12", features = ["serde"] }
@@ -35,6 +33,11 @@ tokio = { version = "1", features = ["full"]}
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 tokio = { version = "1", features = ["rt"]}
 
+[features]
+egui = ["nannou/egui"]
+isf = ["nannou/isf"]
+video = ["nannou/video"]
+
 # Audio
 [[example]]
 name = "hrtf-noise"
@@ -74,12 +77,23 @@ path = "draw/draw_blend.rs"
 name = "draw_capture"
 path = "draw/draw_capture.rs"
 [[example]]
-name = "draw_capture_hi_res"
-path = "draw/draw_capture_hi_res.rs"
+name = "draw_custom_material"
+path = "draw/draw_custom_material.rs"
+required-features = ["nannou/hot_reload"]
+[[example]]
+name = "draw_fragment_shader"
+path = "draw/draw_fragment_shader.rs"
+required-features = ["nannou/nightly", "nannou/hot_reload"]
 [[example]]
 name = "draw_loop"
 path = "draw/draw_loop.rs"
 [[example]]
+name = "draw_material"
+path = "draw/draw_material.rs"
+[[example]]
+name = "draw_material_bloom"
+path = "draw/draw_material_bloom.rs"
+[[example]]
 name = "draw_mesh"
 path = "draw/draw_mesh.rs"
 [[example]]
@@ -113,10 +127,11 @@ path = "draw/draw_textured_polygon.rs"
 name = "draw_transform"
 path = "draw/draw_transform.rs"
 
-# Interactive Shader Format
+# Isf
 [[example]]
-name = "isf_demo"
-path = "isf/isf_demo.rs"
+name = "isf_simple"
+path = "isf/simple.rs"
+required-features = ["isf", "egui"]
 
 # Laser
 [[example]]
@@ -128,6 +143,7 @@ path = "laser/laser_frame_stream.rs"
 [[example]]
 name = "laser_frame_stream_gui"
 path = "laser/laser_frame_stream_gui.rs"
+required-features = ["egui"]
 [[example]]
 name = "laser_raw_stream"
 path = "laser/laser_raw_stream.rs"
@@ -143,9 +159,6 @@ path = "nannou_basics/all_functions.rs"
 name = "window_coordinates"
 path = "nannou_basics/window_coordinates.rs"
 [[example]]
-name = "loop_mode"
-path = "nannou_basics/loop_mode.rs"
-[[example]]
 name = "multi_window"
 path = "nannou_basics/multi_window.rs"
 [[example]]
@@ -195,35 +208,26 @@ path = "templates/template_sketch.rs"
 [[example]]
 name = "circle_packing"
 path = "ui/egui/circle_packing.rs"
+required-features = ["egui"]
 [[example]]
 name = "tune_color"
 path = "ui/egui/tune_color.rs"
+required-features = ["egui"]
 [[example]]
 name = "simple_ui"
 path = "ui/egui/simple_ui.rs"
-
-# WebGPU
+required-features = ["egui"]
 [[example]]
-name = "wgpu_compute_shader"
-path = "wgpu/wgpu_compute_shader/wgpu_compute_shader.rs"
-[[example]]
-name = "wgpu_image"
-path = "wgpu/wgpu_image/wgpu_image.rs"
-[[example]]
-name = "wgpu_image_sequence"
-path = "wgpu/wgpu_image_sequence/wgpu_image_sequence.rs"
-[[example]]
-name = "wgpu_instancing"
-path = "wgpu/wgpu_instancing/wgpu_instancing.rs"
-[[example]]
-name = "wgpu_teapot"
-path = "wgpu/wgpu_teapot/wgpu_teapot.rs"
-[[example]]
-name = "wgpu_teapot_camera"
-path = "wgpu/wgpu_teapot_camera/wgpu_teapot_camera.rs"
+name = "inspector_ui"
+path = "ui/egui/inspector_ui.rs"
+required-features = ["egui"]
+
+# Video
 [[example]]
-name = "wgpu_triangle"
-path = "wgpu/wgpu_triangle/wgpu_triangle.rs"
+name = "simple_video"
+path = "video/simple_video.rs"
+required-features = ["video"]
 [[example]]
-name = "wgpu_triangle_raw_frame"
-path = "wgpu/wgpu_triangle_raw_frame/wgpu_triangle_raw_frame.rs"
+name = "video_material"
+path = "video/video_material.rs"
+required-features = ["video"]
\ No newline at end of file
diff --git a/examples/assets/draw_custom_material.wgsl b/examples/assets/draw_custom_material.wgsl
new file mode 100644
index 000000000..95180787a
--- /dev/null
+++ b/examples/assets/draw_custom_material.wgsl
@@ -0,0 +1,14 @@
+#import bevy_pbr::forward_io::VertexOutput
+
+struct CustomMaterial {
+    color: vec4<f32>,
+};
+
+@group(2) @binding(0) var<uniform> material: CustomMaterial;
+
+@fragment
+fn fragment(
+    mesh: VertexOutput,
+) -> @location(0) vec4<f32> {
+    return material.color;
+}
diff --git a/examples/assets/draw_fragment_shader.wgsl b/examples/assets/draw_fragment_shader.wgsl
new file mode 100644
index 000000000..bf0cfe199
--- /dev/null
+++ b/examples/assets/draw_fragment_shader.wgsl
@@ -0,0 +1,9 @@
+#import bevy_pbr::forward_io::VertexOutput
+
+@fragment
+fn fragment(
+    vertex: VertexOutput,
+) -> @location(0) vec4<f32> {
+    // Filter out the blue channel of the vertex color
+    return vec4(vertex.color.xy, 0.0, 1.0);
+}
diff --git a/examples/assets/draw_video_material.wgsl b/examples/assets/draw_video_material.wgsl
new file mode 100644
index 000000000..0abf5ce9d
--- /dev/null
+++ b/examples/assets/draw_video_material.wgsl
@@ -0,0 +1,23 @@
+#import bevy_pbr::{
+    mesh_view_bindings::view,
+    mesh_view_bindings::globals,
+    forward_io::VertexOutput,
+}
+
+@group(2) @binding(0) var texture: texture_2d<f32>;
+@group(2) @binding(1) var texture_sampler: sampler;
+
+@fragment
+fn fragment(
+    mesh: VertexOutput,
+) -> @location(0) vec4<f32> {
+    let resolution = view.viewport.zw;
+    let time = globals.time;
+    var uv = mesh.uv * resolution;
+    let cp = -1.0 + 2.0 * uv / resolution;
+    let cl = length(cp);
+    uv = uv / resolution + (cp / cl) * cos(cl * 12.0 - time * 1.0) * 0.02;
+    let clamped_uv = clamp(uv, vec2<f32>(0.0), vec2<f32>(1.0));
+    let col = textureSample(texture, texture_sampler, clamped_uv).xyz;
+    return vec4<f32>(col, 1.0);
+}
diff --git a/assets/fonts/NotoSans/LICENSE-2.0.txt b/examples/assets/fonts/NotoSans/LICENSE-2.0.txt
similarity index 100%
rename from assets/fonts/NotoSans/LICENSE-2.0.txt
rename to examples/assets/fonts/NotoSans/LICENSE-2.0.txt
diff --git a/assets/fonts/NotoSans/NotoSans-Bold.ttf b/examples/assets/fonts/NotoSans/NotoSans-Bold.ttf
similarity index 100%
rename from assets/fonts/NotoSans/NotoSans-Bold.ttf
rename to examples/assets/fonts/NotoSans/NotoSans-Bold.ttf
diff --git a/assets/fonts/NotoSans/NotoSans-BoldItalic.ttf b/examples/assets/fonts/NotoSans/NotoSans-BoldItalic.ttf
similarity index 100%
rename from assets/fonts/NotoSans/NotoSans-BoldItalic.ttf
rename to examples/assets/fonts/NotoSans/NotoSans-BoldItalic.ttf
diff --git a/assets/fonts/NotoSans/NotoSans-Italic.ttf b/examples/assets/fonts/NotoSans/NotoSans-Italic.ttf
similarity index 100%
rename from assets/fonts/NotoSans/NotoSans-Italic.ttf
rename to examples/assets/fonts/NotoSans/NotoSans-Italic.ttf
diff --git a/assets/fonts/NotoSans/NotoSans-Regular.ttf b/examples/assets/fonts/NotoSans/NotoSans-Regular.ttf
similarity index 100%
rename from assets/fonts/NotoSans/NotoSans-Regular.ttf
rename to examples/assets/fonts/NotoSans/NotoSans-Regular.ttf
diff --git a/assets/hrir/IRC_1002_C.bin b/examples/assets/hrir/IRC_1002_C.bin
similarity index 100%
rename from assets/hrir/IRC_1002_C.bin
rename to examples/assets/hrir/IRC_1002_C.bin
diff --git a/assets/hrir/README.md b/examples/assets/hrir/README.md
similarity index 100%
rename from assets/hrir/README.md
rename to examples/assets/hrir/README.md
diff --git a/assets/images/bee.jpg b/examples/assets/images/bee.jpg
similarity index 100%
rename from assets/images/bee.jpg
rename to examples/assets/images/bee.jpg
diff --git a/assets/images/generative_examples/p_4_0_01.jpg b/examples/assets/images/generative_examples/p_4_0_01.jpg
similarity index 100%
rename from assets/images/generative_examples/p_4_0_01.jpg
rename to examples/assets/images/generative_examples/p_4_0_01.jpg
diff --git a/assets/images/generative_examples/p_4_1_1_01.jpg b/examples/assets/images/generative_examples/p_4_1_1_01.jpg
similarity index 100%
rename from assets/images/generative_examples/p_4_1_1_01.jpg
rename to examples/assets/images/generative_examples/p_4_1_1_01.jpg
diff --git a/assets/images/generative_examples/p_4_1_2_01.png b/examples/assets/images/generative_examples/p_4_1_2_01.png
similarity index 100%
rename from assets/images/generative_examples/p_4_1_2_01.png
rename to examples/assets/images/generative_examples/p_4_1_2_01.png
diff --git a/assets/images/generative_examples/p_4_3_1_01.png b/examples/assets/images/generative_examples/p_4_3_1_01.png
similarity index 100%
rename from assets/images/generative_examples/p_4_3_1_01.png
rename to examples/assets/images/generative_examples/p_4_3_1_01.png
diff --git a/assets/images/generative_examples/pic1.jpg b/examples/assets/images/generative_examples/pic1.jpg
similarity index 100%
rename from assets/images/generative_examples/pic1.jpg
rename to examples/assets/images/generative_examples/pic1.jpg
diff --git a/assets/images/generative_examples/pic2.jpg b/examples/assets/images/generative_examples/pic2.jpg
similarity index 100%
rename from assets/images/generative_examples/pic2.jpg
rename to examples/assets/images/generative_examples/pic2.jpg
diff --git a/assets/images/generative_examples/pic3.jpg b/examples/assets/images/generative_examples/pic3.jpg
similarity index 100%
rename from assets/images/generative_examples/pic3.jpg
rename to examples/assets/images/generative_examples/pic3.jpg
diff --git a/assets/images/generative_examples/pic4.jpg b/examples/assets/images/generative_examples/pic4.jpg
similarity index 100%
rename from assets/images/generative_examples/pic4.jpg
rename to examples/assets/images/generative_examples/pic4.jpg
diff --git a/assets/images/logo.png b/examples/assets/images/logo.png
similarity index 100%
rename from assets/images/logo.png
rename to examples/assets/images/logo.png
diff --git a/assets/images/nannou.png b/examples/assets/images/nannou.png
similarity index 100%
rename from assets/images/nannou.png
rename to examples/assets/images/nannou.png
diff --git a/assets/images/nature/nature_1.jpg b/examples/assets/images/nature/nature_1.jpg
similarity index 100%
rename from assets/images/nature/nature_1.jpg
rename to examples/assets/images/nature/nature_1.jpg
diff --git a/assets/images/nature/nature_2.jpg b/examples/assets/images/nature/nature_2.jpg
similarity index 100%
rename from assets/images/nature/nature_2.jpg
rename to examples/assets/images/nature/nature_2.jpg
diff --git a/assets/images/nature/nature_3.jpg b/examples/assets/images/nature/nature_3.jpg
similarity index 100%
rename from assets/images/nature/nature_3.jpg
rename to examples/assets/images/nature/nature_3.jpg
diff --git a/assets/images/nature/nature_4.jpg b/examples/assets/images/nature/nature_4.jpg
similarity index 100%
rename from assets/images/nature/nature_4.jpg
rename to examples/assets/images/nature/nature_4.jpg
diff --git a/assets/images/spinning_dancer/spinning_dancer_001.png b/examples/assets/images/spinning_dancer/spinning_dancer_001.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_001.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_001.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_002.png b/examples/assets/images/spinning_dancer/spinning_dancer_002.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_002.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_002.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_003.png b/examples/assets/images/spinning_dancer/spinning_dancer_003.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_003.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_003.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_004.png b/examples/assets/images/spinning_dancer/spinning_dancer_004.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_004.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_004.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_005.png b/examples/assets/images/spinning_dancer/spinning_dancer_005.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_005.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_005.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_006.png b/examples/assets/images/spinning_dancer/spinning_dancer_006.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_006.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_006.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_007.png b/examples/assets/images/spinning_dancer/spinning_dancer_007.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_007.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_007.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_008.png b/examples/assets/images/spinning_dancer/spinning_dancer_008.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_008.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_008.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_009.png b/examples/assets/images/spinning_dancer/spinning_dancer_009.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_009.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_009.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_010.png b/examples/assets/images/spinning_dancer/spinning_dancer_010.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_010.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_010.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_011.png b/examples/assets/images/spinning_dancer/spinning_dancer_011.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_011.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_011.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_012.png b/examples/assets/images/spinning_dancer/spinning_dancer_012.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_012.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_012.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_013.png b/examples/assets/images/spinning_dancer/spinning_dancer_013.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_013.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_013.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_014.png b/examples/assets/images/spinning_dancer/spinning_dancer_014.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_014.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_014.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_015.png b/examples/assets/images/spinning_dancer/spinning_dancer_015.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_015.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_015.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_016.png b/examples/assets/images/spinning_dancer/spinning_dancer_016.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_016.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_016.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_017.png b/examples/assets/images/spinning_dancer/spinning_dancer_017.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_017.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_017.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_018.png b/examples/assets/images/spinning_dancer/spinning_dancer_018.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_018.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_018.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_019.png b/examples/assets/images/spinning_dancer/spinning_dancer_019.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_019.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_019.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_020.png b/examples/assets/images/spinning_dancer/spinning_dancer_020.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_020.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_020.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_021.png b/examples/assets/images/spinning_dancer/spinning_dancer_021.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_021.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_021.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_022.png b/examples/assets/images/spinning_dancer/spinning_dancer_022.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_022.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_022.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_023.png b/examples/assets/images/spinning_dancer/spinning_dancer_023.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_023.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_023.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_024.png b/examples/assets/images/spinning_dancer/spinning_dancer_024.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_024.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_024.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_025.png b/examples/assets/images/spinning_dancer/spinning_dancer_025.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_025.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_025.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_026.png b/examples/assets/images/spinning_dancer/spinning_dancer_026.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_026.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_026.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_027.png b/examples/assets/images/spinning_dancer/spinning_dancer_027.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_027.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_027.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_028.png b/examples/assets/images/spinning_dancer/spinning_dancer_028.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_028.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_028.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_029.png b/examples/assets/images/spinning_dancer/spinning_dancer_029.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_029.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_029.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_030.png b/examples/assets/images/spinning_dancer/spinning_dancer_030.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_030.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_030.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_031.png b/examples/assets/images/spinning_dancer/spinning_dancer_031.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_031.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_031.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_032.png b/examples/assets/images/spinning_dancer/spinning_dancer_032.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_032.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_032.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_033.png b/examples/assets/images/spinning_dancer/spinning_dancer_033.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_033.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_033.png
diff --git a/assets/images/spinning_dancer/spinning_dancer_034.png b/examples/assets/images/spinning_dancer/spinning_dancer_034.png
similarity index 100%
rename from assets/images/spinning_dancer/spinning_dancer_034.png
rename to examples/assets/images/spinning_dancer/spinning_dancer_034.png
diff --git a/assets/isf/Test-Audio.fs b/examples/assets/isf/Test-Audio.fs
similarity index 100%
rename from assets/isf/Test-Audio.fs
rename to examples/assets/isf/Test-Audio.fs
diff --git a/assets/isf/Test-AudioFFT.fs b/examples/assets/isf/Test-AudioFFT.fs
similarity index 100%
rename from assets/isf/Test-AudioFFT.fs
rename to examples/assets/isf/Test-AudioFFT.fs
diff --git a/assets/isf/Test-Bool.fs b/examples/assets/isf/Test-Bool.fs
similarity index 100%
rename from assets/isf/Test-Bool.fs
rename to examples/assets/isf/Test-Bool.fs
diff --git a/assets/isf/Test-Color.fs b/examples/assets/isf/Test-Color.fs
similarity index 100%
rename from assets/isf/Test-Color.fs
rename to examples/assets/isf/Test-Color.fs
diff --git a/assets/isf/Test-Event.fs b/examples/assets/isf/Test-Event.fs
similarity index 100%
rename from assets/isf/Test-Event.fs
rename to examples/assets/isf/Test-Event.fs
diff --git a/assets/isf/Test-Float.fs b/examples/assets/isf/Test-Float.fs
similarity index 100%
rename from assets/isf/Test-Float.fs
rename to examples/assets/isf/Test-Float.fs
diff --git a/assets/isf/Test-Functionality.fs b/examples/assets/isf/Test-Functionality.fs
similarity index 100%
rename from assets/isf/Test-Functionality.fs
rename to examples/assets/isf/Test-Functionality.fs
diff --git a/assets/isf/Test-IMG_NORM_PIXEL.fs b/examples/assets/isf/Test-IMG_NORM_PIXEL.fs
similarity index 100%
rename from assets/isf/Test-IMG_NORM_PIXEL.fs
rename to examples/assets/isf/Test-IMG_NORM_PIXEL.fs
diff --git a/assets/isf/Test-IMG_PIXEL.fs b/examples/assets/isf/Test-IMG_PIXEL.fs
similarity index 100%
rename from assets/isf/Test-IMG_PIXEL.fs
rename to examples/assets/isf/Test-IMG_PIXEL.fs
diff --git a/assets/isf/Test-IMG_THIS_NORM_PIXEL.fs b/examples/assets/isf/Test-IMG_THIS_NORM_PIXEL.fs
similarity index 100%
rename from assets/isf/Test-IMG_THIS_NORM_PIXEL.fs
rename to examples/assets/isf/Test-IMG_THIS_NORM_PIXEL.fs
diff --git a/assets/isf/Test-IMG_THIS_PIXEL.fs b/examples/assets/isf/Test-IMG_THIS_PIXEL.fs
similarity index 100%
rename from assets/isf/Test-IMG_THIS_PIXEL.fs
rename to examples/assets/isf/Test-IMG_THIS_PIXEL.fs
diff --git a/assets/isf/Test-ImportedImage.fs b/examples/assets/isf/Test-ImportedImage.fs
similarity index 100%
rename from assets/isf/Test-ImportedImage.fs
rename to examples/assets/isf/Test-ImportedImage.fs
diff --git a/assets/isf/Test-Long.fs b/examples/assets/isf/Test-Long.fs
similarity index 100%
rename from assets/isf/Test-Long.fs
rename to examples/assets/isf/Test-Long.fs
diff --git a/assets/isf/Test-MultiPassRendering.fs b/examples/assets/isf/Test-MultiPassRendering.fs
similarity index 100%
rename from assets/isf/Test-MultiPassRendering.fs
rename to examples/assets/isf/Test-MultiPassRendering.fs
diff --git a/assets/isf/Test-PersistentBuffer.fs b/examples/assets/isf/Test-PersistentBuffer.fs
similarity index 100%
rename from assets/isf/Test-PersistentBuffer.fs
rename to examples/assets/isf/Test-PersistentBuffer.fs
diff --git a/assets/isf/Test-PersistentBufferDifferingSizes.fs b/examples/assets/isf/Test-PersistentBufferDifferingSizes.fs
similarity index 100%
rename from assets/isf/Test-PersistentBufferDifferingSizes.fs
rename to examples/assets/isf/Test-PersistentBufferDifferingSizes.fs
diff --git a/assets/isf/Test-Point.fs b/examples/assets/isf/Test-Point.fs
similarity index 100%
rename from assets/isf/Test-Point.fs
rename to examples/assets/isf/Test-Point.fs
diff --git a/assets/isf/Test-Sampler.fs b/examples/assets/isf/Test-Sampler.fs
similarity index 100%
rename from assets/isf/Test-Sampler.fs
rename to examples/assets/isf/Test-Sampler.fs
diff --git a/assets/isf/Test-TempBufferDifferingSizes.fs b/examples/assets/isf/Test-TempBufferDifferingSizes.fs
similarity index 96%
rename from assets/isf/Test-TempBufferDifferingSizes.fs
rename to examples/assets/isf/Test-TempBufferDifferingSizes.fs
index 4967abc58..aeb1ce9aa 100644
--- a/assets/isf/Test-TempBufferDifferingSizes.fs
+++ b/examples/assets/isf/Test-TempBufferDifferingSizes.fs
@@ -33,5 +33,7 @@ void main()
 	//	second pass: read from "bufferVariableNameA".  output looks chunky and low-res.
 	else if (PASSINDEX == 1)	{
 		gl_FragColor = IMG_THIS_NORM_PIXEL(bufferVariableNameA);
+	} else {
+	    gl_FragColor = vec4(0.5);
 	}
 }
diff --git a/assets/sounds/thumbpiano.wav b/examples/assets/sounds/thumbpiano.wav
similarity index 100%
rename from assets/sounds/thumbpiano.wav
rename to examples/assets/sounds/thumbpiano.wav
diff --git a/assets/text/faust_kurz.txt b/examples/assets/text/faust_kurz.txt
similarity index 100%
rename from assets/text/faust_kurz.txt
rename to examples/assets/text/faust_kurz.txt
diff --git a/examples/assets/video/file_example_MP4_640_3MG.mp4 b/examples/assets/video/file_example_MP4_640_3MG.mp4
new file mode 100644
index 000000000..61a12bca4
Binary files /dev/null and b/examples/assets/video/file_example_MP4_640_3MG.mp4 differ
diff --git a/examples/audio/feedback.rs b/examples/audio/feedback.rs
index f3d70d859..ff1ec718a 100644
--- a/examples/audio/feedback.rs
+++ b/examples/audio/feedback.rs
@@ -1,18 +1,28 @@
 //! Feeds back the input stream directly into the output stream
 //!
 //! You can play and pause the streams by pressing space key
+use ringbuf::{Consumer, Producer, RingBuffer};
+use std::sync::mpsc::{RecvError, Sender};
+use std::thread::JoinHandle;
+
 use nannou::prelude::*;
 use nannou_audio as audio;
 use nannou_audio::Buffer;
-use ringbuf::{Consumer, Producer, RingBuffer};
 
 fn main() {
-    nannou::app(model).run();
+    nannou::app(model).exit(exit).run();
+}
+
+pub enum AudioCommand {
+    Play,
+    Pause,
+    Exit,
 }
 
 struct Model {
-    in_stream: audio::Stream<InputModel>,
-    out_stream: audio::Stream<OutputModel>,
+    audio_thread: JoinHandle<()>,
+    audio_tx: Sender<AudioCommand>,
+    is_paused: bool,
 }
 
 struct InputModel {
@@ -25,11 +35,7 @@ struct OutputModel {
 
 fn model(app: &App) -> Model {
     // Create a window to receive key pressed events.
-    app.new_window()
-        .key_pressed(key_pressed)
-        .view(view)
-        .build()
-        .unwrap();
+    app.new_window().key_pressed(key_pressed).view(view).build();
 
     // Initialise the audio host so we can spawn an audio stream.
     let audio_host = audio::Host::new();
@@ -44,28 +50,54 @@ fn model(app: &App) -> Model {
         prod.push(0.0).unwrap();
     }
 
-    // Create input model and input stream using that model
-    let in_model = InputModel { producer: prod };
-    let in_stream = audio_host
-        .new_input_stream(in_model)
-        .capture(pass_in)
-        .build()
-        .unwrap();
-
-    // Create output model and output stream using that model
-    let out_model = OutputModel { consumer: cons };
-    let out_stream = audio_host
-        .new_output_stream(out_model)
-        .render(pass_out)
-        .build()
-        .unwrap();
-
-    in_stream.play().unwrap();
-    out_stream.play().unwrap();
+    // Kick off the audio thread
+    let (audio_tx, audio_rx) = std::sync::mpsc::channel();
+    let audio_thread = std::thread::spawn(move || {
+        // Create input model and input stream using that model
+        let in_model = InputModel { producer: prod };
+        let in_stream = audio_host
+            .new_input_stream(in_model)
+            .capture(pass_in)
+            .build()
+            .unwrap();
+
+        // Create output model and output stream using that model
+        let out_model = OutputModel { consumer: cons };
+        let out_stream = audio_host
+            .new_output_stream(out_model)
+            .render(pass_out)
+            .build()
+            .unwrap();
+
+        in_stream.play().unwrap();
+        out_stream.play().unwrap();
+
+        let mut in_stream = in_stream;
+        let mut out_stream = out_stream;
+        loop {
+            match audio_rx.recv() {
+                Ok(AudioCommand::Play) => {
+                    in_stream.play().unwrap();
+                    out_stream.play().unwrap();
+                }
+                Ok(AudioCommand::Pause) => {
+                    in_stream.pause().unwrap();
+                    out_stream.pause().unwrap();
+                }
+                Ok(AudioCommand::Exit) => {
+                    in_stream.pause().ok();
+                    out_stream.pause().ok();
+                    break;
+                }
+                Err(_) => break,
+            }
+        }
+    });
 
     Model {
-        in_stream,
-        out_stream,
+        audio_thread,
+        audio_tx,
+        is_paused: false,
     }
 }
 
@@ -80,30 +112,30 @@ fn pass_in(model: &mut InputModel, buffer: &Buffer) {
 fn pass_out(model: &mut OutputModel, buffer: &mut Buffer) {
     for frame in buffer.frames_mut() {
         for sample in frame {
-            let recorded_sample = match model.consumer.pop() {
-                Some(f) => f,
-                None => 0.0,
-            };
+            let recorded_sample = model.consumer.pop().unwrap_or(0.0);
             *sample = recorded_sample;
         }
     }
 }
 
-fn key_pressed(_app: &App, model: &mut Model, key: Key) {
-    match key {
-        Key::Space => {
-            if model.in_stream.is_paused() {
-                model.in_stream.play().unwrap();
-                model.out_stream.play().unwrap();
-            } else {
-                model.in_stream.pause().unwrap();
-                model.out_stream.pause().unwrap();
-            }
+fn key_pressed(_app: &App, model: &mut Model, key: KeyCode) {
+    if key == KeyCode::Space {
+        if model.is_paused {
+            model.audio_tx.send(AudioCommand::Play).ok();
+            model.is_paused = false;
+        } else {
+            model.audio_tx.send(AudioCommand::Pause).ok();
+            model.is_paused = true;
         }
-        _ => {}
     }
 }
 
-fn view(_app: &App, _model: &Model, frame: Frame) {
-    frame.clear(DIMGRAY);
+fn exit(_app: &App, model: Model) {
+    model.audio_tx.send(AudioCommand::Exit).ok();
+    model.audio_thread.join().ok();
+}
+
+fn view(app: &App, _model: &Model) {
+    let draw = app.draw();
+    draw.background().color(DIM_GRAY);
 }
diff --git a/examples/audio/hrtf-noise.rs b/examples/audio/hrtf-noise.rs
index e1061a770..b53de4e32 100644
--- a/examples/audio/hrtf-noise.rs
+++ b/examples/audio/hrtf-noise.rs
@@ -10,18 +10,31 @@
 //! This effect is best experienced with headphones!
 
 use hrtf::{HrirSphere, HrtfContext, HrtfProcessor};
+use std::sync::mpsc::Sender;
+use std::thread;
+use std::thread::JoinHandle;
+
 use nannou::prelude::*;
 use nannou::rand::{rngs::SmallRng, Rng, SeedableRng};
 use nannou_audio as audio;
 use nannou_audio::Buffer;
 
 fn main() {
-    nannou::app(model).run();
+    nannou::app(model).exit(exit).run();
+}
+
+pub enum AudioCommand {
+    Play,
+    Pause,
+    SourcePosition(Point3),
+    Exit,
 }
 
 struct Model {
-    stream: audio::Stream<Audio>,
+    audio_thread: JoinHandle<()>,
+    audio_tx: Sender<AudioCommand>,
     source_position: Point3,
+    is_paused: bool,
 }
 
 // HRTF requires a fixed sample rate and "block length" (i.e. buffer length in frames).
@@ -70,14 +83,13 @@ fn model(app: &App) -> Model {
         .key_pressed(key_pressed)
         .mouse_moved(mouse_moved)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     // Initialise the audio API so we can spawn an audio stream.
     let audio_host = audio::Host::new();
 
     // Load a HRIR sphere and initialise the processor.
-    let assets = app.assets_path().unwrap();
+    let assets = app.assets_path();
     let hrir_sphere_path = assets.join("hrir").join("IRC_1002_C").with_extension("bin");
     let hrir_sphere = HrirSphere::from_file(hrir_sphere_path, SAMPLE_RATE)
         .expect("failed to load HRIR sphere from file");
@@ -93,20 +105,49 @@ fn model(app: &App) -> Model {
         prev_source_position: [0.0; 3].into(),
     };
 
-    let stream = audio_host
-        .new_output_stream(audio_model)
-        .render(audio)
-        .channels(2)
-        .sample_rate(SAMPLE_RATE)
-        .frames_per_buffer(BUFFER_LEN_FRAMES)
-        .build()
-        .unwrap();
+    // Kick off the audio thread.
+    let (audio_tx, audio_rx) = std::sync::mpsc::channel();
+    let audio_thread = thread::spawn(move || {
+        let stream = audio_host
+            .new_output_stream(audio_model)
+            .render(audio)
+            .channels(2)
+            .sample_rate(SAMPLE_RATE)
+            .frames_per_buffer(BUFFER_LEN_FRAMES)
+            .build()
+            .unwrap();
+
+        stream.play().unwrap();
 
-    stream.play().unwrap();
+        loop {
+            match audio_rx.recv() {
+                Ok(AudioCommand::Play) => {
+                    stream.play().unwrap();
+                }
+                Ok(AudioCommand::Pause) => {
+                    stream.pause().unwrap();
+                }
+                Ok(AudioCommand::Exit) => {
+                    stream.pause().ok();
+                    break;
+                }
+                Ok(AudioCommand::SourcePosition(new_source_position)) => {
+                    stream
+                        .send(move |audio| {
+                            audio.source_position = new_source_position;
+                        })
+                        .unwrap();
+                }
+                Err(_) => break,
+            }
+        }
+    });
 
     Model {
-        stream,
+        audio_thread,
+        audio_tx,
         source_position,
+        is_paused: false,
     }
 }
 
@@ -157,13 +198,14 @@ fn audio(audio: &mut Audio, output: &mut Buffer) {
     }
 }
 
-fn key_pressed(_app: &App, model: &mut Model, key: Key) {
-    // Pause or unpause the audio when Space is pressed.
-    if let Key::Space = key {
-        if model.stream.is_playing() {
-            model.stream.pause().unwrap();
+fn key_pressed(_app: &App, model: &mut Model, key: KeyCode) {
+    if key == KeyCode::Space {
+        if model.is_paused {
+            model.audio_tx.send(AudioCommand::Play).ok();
+            model.is_paused = false;
         } else {
-            model.stream.play().unwrap();
+            model.audio_tx.send(AudioCommand::Pause).ok();
+            model.is_paused = true;
         }
     }
 }
@@ -174,17 +216,22 @@ fn mouse_moved(_app: &App, model: &mut Model, p: Point2) {
     let new_source_position = pt3(x, 0.0, y) / LISTENING_RADIUS;
     model.source_position = new_source_position;
     model
-        .stream
-        .send(move |audio| audio.source_position = new_source_position)
+        .audio_tx
+        .send(AudioCommand::SourcePosition(new_source_position))
         .ok();
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
-    frame.clear(rgb(0.1, 0.12, 0.13));
+fn exit(_app: &App, model: Model) {
+    model.audio_tx.send(AudioCommand::Exit).ok();
+    model.audio_thread.join().ok();
+}
+
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
+    draw.background().color(Color::srgb(0.1, 0.12, 0.13));
 
     // Listenable area.
-    draw.ellipse().radius(LISTENING_RADIUS).rgb(0.1, 0.1, 0.1);
+    draw.ellipse().radius(LISTENING_RADIUS).srgb(0.1, 0.1, 0.1);
 
     // Draw the head.
     draw.ellipse().color(BLUE);
@@ -197,9 +244,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
     // Draw the source.
     let (x, y, z) = model.source_position.into();
     let text = format!("Noise Source:\n[{:.2}, {:.2}, {:.2}]", x, y, z);
-    draw.text(&text).xy(app.mouse.position() + vec2(0.0, 20.0));
-
-    draw.to_frame(app, &frame).unwrap();
+    draw.text(&text).xy(app.mouse() + vec2(0.0, 20.0));
 }
 
 // Simple function for determining a gain based on the distance from the listener.
diff --git a/examples/audio/record_wav.rs b/examples/audio/record_wav.rs
index 8ee69aaa8..a2e819d6a 100644
--- a/examples/audio/record_wav.rs
+++ b/examples/audio/record_wav.rs
@@ -1,21 +1,33 @@
 //! Records a WAV file using the default input device and default input format.
 //!
 //! The input data is recorded to "$CARGO_MANIFEST_DIR/recorded.wav".
+extern crate hound;
+
+use std::fs::File;
+use std::io::BufWriter;
+use std::sync::mpsc::Sender;
+use std::thread::JoinHandle;
+
 use nannou::prelude::*;
 use nannou_audio as audio;
 use nannou_audio::Buffer;
-use std::fs::File;
-use std::io::BufWriter;
-extern crate hound;
 
 type WavWriter = hound::WavWriter<BufWriter<File>>;
 
 fn main() {
-    nannou::app(model).run();
+    nannou::app(model).exit(exit).run();
+}
+
+pub enum AudioCommand {
+    Play,
+    Pause,
+    Exit,
 }
 
 struct Model {
-    stream: audio::Stream<CaptureModel>,
+    audio_thread: JoinHandle<()>,
+    audio_tx: Sender<AudioCommand>,
+    is_paused: bool,
 }
 
 struct CaptureModel {
@@ -24,11 +36,7 @@ struct CaptureModel {
 
 fn model(app: &App) -> Model {
     // Create a window to receive key pressed events.
-    app.new_window()
-        .key_pressed(key_pressed)
-        .view(view)
-        .build()
-        .unwrap();
+    app.new_window().key_pressed(key_pressed).view(view).build();
 
     // Initialise the audio host so we can spawn an audio stream.
     let audio_host = audio::Host::new();
@@ -38,15 +46,39 @@ fn model(app: &App) -> Model {
     let writer = hound::WavWriter::create("recorded.wav", spec).unwrap();
     let capture_model = CaptureModel { writer };
 
-    let stream = audio_host
-        .new_input_stream(capture_model)
-        .capture(capture_fn)
-        .build()
-        .unwrap();
-
-    stream.play().unwrap();
+    // Kick off the audio thread
+    let (audio_tx, audio_rx) = std::sync::mpsc::channel();
+    let audio_thread = std::thread::spawn(move || {
+        let stream = audio_host
+            .new_input_stream(capture_model)
+            .capture(capture_fn)
+            .build()
+            .unwrap();
+
+        stream.play().unwrap();
+
+        loop {
+            match audio_rx.recv() {
+                Ok(AudioCommand::Play) => {
+                    stream.play().unwrap();
+                }
+                Ok(AudioCommand::Pause) => {
+                    stream.pause().unwrap();
+                }
+                Ok(AudioCommand::Exit) => {
+                    stream.pause().ok();
+                    break;
+                }
+                _ => (),
+            }
+        }
+    });
 
-    Model { stream }
+    Model {
+        audio_thread,
+        audio_tx,
+        is_paused: false,
+    }
 }
 
 // A function that captures the audio from the buffer and
@@ -63,27 +95,30 @@ fn capture_fn(audio: &mut CaptureModel, buffer: &Buffer) {
     }
 }
 
-fn key_pressed(_app: &App, model: &mut Model, key: Key) {
-    match key {
-        Key::Space => {
-            if model.stream.is_paused() {
-                model.stream.play().unwrap();
-            } else if model.stream.is_playing() {
-                model.stream.pause().unwrap();
-            }
+fn key_pressed(_app: &App, model: &mut Model, key: KeyCode) {
+    if key == KeyCode::Space {
+        if model.is_paused {
+            model.audio_tx.send(AudioCommand::Play).ok();
+            model.is_paused = false;
+        } else {
+            model.audio_tx.send(AudioCommand::Pause).ok();
+            model.is_paused = true;
         }
-        _ => {}
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
-    frame.clear(DIMGRAY);
+fn exit(_app: &App, model: Model) {
+    model.audio_tx.send(AudioCommand::Exit).ok();
+    model.audio_thread.join().ok();
+}
 
-    if model.stream.is_playing() && app.elapsed_frames() % 30 < 20 {
+fn view(app: &App, model: &Model) {
+    let draw = app.draw();
+    draw.background().color(DIM_GRAY);
+
+    if !model.is_paused && app.elapsed_frames() % 30 < 20 {
         let draw = app.draw();
         draw.ellipse().w_h(100.0, 100.0).color(RED);
-
-        draw.to_frame(app, &frame).unwrap();
     }
 }
 
diff --git a/examples/audio/simple_audio.rs b/examples/audio/simple_audio.rs
index 851319b4c..f45f40069 100644
--- a/examples/audio/simple_audio.rs
+++ b/examples/audio/simple_audio.rs
@@ -1,14 +1,27 @@
+use std::f64::consts::PI;
+use std::sync::mpsc::Sender;
+use std::thread::JoinHandle;
+
 use nannou::prelude::*;
 use nannou_audio as audio;
 use nannou_audio::Buffer;
-use std::f64::consts::PI;
 
 fn main() {
-    nannou::app(model).run();
+    nannou::app(model).exit(exit).run();
+}
+
+enum AudioCommand {
+    Play,
+    Pause,
+    IncreaseFrequency(f64),
+    DecreaseFrequency(f64),
+    Exit,
 }
 
 struct Model {
-    stream: audio::Stream<Audio>,
+    audio_thread: JoinHandle<()>,
+    audio_tx: Sender<AudioCommand>,
+    is_paused: bool,
 }
 
 struct Audio {
@@ -18,11 +31,7 @@ struct Audio {
 
 fn model(app: &App) -> Model {
     // Create a window to receive key pressed events.
-    app.new_window()
-        .key_pressed(key_pressed)
-        .view(view)
-        .build()
-        .unwrap();
+    app.new_window().key_pressed(key_pressed).view(view).build();
 
     // Initialise the audio API so we can spawn an audio stream.
     let audio_host = audio::Host::new();
@@ -33,15 +42,53 @@ fn model(app: &App) -> Model {
         hz: 440.0,
     };
 
-    let stream = audio_host
-        .new_output_stream(model)
-        .render(audio)
-        .build()
-        .unwrap();
+    // Kick off the audio thread.
+    let (audio_tx, audio_rx) = std::sync::mpsc::channel();
+    let audio_thread = std::thread::spawn(move || {
+        let stream = audio_host
+            .new_output_stream(model)
+            .render(audio)
+            .build()
+            .unwrap();
 
-    stream.play().unwrap();
+        stream.play().unwrap();
 
-    Model { stream }
+        loop {
+            match audio_rx.recv() {
+                Ok(AudioCommand::Play) => {
+                    stream.play().unwrap();
+                }
+                Ok(AudioCommand::Pause) => {
+                    stream.pause().unwrap();
+                }
+                Ok(AudioCommand::IncreaseFrequency(hz)) => {
+                    stream
+                        .send(move |audio| {
+                            audio.hz += hz;
+                        })
+                        .unwrap();
+                }
+                Ok(AudioCommand::DecreaseFrequency(hz)) => {
+                    stream
+                        .send(move |audio| {
+                            audio.hz -= hz;
+                        })
+                        .unwrap();
+                }
+                Ok(AudioCommand::Exit) => {
+                    stream.pause().ok();
+                    break;
+                }
+                _ => (),
+            }
+        }
+    });
+
+    Model {
+        audio_thread,
+        audio_tx,
+        is_paused: false,
+    }
 }
 
 // A function that renders the given `Audio` to the given `Buffer`.
@@ -59,38 +106,42 @@ fn audio(audio: &mut Audio, buffer: &mut Buffer) {
     }
 }
 
-fn key_pressed(_app: &App, model: &mut Model, key: Key) {
+fn key_pressed(_app: &App, model: &mut Model, key: KeyCode) {
     match key {
         // Pause or unpause the audio when Space is pressed.
-        Key::Space => {
-            if model.stream.is_playing() {
-                model.stream.pause().unwrap();
+        KeyCode::Space => {
+            if model.is_paused {
+                model.audio_tx.send(AudioCommand::Play).ok();
+                model.is_paused = false;
             } else {
-                model.stream.play().unwrap();
+                model.audio_tx.send(AudioCommand::Pause).ok();
+                model.is_paused = true;
             }
         }
         // Raise the frequency when the up key is pressed.
-        Key::Up => {
+        KeyCode::ArrowUp => {
             model
-                .stream
-                .send(|audio| {
-                    audio.hz += 10.0;
-                })
-                .unwrap();
+                .audio_tx
+                .send(AudioCommand::IncreaseFrequency(10.0))
+                .ok();
         }
         // Lower the frequency when the down key is pressed.
-        Key::Down => {
+        KeyCode::ArrowDown => {
             model
-                .stream
-                .send(|audio| {
-                    audio.hz -= 10.0;
-                })
-                .unwrap();
+                .audio_tx
+                .send(AudioCommand::DecreaseFrequency(10.0))
+                .ok();
         }
         _ => {}
     }
 }
 
-fn view(_app: &App, _model: &Model, frame: Frame) {
-    frame.clear(DIMGRAY);
+fn exit(_app: &App, model: Model) {
+    model.audio_tx.send(AudioCommand::Exit).ok();
+    model.audio_thread.join().ok();
+}
+
+fn view(app: &App, _model: &Model) {
+    let draw = app.draw();
+    draw.background().color(DIM_GRAY);
 }
diff --git a/examples/audio/simple_audio_file.rs b/examples/audio/simple_audio_file.rs
index 3ebd4402a..e3bf8f5a4 100644
--- a/examples/audio/simple_audio_file.rs
+++ b/examples/audio/simple_audio_file.rs
@@ -3,11 +3,18 @@ use nannou_audio as audio;
 use nannou_audio::Buffer;
 
 fn main() {
-    nannou::app(model).run();
+    nannou::app(model).exit(exit).run();
 }
 
 struct Model {
-    stream: audio::Stream<Audio>,
+    audio_thread: std::thread::JoinHandle<()>,
+    audio_tx: std::sync::mpsc::Sender<AudioCommand>,
+    is_paused: bool,
+}
+
+pub enum AudioCommand {
+    PlaySound(audrey::read::BufFileReader),
+    Exit,
 }
 
 struct Audio {
@@ -16,11 +23,7 @@ struct Audio {
 
 fn model(app: &App) -> Model {
     // Create a window to receive key pressed events.
-    app.new_window()
-        .key_pressed(key_pressed)
-        .view(view)
-        .build()
-        .unwrap();
+    app.new_window().key_pressed(key_pressed).view(view).build();
 
     // Initialise the audio host so we can spawn an audio stream.
     let audio_host = audio::Host::new();
@@ -28,15 +31,41 @@ fn model(app: &App) -> Model {
     // Initialise the state that we want to live on the audio thread.
     let sounds = vec![];
     let model = Audio { sounds };
-    let stream = audio_host
-        .new_output_stream(model)
-        .render(audio)
-        .build()
-        .unwrap();
 
-    stream.play().unwrap();
+    // Kick off the audio thread.
+    let (audio_tx, audio_rx) = std::sync::mpsc::channel();
+    let audio_thread = std::thread::spawn(move || {
+        let stream = audio_host
+            .new_output_stream(model)
+            .render(audio)
+            .build()
+            .unwrap();
+
+        stream.play().unwrap();
+
+        loop {
+            match audio_rx.recv() {
+                Ok(AudioCommand::PlaySound(sound)) => {
+                    stream
+                        .send(move |audio| {
+                            audio.sounds.push(sound);
+                        })
+                        .unwrap();
+                }
+                Ok(AudioCommand::Exit) => {
+                    stream.pause().ok();
+                    break;
+                }
+                Err(_) => break,
+            }
+        }
+    });
 
-    Model { stream }
+    Model {
+        audio_thread,
+        audio_tx,
+        is_paused: false,
+    }
 }
 
 // A function that renders the given `Audio` to the given `Buffer`.
@@ -68,24 +97,21 @@ fn audio(audio: &mut Audio, buffer: &mut Buffer) {
     }
 }
 
-fn key_pressed(app: &App, model: &mut Model, key: Key) {
-    match key {
-        // Start playing another instance of the sound.
-        Key::Space => {
-            let assets = app.assets_path().expect("could not find assets directory");
-            let path = assets.join("sounds").join("thumbpiano.wav");
-            let sound = audrey::open(path).expect("failed to load sound");
-            model
-                .stream
-                .send(move |audio| {
-                    audio.sounds.push(sound);
-                })
-                .ok();
-        }
-        _ => {}
+fn key_pressed(app: &App, model: &mut Model, key: KeyCode) {
+    if key == KeyCode::Space {
+        let assets = app.assets_path();
+        let path = assets.join("sounds").join("thumbpiano.wav");
+        let sound = audrey::open(path).expect("failed to load sound");
+        model.audio_tx.send(AudioCommand::PlaySound(sound)).ok();
     }
 }
 
-fn view(_app: &App, _model: &Model, frame: Frame) {
-    frame.clear(DIMGRAY);
+fn exit(_app: &App, model: Model) {
+    model.audio_tx.send(AudioCommand::Exit).ok();
+    model.audio_thread.join().ok();
+}
+
+fn view(app: &App, _model: &Model) {
+    let draw = app.draw();
+    draw.background().color(DIM_GRAY);
 }
diff --git a/examples/communication/osc_receiver.rs b/examples/communication/osc_receiver.rs
index 8c71325d1..28a63f488 100644
--- a/examples/communication/osc_receiver.rs
+++ b/examples/communication/osc_receiver.rs
@@ -19,8 +19,7 @@ fn model(app: &App) -> Model {
         .title("OSC Receiver")
         .size(1400, 480)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     // Bind an `osc::Receiver` to a port.
     let receiver = osc::receiver(PORT).unwrap();
@@ -34,7 +33,7 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(_app: &App, model: &mut Model, _update: Update) {
+fn update(_app: &App, model: &mut Model) {
     // Receive any pending osc packets.
     for (packet, addr) in model.receiver.try_iter() {
         model.received_packets.push((addr, packet));
@@ -48,22 +47,22 @@ fn update(_app: &App, model: &mut Model, _update: Update) {
 }
 
 // Draw the state of your `Model` into the given `Frame` here.
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
-    draw.background().color(DARKBLUE);
+    draw.background().color(DARK_BLUE);
 
     // Create a string showing all the packets.
     let mut packets_text = format!("Listening on port {}\nReceived packets:\n", PORT);
     for &(addr, ref packet) in model.received_packets.iter().rev() {
         packets_text.push_str(&format!("{}: {:?}\n", addr, packet));
     }
-    let rect = frame.rect().pad(10.0);
+
+    let rect = app.window_rect().pad(10.0);
+
     draw.text(&packets_text)
         .font_size(16)
         .align_text_top()
         .line_spacing(10.0)
         .left_justify()
         .wh(rect.wh());
-
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/examples/communication/osc_sender.rs b/examples/communication/osc_sender.rs
index 79eebb5b0..1cd571b72 100644
--- a/examples/communication/osc_sender.rs
+++ b/examples/communication/osc_sender.rs
@@ -18,14 +18,15 @@ fn target_address_string() -> String {
 }
 
 fn model(app: &App) -> Model {
-    let _w_id = app
+    let _w = app
         .new_window()
         .title("OSC Sender")
         .size(680, 480)
-        .event(event)
+        .mouse_pressed(mouse_pressed)
+        .mouse_released(mouse_released)
+        .mouse_moved(mouse_moved)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     // The address to which the `Sender` will send messages.
     let target_addr = target_address_string();
@@ -36,46 +37,38 @@ fn model(app: &App) -> Model {
     Model { sender }
 }
 
-fn event(_app: &App, model: &mut Model, event: WindowEvent) {
-    match event {
-        MouseMoved(pos) => {
-            let addr = "/example/mouse_moved/";
-            let args = vec![Type::Float(pos.x), Type::Float(pos.y)];
-            model.sender.send((addr, args)).ok();
-        }
-
-        MousePressed(button) => {
-            let addr = "/example/mouse_pressed/";
-            let button = format!("{:?}", button);
-            let args = vec![Type::String(button)];
-            model.sender.send((addr, args)).ok();
-        }
+fn mouse_moved(_app: &App, model: &mut Model, pos: Point2) {
+    let addr = "/example/mouse_moved/";
+    let args = vec![Type::Float(pos.x), Type::Float(pos.y)];
+    model.sender.send((addr, args)).ok();
+}
 
-        MouseReleased(button) => {
-            let addr = "/example/mouse_released/";
-            let button = format!("{:?}", button);
-            let args = vec![Type::String(button)];
-            model.sender.send((addr, args)).ok();
-        }
+fn mouse_pressed(_app: &App, model: &mut Model, button: MouseButton) {
+    let addr = "/example/mouse_pressed/";
+    let button = format!("{:?}", button);
+    let args = vec![Type::String(button)];
+    model.sender.send((addr, args)).ok();
+}
 
-        _other => (),
-    }
+fn mouse_released(_app: &App, model: &mut Model, button: MouseButton) {
+    let addr = "/example/mouse_released/";
+    let button = format!("{:?}", button);
+    let args = vec![Type::String(button)];
+    model.sender.send((addr, args)).ok();
 }
 
-fn view(app: &App, _model: &Model, frame: Frame) {
+fn view(app: &App, _model: &Model) {
     let draw = app.draw();
-    draw.background().color(DARKRED);
+    draw.background().color(DARK_RED);
 
     let text = format!(
         "Move or click the mouse to send\nmessages to the \
          receiver example!\n\nSending OSC packets to {}",
         target_address_string()
     );
-    let rect = frame.rect();
+    let rect = app.main_window().rect();
     draw.text(&text)
         .font_size(16)
         .line_spacing(10.0)
         .wh(rect.wh());
-
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/examples/draw/draw.rs b/examples/draw/draw.rs
index f64f6cbcb..ddd113eca 100644
--- a/examples/draw/draw.rs
+++ b/examples/draw/draw.rs
@@ -4,12 +4,12 @@ fn main() {
     nannou::sketch(view).run()
 }
 
-fn view(app: &App, frame: Frame) {
+fn view(app: &App) {
     // Begin drawing
     let draw = app.draw();
 
     // Clear the background to blue.
-    draw.background().color(CORNFLOWERBLUE);
+    draw.background().color(CORNFLOWER_BLUE);
 
     // Draw a purple triangle in the top left half of the window.
     let win = app.window_rect();
@@ -17,10 +17,10 @@ fn view(app: &App, frame: Frame) {
         .points(win.bottom_left(), win.top_left(), win.top_right())
         .color(VIOLET);
 
-    // Draw an ellipse to follow the mouse.
-    let t = app.time;
+    // Draw an ellipse to follow the mouse().
+    let t = app.time();
     draw.ellipse()
-        .x_y(app.mouse.x * t.cos(), app.mouse.y)
+        .x_y(app.mouse().x * t.cos(), app.mouse().y)
         .radius(win.w() * 0.125 * t.sin())
         .color(RED);
 
@@ -28,21 +28,18 @@ fn view(app: &App, frame: Frame) {
     draw.line()
         .weight(10.0 + (t.sin() * 0.5 + 0.5) * 90.0)
         .caps_round()
-        .color(PALEGOLDENROD)
+        .color(PALE_GOLDENROD)
         .points(win.top_left() * t.sin(), win.bottom_right() * t.cos());
 
     // Draw a quad that follows the inverse of the ellipse.
     draw.quad()
-        .x_y(-app.mouse.x, app.mouse.y)
-        .color(DARKGREEN)
+        .x_y(-app.mouse().x, app.mouse().y)
+        .color(DARK_GREEN)
         .rotate(t);
 
     // Draw a rect that follows a different inverse of the ellipse.
     draw.rect()
-        .x_y(app.mouse.y, app.mouse.x)
-        .w(app.mouse.x * 0.25)
+        .x_y(app.mouse().y, app.mouse().x)
+        .w(app.mouse().x * 0.25)
         .hsv(t, 1.0, 1.0);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/examples/draw/draw_arrow.rs b/examples/draw/draw_arrow.rs
index a10dad9ee..7a7c92162 100644
--- a/examples/draw/draw_arrow.rs
+++ b/examples/draw/draw_arrow.rs
@@ -4,23 +4,21 @@ fn main() {
     nannou::sketch(view).run()
 }
 
-fn view(app: &App, frame: Frame) {
+fn view(app: &App) {
     let draw = app.draw();
     let r = app.window_rect();
-    draw.background().color(BLACK);
+    // draw.background().color(BLACK);
 
     for r in r.subdivisions_iter() {
         for r in r.subdivisions_iter() {
             for r in r.subdivisions_iter() {
                 let side = r.w().min(r.h());
                 let start = r.xy();
-                let start_to_mouse = app.mouse.position() - start;
+                let start_to_mouse = app.mouse() - start;
                 let target_mag = start_to_mouse.length().min(side * 0.5);
                 let end = start + start_to_mouse.normalize_or_zero() * target_mag;
                 draw.arrow().weight(5.0).points(start, end);
             }
         }
     }
-
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/examples/draw/draw_blend.rs b/examples/draw/draw_blend.rs
index b7e9b55d5..58e587f2d 100644
--- a/examples/draw/draw_blend.rs
+++ b/examples/draw/draw_blend.rs
@@ -4,12 +4,12 @@ fn main() {
     nannou::sketch(view).run()
 }
 
-fn view(app: &App, frame: Frame) {
+fn view(app: &App) {
     // Change the background luminance based on mouse x.
     let w = app.window_rect();
-    let lum = map_range(app.mouse.x, w.left(), w.right(), 0.0, 1.0);
-    let clear = gray(lum);
-    frame.clear(clear);
+    let lum = map_range(app.mouse().x, w.left(), w.right(), 0.0, 1.0);
+    let clear = Color::gray(lum);
+    // draw.background().color(clear);
 
     // Put all the provided blend modes in a list.
     let blends = [
@@ -22,37 +22,39 @@ fn view(app: &App, frame: Frame) {
     ];
 
     // Select a color blend descriptor based on mouse y.
-    let ix = map_range(app.mouse.y, w.top(), w.bottom(), 0, blends.len());
+    let ix = map_range(app.mouse().x, w.top(), w.bottom(), 0, blends.len());
     let ix = std::cmp::min(ix, blends.len() - 1);
     let (blend_name, desc) = &blends[ix];
 
     // Draw the name of the blend mode and its descriptor.
-    let draw = app.draw();
-    let color = gray(1.0 - lum.round());
-    draw.text(blend_name)
-        .color(color)
-        .font_size(48)
-        .wh(w.wh() * 0.7)
-        .align_text_top();
-    let text = format!("{:?}", desc);
-    draw.text(&text)
-        .color(color)
-        .wh(w.wh() * 0.8)
-        .align_text_bottom();
+    let mut draw = app.draw();
+    draw.background().color(clear);
+    let color = Color::gray(1.0f32 - lum.round());
+    // draw.text(blend_name)
+    //     .color(color)
+    //     .font_size(48)
+    //     .wh(w.wh() * 0.7)
+    //     .align_text_top();
+    // let text = format!("{:?}", desc);
+    // draw.text(&text)
+    //     .color(color)
+    //     .wh(w.wh() * 0.8)
+    //     .align_text_bottom();
 
     // Assign the blend mode.
-    let mut draw = draw.color_blend(desc.clone());
+    // let mut draw = draw.color_blend(desc.clone());
 
     // Draw RGB circles.
-    let t = app.time;
+    let t = app.time();
     let n_circles = 3;
     let radius = w.right().min(w.top()) * 0.5 / n_circles as f32;
     let animate_radius = -((t.sin() * 0.5 + 0.5) * radius * 0.5);
-    draw = draw.x(w.left() * 0.5);
+    draw = draw.x(w.left() * 0.5).color_blend(*desc);
     for i in 0..n_circles {
         let hue = i as f32 / n_circles as f32;
-        let color = hsl(hue, 1.0, 0.5);
+        let color = Color::hsl(hue, 1.0, 0.5);
         draw.ellipse()
+            // .color_blend(desc.clone())
             .radius(radius)
             .color(color)
             .x(radius + animate_radius);
@@ -60,10 +62,10 @@ fn view(app: &App, frame: Frame) {
     }
 
     // Draw CMY.
-    draw = draw.x(w.right() * 0.5);
+    draw = draw.x(w.right() * 0.5).color_blend(*desc);
     for i in 0..n_circles {
         let hue = i as f32 / n_circles as f32;
-        let color = hsl(hue + 0.5, 1.0, 0.5);
+        let color = Color::hsl(hue + 0.5, 1.0, 0.5);
         draw.ellipse()
             .radius(radius)
             .color(color)
@@ -72,16 +74,14 @@ fn view(app: &App, frame: Frame) {
     }
 
     // Draw ascending luminance.
-    draw = draw.x(w.right() * 0.5);
+    draw = draw.x(w.right() * 0.5).color_blend(*desc);
     for i in 0..n_circles {
         let lum = (0.5 + i as f32) / n_circles as f32;
-        let color = gray(lum);
+        let color = Color::gray(lum);
         draw.ellipse()
             .radius(radius)
             .color(color)
             .x(radius + animate_radius);
         draw = draw.rotate(PI * 2.0 / n_circles as f32);
     }
-
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/examples/draw/draw_capture.rs b/examples/draw/draw_capture.rs
index de7d94b72..7f2deb401 100644
--- a/examples/draw/draw_capture.rs
+++ b/examples/draw/draw_capture.rs
@@ -7,53 +7,51 @@ fn main() {
     nannou::sketch(view).run()
 }
 
-fn view(app: &App, frame: Frame) {
+fn view(app: &App) {
     let draw = app.draw();
 
-    draw.background().color(CORNFLOWERBLUE);
+    draw.background().color(CORNFLOWER_BLUE);
 
     let win = app.window_rect();
     draw.tri()
         .points(win.bottom_left(), win.top_left(), win.top_right())
         .color(VIOLET);
 
-    let t = frame.nth() as f32 / 60.0;
+    let t = app.elapsed_frames() as f32 / 60.0;
     draw.ellipse()
-        .x_y(app.mouse.x * t.cos(), app.mouse.y)
+        .x_y(app.mouse().x * t.cos(), app.mouse().x)
         .radius(win.w() * 0.125 * t.sin())
         .color(RED);
 
     draw.line()
         .weight(10.0 + (t.sin() * 0.5 + 0.5) * 90.0)
         .caps_round()
-        .color(PALEGOLDENROD)
+        .color(PALE_GOLDENROD)
         .points(win.top_left() * t.sin(), win.bottom_right() * t.cos());
 
     draw.quad()
-        .x_y(-app.mouse.x, app.mouse.y)
-        .color(DARKGREEN)
+        .x_y(-app.mouse().x, app.mouse().x)
+        .color(DARK_GREEN)
         .rotate(t);
 
     draw.rect()
-        .x_y(app.mouse.y, app.mouse.x)
-        .w(app.mouse.x * 0.25)
+        .x_y(app.mouse().x, app.mouse().x)
+        .w(app.mouse().x * 0.25)
         .hsv(t, 1.0, 1.0);
 
-    draw.to_frame(app, &frame).unwrap();
-
     // Capture the frame!
-    let file_path = captured_frame_path(app, &frame);
-    app.main_window().capture_frame(file_path);
+    let file_path = captured_frame_path(app);
+    app.main_window().save_screenshot(file_path);
 }
 
-fn captured_frame_path(app: &App, frame: &Frame) -> std::path::PathBuf {
+fn captured_frame_path(app: &App) -> std::path::PathBuf {
     // Create a path that we want to save this frame to.
     app.project_path()
         .expect("failed to locate `project_path`")
         // Capture all frames to a directory called `/<path_to_nannou>/nannou/simple_capture`.
         .join(app.exe_name().unwrap())
         // Name each file after the number of the frame.
-        .join(format!("{:03}", frame.nth()))
+        .join(format!("{:03}", app.elapsed_frames()))
         // The extension will be PNG. We also support tiff, bmp, gif, jpeg, webp and some others.
         .with_extension("png")
 }
diff --git a/examples/draw/draw_capture_hi_res.rs b/examples/draw/draw_capture_hi_res.rs
deleted file mode 100644
index 79635b97f..000000000
--- a/examples/draw/draw_capture_hi_res.rs
+++ /dev/null
@@ -1,204 +0,0 @@
-// A demonstration of drawing to a very large texture, capturing the texture in its original size
-// as a PNG and displaying a down-scaled version of the image within the window each frame.
-
-use nannou::prelude::*;
-
-fn main() {
-    nannou::app(model).update(update).exit(exit).run();
-}
-
-struct Model {
-    // The texture that we will draw to.
-    texture: wgpu::Texture,
-    // Create a `Draw` instance for drawing to our texture.
-    draw: nannou::Draw,
-    // The type used to render the `Draw` vertices to our texture.
-    renderer: nannou::draw::Renderer,
-    // The type used to capture the texture.
-    texture_capturer: wgpu::TextureCapturer,
-    // The type used to resize our texture to the window texture.
-    texture_reshaper: wgpu::TextureReshaper,
-}
-
-fn model(app: &App) -> Model {
-    // Lets write to a 4K UHD texture.
-    let texture_size = [3_840, 2_160];
-
-    // Create the window.
-    let [win_w, win_h] = [texture_size[0] / 4, texture_size[1] / 4];
-    let w_id = app
-        .new_window()
-        .size(win_w, win_h)
-        .title("nannou")
-        .view(view)
-        .build()
-        .unwrap();
-    let window = app.window(w_id).unwrap();
-
-    // Retrieve the wgpu device.
-    let device = window.device();
-
-    // Create our custom texture.
-    let sample_count = window.msaa_samples();
-    let texture = wgpu::TextureBuilder::new()
-        .size(texture_size)
-        // Our texture will be used as the RENDER_ATTACHMENT for our `Draw` render pass.
-        // It will also be SAMPLED by the `TextureCapturer` and `TextureResizer`.
-        .usage(wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING)
-        // Use nannou's default multisampling sample count.
-        .sample_count(sample_count)
-        // Use a spacious 16-bit linear sRGBA format suitable for high quality drawing.
-        .format(wgpu::TextureFormat::Rgba16Float)
-        // Build it!
-        .build(device);
-
-    // Create our `Draw` instance and a renderer for it.
-    let draw = nannou::Draw::new();
-    let descriptor = texture.descriptor();
-    let renderer =
-        nannou::draw::RendererBuilder::new().build_from_texture_descriptor(device, descriptor);
-
-    // Create the texture capturer.
-    let texture_capturer = wgpu::TextureCapturer::default();
-
-    // Create the texture reshaper.
-    let texture_view = texture.view().build();
-    let texture_sample_type = texture.sample_type();
-    let dst_format = Frame::TEXTURE_FORMAT;
-    let texture_reshaper = wgpu::TextureReshaper::new(
-        device,
-        &texture_view,
-        sample_count,
-        texture_sample_type,
-        sample_count,
-        dst_format,
-    );
-
-    // Make sure the directory where we will save images to exists.
-    std::fs::create_dir_all(&capture_directory(app)).unwrap();
-
-    Model {
-        texture,
-        draw,
-        renderer,
-        texture_capturer,
-        texture_reshaper,
-    }
-}
-
-fn update(app: &App, model: &mut Model, _update: Update) {
-    // First, reset the `draw` state.
-    let draw = &model.draw;
-    draw.reset();
-
-    // Create a `Rect` for our texture to help with drawing.
-    let [w, h] = model.texture.size();
-    let r = geom::Rect::from_w_h(w as f32, h as f32);
-
-    // Use the frame number to animate, ensuring we get a constant update time.
-    let elapsed_frames = app.main_window().elapsed_frames();
-    let t = elapsed_frames as f32 / 60.0;
-
-    // Draw like we normally would in the `view`.
-    draw.background().color(BLACK);
-    let n_points = 10;
-    let weight = 8.0;
-    let hz = 6.0;
-    let vertices = (0..n_points)
-        .map(|i| {
-            let x = map_range(i, 0, n_points - 1, r.left(), r.right());
-            let fract = i as f32 / n_points as f32;
-            let amp = (t + fract * hz * TAU).sin();
-            let y = map_range(amp, -1.0, 1.0, r.bottom() * 0.75, r.top() * 0.75);
-            pt2(x, y)
-        })
-        .enumerate()
-        .map(|(i, p)| {
-            let fract = i as f32 / n_points as f32;
-            let r = (t + fract) % 1.0;
-            let g = (t + 1.0 - fract) % 1.0;
-            let b = (t + 0.5 + fract) % 1.0;
-            let rgba = srgba(r, g, b, 1.0);
-            (p, rgba)
-        });
-    draw.polyline()
-        .weight(weight)
-        .join_round()
-        .points_colored(vertices);
-
-    // Draw frame number and size in bottom left.
-    let string = format!("Frame {} - {:?}", elapsed_frames, [w, h]);
-    let text = text(&string)
-        .font_size(48)
-        .left_justify()
-        .align_bottom()
-        .build(r.pad(r.h() * 0.05));
-    draw.path().fill().color(WHITE).events(text.path_events());
-
-    // Render our drawing to the texture.
-    let window = app.main_window();
-    let device = window.device();
-    let ce_desc = wgpu::CommandEncoderDescriptor {
-        label: Some("texture renderer"),
-    };
-    let mut encoder = device.create_command_encoder(&ce_desc);
-    model
-        .renderer
-        .render_to_texture(device, &mut encoder, draw, &model.texture);
-
-    // Take a snapshot of the texture. The capturer will do the following:
-    //
-    // 1. Resolve the texture to a non-multisampled texture if necessary.
-    // 2. Convert the format to non-linear 8-bit sRGBA ready for image storage.
-    // 3. Copy the result to a buffer ready to be mapped for reading.
-    let snapshot = model
-        .texture_capturer
-        .capture(device, &mut encoder, &model.texture);
-
-    // Submit the commands for our drawing and texture capture to the GPU.
-    window.queue().submit(Some(encoder.finish()));
-
-    // Submit a function for writing our snapshot to a PNG.
-    //
-    // NOTE: It is essential that the commands for capturing the snapshot are `submit`ted before we
-    // attempt to read the snapshot - otherwise we will read a blank texture!
-    let path = capture_directory(app)
-        .join(elapsed_frames.to_string())
-        .with_extension("png");
-    snapshot
-        .read(move |result| {
-            let image = result.expect("failed to map texture memory").to_owned();
-            image
-                .save(&path)
-                .expect("failed to save texture to png image");
-        })
-        .unwrap();
-}
-
-// Draw the state of your `Model` into the given `Frame` here.
-fn view(_app: &App, model: &Model, frame: Frame) {
-    // Sample the texture and write it to the frame.
-    let mut encoder = frame.command_encoder();
-    model
-        .texture_reshaper
-        .encode_render_pass(frame.texture_view(), &mut *encoder);
-}
-
-// Wait for capture to finish.
-fn exit(app: &App, model: Model) {
-    println!("Waiting for PNG writing to complete...");
-    let window = app.main_window();
-    let device = window.device();
-    model
-        .texture_capturer
-        .await_active_snapshots(&device)
-        .unwrap();
-    println!("Done!");
-}
-
-// The directory where we'll save the frames.
-fn capture_directory(app: &App) -> std::path::PathBuf {
-    app.project_path()
-        .expect("could not locate project_path")
-        .join(app.exe_name().unwrap())
-}
diff --git a/examples/draw/draw_custom_material.rs b/examples/draw/draw_custom_material.rs
new file mode 100644
index 000000000..350b98111
--- /dev/null
+++ b/examples/draw/draw_custom_material.rs
@@ -0,0 +1,46 @@
+use nannou::prelude::*;
+
+fn main() {
+    nannou::app(model)
+        .simple_window(view)
+        // Register our custom material to make it available for use in our drawing
+        .init_custom_material::<CustomMaterial>()
+        .run()
+}
+
+struct Model {}
+
+// This struct defines the data that will be passed to your shader
+#[derive(Asset, TypePath, AsBindGroup, Debug, Clone, Default)]
+struct CustomMaterial {
+    #[uniform(0)]
+    color: LinearRgba,
+}
+
+impl Material for CustomMaterial {
+    fn fragment_shader() -> ShaderRef {
+        "draw_custom_material.wgsl".into()
+    }
+}
+
+fn model(app: &App) -> Model {
+    Model {}
+}
+
+fn view(app: &App, model: &Model, window: Entity) {
+    // Begin drawing
+    let draw = app
+        .draw()
+        // Initialize our draw instance with our custom material
+        .material(CustomMaterial { color: RED.into() });
+
+    draw.ellipse().x(-200.0);
+
+    // We can also map the material manually
+    draw.ellipse()
+        .map_material(|mut mat| {
+            mat.color = BLUE.into();
+            mat
+        })
+        .x(200.0);
+}
diff --git a/examples/draw/draw_fragment_shader.rs b/examples/draw/draw_fragment_shader.rs
new file mode 100644
index 000000000..09568b870
--- /dev/null
+++ b/examples/draw/draw_fragment_shader.rs
@@ -0,0 +1,29 @@
+use nannou::prelude::*;
+
+fn main() {
+    nannou::app(model)
+        .simple_window(view)
+        // We need to initialize the fragment shader with the path to the shader file
+        // in our assets directory so that it will be available to use as a material.
+        .init_fragment_shader::<"draw_fragment_shader.wgsl">()
+        .run()
+}
+
+struct Model {}
+
+fn model(app: &App) -> Model {
+    Model {}
+}
+
+fn view(app: &App, model: &Model, window: Entity) {
+    // Begin drawing
+    let draw = app.draw();
+    // Draw a full-screen quad
+    let window = app.main_window();
+    let window_rect = window.rect();
+    draw.rect()
+        // Specify the shader to use for this draw call
+        .fragment_shader::<"draw_fragment_shader.wgsl">()
+        .w_h(window_rect.w(), window_rect.h())
+        .color(WHITE);
+}
diff --git a/examples/draw/draw_loop.rs b/examples/draw/draw_loop.rs
index d815762c1..44eab1845 100644
--- a/examples/draw/draw_loop.rs
+++ b/examples/draw/draw_loop.rs
@@ -18,21 +18,16 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    let _window = app
-        .new_window()
-        .size(1024, 1024)
-        .view(view)
-        .build()
-        .unwrap();
+    let _window = app.new_window().size_pixels(1024, 1024).view(view).build();
     let mut noise = Perlin::new();
     noise = noise.set_seed(1);
     Model { noise }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Prepare to draw.
     let draw = app.draw();
-    draw.background().color(BLACK);
+    draw.background().color(Color::BLACK);
 
     //the loop is going to be 200 frames long
     let frac = (app.elapsed_frames() % 200) as f32 / (200.0);
@@ -67,10 +62,11 @@ fn view(app: &App, model: &Model, frame: Frame) {
             ));
         }
         //fill the line with black
-        draw.polygon().color(BLACK).points(pts);
+        draw.polygon().color(Color::BLACK).points(pts);
         //draw the white outline on top
-        draw.polyline().color(WHITE).stroke_weight(5.0).points(pts2);
+        draw.polyline()
+            .color(Color::WHITE)
+            .stroke_weight(5.0)
+            .points(pts2);
     }
-
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/examples/draw/draw_material.rs b/examples/draw/draw_material.rs
new file mode 100644
index 000000000..317a841ce
--- /dev/null
+++ b/examples/draw/draw_material.rs
@@ -0,0 +1,66 @@
+use nannou::prelude::light_consts::lux::DIRECT_SUNLIGHT;
+use nannou::prelude::primitive::polygon::PolygonOptions;
+use nannou::prelude::*;
+
+fn main() {
+    nannou::app(model).update(update).run();
+}
+
+struct Model {
+    window: Entity,
+    light: Entity,
+}
+
+fn model(app: &App) -> Model {
+    let light = app.new_light().color(WHITE).illuminance(1000.0).build();
+    let window = app
+        .new_window()
+        .size_pixels(1024, 512)
+        .light(light)
+        .view(view)
+        .build();
+
+    Model { light, window }
+}
+
+fn update(app: &App, model: &mut Model) {
+    let light = app.light(model.light);
+    let window_rect = app.window_rect();
+    let window_center = window_rect.xy();
+    let mouse_x = app.mouse().x;
+    let mouse_y = app.mouse().y;
+    let norm_mouse_x = (mouse_x / window_rect.w()) + 0.5;
+    let norm_mouse_y = (mouse_y / window_rect.h()) + 0.5;
+
+    // Calculate the light's position based on time t
+    let time = app.time();
+    let radius = window_rect.w().min(window_rect.h()) * 0.4;
+    let light_x = window_center.x + radius * (time * 2.0 * PI).cos();
+    let light_y = window_center.y + radius * (time * 2.0 * PI).sin();
+
+    let light_color = Color::hsl((1.0 - norm_mouse_x) * 360.0, 1.0, 0.5);
+    light
+        .color(light_color)
+        .illuminance(norm_mouse_y * DIRECT_SUNLIGHT)
+        .x_y_z(light_x, light_y, 1000.0)
+        .look_at(Vec2::ZERO);
+}
+
+fn view(app: &App, model: &Model) {
+    // Begin drawing
+    let draw = app.draw();
+
+    for y in -2..=2 {
+        for x in -5..=5 {
+            let x01 = (x + 5) as f32 / 10.0;
+            let y01 = (y + 2) as f32 / 2.0;
+
+            draw.ellipse()
+                .w_h(50.0, 50.0)
+                .x_y_z(x as f32 * 100.0, y as f32 * 100.0, 10.0)
+                .roughness(x01)
+                .metallic(y01)
+                .color(Color::gray(0.5));
+        }
+    }
+}
diff --git a/examples/draw/draw_material_bloom.rs b/examples/draw/draw_material_bloom.rs
new file mode 100644
index 000000000..a0e2def2b
--- /dev/null
+++ b/examples/draw/draw_material_bloom.rs
@@ -0,0 +1,58 @@
+use nannou::prelude::*;
+
+fn main() {
+    nannou::app(model).update(update).run();
+}
+
+struct Model {
+    window: Entity,
+    camera: Entity,
+}
+
+fn model(app: &App) -> Model {
+    let camera = app
+        .new_camera()
+        // HDR is required for bloom to work.
+        .hdr(true)
+        // Pick a default bloom settings. This also can be configured manually.
+        .bloom_settings(BloomSettings::OLD_SCHOOL)
+        .build();
+
+    let window = app
+        .new_window()
+        .camera(camera)
+        .size_pixels(1024, 1024)
+        .view(view)
+        .build();
+
+    Model { camera, window }
+}
+
+fn update(app: &App, model: &mut Model) {
+    let camera = app.camera(model.camera);
+    let window_rect = app.window_rect();
+    let norm_mouse_y = (app.mouse().y / window_rect.w()) + 0.5;
+
+    camera.bloom_intensity(norm_mouse_y.clamp(0.0, 0.8));
+}
+
+fn view(app: &App, model: &Model) {
+    // Begin drawing
+    let draw = app.draw();
+    let window_rect = app.window_rect();
+    let norm_mouse_x = (app.mouse().x / window_rect.w()) + 0.5;
+
+    // Use the normalized mouse coordinate to create an initial color.
+    let color_hsl = Color::hsl((1.0 - norm_mouse_x) * 360.0, 1.0, 0.5);
+
+    // Convert the color to linear RGBA and multiply (for emissives, values outside of 1.0 are used).
+    let mut color_linear_rgb: LinearRgba = color_hsl.into();
+    color_linear_rgb = color_linear_rgb * 5.0;
+
+    let t = app.time();
+
+    draw.tri()
+        .width(100.0)
+        .emissive(color_linear_rgb)
+        .color(WHITE);
+}
diff --git a/examples/draw/draw_mesh.rs b/examples/draw/draw_mesh.rs
index 98c8be5b0..80c8ea711 100644
--- a/examples/draw/draw_mesh.rs
+++ b/examples/draw/draw_mesh.rs
@@ -4,18 +4,18 @@ fn main() {
     nannou::sketch(view).run()
 }
 
-fn view(app: &App, frame: Frame) {
+fn view(app: &App) {
     // Begin drawing
     let win = app.window_rect();
-    let t = app.time;
+    let t = app.time();
     let draw = app.draw();
 
     // Clear the background to black.
     draw.background().color(BLACK);
 
     // Use the mouse position to affect the frequency and amplitude.
-    let hz = map_range(app.mouse.x, win.left(), win.right(), 0.0, 100.0);
-    let amp = app.mouse.y;
+    let hz = map_range(app.mouse().x, win.left(), win.right(), 0.0, 100.0);
+    let amp = app.mouse().x;
 
     // Create an iterator yielding triangles for drawing a sine wave.
     let tris = (1..win.w() as usize)
@@ -40,14 +40,11 @@ fn view(app: &App, frame: Frame) {
             // Color the vertices based on their amplitude.
             tri.map_vertices(|v| {
                 let y_fract = map_range(v.y.abs(), 0.0, win.top(), 0.0, 1.0);
-                let color = srgba(y_fract, 1.0 - y_fract, 1.0 - y_fract, 1.0);
+                let color = Color::srgba(y_fract, 1.0 - y_fract, 1.0 - y_fract, 1.0);
                 (v.extend(0.0), color)
             })
         });
 
     // Draw the mesh!
     draw.mesh().tris_colored(tris);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/examples/draw/draw_polygon.rs b/examples/draw/draw_polygon.rs
index 3055b4441..e4b01b359 100644
--- a/examples/draw/draw_polygon.rs
+++ b/examples/draw/draw_polygon.rs
@@ -4,10 +4,10 @@ fn main() {
     nannou::sketch(view).run()
 }
 
-fn view(app: &App, frame: Frame) {
+fn view(app: &App) {
     // Begin drawing
     let win = app.window_rect();
-    let t = app.time;
+    let t = app.time();
     let draw = app.draw();
 
     // Clear the background to black.
@@ -42,13 +42,10 @@ fn view(app: &App, frame: Frame) {
         let r = fract;
         let g = 1.0 - fract;
         let b = (0.5 + fract) % 1.0;
-        (pt2(x, y), rgb(r, g, b))
+        (pt2(x, y), Color::srgb(r, g, b))
     });
     draw.polygon()
         .x(win.w() * 0.25)
         .rotate(t * 0.2)
         .points_colored(points_colored);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/examples/draw/draw_polyline.rs b/examples/draw/draw_polyline.rs
index 4b99a7542..58dfd8bbc 100644
--- a/examples/draw/draw_polyline.rs
+++ b/examples/draw/draw_polyline.rs
@@ -4,7 +4,7 @@ fn main() {
     nannou::sketch(view).run()
 }
 
-fn view(app: &App, frame: Frame) {
+fn view(app: &App) {
     // Begin drawing
     let draw = app.draw();
 
@@ -12,13 +12,13 @@ fn view(app: &App, frame: Frame) {
     draw.background().color(BLACK);
 
     let win = app.window_rect();
-    let t = app.time;
+    let t = app.time();
 
     // Decide on a number of points and a weight.
     let n_points = 10;
     let weight = 8.0;
-    let hz = ((app.mouse.x + win.right()) / win.w()).powi(4) * 1000.0;
-    let vertices = (0..n_points)
+    let hz = ((app.mouse().x + win.right()) / win.w()).powi(4) * 1000.0;
+    let points_colored = (0..n_points)
         // A sine wave mapped to the range of the window.
         .map(|i| {
             let x = map_range(i, 0, n_points - 1, win.left(), win.right());
@@ -34,7 +34,7 @@ fn view(app: &App, frame: Frame) {
             let r = (t + fract) % 1.0;
             let g = (t + 1.0 - fract) % 1.0;
             let b = (t + 0.5 + fract) % 1.0;
-            let rgba = srgba(r, g, b, 1.0);
+            let rgba = Color::srgba(r, g, b, 1.0);
             (p, rgba)
         });
 
@@ -42,8 +42,5 @@ fn view(app: &App, frame: Frame) {
     draw.polyline()
         .weight(weight)
         .join_round()
-        .points_colored(vertices);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
+        .points_colored(points_colored);
 }
diff --git a/examples/draw/draw_text.rs b/examples/draw/draw_text.rs
index 43dd0d8de..3585b43e5 100644
--- a/examples/draw/draw_text.rs
+++ b/examples/draw/draw_text.rs
@@ -8,13 +8,13 @@ fn main() {
     nannou::sketch(view).run()
 }
 
-fn view(app: &App, frame: Frame) {
+fn view(app: &App) {
     // Begin drawing.
     let draw = app.draw();
     draw.background().color(WHITE);
 
     // We'll align to the window dimensions, but padded slightly.
-    let win_rect = app.main_window().rect().pad(20.0);
+    let win_rect = app.window_rect().pad(20.0);
 
     let text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\n\nResize the window to test dynamic layout.";
 
@@ -26,6 +26,4 @@ fn view(app: &App, frame: Frame) {
         .glyph_colors(glyph_colors)
         .font_size(24)
         .wh(win_rect.wh());
-
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/examples/draw/draw_text_path.rs b/examples/draw/draw_text_path.rs
index c350b55fd..5bcb89f5b 100644
--- a/examples/draw/draw_text_path.rs
+++ b/examples/draw/draw_text_path.rs
@@ -9,7 +9,7 @@ fn main() {
     nannou::sketch(view).run()
 }
 
-fn view(app: &App, frame: Frame) {
+fn view(app: &App) {
     // Begin drawing.
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -25,7 +25,7 @@ fn view(app: &App, frame: Frame) {
 
     // Draw rects behind the lines.
     for line_rect in text.line_rects() {
-        let a = map_range(app.mouse.x, win_rect.left(), win_rect.right(), 0.0, 1.0);
+        let a = map_range(app.mouse().x, win_rect.left(), win_rect.right(), 0.0, 1.0);
         draw.rect().xy(line_rect.xy()).wh(line_rect.wh()).hsla(
             -line_rect.y() / win_rect.top(),
             1.0,
@@ -36,7 +36,7 @@ fn view(app: &App, frame: Frame) {
 
     // Draw rects behind the glyphs.
     for (_glyph, rect) in text.glyphs() {
-        let a = map_range(app.mouse.y, win_rect.bottom(), win_rect.top(), 0.0, 1.0);
+        let a = map_range(app.mouse().x, win_rect.bottom(), win_rect.top(), 0.0, 1.0);
         draw.rect().xy(rect.xy()).wh(rect.wh()).hsla(
             (rect.x() + rect.y()) / win_rect.w(),
             1.0,
@@ -46,7 +46,4 @@ fn view(app: &App, frame: Frame) {
     }
 
     draw.path().fill().color(BLACK).events(text.path_events());
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/examples/draw/draw_texture.rs b/examples/draw/draw_texture.rs
index 45eb777c7..3d4d2d02a 100644
--- a/examples/draw/draw_texture.rs
+++ b/examples/draw/draw_texture.rs
@@ -7,25 +7,23 @@ fn main() {
 }
 
 struct Model {
-    texture: wgpu::Texture,
+    texture: Handle<Image>,
 }
 
 fn model(app: &App) -> Model {
     // Create a new window!
-    app.new_window().size(512, 512).view(view).build().unwrap();
+    app.new_window().size(512, 512).view(view).build();
     // Load the image from disk and upload it to a GPU texture.
-    let assets = app.assets_path().unwrap();
+    let assets = app.assets_path();
     let img_path = assets.join("images").join("nature").join("nature_1.jpg");
-    let texture = wgpu::Texture::from_path(app, img_path).unwrap();
+    let texture = app.asset_server().load(img_path);
     Model { texture }
 }
 
 // Draw the state of your `Model` into the given `Frame` here.
-fn view(app: &App, model: &Model, frame: Frame) {
-    frame.clear(BLACK);
-
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
-    draw.texture(&model.texture);
-
-    draw.to_frame(app, &frame).unwrap();
+    draw.background().color(BLACK);
+    let win = app.window_rect();
+    draw.rect().x_y(win.x(), win.y()).texture(&model.texture);
 }
diff --git a/examples/draw/draw_texture_sampler.rs b/examples/draw/draw_texture_sampler.rs
index dfe381806..f6022f613 100644
--- a/examples/draw/draw_texture_sampler.rs
+++ b/examples/draw/draw_texture_sampler.rs
@@ -1,62 +1,65 @@
 //! A simple as possible example demonstrating how to use the `draw` API to display a texture.
 
+use nannou::prelude::bevy_render::texture::{
+    ImageAddressMode, ImageSampler, ImageSamplerDescriptor,
+};
 use nannou::prelude::*;
 
 fn main() {
-    nannou::app(model).run();
+    nannou::app(model).update(update).run();
 }
 
 struct Model {
-    texture: wgpu::Texture,
+    texture: Handle<Image>,
 }
 
 fn model(app: &App) -> Model {
     // Create a new window! Store the ID so we can refer to it later.
-    app.new_window().size(512, 512).view(view).build().unwrap();
+    app.new_window().size(512, 512).view(view).primary().build();
     // Load the image from disk and upload it to a GPU texture.
-    let assets = app.assets_path().unwrap();
-    let img_path = assets.join("images").join("nature").join("nature_1.jpg");
-    let texture = wgpu::Texture::from_path(app, img_path).unwrap();
+    let texture = app.asset_server().load("images/nature/nature_1.jpg");
     Model { texture }
 }
 
-// Draw the state of your `Model` into the given `Frame` here.
-fn view(app: &App, model: &Model, frame: Frame) {
-    frame.clear(BLACK);
+fn update(app: &App, model: &mut Model) {
+    let mut images = app.assets_mut::<Image>();
+    let Some(image) = images.get_mut(&model.texture) else {
+        return;
+    };
+
     let win = app.main_window();
     let win_r = win.rect();
 
     // Let's choose the address mode based on the mouse position.
-    let address_mode = match map_range(app.mouse.y, win_r.top(), win_r.bottom(), 0.0, 3.0) as i8 {
-        0 => wgpu::AddressMode::ClampToEdge,
-        1 => wgpu::AddressMode::Repeat,
-        _ => wgpu::AddressMode::MirrorRepeat,
+    let address_mode = match map_range(app.mouse().y, win_r.top(), win_r.bottom(), 0.0, 3.0) as i8 {
+        0 => ImageAddressMode::ClampToEdge,
+        1 => ImageAddressMode::Repeat,
+        _ => ImageAddressMode::MirrorRepeat,
     };
 
-    // Create a sampler with the chosen address mode.
-    let sampler = wgpu::SamplerBuilder::new()
-        .address_mode(address_mode)
-        .into_descriptor();
+    let descriptor = ImageSamplerDescriptor {
+        address_mode_u: address_mode,
+        address_mode_v: address_mode,
+        ..default()
+    };
 
-    // At any point during drawing, we can create a new `draw` context that will let us use a
-    // different sampler.
+    image.sampler = ImageSampler::Descriptor(descriptor);
+}
+
+// Draw the state of your `Model` into the given `Frame` here.
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
-    let draw = draw.sampler(sampler);
+    draw.background().color(BLACK);
 
     // Change the texture coordinates to sample outside the texture. This will demonstrate how the
     // sampler behaves when sampling beyond the bounds of the texture in each of the different
     // address modes. By default, the bounds of the texture coordinates are 0.0 to 1.0. We will
     // triple the size.
-    let area = geom::Rect::from_x_y_w_h(0.5, 0.5, app.time.sin() * 10.0, app.time.sin() * 10.0);
-
-    draw.texture(&model.texture).area(area);
-
-    // Draw the current address mode in the bottom left corner.
-    let text = format!("Address mode: {:?}", address_mode);
-    draw.text(&text)
-        .wh(win_r.wh() * 0.95)
-        .left_justify()
-        .align_text_bottom();
+    let area = geom::Rect::from_x_y_w_h(0.5, 0.5, app.time().sin() * 10.0, app.time().sin() * 10.0);
+    let window_rect = app.main_window().rect();
 
-    draw.to_frame(app, &frame).unwrap();
+    draw.rect()
+        .w_h(window_rect.w(), window_rect.h())
+        .texture(&model.texture)
+        .area(area);
 }
diff --git a/examples/draw/draw_textured_mesh.rs b/examples/draw/draw_textured_mesh.rs
index 4c483bc94..4fbdab591 100644
--- a/examples/draw/draw_textured_mesh.rs
+++ b/examples/draw/draw_textured_mesh.rs
@@ -5,27 +5,25 @@ fn main() {
 }
 
 struct Model {
-    window_id: window::Id,
-    texture: wgpu::Texture,
+    texture: Handle<Image>,
 }
 
 fn model(app: &App) -> Model {
-    let window_id = app.new_window().size(512, 512).view(view).build().unwrap();
+    app.new_window().size(512, 512).view(view).build();
 
     // Load the image from disk and upload it to a GPU texture.
-    let assets = app.assets_path().unwrap();
+    let assets = app.assets_path();
     let img_path = assets.join("images").join("nature").join("nature_1.jpg");
-    let texture = wgpu::Texture::from_path(app, img_path).unwrap();
+    let texture = app.asset_server().load(img_path);
 
-    Model { window_id, texture }
+    Model { texture }
 }
 
 // Draw the state of your `Model` into the given `Frame` here.
-fn view(app: &App, model: &Model, frame: Frame) {
-    frame.clear(DIMGRAY);
-    let window = app.window(model.window_id).unwrap();
-    let win_rect = window.rect();
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
+    draw.background().color(DIM_GRAY);
+    let win_rect = app.window_rect();
 
     // Generate the triangulated points for a cuboid to use for out mesh.
     let centre = pt3(0.0, 0.0, 0.0);
@@ -44,13 +42,13 @@ fn view(app: &App, model: &Model, frame: Frame) {
 
     // Scale the points up to half the window size.
     let cube_side = win_rect.w().min(win_rect.h()) * 0.5;
+    let t = app.time();
     draw.scale(cube_side)
         .mesh()
-        .points_textured(&model.texture, points)
-        .z_radians(app.time * 0.33)
-        .x_radians(app.time * 0.166 + -app.mouse.y / 100.0)
-        .y_radians(app.time * 0.25 + app.mouse.x / 100.0);
+        .points_textured(model.texture.clone(), points)
+        .z_radians(t * 0.33)
+        .x_radians(t * 0.166 + -app.mouse().x / 100.0)
+        .y_radians(t * 0.25 + app.mouse().x / 100.0);
 
     // Draw to the frame!
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/examples/draw/draw_textured_path.rs b/examples/draw/draw_textured_path.rs
index 00510111f..dedfbfcaf 100644
--- a/examples/draw/draw_textured_path.rs
+++ b/examples/draw/draw_textured_path.rs
@@ -5,31 +5,30 @@ fn main() {
 }
 
 struct Model {
-    window_id: window::Id,
-    texture: wgpu::Texture,
+    window_id: Entity,
+    texture: Handle<Image>,
 }
 
 fn model(app: &App) -> Model {
-    let window_id = app.new_window().size(512, 512).view(view).build().unwrap();
+    let window_id = app.new_window().size(512, 512).view(view).build();
 
     // Load the image from disk and upload it to a GPU texture.
-    let assets = app.assets_path().unwrap();
+    let assets = app.assets_path();
     let img_path = assets.join("images").join("nature").join("nature_1.jpg");
-    let texture = wgpu::Texture::from_path(app, img_path).unwrap();
+    let texture = app.asset_server().load(img_path);
 
     Model { window_id, texture }
 }
 
 // Draw the state of your `Model` into the given `Frame` here.
-fn view(app: &App, model: &Model, frame: Frame) {
-    frame.clear(DIMGRAY);
-    let window = app.window(model.window_id).unwrap();
-    let win_rect = window.rect();
+fn view(app: &App, model: &Model) {
+    let win_rect = app.window_rect();
     let draw = app.draw();
+    draw.background().color(DIM_GRAY);
 
     // Generate a spiral for the path to follow.
     // Modulate the frequency of the spiral with a wave over time.
-    let wave = (app.time * 0.125).cos();
+    let wave = (app.time() * 0.125).cos();
     let freq = map_range(wave, -1.0, 1.0, 2.0, 20.0);
     let spiral_side = win_rect.w().min(win_rect.h()) * 0.5;
     let points = (0..spiral_side as u32).map(|i| {
@@ -40,7 +39,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
         let point = pt2(x, y) * mag;
         // Retrieve the texture points based on the position of the spiral.
         let tex_coords = [x * 0.5 + 0.5, 1.0 - (point.y * 0.5 + 0.5)];
-        (point, tex_coords)
+        (point, Color::WHITE, tex_coords)
     });
 
     // Scale the points up to half the window size.
@@ -48,9 +47,9 @@ fn view(app: &App, model: &Model, frame: Frame) {
         .path()
         .stroke()
         .weight(0.9 / freq)
-        .points_textured(&model.texture, points)
-        .rotate(app.time * 0.25);
+        .points_vertex(points)
+        .texture(&model.texture)
+        .rotate(app.time() * 0.25);
 
     // Draw to the frame!
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/examples/draw/draw_textured_polygon.rs b/examples/draw/draw_textured_polygon.rs
index 51bc7e9f8..ecaaf0e09 100644
--- a/examples/draw/draw_textured_polygon.rs
+++ b/examples/draw/draw_textured_polygon.rs
@@ -5,27 +5,26 @@ fn main() {
 }
 
 struct Model {
-    window_id: window::Id,
-    texture: wgpu::Texture,
+    window_id: Entity,
+    texture: Handle<Image>,
 }
 
 fn model(app: &App) -> Model {
-    let window_id = app.new_window().size(512, 512).view(view).build().unwrap();
+    let window_id = app.new_window().size(512, 512).view(view).build();
 
     // Load the image from disk and upload it to a GPU texture.
-    let assets = app.assets_path().unwrap();
+    let assets = app.assets_path();
     let img_path = assets.join("images").join("nature").join("nature_1.jpg");
-    let texture = wgpu::Texture::from_path(app, img_path).unwrap();
+    let texture = app.asset_server().load(img_path);
 
     Model { window_id, texture }
 }
 
 // Draw the state of your `Model` into the given `Frame` here.
-fn view(app: &App, model: &Model, frame: Frame) {
-    frame.clear(DIMGRAY);
-    let window = app.window(model.window_id).unwrap();
-    let win_rect = window.rect();
+fn view(app: &App, model: &Model) {
+    let win_rect = app.window_rect();
     let draw = app.draw();
+    draw.background().color(DIM_GRAY);
 
     // We'll make a wave from an ellipse with a wave added onto its circumference.
     let resolution = win_rect.right().floor();
@@ -33,8 +32,8 @@ fn view(app: &App, model: &Model, frame: Frame) {
     let ellipse = geom::Ellipse::new(rect, resolution).circumference();
 
     // The wave's frequency and amplitude are derived from the mouse position.
-    let freq = map_range(app.mouse.x, win_rect.left(), win_rect.right(), 1.0, 20.0);
-    let amp = map_range(app.mouse.y, win_rect.bottom(), win_rect.top(), 0.0, 0.5);
+    let freq = map_range(app.mouse().x, win_rect.left(), win_rect.right(), 1.0, 20.0);
+    let amp = map_range(app.mouse().x, win_rect.bottom(), win_rect.top(), 0.0, 0.5);
     let wave = (0..resolution as usize).map(|i| {
         let phase = i as f32 / resolution;
         (phase * freq * PI * 2.0).sin() * amp
@@ -48,16 +47,14 @@ fn view(app: &App, model: &Model, frame: Frame) {
         let tex_coords = [point.x + 0.5, 1.0 - (point.y + 0.5)];
         // Apply the wave to the points.
         let point = point + point * wave;
-        (point, tex_coords)
+        (point, Color::WHITE, tex_coords)
     });
 
     // Scale the points up to half the window size.
     let ellipse_side = win_rect.w().min(win_rect.h()) * 0.75;
     draw.scale(ellipse_side)
         .polygon()
-        .points_textured(&model.texture, points)
-        .rotate(app.time * 0.25);
-
-    // Draw to the frame!
-    draw.to_frame(app, &frame).unwrap();
+        .points_vertex(points)
+        .texture(&model.texture)
+        .rotate(app.time() * 0.25);
 }
diff --git a/examples/draw/draw_transform.rs b/examples/draw/draw_transform.rs
index ded50d265..875d04346 100644
--- a/examples/draw/draw_transform.rs
+++ b/examples/draw/draw_transform.rs
@@ -11,15 +11,14 @@ fn main() {
     nannou::sketch(view).run()
 }
 
-fn view(app: &App, frame: Frame) {
-    frame.clear(BLACK);
-
+fn view(app: &App) {
     // Begin drawing
     let draw = app.draw();
+    draw.background().color(BLACK);
     let w = app.window_rect();
 
     // Slowly turn the whole drawing inside out.
-    let draw = draw.scale((app.time * 0.1).cos());
+    let draw = draw.scale((app.time() * 0.1).cos());
 
     // Draw a tunnel of rectangles.
     let max_side = w.right().max(w.top());
@@ -30,12 +29,12 @@ fn view(app: &App, frame: Frame) {
 
         // Return a new rotated draw instance.
         // This will rotate both the rect and text around the origin.
-        let rotate = (app.time * 0.5).sin() * (app.time * 0.25 + f * PI * 2.0).cos();
+        let rotate = (app.time() * 0.5).sin() * (app.time() * 0.25 + f * PI * 2.0).cos();
         let draw = draw.rotate(rotate);
 
-        let hue = app.time + f * 2.0 * PI;
-        let dive = (f + app.time * 0.1) % 1.0;
-        let color = hsla(hue, 0.5, 0.5, 1.0 - dive.powi(3));
+        let hue = app.time() + f * 2.0 * PI;
+        let dive = (f + app.time() * 0.1) % 1.0;
+        let color = Color::hsla(hue, 0.5, 0.5, 1.0 - dive.powi(3));
         let rect_scale = dive.powi(2) * max_side * 2.0;
         draw.scale(rect_scale)
             .rect()
@@ -53,7 +52,4 @@ fn view(app: &App, frame: Frame) {
             .color(color)
             .font_size(96);
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/examples/isf/isf_demo.rs b/examples/isf/isf_demo.rs
deleted file mode 100644
index 3c9636aaf..000000000
--- a/examples/isf/isf_demo.rs
+++ /dev/null
@@ -1,112 +0,0 @@
-// NOTE: This example is a work-in-progress
-
-use nannou::prelude::*;
-use nannou_isf::{IsfPipeline, IsfTime};
-
-fn main() {
-    nannou::app(model).update(update).run();
-}
-
-struct Model {
-    watch: hotglsl::Watch,
-    isf_pipeline: IsfPipeline,
-    isf_time: IsfTime,
-}
-
-fn model(app: &App) -> Model {
-    app.new_window().view(view).build().unwrap();
-
-    // Watch the shader directory.
-    let assets = app.assets_path().unwrap();
-    let images_dir = assets.join("images");
-    let shader_dir = assets.join("isf");
-    let watch = hotglsl::watch(&shader_dir).unwrap();
-
-    // Create the hotloaded render pipeline.
-    let window = app.main_window();
-    let device = window.device();
-    let vs_path = None;
-    let fs_path = shader_dir.join("Test-Float.fs");
-    let dst_format = Frame::TEXTURE_FORMAT;
-    let sample_count = window.msaa_samples();
-    let desc = wgpu::CommandEncoderDescriptor {
-        label: Some("nannou_isf_pipeline_new"),
-    };
-    let mut encoder = device.create_command_encoder(&desc);
-    let (dst_w, dst_h) = window.inner_size_pixels();
-    let isf_pipeline = IsfPipeline::new(
-        device,
-        &mut encoder,
-        vs_path,
-        fs_path,
-        dst_format,
-        [dst_w, dst_h],
-        sample_count,
-        &images_dir,
-    );
-    window.queue().submit(Some(encoder.finish()));
-
-    let isf_time = Default::default();
-
-    Model {
-        watch,
-        isf_pipeline,
-        isf_time,
-    }
-}
-
-fn update(app: &App, model: &mut Model, update: Update) {
-    let window = app.main_window();
-    let device = window.device();
-    // Feed new compilation result to the render pipeline for hotloading.
-    let touched_shaders = model.watch.paths_touched().unwrap();
-    let assets = app.assets_path().unwrap();
-    let images_dir = assets.join("images");
-    let desc = wgpu::CommandEncoderDescriptor {
-        label: Some("nannou_isf_pipeline_update"),
-    };
-    let mut encoder = device.create_command_encoder(&desc);
-    model
-        .isf_pipeline
-        .encode_update(device, &mut encoder, &images_dir, touched_shaders);
-    window.queue().submit(Some(encoder.finish()));
-    model.isf_time.time = update.since_start.secs() as _;
-    model.isf_time.time_delta = update.since_last.secs() as _;
-}
-
-fn view(app: &App, model: &Model, frame: Frame) {
-    frame.clear(BLACK);
-
-    // Encode a command to draw the render pipeline to the frame's texture.
-    model.isf_pipeline.encode_to_frame(&frame, model.isf_time);
-
-    // Draw some feedback.
-    let win = app.window_rect();
-    let draw = app.draw();
-    let (vs_string, vs_color) = match model.isf_pipeline.vs_err() {
-        None => (format!("Vertex Shader: Compiled Successfully!"), GREEN),
-        Some(e) => (format!("Vertex Shader:\n{}", e), RED),
-    };
-    let (fs_string, fs_color) = match model.isf_pipeline.fs_err() {
-        None => (format!("Fragment Shader: Compiled Successfully!"), GREEN),
-        Some(e) => (format!("Fragment Shader:\n{}", e), RED),
-    };
-    let win_p = win.pad(30.0);
-    let text_area = geom::Rect::from_wh(win_p.wh()).top_left_of(win_p);
-    draw.text(&vs_string)
-        .xy(text_area.xy())
-        .wh(text_area.wh())
-        .font_size(16)
-        .align_text_top()
-        .left_justify()
-        .color(vs_color);
-    let text_area = text_area.shift_y(-30.0);
-    draw.text(&fs_string)
-        .xy(text_area.xy())
-        .wh(text_area.wh())
-        .font_size(16)
-        .align_text_top()
-        .left_justify()
-        .color(fs_color);
-    draw.to_frame(app, &frame).unwrap();
-}
diff --git a/examples/isf/simple.rs b/examples/isf/simple.rs
new file mode 100644
index 000000000..f732a169a
--- /dev/null
+++ b/examples/isf/simple.rs
@@ -0,0 +1,52 @@
+use nannou::prelude::*;
+
+fn main() {
+    nannou::app(model).update(update).run();
+}
+
+#[derive(Reflect)]
+struct Model {
+    window: Entity,
+    camera: Entity,
+    isf: Handle<Isf>,
+    texture_1: Handle<Image>,
+    texture_2: Handle<Image>,
+}
+
+fn model(app: &App) -> Model {
+    let camera = app.new_camera().build();
+    let window = app
+        .new_window()
+        .camera(camera)
+        .primary()
+        .size_pixels(1024, 512)
+        .view(view)
+        .build();
+
+    let isf = app.asset_server().load("isf/Test-MultiPassRendering.fs");
+    let texture_1 = app.asset_server().load("images/nature/nature_1.jpg");
+    let texture_2 = app.asset_server().load("images/nature/nature_2.jpg");
+    Model {
+        window,
+        camera,
+        isf,
+        texture_1,
+        texture_2,
+    }
+}
+
+fn update(app: &App, model: &mut Model) {
+    let Some(isf) = app.assets_mut::<Isf>().get(&model.isf) else {
+        return;
+    };
+
+    let mut inputs = app.resource_mut::<IsfInputs>();
+    inputs.insert(
+        "inputImage".to_string(),
+        IsfInputValue::Image(model.texture_1.clone()),
+    );
+}
+
+fn view(app: &App, model: &Model) {
+    let draw = app.draw();
+}
diff --git a/examples/laser/laser_frame_stream.rs b/examples/laser/laser_frame_stream.rs
index ca4d3616e..44f077c4e 100644
--- a/examples/laser/laser_frame_stream.rs
+++ b/examples/laser/laser_frame_stream.rs
@@ -34,11 +34,7 @@ pub enum TestPattern {
 
 fn model(app: &App) -> Model {
     // Create a window to receive keyboard events.
-    app.new_window()
-        .key_pressed(key_pressed)
-        .view(view)
-        .build()
-        .unwrap();
+    app.new_window().key_pressed(key_pressed).view(view).build();
 
     // Initialise the state that we want to live on the laser thread and spawn the stream.
     let laser_model = Laser {
@@ -88,8 +84,8 @@ fn laser(laser: &mut Laser, frame: &mut laser::Frame) {
             let yb = [0.0, 1.0];
             let x = [lit_p(xa), lit_p(xb)];
             let y = [lit_p(ya), lit_p(yb)];
-            frame.add_lines(&x);
-            frame.add_lines(&y);
+            frame.add_lines(x);
+            frame.add_lines(y);
         }
 
         TestPattern::ThreeVerticalLines => {
@@ -102,14 +98,14 @@ fn laser(laser: &mut Laser, frame: &mut laser::Frame) {
             let l = [lit_p(la), lit_p(lb)];
             let m = [lit_p(ma), lit_p(mb)];
             let r = [lit_p(ra), lit_p(rb)];
-            frame.add_lines(&l);
-            frame.add_lines(&m);
-            frame.add_lines(&r);
+            frame.add_lines(l);
+            frame.add_lines(m);
+            frame.add_lines(r);
         }
 
         TestPattern::Circle => {
             let n_points = frame.points_per_frame() as usize / 4;
-            let rect = Rect::from_w_h(1.0, 1.0);
+            let rect = geom::Rect::from_w_h(1.0, 1.0);
             let ellipse: Vec<_> = geom::ellipse::Circumference::new(rect, n_points as f32)
                 .map(|[x, y]| lit_p([x, y]))
                 .collect();
@@ -136,15 +132,15 @@ fn laser(laser: &mut Laser, frame: &mut laser::Frame) {
     }
 }
 
-fn key_pressed(_app: &App, model: &mut Model, key: Key) {
+fn key_pressed(_app: &App, model: &mut Model, key: KeyCode) {
     // Send a new pattern to the laser on keys 1, 2, 3 and 4.
     let new_pattern = match key {
-        Key::Key1 => TestPattern::Rectangle,
-        Key::Key2 => TestPattern::Triangle,
-        Key::Key3 => TestPattern::Crosshair,
-        Key::Key4 => TestPattern::ThreeVerticalLines,
-        Key::Key5 => TestPattern::Circle,
-        Key::Key6 => TestPattern::Spiral,
+        KeyCode::Digit1 => TestPattern::Rectangle,
+        KeyCode::Digit2 => TestPattern::Triangle,
+        KeyCode::Digit3 => TestPattern::Crosshair,
+        KeyCode::Digit4 => TestPattern::ThreeVerticalLines,
+        KeyCode::Digit5 => TestPattern::Circle,
+        KeyCode::Digit6 => TestPattern::Spiral,
         _ => return,
     };
     model
@@ -155,6 +151,7 @@ fn key_pressed(_app: &App, model: &mut Model, key: Key) {
         .unwrap();
 }
 
-fn view(_app: &App, _model: &Model, frame: Frame) {
-    frame.clear(DIMGRAY);
+fn view(app: &App, _model: &Model) {
+    let draw = app.draw();
+    draw.background().color(DIM_GRAY);
 }
diff --git a/examples/laser/laser_frame_stream_gui.rs b/examples/laser/laser_frame_stream_gui.rs
index e69d8b9b1..77272cd34 100644
--- a/examples/laser/laser_frame_stream_gui.rs
+++ b/examples/laser/laser_frame_stream_gui.rs
@@ -1,12 +1,11 @@
 //! A clone of the `laser_frame_stream.rs` example that allows for configuring laser settings via a
 //! UI.
 
-use nannou::geom::Rect;
+use std::sync::{mpsc, Arc};
+
+use nannou::prelude::egui::FontId;
 use nannou::prelude::*;
-use nannou_egui::egui::FontId;
-use nannou_egui::{self, egui, Egui};
 use nannou_laser as laser;
-use std::sync::{mpsc, Arc};
 
 fn main() {
     nannou::app(model).update(update).run();
@@ -23,8 +22,8 @@ struct Model {
     laser_settings: LaserSettings,
     // For receiving newly detected DACs.
     dac_rx: mpsc::Receiver<laser::DetectedDac>,
-    // The UI for control over laser parameters and settings.
-    egui: Egui,
+    // The egui window.
+    window: Entity,
 }
 
 #[derive(Clone)]
@@ -113,14 +112,12 @@ impl Default for RgbProfile {
 
 fn model(app: &App) -> Model {
     // Create a window to receive keyboard events.
-    let w_id = app
+    let window = app
         .new_window()
         .size(312, 530)
         .key_pressed(key_pressed)
-        .raw_event(raw_window_event)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     // Initialise the state that we want to live on the laser thread and spawn the stream.
     let laser_settings = LaserSettings::default();
@@ -154,9 +151,9 @@ fn model(app: &App) -> Model {
     let laser_streams = vec![];
 
     // A user-interface to tweak the settings.
-    let window = app.window(w_id).unwrap();
-    let egui = Egui::from_window(&window);
-    egui.ctx().set_style(style());
+    let mut egui_ctx = app.egui();
+    let ctx = egui_ctx.get_mut();
+    ctx.set_style(style());
 
     Model {
         laser_api,
@@ -164,7 +161,7 @@ fn model(app: &App) -> Model {
         laser_model,
         laser_streams,
         dac_rx,
-        egui,
+        window,
     }
 }
 
@@ -175,7 +172,7 @@ where
     I::Item: AsRef<laser::Point>,
 {
     let points = points.into_iter().map(|p| {
-        let mut p = p.as_ref().clone();
+        let mut p = *p.as_ref();
         p.position[0] *= scale;
         p.position[1] *= scale;
         p
@@ -224,8 +221,8 @@ fn laser(laser: &mut Laser, frame: &mut laser::Frame) {
             let yb = [0.0, 1.0];
             let x = [lit_p(xa), lit_p(xb)];
             let y = [lit_p(ya), lit_p(yb)];
-            add_points(&x, laser.draw_mode, laser.scale, frame);
-            add_points(&y, laser.draw_mode, laser.scale, frame);
+            add_points(x, laser.draw_mode, laser.scale, frame);
+            add_points(y, laser.draw_mode, laser.scale, frame);
         }
 
         TestPattern::ThreeVerticalLines => {
@@ -238,14 +235,14 @@ fn laser(laser: &mut Laser, frame: &mut laser::Frame) {
             let l = [lit_p(la), lit_p(lb)];
             let m = [lit_p(ma), lit_p(mb)];
             let r = [lit_p(ra), lit_p(rb)];
-            add_points(&l, laser.draw_mode, laser.scale, frame);
-            add_points(&m, laser.draw_mode, laser.scale, frame);
-            add_points(&r, laser.draw_mode, laser.scale, frame);
+            add_points(l, laser.draw_mode, laser.scale, frame);
+            add_points(m, laser.draw_mode, laser.scale, frame);
+            add_points(r, laser.draw_mode, laser.scale, frame);
         }
 
         TestPattern::Circle => {
             let n_points = frame.points_per_frame() as usize / 4;
-            let rect = Rect::from_w_h(2.0, 2.0);
+            let rect = geom::Rect::from_w_h(2.0, 2.0);
             let ellipse: Vec<_> = geom::ellipse::Circumference::new(rect, n_points as f32)
                 .map(|[x, y]| lit_p([x, y]))
                 .collect();
@@ -272,11 +269,7 @@ fn laser(laser: &mut Laser, frame: &mut laser::Frame) {
     }
 }
 
-fn raw_window_event(_app: &App, model: &mut Model, event: &nannou::winit::event::WindowEvent) {
-    model.egui.handle_raw_event(event);
-}
-
-fn update(_app: &App, model: &mut Model, update: Update) {
+fn update(app: &App, model: &mut Model) {
     // First, check for new laser DACs.
     for dac in model.dac_rx.try_iter() {
         println!("Detected DAC {:?}!", dac.id());
@@ -323,18 +316,17 @@ fn update(_app: &App, model: &mut Model, update: Update) {
 
     // Update the GUI.
     let Model {
-        ref mut egui,
         ref laser_streams,
         ref mut laser_model,
         ref mut laser_settings,
         ..
     } = *model;
 
-    egui.set_elapsed_time(update.since_start);
-    let ctx = egui.begin_frame();
+    let mut egui_ctx = app.egui();
+    let ctx = egui_ctx.get_mut();
 
     // The timeline area.
-    egui::containers::CentralPanel::default().show(&ctx, |ui| {
+    egui::containers::CentralPanel::default().show(ctx, |ui| {
         fn grid_min_col_width(ui: &egui::Ui, n_options: usize) -> f32 {
             let gap_space = ui.spacing().item_spacing.x * (n_options as f32 - 1.0);
             let grid_w = ui.available_width();
@@ -485,15 +477,15 @@ fn update(_app: &App, model: &mut Model, update: Update) {
     });
 }
 
-fn key_pressed(_app: &App, model: &mut Model, key: Key) {
+fn key_pressed(_app: &App, model: &mut Model, key: KeyCode) {
     // Send a new pattern to the laser on keys 1, 2, 3 and 4.
     let new_pattern = match key {
-        Key::Key1 => TestPattern::Rectangle,
-        Key::Key2 => TestPattern::Triangle,
-        Key::Key3 => TestPattern::Crosshair,
-        Key::Key4 => TestPattern::ThreeVerticalLines,
-        Key::Key5 => TestPattern::Circle,
-        Key::Key6 => TestPattern::Spiral,
+        KeyCode::Digit1 => TestPattern::Rectangle,
+        KeyCode::Digit2 => TestPattern::Triangle,
+        KeyCode::Digit3 => TestPattern::Crosshair,
+        KeyCode::Digit4 => TestPattern::ThreeVerticalLines,
+        KeyCode::Digit5 => TestPattern::Circle,
+        KeyCode::Digit6 => TestPattern::Spiral,
         _ => return,
     };
     for stream in &model.laser_streams {
@@ -503,9 +495,7 @@ fn key_pressed(_app: &App, model: &mut Model, key: Key) {
     }
 }
 
-fn view(_app: &App, model: &Model, frame: Frame) {
-    model.egui.draw_to_frame(&frame).unwrap();
-}
+fn view(_app: &App, model: &Model) {}
 
 // The following functions are some custom styling preferences in an attempt to improve on the
 // default egui theming.
diff --git a/examples/laser/laser_ilda_idtf.rs b/examples/laser/laser_ilda_idtf.rs
index b0c94e197..0ad74e8e5 100644
--- a/examples/laser/laser_ilda_idtf.rs
+++ b/examples/laser/laser_ilda_idtf.rs
@@ -7,11 +7,12 @@
 //! cargo run --release -p examples --example laser_ilda_idtf -- /path/to/ilda/files
 //! ```
 
+use std::path::{Path, PathBuf};
+use std::time::{Duration, Instant};
+
 use nannou::prelude::*;
 use nannou_laser as laser;
 use nannou_laser::ilda_idtf::BufFileFrameReader;
-use std::path::{Path, PathBuf};
-use std::time::{Duration, Instant};
 
 fn main() {
     nannou::app(model).run();
@@ -31,7 +32,7 @@ struct Laser {
 
 fn model(app: &App) -> Model {
     // Create a window to receive keyboard events.
-    app.new_window().view(view).build().unwrap();
+    app.new_window().view(view).build();
 
     // Test file directory from the command line.
     let test_files = match std::env::args().nth(1) {
@@ -50,7 +51,7 @@ fn model(app: &App) -> Model {
     let current_path = 0;
     let path = &ilda_paths[current_path];
     let last_change = Instant::now();
-    let frame_reader = BufFileFrameReader::open(&path).unwrap();
+    let frame_reader = BufFileFrameReader::open(path).unwrap();
     let laser_model = Laser {
         ilda_paths,
         last_change,
@@ -76,8 +77,9 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn view(_app: &App, _model: &Model, frame: Frame) {
-    frame.clear(DIMGRAY);
+fn view(app: &App, _model: &Model) {
+    let draw = app.draw();
+    draw.background().color(DIM_GRAY);
 }
 
 fn laser(laser: &mut Laser, frame: &mut laser::Frame) {
@@ -103,7 +105,7 @@ fn laser(laser: &mut Laser, frame: &mut laser::Frame) {
         laser.current_path %= laser.ilda_paths.len();
         let path = &laser.ilda_paths[laser.current_path];
         println!("{}", path.display());
-        laser.frame_reader = BufFileFrameReader::open(&path).unwrap();
+        laser.frame_reader = BufFileFrameReader::open(path).unwrap();
     }
 }
 
diff --git a/examples/laser/laser_raw_stream.rs b/examples/laser/laser_raw_stream.rs
index 9afb7594b..f84356161 100644
--- a/examples/laser/laser_raw_stream.rs
+++ b/examples/laser/laser_raw_stream.rs
@@ -20,11 +20,7 @@ struct Laser {
 
 fn model(app: &App) -> Model {
     // Create a window to receive mouse events.
-    app.new_window()
-        .mouse_moved(mouse_moved)
-        .view(view)
-        .build()
-        .unwrap();
+    app.new_window().mouse_moved(mouse_moved).view(view).build();
 
     // Initialise the state that we want to live on the laser thread and spawn the stream.
     let laser_model = Laser {
@@ -76,10 +72,9 @@ fn mouse_moved(app: &App, model: &mut Model, pos: Point2) {
         .unwrap();
 }
 
-fn view(app: &App, _model: &Model, frame: Frame) {
+fn view(app: &App, _model: &Model) {
     // Visualise the point in the window.
     let draw = app.draw();
-    draw.background().color(DIMGRAY);
-    draw.ellipse().w_h(5.0, 5.0).xy(app.mouse.position());
-    draw.to_frame(app, &frame).unwrap();
+    draw.background().color(DIM_GRAY);
+    draw.ellipse().w_h(5.0, 5.0).xy(app.mouse());
 }
diff --git a/examples/nannou_basics/all_functions.rs b/examples/nannou_basics/all_functions.rs
index 6d6fd7f32..b7435fae3 100644
--- a/examples/nannou_basics/all_functions.rs
+++ b/examples/nannou_basics/all_functions.rs
@@ -1,11 +1,7 @@
 use nannou::prelude::*;
 
 fn main() {
-    nannou::app(model)
-        .event(event)
-        .update(update)
-        .view(view)
-        .run();
+    nannou::app(model).update(update).view(view).run();
 }
 
 struct Model {}
@@ -13,8 +9,6 @@ struct Model {}
 fn model(app: &App) -> Model {
     app.new_window()
         .size(720, 720)
-        .event(window_event)
-        .raw_event(raw_window_event)
         .key_pressed(key_pressed)
         .key_released(key_released)
         .mouse_moved(mouse_moved)
@@ -24,7 +18,6 @@ fn model(app: &App) -> Model {
         .mouse_entered(mouse_entered)
         .mouse_exited(mouse_exited)
         .touch(touch)
-        .touchpad_pressure(touchpad_pressure)
         .moved(window_moved)
         .resized(window_resized)
         .hovered_file(hovered_file)
@@ -33,60 +26,20 @@ fn model(app: &App) -> Model {
         .focused(window_focused)
         .unfocused(window_unfocused)
         .closed(window_closed)
-        .build()
-        .unwrap();
+        .build();
     Model {}
 }
 
-fn event(_app: &App, _model: &mut Model, event: Event) {
-    match event {
-        Event::WindowEvent {
-            id: _,
-            //raw: _,
-            simple: _,
-        } => {}
-        Event::DeviceEvent(_device_id, _event) => {}
-        Event::Update(_dt) => {}
-        Event::Suspended => {}
-        Event::Resumed => {}
-    }
-}
-
-fn update(_app: &App, _model: &mut Model, _update: Update) {}
-
-fn view(_app: &App, _model: &Model, frame: Frame) {
-    frame.clear(SKYBLUE);
-}
+fn update(_app: &App, _model: &mut Model) {}
 
-fn window_event(_app: &App, _model: &mut Model, event: WindowEvent) {
-    match event {
-        KeyPressed(_key) => {}
-        KeyReleased(_key) => {}
-        ReceivedCharacter(_char) => {}
-        MouseMoved(_pos) => {}
-        MousePressed(_button) => {}
-        MouseReleased(_button) => {}
-        MouseEntered => {}
-        MouseExited => {}
-        MouseWheel(_amount, _phase) => {}
-        Moved(_pos) => {}
-        Resized(_size) => {}
-        Touch(_touch) => {}
-        TouchPressure(_pressure) => {}
-        HoveredFile(_path) => {}
-        DroppedFile(_path) => {}
-        HoveredFileCancelled => {}
-        Focused => {}
-        Unfocused => {}
-        Closed => {}
-    }
+fn view(app: &App, _model: &Model, _entity: Entity) {
+    let draw = app.draw();
+    draw.background().color(SKY_BLUE);
 }
 
-fn raw_window_event(_app: &App, _model: &mut Model, _event: &nannou::winit::event::WindowEvent) {}
-
-fn key_pressed(_app: &App, _model: &mut Model, _key: Key) {}
+fn key_pressed(_app: &App, _model: &mut Model, _key: KeyCode) {}
 
-fn key_released(_app: &App, _model: &mut Model, _key: Key) {}
+fn key_released(_app: &App, _model: &mut Model, _key: KeyCode) {}
 
 fn mouse_moved(_app: &App, _model: &mut Model, _pos: Point2) {}
 
@@ -94,17 +47,15 @@ fn mouse_pressed(_app: &App, _model: &mut Model, _button: MouseButton) {}
 
 fn mouse_released(_app: &App, _model: &mut Model, _button: MouseButton) {}
 
-fn mouse_wheel(_app: &App, _model: &mut Model, _dt: MouseScrollDelta, _phase: TouchPhase) {}
+fn mouse_wheel(_app: &App, _model: &mut Model, _wheel: MouseWheel) {}
 
 fn mouse_entered(_app: &App, _model: &mut Model) {}
 
 fn mouse_exited(_app: &App, _model: &mut Model) {}
 
-fn touch(_app: &App, _model: &mut Model, _touch: TouchEvent) {}
-
-fn touchpad_pressure(_app: &App, _model: &mut Model, _pressure: TouchpadPressure) {}
+fn touch(_app: &App, _model: &mut Model, _touch: TouchInput) {}
 
-fn window_moved(_app: &App, _model: &mut Model, _pos: Point2) {}
+fn window_moved(_app: &App, _model: &mut Model, _pos: IVec2) {}
 
 fn window_resized(_app: &App, _model: &mut Model, _dim: Vec2) {}
 
diff --git a/examples/nannou_basics/loop_mode.rs b/examples/nannou_basics/loop_mode.rs
deleted file mode 100644
index 32c6d1934..000000000
--- a/examples/nannou_basics/loop_mode.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-//! A simple example demonstrating the behaviour of the three `LoopMode` variants supported by
-//! nannou.
-//!
-//! The `LoopMode` determines how the nannou application loop is driven.
-//!
-//! See the `LoopMode` docs for more details:
-//!
-//! https://docs.rs/nannou/latest/nannou/app/enum.LoopMode.html
-
-use nannou::prelude::*;
-
-fn main() {
-    // Start in `Wait` mode. In other words, don't keep looping, just wait for events.
-    nannou::app(model)
-        .loop_mode(LoopMode::Wait)
-        .update(update)
-        .run();
-}
-
-struct Model;
-
-fn model(app: &App) -> Model {
-    let _window = app
-        .new_window()
-        .title(format!(
-            "`LoopMode` Demonstration - `{:?}`",
-            app.loop_mode()
-        ))
-        .key_pressed(key_pressed)
-        .view(view)
-        .build()
-        .unwrap();
-    Model
-}
-
-fn update(_app: &App, _model: &mut Model, update: Update) {
-    println!("{:?}", update);
-}
-
-fn key_pressed(app: &App, _model: &mut Model, _key: Key) {
-    // Switch to the next loop mode on key pressed.
-    match app.loop_mode() {
-        LoopMode::Wait { .. } => app.set_loop_mode(LoopMode::RefreshSync),
-        LoopMode::RefreshSync { .. } => app.set_loop_mode(LoopMode::rate_fps(60.0)),
-        LoopMode::Rate { .. } => app.set_loop_mode(LoopMode::loop_once()),
-        LoopMode::NTimes { .. } => app.set_loop_mode(LoopMode::Wait),
-    }
-    println!("Loop mode switched to: {:?}", app.loop_mode());
-    let title = format!("`LoopMode` Demonstration - `{:?}`", app.loop_mode());
-    app.main_window().set_title(&title);
-}
-
-fn view(_app: &App, _model: &Model, frame: Frame) {
-    frame.clear(DIMGRAY);
-}
diff --git a/examples/nannou_basics/multi_window.rs b/examples/nannou_basics/multi_window.rs
index 9d5710db8..84b721c23 100644
--- a/examples/nannou_basics/multi_window.rs
+++ b/examples/nannou_basics/multi_window.rs
@@ -5,52 +5,47 @@ fn main() {
 }
 
 struct Model {
-    a: WindowId,
-    b: WindowId,
-    c: WindowId,
+    a: Entity,
+    b: Entity,
+    c: Entity,
 }
 
 fn model(app: &App) -> Model {
-    let a = app
-        .new_window()
-        .title("window a")
-        .event(event_a)
-        .build()
-        .unwrap();
-    let b = app
-        .new_window()
-        .title("window b")
-        .event(event_b)
-        .build()
-        .unwrap();
-    let c = app
-        .new_window()
-        .title("window c")
-        .event(event_c)
-        .build()
-        .unwrap();
+    let a = app.new_window().focused(focus_a).title("window a").build();
+    let b = app.new_window().focused(focus_b).title("window b").build();
+    let c = app.new_window().focused(focus_c).title("window c").build();
     Model { a, b, c }
 }
 
-fn update(_app: &App, _model: &mut Model, _update: Update) {}
-
-fn event_a(_app: &App, _model: &mut Model, event: WindowEvent) {
-    println!("window a: {:?}", event);
+fn focus_a(app: &App, model: &mut Model) {
+    info!("focusing window a");
 }
 
-fn event_b(_app: &App, _model: &mut Model, event: WindowEvent) {
-    println!("window b: {:?}", event);
+fn focus_b(app: &App, model: &mut Model) {
+    info!("focusing window b");
 }
 
-fn event_c(_app: &App, _model: &mut Model, event: WindowEvent) {
-    println!("window c: {:?}", event);
+fn focus_c(app: &App, model: &mut Model) {
+    info!("focusing window c");
 }
 
-fn view(_app: &App, model: &Model, frame: Frame) {
-    match frame.window_id() {
-        id if id == model.a => frame.clear(INDIANRED),
-        id if id == model.b => frame.clear(LIGHTGREEN),
-        id if id == model.c => frame.clear(CORNFLOWERBLUE),
-        _ => (),
-    }
+fn update(_app: &App, _model: &mut Model) {}
+
+fn view(app: &App, model: &Model, window: Entity) {
+    let draw = app.draw_for_window(window);
+    match window {
+        id if id == model.a => {
+            draw.tri().color(RED);
+            draw.background().color(INDIAN_RED)
+        }
+        id if id == model.b => {
+            draw.tri().color(GREEN);
+            draw.background().color(LIGHT_GREEN)
+        }
+        id if id == model.c => {
+            draw.tri().color(BLUE);
+            draw.background().color(CORNFLOWER_BLUE)
+        }
+        _ => panic!("unexpected window entity"),
+    };
 }
diff --git a/examples/nannou_basics/multi_window_draw.rs b/examples/nannou_basics/multi_window_draw.rs
index 0e045a8e4..a57431b20 100644
--- a/examples/nannou_basics/multi_window_draw.rs
+++ b/examples/nannou_basics/multi_window_draw.rs
@@ -5,64 +5,47 @@ fn main() {
 }
 
 struct Model {
-    a: WindowId,
-    b: WindowId,
-    c: WindowId,
+    a: Entity,
+    b: Entity,
+    c: Entity,
 }
 
 fn model(app: &App) -> Model {
-    let a = app
-        .new_window()
-        .title("window a")
-        .event(event_a)
-        .build()
-        .unwrap();
-    let b = app
-        .new_window()
-        .title("window b")
-        .event(event_b)
-        .build()
-        .unwrap();
-    let c = app
-        .new_window()
-        .title("window c")
-        .event(event_c)
-        .build()
-        .unwrap();
+    let a = app.new_window().title("window a").focused(event_a).build();
+    let b = app.new_window().title("window b").focused(event_b).build();
+    let c = app.new_window().title("window c").focused(event_c).build();
     Model { a, b, c }
 }
 
-fn update(_app: &App, _model: &mut Model, _update: Update) {}
+fn update(_app: &App, _model: &mut Model) {}
 
-fn event_a(_app: &App, _model: &mut Model, event: WindowEvent) {
-    println!("window a: {:?}", event);
+fn event_a(_app: &App, _model: &mut Model) {
+    println!("window a");
 }
 
-fn event_b(_app: &App, _model: &mut Model, event: WindowEvent) {
-    println!("window b: {:?}", event);
+fn event_b(_app: &App, _model: &mut Model) {
+    println!("window b");
 }
 
-fn event_c(_app: &App, _model: &mut Model, event: WindowEvent) {
-    println!("window c: {:?}", event);
+fn event_c(_app: &App, _model: &mut Model) {
+    println!("window c");
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model, window: Entity) {
     let draw = app.draw();
-    match frame.window_id() {
+    match window {
         id if id == model.a => {
-            draw.background().color(INDIANRED);
-            draw.ellipse().color(LIGHTGREEN);
+            draw.background().color(INDIAN_RED);
+            draw.ellipse().color(LIGHT_GREEN);
         }
         id if id == model.b => {
-            draw.background().color(LIGHTGREEN);
-            draw.tri().color(CORNFLOWERBLUE);
+            draw.background().color(LIGHT_GREEN);
+            draw.tri().color(CORNFLOWER_BLUE);
         }
         id if id == model.c => {
-            draw.background().color(CORNFLOWERBLUE);
-            draw.rect().color(INDIANRED);
+            draw.background().color(CORNFLOWER_BLUE);
+            draw.rect().color(INDIAN_RED);
         }
         _ => (),
     }
-
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/examples/nannou_basics/simple_window.rs b/examples/nannou_basics/simple_window.rs
index 63707b19e..eb2312ae3 100644
--- a/examples/nannou_basics/simple_window.rs
+++ b/examples/nannou_basics/simple_window.rs
@@ -6,7 +6,7 @@ fn main() {
 
 struct Model {
     // Store the window ID so we can refer to this specific window later if needed.
-    _window: WindowId,
+    _window: Entity,
 }
 
 fn model(app: &App) -> Model {
@@ -16,18 +16,18 @@ fn model(app: &App) -> Model {
         .size(512, 512)
         .title("nannou")
         .view(view) // The function that will be called for presenting graphics to a frame.
-        .event(event) // The function that will be called when the window receives events.
-        .build()
-        .unwrap();
+        .focused(focus) // The function that will be called when the window receives events.
+        .build();
     Model { _window }
 }
 
 // Handle events related to the window and update the model if necessary
-fn event(_app: &App, _model: &mut Model, event: WindowEvent) {
-    println!("{:?}", event);
+fn focus(_app: &App, _model: &mut Model) {
+    println!("Focused");
 }
 
 // Draw the state of your `Model` into the given `Frame` here.
-fn view(_app: &App, _model: &Model, frame: Frame) {
-    frame.clear(CORNFLOWERBLUE);
+fn view(_app: &App, _model: &Model) {
+    let draw = _app.draw();
+    draw.background().color(CORNFLOWER_BLUE);
 }
diff --git a/examples/nannou_basics/window_coordinates.rs b/examples/nannou_basics/window_coordinates.rs
index 04f1c95c4..25a941ca8 100644
--- a/examples/nannou_basics/window_coordinates.rs
+++ b/examples/nannou_basics/window_coordinates.rs
@@ -4,18 +4,18 @@ fn main() {
     nannou::sketch(view).run()
 }
 
-fn view(app: &App, frame: Frame) {
+fn view(app: &App) {
     let draw = app.draw();
     let window = app.main_window();
     let win = window.rect();
-    draw.background().rgb(0.11, 0.12, 0.13);
+    draw.background().srgb(0.11, 0.12, 0.13);
 
     // 100-step and 10-step grids.
     draw_grid(&draw, &win, 100.0, 1.0);
     draw_grid(&draw, &win, 25.0, 0.5);
 
     // Crosshair.
-    let crosshair_color = gray(0.5);
+    let crosshair_color = Color::gray(0.5);
     let ends = [
         win.mid_top(),
         win.mid_right(),
@@ -68,57 +68,55 @@ fn view(app: &App, frame: Frame) {
         .y(y_off);
 
     // Window and monitor details.
-    if let Some(monitor) = window.current_monitor() {
-        let w_scale_factor = window.scale_factor();
-        let m_scale_factor = monitor.scale_factor();
-        let mon_phys = monitor.size();
-        let mon = mon_phys.to_logical(w_scale_factor as f64);
-        let mon_w: f32 = mon.width;
-        let mon_h: f32 = mon.height;
-        let text = format!(
-            "
-        Window size: [{:.0}, {:.0}]
-        Window ratio: {:.2}
-        Window scale factor: {:.2}
-        Monitor size: [{:.0}, {:.0}]
-        Monitor ratio: {:.2}
-        Monitor scale factor: {:.2}
-        ",
-            win.w(),
-            win.h(),
-            win.w() / win.h(),
-            w_scale_factor,
-            mon_w,
-            mon_h,
-            mon_w / mon_h,
-            m_scale_factor
-        );
-        let pad = 6.0;
-        draw.text(&text)
-            .h(win.pad(pad).h())
-            .w(win.pad(pad).w())
-            .line_spacing(pad)
-            .font_size(14)
-            .align_text_bottom()
-            .color(crosshair_color)
-            .left_justify();
-
-        // Ellipse at mouse.
-        draw.ellipse().wh([5.0; 2].into()).xy(app.mouse.position());
-
-        // Mouse position text.
-        let mouse = app.mouse.position();
-        let pos = format!("[{:.1}, {:.1}]", mouse.x, mouse.y);
-        draw.text(&pos)
-            .xy(mouse + vec2(0.0, 20.0))
-            .font_size(14)
-            .color(WHITE);
-    }
-
-    draw.to_frame(app, &frame).unwrap();
+    // if let Some(monitor) = window.current_monitor() {
+    //     let w_scale_factor = window.scale_factor();
+    //     let m_scale_factor = monitor.scale_factor();
+    //     let mon_phys = monitor.size();
+    //     let mon = mon_phys.to_logical(w_scale_factor as f64);
+    //     let mon_w: f32 = mon.width;
+    //     let mon_h: f32 = mon.height;
+    //     let text = format!(
+    //         "
+    //     Window size: [{:.0}, {:.0}]
+    //     Window ratio: {:.2}
+    //     Window scale factor: {:.2}
+    //     Monitor size: [{:.0}, {:.0}]
+    //     Monitor ratio: {:.2}
+    //     Monitor scale factor: {:.2}
+    //     ",
+    //         win.w(),
+    //         win.h(),
+    //         win.w() / win.h(),
+    //         w_scale_factor,
+    //         mon_w,
+    //         mon_h,
+    //         mon_w / mon_h,
+    //         m_scale_factor
+    //     );
+    //     let pad = 6.0;
+    //     draw.text(&text)
+    //         .h(win.pad(pad).h())
+    //         .w(win.pad(pad).w())
+    //         .line_spacing(pad)
+    //         .font_size(14)
+    //         .align_text_bottom()
+    //         .color(crosshair_color)
+    //         .left_justify();
+    //
+    //     // Ellipse at mouse.
+    //     draw.ellipse().wh([5.0; 2].into()).xy(app.mouse());
+    //
+    //     // Mouse position text.
+    //     let mouse = app.mouse();
+    //     let pos = format!("[{:.1}, {:.1}]", mouse.x, mouse.y);
+    //     draw.text(&pos)
+    //         .xy(mouse + vec2(0.0, 20.0))
+    //         .font_size(14)
+    //         .color(WHITE);
+    // }
 }
 
-fn draw_grid(draw: &Draw, win: &Rect, step: f32, weight: f32) {
+fn draw_grid(draw: &Draw, win: &geom::Rect, step: f32, weight: f32) {
     let step_by = || (0..).map(|i| i as f32 * step);
     let r_iter = step_by().take_while(|&f| f < win.right());
     let l_iter = step_by().map(|f| -f).take_while(|&f| f > win.left());
diff --git a/examples/offline/colors.rs b/examples/offline/colors.rs
index 8f88b3f8e..4f558a7e1 100644
--- a/examples/offline/colors.rs
+++ b/examples/offline/colors.rs
@@ -1,12 +1,10 @@
 // Colors tools
 // Alexis Andre (@mactuitui)
 
-use nannou::color::Hsv;
-use nannou::color::Rgb;
-use nannou::color::Srgb;
+use nannou::prelude::{Hsva, Srgba};
 
 pub struct Palette {
-    pub colors: Vec<Rgb>,
+    pub colors: Vec<Srgba>,
     pub len: usize,
 }
 
@@ -25,40 +23,41 @@ impl Palette {
         let raw_colorsv = raw_colors.to_vec();
 
         //do the conversion myself
-        let mut cols_rgb: Vec<Rgb> = raw_colorsv
+        let mut cols_rgb: Vec<Srgba> = raw_colorsv
             .into_iter()
             .map(|c| {
                 let blue: u8 = (c & 0xFF) as u8;
                 let green: u8 = ((c >> 8) & 0xFF) as u8;
                 let red: u8 = ((c >> 16) & 0xFF) as u8;
-                let c = Srgb::new(
+
+                Srgba::new(
                     red as f32 / 255.0,
                     green as f32 / 255.0,
                     blue as f32 / 255.0,
-                );
-                c
+                    1.0,
+                )
             })
             .collect();
 
         //sort on sat/value/hue
         cols_rgb.sort_unstable_by(|&a, &b| {
-            let ahsv: Hsv = a.into();
-            let bhsv: Hsv = b.into();
+            let ahsv: Hsva = a.into();
+            let bhsv: Hsva = b.into();
             //colors are rgb
             //convert to hsv
-            let ahue = ahsv.hue.to_positive_radians();
-            let bhue = bhsv.hue.to_positive_radians();
+            let ahue = ahsv.hue.to_radians();
+            let bhue = bhsv.hue.to_radians();
             ahue.partial_cmp(&bhue).unwrap()
         });
 
         let len = cols_rgb.len();
         Palette {
             colors: cols_rgb,
-            len: len,
+            len,
         }
     }
 
-    pub fn somecolor_frac(&self, mut frac: f32) -> Rgb {
+    pub fn somecolor_frac(&self, mut frac: f32) -> Srgba {
         while frac < 0.0 {
             frac += 1.0;
         }
diff --git a/examples/offline/quadtree.rs b/examples/offline/quadtree.rs
index 853aa9c47..7561e5ce6 100644
--- a/examples/offline/quadtree.rs
+++ b/examples/offline/quadtree.rs
@@ -95,20 +95,17 @@ impl QuadTree {
     }
 
     pub fn insert_children<T: WithPos>(&mut self, elements: &[T], index: usize) {
-        match self.children.as_mut() {
-            Some(children) => {
-                //TODO faster sort
-                if children[0].contains(&elements[index]) {
-                    children[0].insert(elements, index);
-                } else if children[1].contains(&elements[index]) {
-                    children[1].insert(elements, index);
-                } else if children[2].contains(&elements[index]) {
-                    children[2].insert(elements, index);
-                } else if children[3].contains(&elements[index]) {
-                    children[3].insert(elements, index);
-                }
+        if let Some(children) = self.children.as_mut() {
+            //TODO faster sort
+            if children[0].contains(&elements[index]) {
+                children[0].insert(elements, index);
+            } else if children[1].contains(&elements[index]) {
+                children[1].insert(elements, index);
+            } else if children[2].contains(&elements[index]) {
+                children[2].insert(elements, index);
+            } else if children[3].contains(&elements[index]) {
+                children[3].insert(elements, index);
             }
-            None => {}
         }
     }
 
@@ -121,7 +118,7 @@ impl QuadTree {
             return false;
         }
 
-        return true;
+        true
     }
 
     pub fn get_elements<T: WithPos>(
diff --git a/examples/offline/tree.rs b/examples/offline/tree.rs
index 10260ca6d..ae5ccac96 100644
--- a/examples/offline/tree.rs
+++ b/examples/offline/tree.rs
@@ -1,11 +1,12 @@
 // Daily Sketch 2019-04-22
 // Alexis Andre (@mactuitui)
 
+use nannou::prelude::*;
+
+use crate::colors::Palette;
+
 mod colors;
 mod quadtree;
-use crate::colors::Palette;
-use nannou::prelude::Frame;
-use nannou::prelude::*;
 
 const LENGTH_FRAME: u64 = 700;
 //const START_FRAME: u64 = 0;
@@ -72,13 +73,7 @@ impl Thing {
 }
 
 fn model(app: &App) -> Model {
-    let _window = app
-        .new_window()
-        .size(1024, 1024)
-        .view(view)
-        .event(window_event)
-        .build()
-        .unwrap();
+    let _window = app.new_window().size(1024, 1024).view(view).build();
 
     //create the random values we will need each frame
 
@@ -94,38 +89,10 @@ fn model(app: &App) -> Model {
     let candidate = Thing::new(x, y, size, frac, None);
     things.push(candidate);
 
-    Model {
-        palette: palette,
-        things,
-    }
-}
-
-//nothing to do here
-fn window_event(_app: &App, _model: &mut Model, event: WindowEvent) {
-    match event {
-        KeyPressed(_key) => {}
-        KeyReleased(_key) => {}
-        ReceivedCharacter(_char) => {}
-        MouseMoved(_pos) => {}
-        MousePressed(_button) => {}
-        MouseReleased(_button) => {}
-        MouseEntered => {}
-        MouseExited => {}
-        MouseWheel(_amount, _phase) => {}
-        Moved(_pos) => {}
-        Resized(_size) => {}
-        Touch(_touch) => {}
-        TouchPressure(_pressure) => {}
-        HoveredFile(_path) => {}
-        DroppedFile(_path) => {}
-        HoveredFileCancelled => {}
-        Focused => {}
-        Unfocused => {}
-        Closed => {}
-    }
+    Model { palette, things }
 }
 
-fn update(app: &App, model: &mut Model, _update: Update) {
+fn update(app: &App, model: &mut Model) {
     //try to grow each circle until it hits another one
 
     //recreate the tree
@@ -139,12 +106,10 @@ fn update(app: &App, model: &mut Model, _update: Update) {
         tree.insert(&model.things, i);
     }
     for i in 0..max_count {
-        if model.things[i].parent == None {
-            if app.elapsed_frames() < 1000 {
-                model.things[i].energy += 10000.0;
-                if model.things[i].alive == true {
-                    model.things[i].grown = true;
-                }
+        if model.things[i].parent.is_none() && app.elapsed_frames() < 1000 {
+            model.things[i].energy += 10000.0;
+            if model.things[i].alive {
+                model.things[i].grown = true;
             }
         }
         //move the size to the children
@@ -191,14 +156,12 @@ fn update(app: &App, model: &mut Model, _update: Update) {
                     model.things[i].children.push(s);
                 }
             }
-            if model.things[i].energy > 10.0 {
-                if model.things[i].children.len() > 0 {
-                    model.things[i].energy -= 1.0;
-                    for k in 0..model.things[i].children.len() {
-                        let other = model.things[i].children[k];
-                        model.things[other].energy += 3.0;
-                        model.things[other].grown = true;
-                    }
+            if model.things[i].energy > 10.0 && !model.things[i].children.is_empty() {
+                model.things[i].energy -= 1.0;
+                for k in 0..model.things[i].children.len() {
+                    let other = model.things[i].children[k];
+                    model.things[other].energy += 3.0;
+                    model.things[other].grown = true;
                 }
             }
         }
@@ -206,7 +169,7 @@ fn update(app: &App, model: &mut Model, _update: Update) {
 
     //check if the grown things are free
     for i in 0..model.things.len() {
-        if model.things[i].grown == true {
+        if model.things[i].grown {
             let indices = tree.get_elements(
                 &model.things,
                 model.things[i].position.x,
@@ -231,7 +194,7 @@ fn update(app: &App, model: &mut Model, _update: Update) {
                     }
                 }
             }
-            if model.things[i].alive == true {
+            if model.things[i].alive {
                 if model.things[i].size > 29.0 {
                     model.things[i].alive = false;
                 } else {
@@ -251,7 +214,7 @@ fn update(app: &App, model: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Prepare to draw.
     let draw = app.draw();
 
@@ -264,15 +227,15 @@ fn view(app: &App, model: &Model, frame: Frame) {
     let mut frac_end = (((app.elapsed_frames() + 120) as i32 - LENGTH_FRAME as i32) as f32) / 100.0;
     frac_end = frac_end.max(0.0).min(1.0);
 
-    let c: Rgba = rgba(1.0, 1.0, 1.0, 1.0 - frac_end);
+    let c: Srgba = Color::srgba(1.0, 1.0, 1.0, 1.0 - frac_end).into();
 
     //draw ALL THE THINGS
     for k in 0..model.things.len() {
         //get a color from the palette indexed by frac
-        let mut c2: Rgba = model.palette.somecolor_frac(model.things[k].frac).into();
+        let mut c2: Srgba = model.palette.somecolor_frac(model.things[k].frac);
         // make it fade
         c2.alpha = 1.0 - frac_end;
-        let c3 = rgba(0.0, 0.0, 0.0, 1.0 - frac_end);
+        let c3 = Color::srgba(0.0, 0.0, 0.0, 1.0 - frac_end);
 
         //draw in three steps
         draw.ellipse()
@@ -310,8 +273,5 @@ fn view(app: &App, model: &Model, frame: Frame) {
         }
     }
 
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
-
     //TODO add screenshot
 }
diff --git a/examples/rust_basics/1_nannou_events.rs b/examples/rust_basics/1_nannou_events.rs
index 8be3921bf..57924948e 100644
--- a/examples/rust_basics/1_nannou_events.rs
+++ b/examples/rust_basics/1_nannou_events.rs
@@ -13,51 +13,15 @@ struct Model;
 // This function is where we setup the application and create the `Model` for the first time.
 fn model(app: &App) -> Model {
     // Create a window that can receive user input like mouse and keyboard events.
-    app.new_window().event(event).view(view).build().unwrap();
+    app.new_window().view(view).build();
     Model
 }
 
 // Update the state of your application here. By default, this gets called right before `view`.
-fn update(_app: &App, _model: &mut Model, _update: Update) {}
-
-// We can also update the application based on events received by the window like key presses and
-// mouse movement here.
-fn event(_app: &App, _model: &mut Model, event: WindowEvent) {
-    // Print events as they occur to the console
-    println!("{:?}", event);
-
-    // We can `match` on the event to do something different depending on the kind of event.
-    match event {
-        // Keyboard events
-        KeyPressed(_key) => {}
-        KeyReleased(_key) => {}
-        ReceivedCharacter(_char) => {}
-
-        // Mouse events
-        MouseMoved(_pos) => {}
-        MousePressed(_button) => {}
-        MouseReleased(_button) => {}
-        MouseWheel(_amount, _phase) => {}
-        MouseEntered => {}
-        MouseExited => {}
-
-        // Touch events
-        Touch(_touch) => {}
-        TouchPressure(_pressure) => {}
-
-        // Window events
-        Moved(_pos) => {}
-        Resized(_size) => {}
-        HoveredFile(_path) => {}
-        DroppedFile(_path) => {}
-        HoveredFileCancelled => {}
-        Focused => {}
-        Unfocused => {}
-        Closed => {}
-    }
-}
+fn update(_app: &App, _model: &mut Model) {}
 
 // Put your drawing code, called once per frame, per window.
-fn view(_app: &App, _model: &Model, frame: Frame) {
-    frame.clear(DIMGRAY);
+fn view(app: &App, _model: &Model) {
+    let draw = app.draw();
+    draw.background().color(DIM_GRAY);
 }
diff --git a/examples/rust_basics/2_variables_window_console.rs b/examples/rust_basics/2_variables_window_console.rs
index 3610c8e5f..a92ae36e1 100644
--- a/examples/rust_basics/2_variables_window_console.rs
+++ b/examples/rust_basics/2_variables_window_console.rs
@@ -22,11 +22,12 @@ fn model(app: &App) -> Model {
     println!("message = {}", message);
 
     // Construct and define the size of our window using `.size(width, height)`.
-    app.new_window().size(640, 480).build().unwrap();
+    app.new_window::<Model>().size(640, 480).build();
 
     Model
 }
 
-fn view(_app: &App, _model: &Model, frame: Frame) {
-    frame.clear(DIMGRAY);
+fn view(app: &App, _model: &Model, _entity: Entity) {
+    let draw = app.draw();
+    draw.background().color(DIM_GRAY);
 }
diff --git a/examples/rust_basics/3_variable_scope.rs b/examples/rust_basics/3_variable_scope.rs
index 740aedc48..66f42f64e 100644
--- a/examples/rust_basics/3_variable_scope.rs
+++ b/examples/rust_basics/3_variable_scope.rs
@@ -15,7 +15,12 @@ struct Model {
 
 fn model(app: &App) -> Model {
     // Make a window.
-    app.new_window().event(event).view(view).build().unwrap();
+    app.new_window()
+        .key_pressed(key_pressed)
+        .key_released(key_released)
+        .mouse_pressed(mouse_pressed)
+        .view(view)
+        .build();
     // Initialise our model's fields.
     let foo = 80;
     let bar = 3.14;
@@ -23,23 +28,21 @@ fn model(app: &App) -> Model {
     Model { foo, bar }
 }
 
-fn event(_app: &App, model: &mut Model, event: WindowEvent) {
-    match event {
-        KeyPressed(_key) => {
-            println!("foo = {}", model.foo);
-            println!("bar = {}", model.bar);
-        }
-        KeyReleased(_key) => {
-            let local_var = 94;
-            println!("local_variable to KeyReleased = {}", local_var);
-        }
-        MousePressed(_button) => {
-            println!("global scope: GLOBAL = {}", GLOBAL);
-        }
-        _other => (),
-    }
+fn key_pressed(_app: &App, model: &mut Model, _key: KeyCode) {
+    println!("foo = {}", model.foo);
+    println!("bar = {}", model.bar);
 }
 
-fn view(_app: &App, _model: &Model, frame: Frame) {
-    frame.clear(DIMGRAY);
+fn key_released(_app: &App, _model: &mut Model, _key: KeyCode) {
+    let local_var = 94;
+    println!("local_variable to KeyReleased = {}", local_var);
+}
+
+fn mouse_pressed(_app: &App, _model: &mut Model, _button: MouseButton) {
+    println!("global scope: GLOBAL = {}", GLOBAL);
+}
+
+fn view(app: &App, _model: &Model) {
+    let draw = app.draw();
+    draw.background().color(DIM_GRAY);
 }
diff --git a/examples/rust_basics/4_conditionals.rs b/examples/rust_basics/4_conditionals.rs
index b40ccf168..e1dfc11a5 100644
--- a/examples/rust_basics/4_conditionals.rs
+++ b/examples/rust_basics/4_conditionals.rs
@@ -4,13 +4,13 @@ fn main() {
     nannou::sketch(view).run();
 }
 
-fn view(app: &App, frame: Frame) {
+fn view(app: &App) {
     // Prepare to draw.
     let draw = app.draw();
 
     let win = app.window_rect();
 
-    let color_select = map_range(app.mouse.y, win.top(), win.bottom(), 0.0, 5.0) as i32;
+    let color_select = map_range(app.mouse().x, win.top(), win.bottom(), 0.0, 5.0) as i32;
 
     let bg_color = match color_select {
         0 => RED,
@@ -23,12 +23,11 @@ fn view(app: &App, frame: Frame) {
 
     draw.background().color(bg_color);
 
-    if app.mouse.x < 0.0 {
-        draw.ellipse().color(STEELBLUE);
+    if app.mouse().x < 0.0 {
+        draw.ellipse().color(STEEL_BLUE);
     } else {
-        draw.ellipse().color(SEAGREEN);
+        draw.ellipse().color(SEA_GREEN);
     }
 
     // Draw to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/examples/rust_basics/5_loops.rs b/examples/rust_basics/5_loops.rs
index 06605f870..a5331a251 100644
--- a/examples/rust_basics/5_loops.rs
+++ b/examples/rust_basics/5_loops.rs
@@ -42,6 +42,7 @@ fn model(_app: &App) -> Model {
     Model
 }
 
-fn view(_app: &App, _model: &Model, frame: Frame) {
-    frame.clear(DIMGRAY);
+fn view(app: &App, _model: &Model, window: Entity) {
+    let draw = app.draw();
+    draw.background().color(DIM_GRAY);
 }
diff --git a/examples/rust_basics/6_functions.rs b/examples/rust_basics/6_functions.rs
index 482f696ca..63b224ade 100644
--- a/examples/rust_basics/6_functions.rs
+++ b/examples/rust_basics/6_functions.rs
@@ -7,12 +7,16 @@ fn main() {
 struct Model;
 
 fn model(app: &App) -> Model {
-    app.new_window().event(event).view(view).build().unwrap();
+    app.new_window()
+        .key_pressed(key_pressed)
+        .mouse_pressed(mouse_pressed)
+        .view(view)
+        .build();
     Model
 }
 
 // Void functions that do not return anything
-fn do_something() -> () {
+fn do_something() {
     println!("DO IT!!!!");
 }
 
@@ -36,22 +40,19 @@ fn random() -> f32 {
     nannou::rand::random()
 }
 
-fn event(_app: &App, _model: &mut Model, event: WindowEvent) {
-    match event {
-        KeyPressed(_key) => {
-            println!("add 10 + 2 = {}", add(10, 2));
-            println!("subtract 100 - 30 = {}", subtract(100, 30));
-            println!("multiply 3.5 * 10.2 = {}", multiply(3.5, 10.2));
-            println!("random = {}", random());
-            println!("remaped value = {}", random_range(0.0f32, 100.0));
-        }
-        MousePressed(_button) => {
-            do_something();
-        }
-        _other => {}
-    }
-}
-
-fn view(_app: &App, _model: &Model, frame: Frame) {
-    frame.clear(DIMGRAY);
+fn key_pressed(_app: &App, _model: &mut Model, _key: KeyCode) {
+    println!("add 10 + 2 = {}", add(10, 2));
+    println!("subtract 100 - 30 = {}", subtract(100, 30));
+    println!("multiply 3.5 * 10.2 = {}", multiply(3.5, 10.2));
+    println!("random = {}", random());
+    println!("remaped value = {}", random_range(0.0f32, 100.0));
+}
+
+fn mouse_pressed(_app: &App, _model: &mut Model, _button: MouseButton) {
+    do_something();
+}
+
+fn view(app: &App, _model: &Model) {
+    let draw = app.draw();
+    draw.background().color(DIM_GRAY);
 }
diff --git a/examples/rust_basics/7_modules/7_modules.rs b/examples/rust_basics/7_modules/7_modules.rs
index 027d23b29..ed9e21d27 100644
--- a/examples/rust_basics/7_modules/7_modules.rs
+++ b/examples/rust_basics/7_modules/7_modules.rs
@@ -1,8 +1,9 @@
 use nannou::prelude::*;
 
-mod ball;
 use crate::ball::Ball;
 
+mod ball;
+
 fn main() {
     nannou::app(model).update(update).simple_window(view).run();
 }
@@ -19,17 +20,15 @@ fn model(_app: &App) -> Model {
 }
 
 // By default, `update` is called right before `view` is called each frame.
-fn update(app: &App, model: &mut Model, _update: Update) {
-    model.ball.position = pt2(app.mouse.x, app.mouse.y);
+fn update(app: &App, model: &mut Model) {
+    model.ball.position = pt2(app.mouse().x, app.mouse().y);
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model, _window: Entity) {
     // Begin drawing.
     let draw = app.draw();
     // Draw dark gray for the background
-    draw.background().color(DIMGRAY);
+    draw.background().color(DIM_GRAY);
     // Draw our ball
     model.ball.display(&draw);
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/examples/rust_basics/7_modules/ball.rs b/examples/rust_basics/7_modules/ball.rs
index 91dc43887..c3b5591b1 100644
--- a/examples/rust_basics/7_modules/ball.rs
+++ b/examples/rust_basics/7_modules/ball.rs
@@ -2,11 +2,11 @@ use nannou::prelude::*;
 
 pub struct Ball {
     pub position: Point2,
-    color: Srgb<u8>,
+    color: Srgba,
 }
 
 impl Ball {
-    pub fn new(color: Srgb<u8>) -> Self {
+    pub fn new(color: Srgba) -> Self {
         let position = pt2(0.0, 0.0);
         Ball { position, color }
     }
diff --git a/examples/templates/template_app.rs b/examples/templates/template_app.rs
index 9499ff2f5..21ed9fa98 100644
--- a/examples/templates/template_app.rs
+++ b/examples/templates/template_app.rs
@@ -5,19 +5,18 @@ fn main() {
 }
 
 struct Model {
-    _window: window::Id,
+    _window: Entity,
 }
 
 fn model(app: &App) -> Model {
-    let _window = app.new_window().view(view).build().unwrap();
+    let _window = app.new_window().view(view).build();
     Model { _window }
 }
 
-fn update(_app: &App, _model: &mut Model, _update: Update) {}
+fn update(_app: &App, _model: &mut Model) {}
 
-fn view(app: &App, _model: &Model, frame: Frame) {
+fn view(app: &App, _model: &Model) {
     let draw = app.draw();
     draw.background().color(PLUM);
-    draw.ellipse().color(STEELBLUE);
-    draw.to_frame(app, &frame).unwrap();
+    draw.ellipse().color(STEEL_BLUE);
 }
diff --git a/examples/templates/template_sketch.rs b/examples/templates/template_sketch.rs
index bc34f3e1a..9173bc016 100644
--- a/examples/templates/template_sketch.rs
+++ b/examples/templates/template_sketch.rs
@@ -4,9 +4,8 @@ fn main() {
     nannou::sketch(view).run()
 }
 
-fn view(app: &App, frame: Frame) {
+fn view(app: &App) {
     let draw = app.draw();
     draw.background().color(PLUM);
-    draw.ellipse().color(STEELBLUE);
-    draw.to_frame(app, &frame).unwrap();
+    draw.ellipse().color(STEEL_BLUE);
 }
diff --git a/examples/ui/egui/circle_packing.rs b/examples/ui/egui/circle_packing.rs
index 3a9c0f6d1..4b8af3a96 100644
--- a/examples/ui/egui/circle_packing.rs
+++ b/examples/ui/egui/circle_packing.rs
@@ -1,6 +1,5 @@
-use nannou::{color::rgb_u32, rand::thread_rng};
+use nannou::rand::thread_rng;
 use nannou::{prelude::*, rand::prelude::SliceRandom};
-use nannou_egui::{self, egui, Egui};
 
 const WIDTH: f32 = 640.0;
 const HEIGHT: f32 = 360.0;
@@ -13,7 +12,7 @@ struct Circle {
     x: f32,
     y: f32,
     radius: f32,
-    color: Hsv,
+    color: Hsva,
 }
 
 struct Settings {
@@ -25,23 +24,19 @@ struct Settings {
 struct Model {
     circles: Vec<Circle>,
     settings: Settings,
-    egui: Egui,
+    window: Entity,
 }
 
 fn model(app: &App) -> Model {
-    let window_id = app
+    let window = app
         .new_window()
         .size(WIDTH as u32, HEIGHT as u32)
         .view(view)
-        .raw_event(raw_window_event)
-        .build()
-        .unwrap();
+        .build();
 
-    let window = app.window(window_id).unwrap();
-    let egui = Egui::from_window(&window);
     Model {
         circles: Vec::new(),
-        egui,
+        window,
         settings: Settings {
             min_radius: 10.0,
             max_radius: 100.0,
@@ -50,16 +45,17 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(_app: &App, model: &mut Model, update: Update) {
+fn update(app: &App, model: &mut Model) {
     let Model {
-        ref mut egui,
+        window,
         ref mut settings,
         ref mut circles,
         ..
     } = *model;
 
-    egui.set_elapsed_time(update.since_start);
-    let ctx = egui.begin_frame();
+    let mut egui_ctx = app.egui_for_window(window);
+    let ctx = &egui_ctx.get_mut();
+
     egui::Window::new("Workshop window").show(&ctx, |ui| {
         let mut changed = false;
         changed |= ui
@@ -78,11 +74,7 @@ fn update(_app: &App, model: &mut Model, update: Update) {
     });
 }
 
-fn raw_window_event(_app: &App, model: &mut Model, event: &nannou::winit::event::WindowEvent) {
-    model.egui.handle_raw_event(event);
-}
-
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
 
     draw.background().color(BLACK);
@@ -93,10 +85,6 @@ fn view(app: &App, model: &Model, frame: Frame) {
             .radius(circle.radius)
             .color(circle.color);
     }
-
-    draw.to_frame(app, &frame).unwrap();
-
-    model.egui.draw_to_frame(&frame).unwrap();
 }
 
 fn intersects(circle: &Circle, circles: &Vec<Circle>) -> bool {
@@ -112,11 +100,11 @@ fn intersects(circle: &Circle, circles: &Vec<Circle>) -> bool {
 
 fn generate_circles(settings: &mut Settings) -> Vec<Circle> {
     let colors = [
-        hsv_from_hex_rgb(0x264653),
-        hsv_from_hex_rgb(0x2a9d8f),
-        hsv_from_hex_rgb(0xe9c46a),
-        hsv_from_hex_rgb(0xf4a261),
-        hsv_from_hex_rgb(0xe76f51),
+        hsv_from_hex_rgb("#264653"),
+        hsv_from_hex_rgb("#2a9d8f"),
+        hsv_from_hex_rgb("#e9c46a"),
+        hsv_from_hex_rgb("#f4a261"),
+        hsv_from_hex_rgb("#e76f51"),
     ];
 
     let mut circles = Vec::new();
@@ -167,13 +155,6 @@ fn generate_circles(settings: &mut Settings) -> Vec<Circle> {
     circles
 }
 
-fn hsv_from_hex_rgb(color: u32) -> Hsv {
-    let color = rgb_u32(color);
-    rgba(
-        color.red as f32 / 255.0,
-        color.green as f32 / 255.0,
-        color.blue as f32 / 255.0,
-        1.0,
-    )
-    .into()
+fn hsv_from_hex_rgb(color: &str) -> Hsva {
+    Srgba::hex(color).unwrap().into()
 }
diff --git a/examples/ui/egui/inspector_ui.rs b/examples/ui/egui/inspector_ui.rs
new file mode 100644
index 000000000..cccc526be
--- /dev/null
+++ b/examples/ui/egui/inspector_ui.rs
@@ -0,0 +1,44 @@
+use nannou::prelude::*;
+
+const WIDTH: f32 = 640.0;
+const HEIGHT: f32 = 360.0;
+
+fn main() {
+    nannou::app(model).model_ui().run();
+}
+
+#[derive(Resource, Reflect)]
+struct Model {
+    window: Entity,
+    radius: f32,
+    color: Hsva,
+}
+
+fn model(app: &App) -> Model {
+    // Create a new window! Store the ID so we can refer to it later.
+    let window = app
+        .new_window()
+        .primary()
+        .title("Nannou")
+        .size(WIDTH as u32, HEIGHT as u32)
+        .view(view) // The function that will be called for presenting graphics to a frame.
+        .build();
+
+    Model {
+        window,
+        radius: 40.0,
+        color: Color::hsv(10.0, 0.5, 1.0).into(),
+    }
+}
+
+// Draw the state of your `Model` into the given `Frame` here.
+fn view(app: &App, model: &Model) {
+    let draw = app.draw();
+
+    draw.background().color(BLACK);
+
+    draw.ellipse()
+        .x_y(100.0, 100.0)
+        .radius(model.radius)
+        .color(model.color);
+}
diff --git a/examples/ui/egui/simple_ui.rs b/examples/ui/egui/simple_ui.rs
index df77dc26c..9d58e0def 100644
--- a/examples/ui/egui/simple_ui.rs
+++ b/examples/ui/egui/simple_ui.rs
@@ -1,5 +1,4 @@
 use nannou::prelude::*;
-use nannou_egui::{self, egui, Egui};
 
 fn main() {
     nannou::app(model).update(update).run();
@@ -9,29 +8,21 @@ struct Settings {
     resolution: u32,
     scale: f32,
     rotation: f32,
-    color: Srgb<u8>,
+    color: Srgba,
     position: Vec2,
 }
 
 struct Model {
     settings: Settings,
-    egui: Egui,
+    window: Entity,
 }
 
 fn model(app: &App) -> Model {
     // Create window
-    let window_id = app
-        .new_window()
-        .view(view)
-        .raw_event(raw_window_event)
-        .build()
-        .unwrap();
-    let window = app.window(window_id).unwrap();
-
-    let egui = Egui::from_window(&window);
+    let window = app.new_window().primary().view(view).build();
 
     Model {
-        egui,
+        window,
         settings: Settings {
             resolution: 10,
             scale: 200.0,
@@ -42,14 +33,13 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(_app: &App, model: &mut Model, update: Update) {
-    let egui = &mut model.egui;
+fn update(app: &App, model: &mut Model) {
     let settings = &mut model.settings;
 
-    egui.set_elapsed_time(update.since_start);
-    let ctx = egui.begin_frame();
+    let mut egui_ctx = app.egui_for_window(model.window);
+    let ctx = egui_ctx.get_mut();
 
-    egui::Window::new("Settings").show(&ctx, |ui| {
+    egui::Window::new("Settings").show(ctx, |ui| {
         // Resolution slider
         ui.label("Resolution:");
         ui.add(egui::Slider::new(&mut settings.resolution, 1..=40));
@@ -66,17 +56,12 @@ fn update(_app: &App, model: &mut Model, update: Update) {
         let clicked = ui.button("Random color").clicked();
 
         if clicked {
-            settings.color = rgb(random(), random(), random());
+            settings.color = Color::srgb(random(), random(), random()).into();
         }
     });
 }
 
-fn raw_window_event(_app: &App, model: &mut Model, event: &nannou::winit::event::WindowEvent) {
-    // Let egui handle things like keyboard and mouse input.
-    model.egui.handle_raw_event(event);
-}
-
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let settings = &model.settings;
 
     let draw = app.draw();
@@ -89,7 +74,4 @@ fn view(app: &App, model: &Model, frame: Frame) {
         .color(settings.color)
         .rotate(-rotation_radians)
         .radius(settings.scale);
-
-    draw.to_frame(app, &frame).unwrap();
-    model.egui.draw_to_frame(&frame).unwrap();
 }
diff --git a/examples/ui/egui/tune_color.rs b/examples/ui/egui/tune_color.rs
index dc0ceae59..38db66436 100644
--- a/examples/ui/egui/tune_color.rs
+++ b/examples/ui/egui/tune_color.rs
@@ -1,5 +1,4 @@
 use nannou::prelude::*;
-use nannou_egui::{egui, Egui};
 
 const WIDTH: f32 = 640.0;
 const HEIGHT: f32 = 360.0;
@@ -9,40 +8,36 @@ fn main() {
 }
 
 struct Model {
-    egui: Egui,
+    window: Entity,
     radius: f32,
-    color: Hsv,
+    color: Hsva,
 }
 
 fn model(app: &App) -> Model {
     // Create a new window! Store the ID so we can refer to it later.
-    let window_id = app
+    let window = app
         .new_window()
         .title("Nannou + Egui")
         .size(WIDTH as u32, HEIGHT as u32)
-        .raw_event(raw_window_event) // This is where we forward all raw events for egui to process them
         .view(view) // The function that will be called for presenting graphics to a frame.
-        .build()
-        .unwrap();
-
-    let window = app.window(window_id).unwrap();
+        .build();
 
     Model {
-        egui: Egui::from_window(&window),
+        window,
         radius: 40.0,
-        color: hsv(10.0, 0.5, 1.0),
+        color: Color::hsv(10.0, 0.5, 1.0).into(),
     }
 }
 
-fn update(_app: &App, model: &mut Model, update: Update) {
+fn update(app: &App, model: &mut Model) {
     let Model {
-        ref mut egui,
+        window,
         ref mut radius,
         ref mut color,
     } = *model;
 
-    egui.set_elapsed_time(update.since_start);
-    let ctx = egui.begin_frame();
+    let mut egui_ctx = app.egui_for_window(window);
+    let ctx = &egui_ctx.get_mut();
     egui::Window::new("EGUI window")
         .default_size(egui::vec2(0.0, 200.0))
         .show(&ctx, |ui| {
@@ -53,28 +48,19 @@ fn update(_app: &App, model: &mut Model, update: Update) {
         });
 }
 
-fn raw_window_event(_app: &App, model: &mut Model, event: &nannou::winit::event::WindowEvent) {
-    model.egui.handle_raw_event(event);
-}
-
 // Draw the state of your `Model` into the given `Frame` here.
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
 
-    frame.clear(BLACK);
+    draw.background().color(BLACK);
 
     draw.ellipse()
         .x_y(100.0, 100.0)
         .radius(model.radius)
         .color(model.color);
-
-    draw.to_frame(app, &frame).unwrap();
-
-    // Do this as the last operation on your frame.
-    model.egui.draw_to_frame(&frame).unwrap();
 }
 
-fn edit_hsv(ui: &mut egui::Ui, color: &mut Hsv) {
+fn edit_hsv(ui: &mut egui::Ui, color: &mut Hsva) {
     let mut egui_hsv = egui::ecolor::Hsva::new(
         color.hue.to_positive_radians() as f32 / (std::f32::consts::PI * 2.0),
         color.saturation,
@@ -89,6 +75,6 @@ fn edit_hsv(ui: &mut egui::Ui, color: &mut Hsv) {
     )
     .changed()
     {
-        *color = nannou::color::hsv(egui_hsv.h, egui_hsv.s, egui_hsv.v);
+        *color = Color::hsv(egui_hsv.h, egui_hsv.s, egui_hsv.v).into();
     }
 }
diff --git a/examples/video/simple_video.rs b/examples/video/simple_video.rs
new file mode 100644
index 000000000..7ed0c579b
--- /dev/null
+++ b/examples/video/simple_video.rs
@@ -0,0 +1,41 @@
+use nannou::noise::NoiseFn;
+use nannou::prelude::*;
+
+fn main() {
+    nannou::app(model).run();
+}
+
+#[derive(Reflect)]
+struct Model {
+    window: Entity,
+    camera: Entity,
+    video: Handle<Video>,
+}
+
+fn model(app: &App) -> Model {
+    let camera = app.new_camera().build();
+    let window = app
+        .new_window()
+        .camera(camera)
+        .primary()
+        .size_pixels(1024, 512)
+        .view(view)
+        .build();
+
+    let video = app
+        .asset_server()
+        .load("video/file_example_MP4_640_3MG.mp4");
+    Model {
+        window,
+        camera,
+        video,
+    }
+}
+fn view(app: &App, model: &Model) {
+    let Some(video) = app.assets().get(&model.video) else {
+        return;
+    };
+
+    let draw = app.draw();
+    draw.rect().w_h(640.0, 400.0).texture(&video.texture);
+}
diff --git a/examples/video/video_material.rs b/examples/video/video_material.rs
new file mode 100644
index 000000000..f5df17231
--- /dev/null
+++ b/examples/video/video_material.rs
@@ -0,0 +1,65 @@
+use nannou::noise::NoiseFn;
+use nannou::prelude::*;
+
+fn main() {
+    nannou::app(model)
+        // Register our custom material to make it available for use in our drawing
+        .init_custom_material::<VideoMaterial>()
+        .run();
+}
+
+#[derive(Reflect)]
+struct Model {
+    window: Entity,
+    camera: Entity,
+    video: Handle<Video>,
+}
+
+// This struct defines the data that will be passed to your shader
+#[derive(Asset, TypePath, AsBindGroup, Debug, Clone, Default)]
+struct VideoMaterial {
+    #[texture(0)]
+    #[sampler(1)]
+    texture: Handle<Image>,
+}
+
+impl Material for VideoMaterial {
+    fn fragment_shader() -> ShaderRef {
+        "draw_video_material.wgsl".into()
+    }
+}
+
+fn model(app: &App) -> Model {
+    let camera = app.new_camera().build();
+    let window = app
+        .new_window()
+        .camera(camera)
+        .primary()
+        .size_pixels(1024, 512)
+        .view(view)
+        .build();
+
+    let video = app
+        .asset_server()
+        .load("video/file_example_MP4_640_3MG.mp4");
+    Model {
+        window,
+        camera,
+        video,
+    }
+}
+
+fn view(app: &App, model: &Model) {
+    let Some(video) = app.assets().get(&model.video) else {
+        return;
+    };
+
+    let draw = app
+        .draw()
+        // Initialize our draw instance with our custom material
+        .material(VideoMaterial {
+            texture: video.texture.clone(),
+        });
+
+    draw.rect().w_h(640.0, 400.0);
+}
diff --git a/examples/wgpu/wgpu_compute_shader/shaders/cs.wgsl b/examples/wgpu/wgpu_compute_shader/shaders/cs.wgsl
deleted file mode 100644
index 9daac0bfc..000000000
--- a/examples/wgpu/wgpu_compute_shader/shaders/cs.wgsl
+++ /dev/null
@@ -1,22 +0,0 @@
-struct Buffer {
-    data: array<f32>,
-};
-
-struct Uniforms {
-    time: f32,
-    freq: f32,
-    oscillator_count: u32,
-};
-
-@group(0) @binding(0)
-var<storage, read_write> output: Buffer;
-@group(0) @binding(1)
-var<uniform> uniforms: Uniforms;
-
-@compute @workgroup_size(1, 1, 1)
-fn main(@builtin(global_invocation_id) id: vec3<u32>) {
-    let index: u32 = id.x;
-    let phase: f32 = uniforms.time + f32(index) * uniforms.freq / f32(uniforms.oscillator_count);
-    output.data[index] = sin(phase) * 0.5 + 0.5;
-    return;
-}
diff --git a/examples/wgpu/wgpu_compute_shader/wgpu_compute_shader.rs b/examples/wgpu/wgpu_compute_shader/wgpu_compute_shader.rs
deleted file mode 100644
index 518b00200..000000000
--- a/examples/wgpu/wgpu_compute_shader/wgpu_compute_shader.rs
+++ /dev/null
@@ -1,282 +0,0 @@
-//! A small GPU compute shader demonstration.
-//!
-//! Here we use a compute shader to calculate the amplitude of `OSCILLATOR_COUNT` number of
-//! oscillators. The oscillator amplitudes are then laid out across the screen using rectangles
-//! with a gray value equal to the amplitude. Real-time interaction is demonstrated by providing
-//! access to time, frequency (mouse `x`) and the number of oscillators via uniform data.
-
-use nannou::prelude::*;
-use nannou::wgpu::BufferInitDescriptor;
-use std::sync::{Arc, Mutex};
-
-struct Model {
-    compute: Compute,
-    oscillators: Arc<Mutex<Vec<f32>>>,
-}
-
-struct Compute {
-    oscillator_buffer: wgpu::Buffer,
-    oscillator_buffer_size: wgpu::BufferAddress,
-    uniform_buffer: wgpu::Buffer,
-    bind_group: wgpu::BindGroup,
-    pipeline: wgpu::ComputePipeline,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct Uniforms {
-    time: f32,
-    freq: f32,
-    oscillator_count: u32,
-}
-
-const OSCILLATOR_COUNT: u32 = 128;
-
-fn main() {
-    nannou::app(model).update(update).run();
-}
-
-fn model(app: &App) -> Model {
-    let w_id = app.new_window().size(1440, 512).view(view).build().unwrap();
-    let window = app.window(w_id).unwrap();
-    let device = window.device();
-
-    // Create the compute shader module.
-    let cs_desc = wgpu::include_wgsl!("shaders/cs.wgsl");
-    let cs_mod = device.create_shader_module(cs_desc);
-
-    // Create the buffer that will store the result of our compute operation.
-    let oscillator_buffer_size =
-        (OSCILLATOR_COUNT as usize * std::mem::size_of::<f32>()) as wgpu::BufferAddress;
-    let oscillator_buffer = device.create_buffer(&wgpu::BufferDescriptor {
-        label: Some("oscillators"),
-        size: oscillator_buffer_size,
-        usage: wgpu::BufferUsages::STORAGE
-            | wgpu::BufferUsages::COPY_DST
-            | wgpu::BufferUsages::COPY_SRC,
-        mapped_at_creation: false,
-    });
-
-    // Create the buffer that will store time.
-    let uniforms = create_uniforms(app.time, app.mouse.x, window.rect());
-    let uniforms_bytes = uniforms_as_bytes(&uniforms);
-    let usage = wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST;
-    let uniform_buffer = device.create_buffer_init(&BufferInitDescriptor {
-        label: Some("uniform-buffer"),
-        contents: uniforms_bytes,
-        usage,
-    });
-
-    // Create the bind group and pipeline.
-    let bind_group_layout = create_bind_group_layout(device);
-    let bind_group = create_bind_group(
-        device,
-        &bind_group_layout,
-        &oscillator_buffer,
-        oscillator_buffer_size,
-        &uniform_buffer,
-    );
-    let pipeline_layout = create_pipeline_layout(device, &bind_group_layout);
-    let pipeline = create_compute_pipeline(device, &pipeline_layout, &cs_mod);
-
-    let compute = Compute {
-        oscillator_buffer,
-        oscillator_buffer_size,
-        uniform_buffer,
-        bind_group,
-        pipeline,
-    };
-
-    // The vector that we will write oscillator values to.
-    let oscillators = Arc::new(Mutex::new(vec![0.0; OSCILLATOR_COUNT as usize]));
-
-    Model {
-        compute,
-        oscillators,
-    }
-}
-
-fn update(app: &App, model: &mut Model, _update: Update) {
-    let window = app.main_window();
-    let device = window.device();
-    let win_rect = window.rect();
-    let compute = &mut model.compute;
-
-    // The buffer into which we'll read some data.
-    let read_buffer = device.create_buffer(&wgpu::BufferDescriptor {
-        label: Some("read-oscillators"),
-        size: compute.oscillator_buffer_size,
-        usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
-        mapped_at_creation: false,
-    });
-
-    // An update for the uniform buffer with the current time.
-    let uniforms = create_uniforms(app.time, app.mouse.x, win_rect);
-    let uniforms_size = std::mem::size_of::<Uniforms>() as wgpu::BufferAddress;
-    let uniforms_bytes = uniforms_as_bytes(&uniforms);
-    let usage = wgpu::BufferUsages::COPY_SRC;
-    let new_uniform_buffer = device.create_buffer_init(&BufferInitDescriptor {
-        label: Some("uniform-data-transfer"),
-        contents: uniforms_bytes,
-        usage,
-    });
-
-    // The encoder we'll use to encode the compute pass.
-    let desc = wgpu::CommandEncoderDescriptor {
-        label: Some("oscillator-compute"),
-    };
-    let mut encoder = device.create_command_encoder(&desc);
-    encoder.copy_buffer_to_buffer(
-        &new_uniform_buffer,
-        0,
-        &compute.uniform_buffer,
-        0,
-        uniforms_size,
-    );
-    {
-        let pass_desc = wgpu::ComputePassDescriptor {
-            label: Some("nannou-wgpu_compute_shader-compute_pass"),
-        };
-        let mut cpass = encoder.begin_compute_pass(&pass_desc);
-        cpass.set_pipeline(&compute.pipeline);
-        cpass.set_bind_group(0, &compute.bind_group, &[]);
-        cpass.dispatch_workgroups(OSCILLATOR_COUNT as u32, 1, 1);
-    }
-    encoder.copy_buffer_to_buffer(
-        &compute.oscillator_buffer,
-        0,
-        &read_buffer,
-        0,
-        compute.oscillator_buffer_size,
-    );
-
-    // Submit the compute pass to the device's queue.
-    window.queue().submit(Some(encoder.finish()));
-
-    // Spawn a future that reads the result of the compute pass.
-    let oscillators = model.oscillators.clone();
-    let future = async move {
-        let slice = read_buffer.slice(..);
-        let (tx, rx) = futures::channel::oneshot::channel();
-        slice.map_async(wgpu::MapMode::Read, |res| {
-            tx.send(res).expect("The channel was closed");
-        });
-        if let Ok(_) = rx.await {
-            if let Ok(mut oscillators) = oscillators.lock() {
-                let bytes = &slice.get_mapped_range()[..];
-                // "Cast" the slice of bytes to a slice of floats as required.
-                let floats = {
-                    let len = bytes.len() / std::mem::size_of::<f32>();
-                    let ptr = bytes.as_ptr() as *const f32;
-                    unsafe { std::slice::from_raw_parts(ptr, len) }
-                };
-                oscillators.copy_from_slice(floats);
-            }
-        }
-    };
-    tokio::spawn(future);
-
-    // Check for resource cleanups and mapping callbacks.
-    //
-    // Note that this line is not necessary in our case, as the device we are using already gets
-    // polled when nannou submits the command buffer for drawing and presentation after `view`
-    // completes. If we were to use a standalone device to create our buffer and perform our
-    // compute (rather than the device requested during window creation), calling `poll` regularly
-    // would be a must.
-    //
-    // device.poll(false);
-}
-
-fn view(app: &App, model: &Model, frame: Frame) {
-    frame.clear(BLACK);
-    let draw = app.draw();
-    let window = app.window(frame.window_id()).unwrap();
-    let rect = window.rect();
-
-    if let Ok(oscillators) = model.oscillators.lock() {
-        let w = rect.w() / OSCILLATOR_COUNT as f32;
-        let h = rect.h();
-        let half_w = w * 0.5;
-        for (i, &osc) in oscillators.iter().enumerate() {
-            let x = half_w + map_range(i as u32, 0, OSCILLATOR_COUNT, rect.left(), rect.right());
-            draw.rect().w_h(w, h).x(x).color(gray(osc));
-        }
-    }
-
-    draw.to_frame(app, &frame).unwrap();
-}
-
-fn create_uniforms(time: f32, mouse_x: f32, win_rect: geom::Rect) -> Uniforms {
-    let freq = map_range(
-        mouse_x,
-        win_rect.left(),
-        win_rect.right(),
-        0.0,
-        win_rect.w(),
-    );
-    let oscillator_count = OSCILLATOR_COUNT;
-    Uniforms {
-        time,
-        freq,
-        oscillator_count,
-    }
-}
-
-fn create_bind_group_layout(device: &wgpu::Device) -> wgpu::BindGroupLayout {
-    let storage_dynamic = false;
-    let storage_readonly = false;
-    let uniform_dynamic = false;
-    wgpu::BindGroupLayoutBuilder::new()
-        .storage_buffer(
-            wgpu::ShaderStages::COMPUTE,
-            storage_dynamic,
-            storage_readonly,
-        )
-        .uniform_buffer(wgpu::ShaderStages::COMPUTE, uniform_dynamic)
-        .build(device)
-}
-
-fn create_bind_group(
-    device: &wgpu::Device,
-    layout: &wgpu::BindGroupLayout,
-    oscillator_buffer: &wgpu::Buffer,
-    oscillator_buffer_size: wgpu::BufferAddress,
-    uniform_buffer: &wgpu::Buffer,
-) -> wgpu::BindGroup {
-    let buffer_size_bytes = std::num::NonZeroU64::new(oscillator_buffer_size).unwrap();
-    wgpu::BindGroupBuilder::new()
-        .buffer_bytes(oscillator_buffer, 0, Some(buffer_size_bytes))
-        .buffer::<Uniforms>(uniform_buffer, 0..1)
-        .build(device, layout)
-}
-
-fn create_pipeline_layout(
-    device: &wgpu::Device,
-    bind_group_layout: &wgpu::BindGroupLayout,
-) -> wgpu::PipelineLayout {
-    device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
-        label: Some("nannou"),
-        bind_group_layouts: &[&bind_group_layout],
-        push_constant_ranges: &[],
-    })
-}
-
-fn create_compute_pipeline(
-    device: &wgpu::Device,
-    layout: &wgpu::PipelineLayout,
-    cs_mod: &wgpu::ShaderModule,
-) -> wgpu::ComputePipeline {
-    let desc = wgpu::ComputePipelineDescriptor {
-        label: Some("nannou"),
-        layout: Some(layout),
-        module: &cs_mod,
-        entry_point: "main",
-    };
-    device.create_compute_pipeline(&desc)
-}
-
-// See `nannou::wgpu::bytes` docs for why these are necessary.
-
-fn uniforms_as_bytes(uniforms: &Uniforms) -> &[u8] {
-    unsafe { wgpu::bytes::from(uniforms) }
-}
diff --git a/examples/wgpu/wgpu_image/shaders/fs.wgsl b/examples/wgpu/wgpu_image/shaders/fs.wgsl
deleted file mode 100644
index 5fd305572..000000000
--- a/examples/wgpu/wgpu_image/shaders/fs.wgsl
+++ /dev/null
@@ -1,14 +0,0 @@
-struct FragmentOutput {
-    @location(0) f_color: vec4<f32>,
-};
-
-@group(0) @binding(0)
-var tex: texture_2d<f32>;
-@group(0) @binding(1)
-var tex_sampler: sampler;
-
-@fragment
-fn main(@location(0) tex_coords: vec2<f32>) -> FragmentOutput {
-    let out_color: vec4<f32> = textureSample(tex, tex_sampler, tex_coords);
-    return FragmentOutput(out_color);
-}
diff --git a/examples/wgpu/wgpu_image/shaders/vs.wgsl b/examples/wgpu/wgpu_image/shaders/vs.wgsl
deleted file mode 100644
index e9925b28b..000000000
--- a/examples/wgpu/wgpu_image/shaders/vs.wgsl
+++ /dev/null
@@ -1,11 +0,0 @@
-struct VertexOutput {
-    @location(0) tex_coords: vec2<f32>,
-    @builtin(position) out_pos: vec4<f32>,
-};
-
-@vertex
-fn main(@location(0) pos: vec2<f32>) -> VertexOutput {
-    let tex_coords: vec2<f32> = vec2<f32>(pos.x * 0.5 + 0.5, 1.0 - (pos.y * 0.5 + 0.5));
-    let out_pos: vec4<f32> = vec4<f32>(pos, 0.0, 1.0);
-    return VertexOutput(tex_coords, out_pos);
-}
diff --git a/examples/wgpu/wgpu_image/wgpu_image.rs b/examples/wgpu/wgpu_image/wgpu_image.rs
deleted file mode 100644
index 156c4390c..000000000
--- a/examples/wgpu/wgpu_image/wgpu_image.rs
+++ /dev/null
@@ -1,170 +0,0 @@
-use nannou::image;
-use nannou::image::GenericImageView;
-use nannou::prelude::*;
-
-struct Model {
-    bind_group: wgpu::BindGroup,
-    render_pipeline: wgpu::RenderPipeline,
-    vertex_buffer: wgpu::Buffer,
-}
-
-// The vertex type that we will use to represent a point on our triangle.
-#[repr(C)]
-#[derive(Clone, Copy)]
-struct Vertex {
-    position: [f32; 2],
-}
-
-// The vertices that make up the rectangle to which the image will be drawn.
-const VERTICES: [Vertex; 4] = [
-    Vertex {
-        position: [-1.0, 1.0],
-    },
-    Vertex {
-        position: [-1.0, -1.0],
-    },
-    Vertex {
-        position: [1.0, 1.0],
-    },
-    Vertex {
-        position: [1.0, -1.0],
-    },
-];
-
-fn main() {
-    nannou::app(model).run();
-}
-
-fn model(app: &App) -> Model {
-    // Load the image.
-    let logo_path = app.assets_path().unwrap().join("images").join("nannou.png");
-    let image = image::open(logo_path).unwrap();
-    let (img_w, img_h) = image.dimensions();
-
-    let w_id = app
-        .new_window()
-        .size(img_w, img_h)
-        .view(view)
-        .build()
-        .unwrap();
-    let window = app.window(w_id).unwrap();
-    let device = window.device();
-    let format = Frame::TEXTURE_FORMAT;
-    let msaa_samples = window.msaa_samples();
-
-    let vs_desc = wgpu::include_wgsl!("shaders/vs.wgsl");
-    let fs_desc = wgpu::include_wgsl!("shaders/fs.wgsl");
-    let vs_mod = device.create_shader_module(vs_desc);
-    let fs_mod = device.create_shader_module(fs_desc);
-
-    // Load the image as a texture.
-    let texture = wgpu::Texture::from_image(&window, &image);
-    let texture_view = texture.view().build();
-
-    // Create the sampler for sampling from the source texture.
-    let sampler_desc = wgpu::SamplerBuilder::new().into_descriptor();
-    let sampler_filtering = wgpu::sampler_filtering(&sampler_desc);
-    let sampler = device.create_sampler(&sampler_desc);
-
-    let bind_group_layout =
-        create_bind_group_layout(device, texture_view.sample_type(), sampler_filtering);
-    let bind_group = create_bind_group(device, &bind_group_layout, &texture_view, &sampler);
-    let pipeline_layout = create_pipeline_layout(device, &bind_group_layout);
-    let render_pipeline = create_render_pipeline(
-        device,
-        &pipeline_layout,
-        &vs_mod,
-        &fs_mod,
-        format,
-        msaa_samples,
-    );
-
-    let vertices_bytes = vertices_as_bytes(&VERTICES[..]);
-    let usage = wgpu::BufferUsages::VERTEX;
-    let vertex_buffer = device.create_buffer_init(&BufferInitDescriptor {
-        label: None,
-        contents: vertices_bytes,
-        usage,
-    });
-
-    Model {
-        bind_group,
-        vertex_buffer,
-        render_pipeline,
-    }
-}
-
-fn view(_app: &App, model: &Model, frame: Frame) {
-    let mut encoder = frame.command_encoder();
-    let mut render_pass = wgpu::RenderPassBuilder::new()
-        .color_attachment(frame.texture_view(), |color| color)
-        .begin(&mut encoder);
-    render_pass.set_bind_group(0, &model.bind_group, &[]);
-    render_pass.set_pipeline(&model.render_pipeline);
-    render_pass.set_vertex_buffer(0, model.vertex_buffer.slice(..));
-    let vertex_range = 0..VERTICES.len() as u32;
-    let instance_range = 0..1;
-    render_pass.draw(vertex_range, instance_range);
-}
-
-fn create_bind_group_layout(
-    device: &wgpu::Device,
-    texture_sample_type: wgpu::TextureSampleType,
-    sampler_filtering: bool,
-) -> wgpu::BindGroupLayout {
-    wgpu::BindGroupLayoutBuilder::new()
-        .texture(
-            wgpu::ShaderStages::FRAGMENT,
-            false,
-            wgpu::TextureViewDimension::D2,
-            texture_sample_type,
-        )
-        .sampler(wgpu::ShaderStages::FRAGMENT, sampler_filtering)
-        .build(device)
-}
-
-fn create_bind_group(
-    device: &wgpu::Device,
-    layout: &wgpu::BindGroupLayout,
-    texture: &wgpu::TextureView,
-    sampler: &wgpu::Sampler,
-) -> wgpu::BindGroup {
-    wgpu::BindGroupBuilder::new()
-        .texture_view(texture)
-        .sampler(sampler)
-        .build(device, layout)
-}
-
-fn create_pipeline_layout(
-    device: &wgpu::Device,
-    bind_group_layout: &wgpu::BindGroupLayout,
-) -> wgpu::PipelineLayout {
-    let desc = wgpu::PipelineLayoutDescriptor {
-        label: None,
-        bind_group_layouts: &[&bind_group_layout],
-        push_constant_ranges: &[],
-    };
-    device.create_pipeline_layout(&desc)
-}
-
-fn create_render_pipeline(
-    device: &wgpu::Device,
-    layout: &wgpu::PipelineLayout,
-    vs_mod: &wgpu::ShaderModule,
-    fs_mod: &wgpu::ShaderModule,
-    dst_format: wgpu::TextureFormat,
-    sample_count: u32,
-) -> wgpu::RenderPipeline {
-    wgpu::RenderPipelineBuilder::from_layout(layout, vs_mod)
-        .fragment_shader(fs_mod)
-        .color_format(dst_format)
-        .add_vertex_buffer::<Vertex>(&wgpu::vertex_attr_array![0 => Float32x2])
-        .sample_count(sample_count)
-        .primitive_topology(wgpu::PrimitiveTopology::TriangleStrip)
-        .build(device)
-}
-
-// See the `nannou::wgpu::bytes` documentation for why this is necessary.
-fn vertices_as_bytes(data: &[Vertex]) -> &[u8] {
-    unsafe { wgpu::bytes::from_slice(data) }
-}
diff --git a/examples/wgpu/wgpu_image_sequence/shaders/fs.wgsl b/examples/wgpu/wgpu_image_sequence/shaders/fs.wgsl
deleted file mode 100644
index 5fd305572..000000000
--- a/examples/wgpu/wgpu_image_sequence/shaders/fs.wgsl
+++ /dev/null
@@ -1,14 +0,0 @@
-struct FragmentOutput {
-    @location(0) f_color: vec4<f32>,
-};
-
-@group(0) @binding(0)
-var tex: texture_2d<f32>;
-@group(0) @binding(1)
-var tex_sampler: sampler;
-
-@fragment
-fn main(@location(0) tex_coords: vec2<f32>) -> FragmentOutput {
-    let out_color: vec4<f32> = textureSample(tex, tex_sampler, tex_coords);
-    return FragmentOutput(out_color);
-}
diff --git a/examples/wgpu/wgpu_image_sequence/shaders/vs.wgsl b/examples/wgpu/wgpu_image_sequence/shaders/vs.wgsl
deleted file mode 100644
index e9925b28b..000000000
--- a/examples/wgpu/wgpu_image_sequence/shaders/vs.wgsl
+++ /dev/null
@@ -1,11 +0,0 @@
-struct VertexOutput {
-    @location(0) tex_coords: vec2<f32>,
-    @builtin(position) out_pos: vec4<f32>,
-};
-
-@vertex
-fn main(@location(0) pos: vec2<f32>) -> VertexOutput {
-    let tex_coords: vec2<f32> = vec2<f32>(pos.x * 0.5 + 0.5, 1.0 - (pos.y * 0.5 + 0.5));
-    let out_pos: vec4<f32> = vec4<f32>(pos, 0.0, 1.0);
-    return VertexOutput(tex_coords, out_pos);
-}
diff --git a/examples/wgpu/wgpu_image_sequence/wgpu_image_sequence.rs b/examples/wgpu/wgpu_image_sequence/wgpu_image_sequence.rs
deleted file mode 100644
index 6291353a0..000000000
--- a/examples/wgpu/wgpu_image_sequence/wgpu_image_sequence.rs
+++ /dev/null
@@ -1,264 +0,0 @@
-//! A demonstration of playing back a sequence of images.
-//!
-//! This approach loads a directory of images into a single texture array. We only ever present a
-//! single layer of the texture at a time by creating a texture view. We select which layer to view
-//! by using a `current_layer` variable and updating it based on a frame rate that we determine by
-//! the mouse x position.
-//!
-//! An interesting exercise might be to make a copy of this example and attempt to smooth the slow
-//! frame rates by interpolating between two of the layers at a time. Hint: this would likely
-//! require adding a second texture view binding to the bind group and its layout.
-
-use nannou::image;
-use nannou::image::RgbaImage;
-use nannou::prelude::*;
-use std::path::{Path, PathBuf};
-
-struct Model {
-    current_layer: f32,
-    texture_array: wgpu::Texture,
-    texture_view: wgpu::TextureView,
-    sampler: wgpu::Sampler,
-    bind_group_layout: wgpu::BindGroupLayout,
-    bind_group: wgpu::BindGroup,
-    render_pipeline: wgpu::RenderPipeline,
-    vertex_buffer: wgpu::Buffer,
-}
-
-// The vertex type that we will use to represent a point on our triangle.
-#[repr(C)]
-#[derive(Clone, Copy)]
-struct Vertex {
-    position: [f32; 2],
-}
-
-// The vertices that make up the rectangle to which the image will be drawn.
-const VERTICES: [Vertex; 4] = [
-    Vertex {
-        position: [-1.0, 1.0],
-    },
-    Vertex {
-        position: [-1.0, -1.0],
-    },
-    Vertex {
-        position: [1.0, 1.0],
-    },
-    Vertex {
-        position: [1.0, -1.0],
-    },
-];
-
-fn main() {
-    nannou::app(model).update(update).run();
-}
-
-fn model(app: &App) -> Model {
-    // Load the images.
-    let sequence_path = app
-        .assets_path()
-        .unwrap()
-        .join("images")
-        .join("spinning_dancer");
-
-    println!("Loading images...");
-    let (images, (img_w, img_h)) = load_images(&sequence_path);
-    println!("Done!");
-
-    let w_id = app
-        .new_window()
-        .size(img_w, img_h)
-        .view(view)
-        .build()
-        .unwrap();
-
-    let window = app.window(w_id).unwrap();
-    let device = window.device();
-    let format = Frame::TEXTURE_FORMAT;
-    let msaa_samples = window.msaa_samples();
-
-    let vs_desc = wgpu::include_wgsl!("shaders/vs.wgsl");
-    let fs_desc = wgpu::include_wgsl!("shaders/fs.wgsl");
-    let vs_mod = device.create_shader_module(vs_desc);
-    let fs_mod = device.create_shader_module(fs_desc);
-
-    let texture_array = {
-        // The wgpu device queue used to load the image data.
-        let queue = window.queue();
-        // Describe how we will use the texture so that the GPU may handle it efficiently.
-        let usage = wgpu::TextureUsages::TEXTURE_BINDING;
-        let iter = images.iter().map(|&(_, ref img)| img);
-        wgpu::Texture::load_array_from_image_buffers(device, queue, usage, iter)
-            .expect("tied to load texture array with an empty image buffer sequence")
-    };
-    let layer = 0;
-    let texture_view = texture_array.view().layer(layer).build();
-
-    // Create the sampler for sampling from the source texture.
-    let sampler_desc = wgpu::SamplerBuilder::new().into_descriptor();
-    let sampler_filtering = wgpu::sampler_filtering(&sampler_desc);
-    let sampler = device.create_sampler(&sampler_desc);
-
-    let bind_group_layout =
-        create_bind_group_layout(device, texture_view.sample_type(), sampler_filtering);
-    let bind_group = create_bind_group(device, &bind_group_layout, &texture_view, &sampler);
-    let pipeline_layout = create_pipeline_layout(device, &bind_group_layout);
-    let render_pipeline = create_render_pipeline(
-        device,
-        &pipeline_layout,
-        &vs_mod,
-        &fs_mod,
-        format,
-        msaa_samples,
-    );
-
-    // Create the vertex buffer.
-    let vertices_bytes = vertices_as_bytes(&VERTICES[..]);
-    let usage = wgpu::BufferUsages::VERTEX;
-    let vertex_buffer = device.create_buffer_init(&BufferInitDescriptor {
-        label: None,
-        contents: vertices_bytes,
-        usage,
-    });
-
-    Model {
-        current_layer: 0.0,
-        texture_array,
-        texture_view,
-        sampler,
-        bind_group_layout,
-        bind_group,
-        vertex_buffer,
-        render_pipeline,
-    }
-}
-
-fn update(app: &App, model: &mut Model, update: Update) {
-    // Update which layer in the texture array that are viewing.
-    let window = app.main_window();
-    let device = window.device();
-
-    // Determine how fast to play back the frames based on the mouse x.
-    let win_rect = window.rect();
-    let fps = map_range(
-        app.mouse.x,
-        win_rect.left(),
-        win_rect.right(),
-        -100.0,
-        100.0,
-    );
-
-    // Update which layer we are viewing based on the playback speed and layer count.
-    let layer_count = model.texture_array.extent().depth_or_array_layers;
-    model.current_layer = fmod(
-        model.current_layer + update.since_last.secs() as f32 * fps,
-        layer_count as f32,
-    );
-
-    // Update the view and the bind group ready for drawing.
-    let layer = model.current_layer as u32;
-    model.texture_view = model.texture_array.view().layer(layer).build();
-    model.bind_group = create_bind_group(
-        device,
-        &model.bind_group_layout,
-        &model.texture_view,
-        &model.sampler,
-    );
-}
-
-fn view(_app: &App, model: &Model, frame: Frame) {
-    let mut encoder = frame.command_encoder();
-    let mut render_pass = wgpu::RenderPassBuilder::new()
-        .color_attachment(frame.texture_view(), |color| color)
-        .begin(&mut encoder);
-    render_pass.set_bind_group(0, &model.bind_group, &[]);
-    render_pass.set_pipeline(&model.render_pipeline);
-    render_pass.set_vertex_buffer(0, model.vertex_buffer.slice(..));
-    let vertex_range = 0..VERTICES.len() as u32;
-    let instance_range = 0..1;
-    render_pass.draw(vertex_range, instance_range);
-}
-
-// Load a directory of images and returns them sorted by filename alongside their dimensions.
-// This function assumes all the images have the same dimensions.
-fn load_images(dir: &Path) -> (Vec<(PathBuf, RgbaImage)>, (u32, u32)) {
-    let mut images = vec![];
-    let mut dims = (0, 0);
-    for entry in std::fs::read_dir(dir).unwrap() {
-        let entry = entry.unwrap();
-        let path = entry.path();
-        let image = match image::open(&path) {
-            Ok(img) => img.into_rgba8(),
-            Err(err) => {
-                eprintln!("failed to open {} as an image: {}", path.display(), err);
-                continue;
-            }
-        };
-        let (w, h) = image.dimensions();
-        dims = (w, h);
-        images.push((path, image));
-    }
-    images.sort_by_key(|(path, _)| path.clone());
-    (images, dims)
-}
-
-fn create_bind_group_layout(
-    device: &wgpu::Device,
-    texture_sample_type: wgpu::TextureSampleType,
-    sampler_filtering: bool,
-) -> wgpu::BindGroupLayout {
-    wgpu::BindGroupLayoutBuilder::new()
-        .texture(
-            wgpu::ShaderStages::FRAGMENT,
-            false,
-            wgpu::TextureViewDimension::D2,
-            texture_sample_type,
-        )
-        .sampler(wgpu::ShaderStages::FRAGMENT, sampler_filtering)
-        .build(device)
-}
-
-fn create_bind_group(
-    device: &wgpu::Device,
-    layout: &wgpu::BindGroupLayout,
-    texture: &wgpu::TextureView,
-    sampler: &wgpu::Sampler,
-) -> wgpu::BindGroup {
-    wgpu::BindGroupBuilder::new()
-        .texture_view(texture)
-        .sampler(sampler)
-        .build(device, layout)
-}
-
-fn create_pipeline_layout(
-    device: &wgpu::Device,
-    bind_group_layout: &wgpu::BindGroupLayout,
-) -> wgpu::PipelineLayout {
-    let desc = wgpu::PipelineLayoutDescriptor {
-        label: None,
-        bind_group_layouts: &[&bind_group_layout],
-        push_constant_ranges: &[],
-    };
-    device.create_pipeline_layout(&desc)
-}
-
-fn create_render_pipeline(
-    device: &wgpu::Device,
-    layout: &wgpu::PipelineLayout,
-    vs_mod: &wgpu::ShaderModule,
-    fs_mod: &wgpu::ShaderModule,
-    dst_format: wgpu::TextureFormat,
-    sample_count: u32,
-) -> wgpu::RenderPipeline {
-    wgpu::RenderPipelineBuilder::from_layout(layout, vs_mod)
-        .fragment_shader(fs_mod)
-        .color_format(dst_format)
-        .add_vertex_buffer::<Vertex>(&wgpu::vertex_attr_array![0 => Float32x2])
-        .sample_count(sample_count)
-        .primitive_topology(wgpu::PrimitiveTopology::TriangleStrip)
-        .build(device)
-}
-
-// See the `nannou::wgpu::bytes` documentation for why this is necessary.
-fn vertices_as_bytes(data: &[Vertex]) -> &[u8] {
-    unsafe { wgpu::bytes::from_slice(data) }
-}
diff --git a/examples/wgpu/wgpu_instancing/data.rs b/examples/wgpu/wgpu_instancing/data.rs
deleted file mode 100644
index 61aefab11..000000000
--- a/examples/wgpu/wgpu_instancing/data.rs
+++ /dev/null
@@ -1,3354 +0,0 @@
-use crate::{Normal, Vertex};
-
-pub const VERTICES: [Vertex; 531] = [
-    Vertex {
-        position: (0.0, 0.0, 0.0),
-    }, // dummy vector because in the original model indices
-    // start at 1
-    Vertex {
-        position: (40.6266, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (40.0714, 30.4443, -1.10804),
-    },
-    Vertex {
-        position: (40.7155, 31.1438, -1.10804),
-    },
-    Vertex {
-        position: (42.0257, 30.4443, -1.10804),
-    },
-    Vertex {
-        position: (43.4692, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (37.5425, 28.3457, 14.5117),
-    },
-    Vertex {
-        position: (37.0303, 30.4443, 14.2938),
-    },
-    Vertex {
-        position: (37.6244, 31.1438, 14.5466),
-    },
-    Vertex {
-        position: (38.8331, 30.4443, 15.0609),
-    },
-    Vertex {
-        position: (40.1647, 28.3457, 15.6274),
-    },
-    Vertex {
-        position: (29.0859, 28.3457, 27.1468),
-    },
-    Vertex {
-        position: (28.6917, 30.4443, 26.7527),
-    },
-    Vertex {
-        position: (29.149, 31.1438, 27.2099),
-    },
-    Vertex {
-        position: (30.0792, 30.4443, 28.1402),
-    },
-    Vertex {
-        position: (31.1041, 28.3457, 29.165),
-    },
-    Vertex {
-        position: (16.4508, 28.3457, 35.6034),
-    },
-    Vertex {
-        position: (16.2329, 30.4443, 35.0912),
-    },
-    Vertex {
-        position: (16.4857, 31.1438, 35.6853),
-    },
-    Vertex {
-        position: (16.9999, 30.4443, 36.894),
-    },
-    Vertex {
-        position: (17.5665, 28.3457, 38.2256),
-    },
-    Vertex {
-        position: (0.831025, 28.3457, 38.6876),
-    },
-    Vertex {
-        position: (0.831025, 30.4443, 38.1324),
-    },
-    Vertex {
-        position: (0.831025, 31.1438, 38.7764),
-    },
-    Vertex {
-        position: (0.831025, 30.4443, 40.0866),
-    },
-    Vertex {
-        position: (0.831025, 28.3457, 41.5301),
-    },
-    Vertex {
-        position: (-15.868, 28.3457, 35.6034),
-    },
-    Vertex {
-        position: (-15.0262, 30.4443, 35.0912),
-    },
-    Vertex {
-        position: (-14.9585, 31.1438, 35.6853),
-    },
-    Vertex {
-        position: (-15.3547, 30.4443, 36.894),
-    },
-    Vertex {
-        position: (-15.9044, 28.3457, 38.2256),
-    },
-    Vertex {
-        position: (-28.3832, 28.3457, 27.1468),
-    },
-    Vertex {
-        position: (-27.4344, 30.4443, 26.7527),
-    },
-    Vertex {
-        position: (-27.6068, 31.1438, 27.2099),
-    },
-    Vertex {
-        position: (-28.4322, 30.4443, 28.1402),
-    },
-    Vertex {
-        position: (-29.4421, 28.3457, 29.165),
-    },
-    Vertex {
-        position: (-36.2402, 28.3457, 14.5117),
-    },
-    Vertex {
-        position: (-35.52, 30.4443, 14.2938),
-    },
-    Vertex {
-        position: (-36.0073, 31.1438, 14.5466),
-    },
-    Vertex {
-        position: (-37.1767, 30.4443, 15.0609),
-    },
-    Vertex {
-        position: (-38.5027, 28.3457, 15.6274),
-    },
-    Vertex {
-        position: (-38.9646, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (-38.4094, 30.4443, -1.10804),
-    },
-    Vertex {
-        position: (-39.0534, 31.1438, -1.10804),
-    },
-    Vertex {
-        position: (-40.3636, 30.4443, -1.10804),
-    },
-    Vertex {
-        position: (-41.8071, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (-35.8804, 28.3457, -16.7278),
-    },
-    Vertex {
-        position: (-35.3683, 30.4443, -16.5099),
-    },
-    Vertex {
-        position: (-35.9624, 31.1438, -16.7627),
-    },
-    Vertex {
-        position: (-37.1711, 30.4443, -17.2769),
-    },
-    Vertex {
-        position: (-38.5027, 28.3457, -17.8435),
-    },
-    Vertex {
-        position: (-27.4238, 28.3457, -29.3629),
-    },
-    Vertex {
-        position: (-27.0297, 30.4443, -28.9687),
-    },
-    Vertex {
-        position: (-27.4869, 31.1438, -29.426),
-    },
-    Vertex {
-        position: (-28.4172, 30.4443, -30.3562),
-    },
-    Vertex {
-        position: (-29.4421, 28.3457, -31.3811),
-    },
-    Vertex {
-        position: (-14.7887, 28.3457, -37.8195),
-    },
-    Vertex {
-        position: (-14.5708, 30.4443, -37.3073),
-    },
-    Vertex {
-        position: (-14.8236, 31.1438, -37.9014),
-    },
-    Vertex {
-        position: (-15.3379, 30.4443, -39.1101),
-    },
-    Vertex {
-        position: (-15.9044, 28.3457, -40.4417),
-    },
-    Vertex {
-        position: (0.831025, 28.3457, -40.9036),
-    },
-    Vertex {
-        position: (0.831025, 30.4443, -40.3484),
-    },
-    Vertex {
-        position: (0.831025, 31.1438, -40.9925),
-    },
-    Vertex {
-        position: (0.831025, 30.4443, -42.3027),
-    },
-    Vertex {
-        position: (0.831025, 28.3457, -43.7462),
-    },
-    Vertex {
-        position: (16.4508, 28.3457, -37.8195),
-    },
-    Vertex {
-        position: (16.2329, 30.4443, -37.3073),
-    },
-    Vertex {
-        position: (16.4857, 31.1438, -37.9014),
-    },
-    Vertex {
-        position: (16.9999, 30.4443, -39.1101),
-    },
-    Vertex {
-        position: (17.5665, 28.3457, -40.4417),
-    },
-    Vertex {
-        position: (29.0859, 28.3457, -29.3629),
-    },
-    Vertex {
-        position: (28.6917, 30.4443, -28.9687),
-    },
-    Vertex {
-        position: (29.149, 31.1438, -29.426),
-    },
-    Vertex {
-        position: (30.0792, 30.4443, -30.3562),
-    },
-    Vertex {
-        position: (31.1041, 28.3457, -31.3811),
-    },
-    Vertex {
-        position: (37.5425, 28.3457, -16.7278),
-    },
-    Vertex {
-        position: (37.0303, 30.4443, -16.5099),
-    },
-    Vertex {
-        position: (37.6244, 31.1438, -16.7627),
-    },
-    Vertex {
-        position: (38.8331, 30.4443, -17.2769),
-    },
-    Vertex {
-        position: (40.1647, 28.3457, -17.8435),
-    },
-    Vertex {
-        position: (48.6879, 17.1865, -1.10804),
-    },
-    Vertex {
-        position: (53.2404, 6.22714, -1.10804),
-    },
-    Vertex {
-        position: (56.4605, -4.33246, -1.10804),
-    },
-    Vertex {
-        position: (57.6819, -14.2925, -1.10804),
-    },
-    Vertex {
-        position: (44.979, 17.1865, 17.6758),
-    },
-    Vertex {
-        position: (49.1787, 6.22714, 19.4626),
-    },
-    Vertex {
-        position: (52.1492, -4.33246, 20.7265),
-    },
-    Vertex {
-        position: (53.2759, -14.2925, 21.2059),
-    },
-    Vertex {
-        position: (34.8094, 17.1865, 32.8703),
-    },
-    Vertex {
-        position: (38.0417, 6.22714, 36.1026),
-    },
-    Vertex {
-        position: (40.3279, -4.33246, 38.3889),
-    },
-    Vertex {
-        position: (41.1951, -14.2925, 39.2561),
-    },
-    Vertex {
-        position: (19.6148, 17.1865, 43.0399),
-    },
-    Vertex {
-        position: (21.4017, 6.22714, 47.2396),
-    },
-    Vertex {
-        position: (22.6656, -4.33246, 50.2101),
-    },
-    Vertex {
-        position: (23.145, -14.2925, 51.3369),
-    },
-    Vertex {
-        position: (0.831025, 17.1865, 46.7488),
-    },
-    Vertex {
-        position: (0.831025, 6.22714, 51.3013),
-    },
-    Vertex {
-        position: (0.831025, -4.33246, 54.5214),
-    },
-    Vertex {
-        position: (0.831025, -14.2925, 55.7428),
-    },
-    Vertex {
-        position: (-17.9528, 17.1865, 43.0399),
-    },
-    Vertex {
-        position: (-19.7397, 6.22714, 47.2396),
-    },
-    Vertex {
-        position: (-21.0035, -4.33246, 50.2101),
-    },
-    Vertex {
-        position: (-21.4829, -14.2925, 51.3369),
-    },
-    Vertex {
-        position: (-33.1474, 17.1865, 32.8703),
-    },
-    Vertex {
-        position: (-36.3796, 6.22714, 36.1026),
-    },
-    Vertex {
-        position: (-38.6659, -4.33246, 38.3889),
-    },
-    Vertex {
-        position: (-39.5331, -14.2925, 39.2561),
-    },
-    Vertex {
-        position: (-43.3169, 17.1865, 17.6758),
-    },
-    Vertex {
-        position: (-47.5166, 6.22714, 19.4626),
-    },
-    Vertex {
-        position: (-50.4871, -4.33246, 20.7265),
-    },
-    Vertex {
-        position: (-51.6139, -14.2925, 21.2059),
-    },
-    Vertex {
-        position: (-47.0258, 17.1865, -1.10804),
-    },
-    Vertex {
-        position: (-51.5784, 6.22714, -1.10804),
-    },
-    Vertex {
-        position: (-54.7984, -4.33246, -1.10804),
-    },
-    Vertex {
-        position: (-56.0198, -14.2925, -1.10804),
-    },
-    Vertex {
-        position: (-43.3169, 17.1865, -19.8919),
-    },
-    Vertex {
-        position: (-47.5166, 6.22714, -21.6787),
-    },
-    Vertex {
-        position: (-50.4871, -4.33246, -22.9426),
-    },
-    Vertex {
-        position: (-51.6139, -14.2925, -23.422),
-    },
-    Vertex {
-        position: (-33.1474, 17.1865, -35.0864),
-    },
-    Vertex {
-        position: (-36.3796, 6.22714, -38.3187),
-    },
-    Vertex {
-        position: (-38.6659, -4.33246, -40.6049),
-    },
-    Vertex {
-        position: (-39.5331, -14.2925, -41.4721),
-    },
-    Vertex {
-        position: (-17.9528, 17.1865, -45.256),
-    },
-    Vertex {
-        position: (-19.7397, 6.22714, -49.4557),
-    },
-    Vertex {
-        position: (-21.0035, -4.33246, -52.4262),
-    },
-    Vertex {
-        position: (-21.4829, -14.2925, -53.5529),
-    },
-    Vertex {
-        position: (0.831025, 17.1865, -48.9649),
-    },
-    Vertex {
-        position: (0.831025, 6.22714, -53.5174),
-    },
-    Vertex {
-        position: (0.831025, -4.33246, -56.7375),
-    },
-    Vertex {
-        position: (0.831025, -14.2925, -57.9589),
-    },
-    Vertex {
-        position: (19.6148, 17.1865, -45.256),
-    },
-    Vertex {
-        position: (21.4017, 6.22714, -49.4557),
-    },
-    Vertex {
-        position: (22.6656, -4.33246, -52.4262),
-    },
-    Vertex {
-        position: (23.145, -14.2925, -53.5529),
-    },
-    Vertex {
-        position: (34.8094, 17.1865, -35.0864),
-    },
-    Vertex {
-        position: (38.0417, 6.22714, -38.3187),
-    },
-    Vertex {
-        position: (40.3279, -4.33246, -40.6049),
-    },
-    Vertex {
-        position: (41.1951, -14.2925, -41.4721),
-    },
-    Vertex {
-        position: (44.979, 17.1865, -19.8919),
-    },
-    Vertex {
-        position: (49.1787, 6.22714, -21.6787),
-    },
-    Vertex {
-        position: (52.1492, -4.33246, -22.9426),
-    },
-    Vertex {
-        position: (53.2759, -14.2925, -23.422),
-    },
-    Vertex {
-        position: (55.4611, -22.7202, -1.10804),
-    },
-    Vertex {
-        position: (50.5755, -28.9493, -1.10804),
-    },
-    Vertex {
-        position: (45.6899, -33.1798, -1.10804),
-    },
-    Vertex {
-        position: (43.4692, -35.6115, -1.10804),
-    },
-    Vertex {
-        position: (51.2273, -22.7202, 20.3343),
-    },
-    Vertex {
-        position: (46.7203, -28.9493, 18.4167),
-    },
-    Vertex {
-        position: (42.2133, -33.1798, 16.4991),
-    },
-    Vertex {
-        position: (40.1647, -35.6115, 15.6274),
-    },
-    Vertex {
-        position: (39.6184, -22.7202, 37.6793),
-    },
-    Vertex {
-        position: (36.1496, -28.9493, 34.2106),
-    },
-    Vertex {
-        position: (32.6808, -33.1798, 30.7418),
-    },
-    Vertex {
-        position: (31.1041, -35.6115, 29.165),
-    },
-    Vertex {
-        position: (22.2733, -22.7202, 49.2882),
-    },
-    Vertex {
-        position: (20.3557, -28.9493, 44.7813),
-    },
-    Vertex {
-        position: (18.4381, -33.1798, 40.2743),
-    },
-    Vertex {
-        position: (17.5665, -35.6115, 38.2256),
-    },
-    Vertex {
-        position: (0.831025, -22.7202, 53.5221),
-    },
-    Vertex {
-        position: (0.831025, -28.9493, 48.6365),
-    },
-    Vertex {
-        position: (0.831025, -33.1798, 43.7508),
-    },
-    Vertex {
-        position: (0.831025, -35.6115, 41.5301),
-    },
-    Vertex {
-        position: (-20.6113, -22.7202, 49.2882),
-    },
-    Vertex {
-        position: (-18.6937, -28.9493, 44.7813),
-    },
-    Vertex {
-        position: (-16.7761, -33.1798, 40.2743),
-    },
-    Vertex {
-        position: (-15.9044, -35.6115, 38.2256),
-    },
-    Vertex {
-        position: (-37.9564, -22.7202, 37.6793),
-    },
-    Vertex {
-        position: (-34.4876, -28.9493, 34.2106),
-    },
-    Vertex {
-        position: (-31.0188, -33.1798, 30.7418),
-    },
-    Vertex {
-        position: (-29.4421, -35.6115, 29.165),
-    },
-    Vertex {
-        position: (-49.5653, -22.7202, 20.3343),
-    },
-    Vertex {
-        position: (-45.0583, -28.9493, 18.4167),
-    },
-    Vertex {
-        position: (-40.5513, -33.1798, 16.4991),
-    },
-    Vertex {
-        position: (-38.5027, -35.6115, 15.6274),
-    },
-    Vertex {
-        position: (-53.7991, -22.7202, -1.10804),
-    },
-    Vertex {
-        position: (-48.9135, -28.9493, -1.10804),
-    },
-    Vertex {
-        position: (-44.0279, -33.1798, -1.10804),
-    },
-    Vertex {
-        position: (-41.8071, -35.6115, -1.10804),
-    },
-    Vertex {
-        position: (-49.5653, -22.7202, -22.5504),
-    },
-    Vertex {
-        position: (-45.0583, -28.9493, -20.6327),
-    },
-    Vertex {
-        position: (-40.5513, -33.1798, -18.7151),
-    },
-    Vertex {
-        position: (-38.5027, -35.6115, -17.8435),
-    },
-    Vertex {
-        position: (-37.9564, -22.7202, -39.8954),
-    },
-    Vertex {
-        position: (-34.4876, -28.9493, -36.4266),
-    },
-    Vertex {
-        position: (-31.0188, -33.1798, -32.9578),
-    },
-    Vertex {
-        position: (-29.4421, -35.6115, -31.3811),
-    },
-    Vertex {
-        position: (-20.6113, -22.7202, -51.5043),
-    },
-    Vertex {
-        position: (-18.6937, -28.9493, -46.9973),
-    },
-    Vertex {
-        position: (-16.7761, -33.1798, -42.4903),
-    },
-    Vertex {
-        position: (-15.9044, -35.6115, -40.4417),
-    },
-    Vertex {
-        position: (0.831025, -22.7202, -55.7382),
-    },
-    Vertex {
-        position: (0.831025, -28.9493, -50.8525),
-    },
-    Vertex {
-        position: (0.831025, -33.1798, -45.9669),
-    },
-    Vertex {
-        position: (0.831025, -35.6115, -43.7462),
-    },
-    Vertex {
-        position: (22.2733, -22.7202, -51.5043),
-    },
-    Vertex {
-        position: (20.3557, -28.9493, -46.9973),
-    },
-    Vertex {
-        position: (18.4381, -33.1798, -42.4903),
-    },
-    Vertex {
-        position: (17.5665, -35.6115, -40.4417),
-    },
-    Vertex {
-        position: (39.6184, -22.7202, -39.8954),
-    },
-    Vertex {
-        position: (36.1496, -28.9493, -36.4266),
-    },
-    Vertex {
-        position: (32.6808, -33.1798, -32.9578),
-    },
-    Vertex {
-        position: (31.1041, -35.6115, -31.3811),
-    },
-    Vertex {
-        position: (51.2273, -22.7202, -22.5504),
-    },
-    Vertex {
-        position: (46.7203, -28.9493, -20.6327),
-    },
-    Vertex {
-        position: (42.2133, -33.1798, -18.7151),
-    },
-    Vertex {
-        position: (40.1647, -35.6115, -17.8435),
-    },
-    Vertex {
-        position: (42.5031, -37.1772, -1.10804),
-    },
-    Vertex {
-        position: (37.3399, -38.5429, -1.10804),
-    },
-    Vertex {
-        position: (24.5818, -39.5089, -1.10804),
-    },
-    Vertex {
-        position: (0.831025, -39.8754, -1.10804),
-    },
-    Vertex {
-        position: (39.2736, -37.1772, 15.2483),
-    },
-    Vertex {
-        position: (34.5105, -38.5429, 13.2217),
-    },
-    Vertex {
-        position: (22.7411, -39.5089, 8.21414),
-    },
-    Vertex {
-        position: (30.4182, -37.1772, 28.4792),
-    },
-    Vertex {
-        position: (26.7523, -38.5429, 24.8133),
-    },
-    Vertex {
-        position: (17.6941, -39.5089, 15.755),
-    },
-    Vertex {
-        position: (17.1873, -37.1772, 37.3345),
-    },
-    Vertex {
-        position: (15.1608, -38.5429, 32.5714),
-    },
-    Vertex {
-        position: (10.1532, -39.5089, 20.8021),
-    },
-    Vertex {
-        position: (0.831025, -37.1772, 40.5641),
-    },
-    Vertex {
-        position: (0.831025, -38.5429, 35.4009),
-    },
-    Vertex {
-        position: (0.831025, -39.5089, 22.6427),
-    },
-    Vertex {
-        position: (-15.5253, -37.1772, 37.3345),
-    },
-    Vertex {
-        position: (-13.4987, -38.5429, 32.5714),
-    },
-    Vertex {
-        position: (-8.49115, -39.5089, 20.8021),
-    },
-    Vertex {
-        position: (-28.7562, -37.1772, 28.4792),
-    },
-    Vertex {
-        position: (-25.0903, -38.5429, 24.8133),
-    },
-    Vertex {
-        position: (-16.032, -39.5089, 15.755),
-    },
-    Vertex {
-        position: (-37.6115, -37.1772, 15.2483),
-    },
-    Vertex {
-        position: (-32.8484, -38.5429, 13.2217),
-    },
-    Vertex {
-        position: (-21.0791, -39.5089, 8.21414),
-    },
-    Vertex {
-        position: (-40.8411, -37.1772, -1.10804),
-    },
-    Vertex {
-        position: (-35.6779, -38.5429, -1.10804),
-    },
-    Vertex {
-        position: (-22.9198, -39.5089, -1.10804),
-    },
-    Vertex {
-        position: (-37.6115, -37.1772, -17.4643),
-    },
-    Vertex {
-        position: (-32.8484, -38.5429, -15.4378),
-    },
-    Vertex {
-        position: (-21.0791, -39.5089, -10.4302),
-    },
-    Vertex {
-        position: (-28.7562, -37.1772, -30.6952),
-    },
-    Vertex {
-        position: (-25.0903, -38.5429, -27.0294),
-    },
-    Vertex {
-        position: (-16.032, -39.5089, -17.9711),
-    },
-    Vertex {
-        position: (-15.5253, -37.1772, -39.5506),
-    },
-    Vertex {
-        position: (-13.4987, -38.5429, -34.7875),
-    },
-    Vertex {
-        position: (-8.49115, -39.5089, -23.0181),
-    },
-    Vertex {
-        position: (0.831025, -37.1772, -42.7802),
-    },
-    Vertex {
-        position: (0.831025, -38.5429, -37.6169),
-    },
-    Vertex {
-        position: (0.831025, -39.5089, -24.8588),
-    },
-    Vertex {
-        position: (17.1873, -37.1772, -39.5506),
-    },
-    Vertex {
-        position: (15.1608, -38.5429, -34.7875),
-    },
-    Vertex {
-        position: (10.1532, -39.5089, -23.0181),
-    },
-    Vertex {
-        position: (30.4182, -37.1772, -30.6952),
-    },
-    Vertex {
-        position: (26.7523, -38.5429, -27.0294),
-    },
-    Vertex {
-        position: (17.6941, -39.5089, -17.9711),
-    },
-    Vertex {
-        position: (39.2736, -37.1772, -17.4643),
-    },
-    Vertex {
-        position: (34.5105, -38.5429, -15.4378),
-    },
-    Vertex {
-        position: (22.7411, -39.5089, -10.4302),
-    },
-    Vertex {
-        position: (-44.6497, 17.6861, -1.10804),
-    },
-    Vertex {
-        position: (-57.9297, 17.5862, -1.10804),
-    },
-    Vertex {
-        position: (-67.7453, 16.8867, -1.10804),
-    },
-    Vertex {
-        position: (-73.8301, 14.9879, -1.10804),
-    },
-    Vertex {
-        position: (-75.9176, 11.2904, -1.10804),
-    },
-    Vertex {
-        position: (-44.2055, 18.6855, 3.68876),
-    },
-    Vertex {
-        position: (-58.3252, 18.5699, 3.68876),
-    },
-    Vertex {
-        position: (-68.6891, 17.7611, 3.68876),
-    },
-    Vertex {
-        position: (-75.0724, 15.5657, 3.68876),
-    },
-    Vertex {
-        position: (-77.2501, 11.2904, 3.68876),
-    },
-    Vertex {
-        position: (-43.2284, 20.884, 5.28769),
-    },
-    Vertex {
-        position: (-59.1955, 20.7341, 5.28769),
-    },
-    Vertex {
-        position: (-70.7655, 19.6848, 5.28769),
-    },
-    Vertex {
-        position: (-77.8053, 16.8367, 5.28769),
-    },
-    Vertex {
-        position: (-80.1814, 11.2904, 5.28769),
-    },
-    Vertex {
-        position: (-42.2513, 23.0825, 3.68876),
-    },
-    Vertex {
-        position: (-60.0657, 22.8983, 3.68876),
-    },
-    Vertex {
-        position: (-72.8419, 21.6085, 3.68876),
-    },
-    Vertex {
-        position: (-80.5381, 18.1077, 3.68876),
-    },
-    Vertex {
-        position: (-83.1128, 11.2904, 3.68876),
-    },
-    Vertex {
-        position: (-41.8071, 24.0819, -1.10804),
-    },
-    Vertex {
-        position: (-60.4613, 23.882, -1.10804),
-    },
-    Vertex {
-        position: (-73.7857, 22.4829, -1.10804),
-    },
-    Vertex {
-        position: (-81.7804, 18.6855, -1.10804),
-    },
-    Vertex {
-        position: (-84.4453, 11.2904, -1.10804),
-    },
-    Vertex {
-        position: (-42.2513, 23.0825, -5.90483),
-    },
-    Vertex {
-        position: (-60.0657, 22.8983, -5.90483),
-    },
-    Vertex {
-        position: (-72.8419, 21.6085, -5.90483),
-    },
-    Vertex {
-        position: (-80.5381, 18.1077, -5.90483),
-    },
-    Vertex {
-        position: (-83.1128, 11.2904, -5.90483),
-    },
-    Vertex {
-        position: (-43.2284, 20.884, -7.50376),
-    },
-    Vertex {
-        position: (-59.1955, 20.7341, -7.50376),
-    },
-    Vertex {
-        position: (-70.7655, 19.6848, -7.50376),
-    },
-    Vertex {
-        position: (-77.8053, 16.8367, -7.50376),
-    },
-    Vertex {
-        position: (-80.1814, 11.2904, -7.50376),
-    },
-    Vertex {
-        position: (-44.2055, 18.6855, -5.90483),
-    },
-    Vertex {
-        position: (-58.3252, 18.5699, -5.90483),
-    },
-    Vertex {
-        position: (-68.6891, 17.7611, -5.90483),
-    },
-    Vertex {
-        position: (-75.0724, 15.5657, -5.90483),
-    },
-    Vertex {
-        position: (-77.2501, 11.2904, -5.90483),
-    },
-    Vertex {
-        position: (-74.8073, 5.4943, -1.10804),
-    },
-    Vertex {
-        position: (-71.2985, -1.50103, -1.10804),
-    },
-    Vertex {
-        position: (-65.1248, -8.49634, -1.10804),
-    },
-    Vertex {
-        position: (-56.0198, -14.2925, -1.10804),
-    },
-    Vertex {
-        position: (-76.0183, 4.93477, 3.68876),
-    },
-    Vertex {
-        position: (-72.159, -2.35462, 3.68876),
-    },
-    Vertex {
-        position: (-65.4267, -9.55033, 3.68876),
-    },
-    Vertex {
-        position: (-55.5757, -15.6249, 3.68876),
-    },
-    Vertex {
-        position: (-78.6824, 3.70383, 5.28769),
-    },
-    Vertex {
-        position: (-74.0522, -4.23253, 5.28769),
-    },
-    Vertex {
-        position: (-66.0909, -11.8691, 5.28769),
-    },
-    Vertex {
-        position: (-54.5986, -18.5563, 5.28769),
-    },
-    Vertex {
-        position: (-81.3466, 2.47288, 3.68876),
-    },
-    Vertex {
-        position: (-75.9454, -6.11044, 3.68876),
-    },
-    Vertex {
-        position: (-66.755, -14.1878, 3.68876),
-    },
-    Vertex {
-        position: (-53.6214, -21.4877, 3.68876),
-    },
-    Vertex {
-        position: (-82.5576, 1.91336, -1.10804),
-    },
-    Vertex {
-        position: (-76.8059, -6.96404, -1.10804),
-    },
-    Vertex {
-        position: (-67.0569, -15.2418, -1.10804),
-    },
-    Vertex {
-        position: (-53.1773, -22.8201, -1.10804),
-    },
-    Vertex {
-        position: (-81.3466, 2.47288, -5.90483),
-    },
-    Vertex {
-        position: (-75.9454, -6.11044, -5.90483),
-    },
-    Vertex {
-        position: (-66.755, -14.1878, -5.90483),
-    },
-    Vertex {
-        position: (-53.6214, -21.4877, -5.90483),
-    },
-    Vertex {
-        position: (-78.6824, 3.70383, -7.50376),
-    },
-    Vertex {
-        position: (-74.0522, -4.23253, -7.50376),
-    },
-    Vertex {
-        position: (-66.0909, -11.8691, -7.50376),
-    },
-    Vertex {
-        position: (-54.5986, -18.5563, -7.50376),
-    },
-    Vertex {
-        position: (-76.0183, 4.93477, -5.90483),
-    },
-    Vertex {
-        position: (-72.159, -2.35462, -5.90483),
-    },
-    Vertex {
-        position: (-65.4267, -9.55033, -5.90483),
-    },
-    Vertex {
-        position: (-55.5757, -15.6249, -5.90483),
-    },
-    Vertex {
-        position: (49.1543, 0.630882, -1.10804),
-    },
-    Vertex {
-        position: (62.7896, 3.76212, -1.10804),
-    },
-    Vertex {
-        position: (68.6967, 11.2904, -1.10804),
-    },
-    Vertex {
-        position: (71.939, 20.4176, -1.10804),
-    },
-    Vertex {
-        position: (77.5797, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (49.1543, -3.03333, 9.4449),
-    },
-    Vertex {
-        position: (63.8305, 1.04519, 8.42059),
-    },
-    Vertex {
-        position: (70.0292, 9.70814, 6.1671),
-    },
-    Vertex {
-        position: (73.5629, 19.8451, 3.91361),
-    },
-    Vertex {
-        position: (80.2446, 28.3457, 2.88929),
-    },
-    Vertex {
-        position: (49.1543, -11.0946, 12.9626),
-    },
-    Vertex {
-        position: (66.1207, -4.93206, 11.5968),
-    },
-    Vertex {
-        position: (72.9605, 6.22714, 8.59214),
-    },
-    Vertex {
-        position: (77.1355, 18.5855, 5.58749),
-    },
-    Vertex {
-        position: (86.1073, 28.3457, 4.22173),
-    },
-    Vertex {
-        position: (49.1543, -19.1559, 9.4449),
-    },
-    Vertex {
-        position: (68.4108, -10.9093, 8.42059),
-    },
-    Vertex {
-        position: (75.8919, 2.74614, 6.1671),
-    },
-    Vertex {
-        position: (80.7081, 17.326, 3.91361),
-    },
-    Vertex {
-        position: (91.97, 28.3457, 2.88929),
-    },
-    Vertex {
-        position: (49.1543, -22.8201, -1.10804),
-    },
-    Vertex {
-        position: (69.4518, -13.6262, -1.10804),
-    },
-    Vertex {
-        position: (77.2244, 1.16386, -1.10804),
-    },
-    Vertex {
-        position: (82.3321, 16.7534, -1.10804),
-    },
-    Vertex {
-        position: (94.6349, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (49.1543, -19.1559, -11.661),
-    },
-    Vertex {
-        position: (68.4108, -10.9093, -10.6367),
-    },
-    Vertex {
-        position: (75.8919, 2.74614, -8.38317),
-    },
-    Vertex {
-        position: (80.7081, 17.326, -6.12968),
-    },
-    Vertex {
-        position: (91.97, 28.3457, -5.10536),
-    },
-    Vertex {
-        position: (49.1543, -11.0946, -15.1786),
-    },
-    Vertex {
-        position: (66.1207, -4.93206, -13.8129),
-    },
-    Vertex {
-        position: (72.9605, 6.22714, -10.8082),
-    },
-    Vertex {
-        position: (77.1355, 18.5855, -7.80356),
-    },
-    Vertex {
-        position: (86.1073, 28.3457, -6.4378),
-    },
-    Vertex {
-        position: (49.1543, -3.03333, -11.661),
-    },
-    Vertex {
-        position: (63.8305, 1.04519, -10.6367),
-    },
-    Vertex {
-        position: (70.0292, 9.70814, -8.38317),
-    },
-    Vertex {
-        position: (73.5629, 19.8451, -6.12968),
-    },
-    Vertex {
-        position: (80.2446, 28.3457, -5.10536),
-    },
-    Vertex {
-        position: (79.6227, 29.5449, -1.10804),
-    },
-    Vertex {
-        position: (81.1329, 29.9446, -1.10804),
-    },
-    Vertex {
-        position: (81.577, 29.5449, -1.10804),
-    },
-    Vertex {
-        position: (80.4222, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (82.4767, 29.6034, 2.63946),
-    },
-    Vertex {
-        position: (83.8116, 30.0383, 2.08983),
-    },
-    Vertex {
-        position: (83.8515, 29.6268, 1.54019),
-    },
-    Vertex {
-        position: (82.1988, 28.3457, 1.29036),
-    },
-    Vertex {
-        position: (88.7555, 29.7322, 3.88862),
-    },
-    Vertex {
-        position: (89.7049, 30.2444, 3.15578),
-    },
-    Vertex {
-        position: (88.8555, 29.8072, 2.42294),
-    },
-    Vertex {
-        position: (86.1073, 28.3457, 2.08983),
-    },
-    Vertex {
-        position: (95.0343, 29.8611, 2.63946),
-    },
-    Vertex {
-        position: (95.5982, 30.4505, 2.08983),
-    },
-    Vertex {
-        position: (93.8594, 29.9875, 1.54019),
-    },
-    Vertex {
-        position: (90.0158, 28.3457, 1.29036),
-    },
-    Vertex {
-        position: (97.8883, 29.9196, -1.10804),
-    },
-    Vertex {
-        position: (98.2769, 30.5442, -1.10804),
-    },
-    Vertex {
-        position: (96.1339, 30.0695, -1.10804),
-    },
-    Vertex {
-        position: (91.7924, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (95.0343, 29.8611, -4.85553),
-    },
-    Vertex {
-        position: (95.5982, 30.4505, -4.3059),
-    },
-    Vertex {
-        position: (93.8594, 29.9875, -3.75626),
-    },
-    Vertex {
-        position: (90.0158, 28.3457, -3.50643),
-    },
-    Vertex {
-        position: (88.7555, 29.7322, -6.10469),
-    },
-    Vertex {
-        position: (89.7049, 30.2444, -5.37185),
-    },
-    Vertex {
-        position: (88.8555, 29.8072, -4.63901),
-    },
-    Vertex {
-        position: (86.1073, 28.3457, -4.3059),
-    },
-    Vertex {
-        position: (82.4767, 29.6034, -4.85553),
-    },
-    Vertex {
-        position: (83.8116, 30.0383, -4.3059),
-    },
-    Vertex {
-        position: (83.8515, 29.6268, -3.75626),
-    },
-    Vertex {
-        position: (82.1988, 28.3457, -3.50643),
-    },
-    Vertex {
-        position: (0.831025, 49.6647, -1.10804),
-    },
-    Vertex {
-        position: (10.5134, 48.2657, -1.10804),
-    },
-    Vertex {
-        position: (10.0693, 44.868, -1.10804),
-    },
-    Vertex {
-        position: (6.42728, 40.6708, -1.10804),
-    },
-    Vertex {
-        position: (6.51611, 36.8733, -1.10804),
-    },
-    Vertex {
-        position: (9.76642, 48.2657, 2.70243),
-    },
-    Vertex {
-        position: (9.35632, 44.868, 2.52698),
-    },
-    Vertex {
-        position: (5.9947, 40.6708, 1.09187),
-    },
-    Vertex {
-        position: (6.07552, 36.8733, 1.12336),
-    },
-    Vertex {
-        position: (7.71453, 48.2657, 5.77547),
-    },
-    Vertex {
-        position: (7.39819, 44.868, 5.45913),
-    },
-    Vertex {
-        position: (4.80736, 40.6708, 2.8683),
-    },
-    Vertex {
-        position: (4.86744, 36.8733, 2.92838),
-    },
-    Vertex {
-        position: (4.64149, 48.2657, 7.82736),
-    },
-    Vertex {
-        position: (4.46604, 44.868, 7.41726),
-    },
-    Vertex {
-        position: (3.03093, 40.6708, 4.05564),
-    },
-    Vertex {
-        position: (3.06242, 36.8733, 4.13646),
-    },
-    Vertex {
-        position: (0.831025, 48.2657, 8.57438),
-    },
-    Vertex {
-        position: (0.831025, 44.868, 8.13023),
-    },
-    Vertex {
-        position: (0.831025, 40.6708, 4.48822),
-    },
-    Vertex {
-        position: (0.831025, 36.8733, 4.57705),
-    },
-    Vertex {
-        position: (-2.97944, 48.2657, 7.82736),
-    },
-    Vertex {
-        position: (-2.80399, 44.868, 7.41726),
-    },
-    Vertex {
-        position: (-1.36888, 40.6708, 4.05564),
-    },
-    Vertex {
-        position: (-1.40037, 36.8733, 4.13646),
-    },
-    Vertex {
-        position: (-6.05248, 48.2657, 5.77547),
-    },
-    Vertex {
-        position: (-5.73614, 44.868, 5.45913),
-    },
-    Vertex {
-        position: (-3.14531, 40.6708, 2.8683),
-    },
-    Vertex {
-        position: (-3.20539, 36.8733, 2.92838),
-    },
-    Vertex {
-        position: (-8.10437, 48.2657, 2.70243),
-    },
-    Vertex {
-        position: (-7.69427, 44.868, 2.52698),
-    },
-    Vertex {
-        position: (-4.33265, 40.6708, 1.09187),
-    },
-    Vertex {
-        position: (-4.41347, 36.8733, 1.12336),
-    },
-    Vertex {
-        position: (-8.85139, 48.2657, -1.10804),
-    },
-    Vertex {
-        position: (-8.40724, 44.868, -1.10804),
-    },
-    Vertex {
-        position: (-4.76523, 40.6708, -1.10804),
-    },
-    Vertex {
-        position: (-4.85406, 36.8733, -1.10804),
-    },
-    Vertex {
-        position: (-8.10437, 48.2657, -4.9185),
-    },
-    Vertex {
-        position: (-7.69427, 44.868, -4.74305),
-    },
-    Vertex {
-        position: (-4.33265, 40.6708, -3.30794),
-    },
-    Vertex {
-        position: (-4.41347, 36.8733, -3.33943),
-    },
-    Vertex {
-        position: (-6.05248, 48.2657, -7.99154),
-    },
-    Vertex {
-        position: (-5.73614, 44.868, -7.6752),
-    },
-    Vertex {
-        position: (-3.14531, 40.6708, -5.08437),
-    },
-    Vertex {
-        position: (-3.20539, 36.8733, -5.14445),
-    },
-    Vertex {
-        position: (-2.97944, 48.2657, -10.0434),
-    },
-    Vertex {
-        position: (-2.80399, 44.868, -9.63333),
-    },
-    Vertex {
-        position: (-1.36888, 40.6708, -6.27171),
-    },
-    Vertex {
-        position: (-1.40037, 36.8733, -6.35253),
-    },
-    Vertex {
-        position: (0.831025, 48.2657, -10.7904),
-    },
-    Vertex {
-        position: (0.831025, 44.868, -10.3463),
-    },
-    Vertex {
-        position: (0.831025, 40.6708, -6.70429),
-    },
-    Vertex {
-        position: (0.831025, 36.8733, -6.79312),
-    },
-    Vertex {
-        position: (4.64149, 48.2657, -10.0434),
-    },
-    Vertex {
-        position: (4.46604, 44.868, -9.63333),
-    },
-    Vertex {
-        position: (3.03093, 40.6708, -6.27171),
-    },
-    Vertex {
-        position: (3.06242, 36.8733, -6.35253),
-    },
-    Vertex {
-        position: (7.71453, 48.2657, -7.99154),
-    },
-    Vertex {
-        position: (7.39819, 44.868, -7.6752),
-    },
-    Vertex {
-        position: (4.80736, 40.6708, -5.08437),
-    },
-    Vertex {
-        position: (4.86744, 36.8733, -5.14445),
-    },
-    Vertex {
-        position: (9.76642, 48.2657, -4.9185),
-    },
-    Vertex {
-        position: (9.35632, 44.868, -4.74305),
-    },
-    Vertex {
-        position: (5.9947, 40.6708, -3.30794),
-    },
-    Vertex {
-        position: (6.07552, 36.8733, -3.33943),
-    },
-    Vertex {
-        position: (13.8001, 34.3417, -1.10804),
-    },
-    Vertex {
-        position: (24.282, 32.6095, -1.10804),
-    },
-    Vertex {
-        position: (33.6979, 30.8773, -1.10804),
-    },
-    Vertex {
-        position: (37.7841, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (12.795, 34.3417, 3.98234),
-    },
-    Vertex {
-        position: (22.4646, 32.6095, 8.09647),
-    },
-    Vertex {
-        position: (31.1507, 30.8773, 11.7922),
-    },
-    Vertex {
-        position: (34.9202, 28.3457, 13.396),
-    },
-    Vertex {
-        position: (10.0391, 34.3417, 8.10003),
-    },
-    Vertex {
-        position: (17.4812, 32.6095, 15.5422),
-    },
-    Vertex {
-        position: (24.1665, 30.8773, 22.2275),
-    },
-    Vertex {
-        position: (27.0677, 28.3457, 25.1286),
-    },
-    Vertex {
-        position: (5.9214, 34.3417, 10.856),
-    },
-    Vertex {
-        position: (10.0355, 32.6095, 20.5255),
-    },
-    Vertex {
-        position: (13.7313, 30.8773, 29.2117),
-    },
-    Vertex {
-        position: (15.3351, 28.3457, 32.9812),
-    },
-    Vertex {
-        position: (0.831025, 34.3417, 11.8611),
-    },
-    Vertex {
-        position: (0.831025, 32.6095, 22.3429),
-    },
-    Vertex {
-        position: (0.831025, 30.8773, 31.7589),
-    },
-    Vertex {
-        position: (0.831025, 28.3457, 35.845),
-    },
-    Vertex {
-        position: (-4.25935, 34.3417, 10.856),
-    },
-    Vertex {
-        position: (-8.37348, 32.6095, 20.5255),
-    },
-    Vertex {
-        position: (-12.0692, 30.8773, 29.2117),
-    },
-    Vertex {
-        position: (-13.673, 28.3457, 32.9812),
-    },
-    Vertex {
-        position: (-8.37704, 34.3417, 8.10003),
-    },
-    Vertex {
-        position: (-15.8192, 32.6095, 15.5422),
-    },
-    Vertex {
-        position: (-22.5045, 30.8773, 22.2275),
-    },
-    Vertex {
-        position: (-25.4056, 28.3457, 25.1286),
-    },
-    Vertex {
-        position: (-11.133, 34.3417, 3.98234),
-    },
-    Vertex {
-        position: (-20.8025, 32.6095, 8.09647),
-    },
-    Vertex {
-        position: (-29.4887, 30.8773, 11.7922),
-    },
-    Vertex {
-        position: (-33.2582, 28.3457, 13.396),
-    },
-    Vertex {
-        position: (-12.1381, 34.3417, -1.10804),
-    },
-    Vertex {
-        position: (-22.62, 32.6095, -1.10804),
-    },
-    Vertex {
-        position: (-32.0359, 30.8773, -1.10804),
-    },
-    Vertex {
-        position: (-36.122, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (-11.133, 34.3417, -6.19841),
-    },
-    Vertex {
-        position: (-20.8025, 32.6095, -10.3125),
-    },
-    Vertex {
-        position: (-29.4887, 30.8773, -14.0083),
-    },
-    Vertex {
-        position: (-33.2582, 28.3457, -15.6121),
-    },
-    Vertex {
-        position: (-8.37704, 34.3417, -10.3161),
-    },
-    Vertex {
-        position: (-15.8192, 32.6095, -17.7582),
-    },
-    Vertex {
-        position: (-22.5045, 30.8773, -24.4435),
-    },
-    Vertex {
-        position: (-25.4056, 28.3457, -27.3447),
-    },
-    Vertex {
-        position: (-4.25935, 34.3417, -13.072),
-    },
-    Vertex {
-        position: (-8.37348, 32.6095, -22.7416),
-    },
-    Vertex {
-        position: (-12.0692, 30.8773, -31.4277),
-    },
-    Vertex {
-        position: (-13.673, 28.3457, -35.1972),
-    },
-    Vertex {
-        position: (0.831025, 34.3417, -14.0771),
-    },
-    Vertex {
-        position: (0.831025, 32.6095, -24.559),
-    },
-    Vertex {
-        position: (0.831025, 30.8773, -33.9749),
-    },
-    Vertex {
-        position: (0.831025, 28.3457, -38.0611),
-    },
-    Vertex {
-        position: (5.9214, 34.3417, -13.072),
-    },
-    Vertex {
-        position: (10.0355, 32.6095, -22.7416),
-    },
-    Vertex {
-        position: (13.7313, 30.8773, -31.4277),
-    },
-    Vertex {
-        position: (15.3351, 28.3457, -35.1972),
-    },
-    Vertex {
-        position: (10.0391, 34.3417, -10.3161),
-    },
-    Vertex {
-        position: (17.4812, 32.6095, -17.7582),
-    },
-    Vertex {
-        position: (24.1665, 30.8773, -24.4435),
-    },
-    Vertex {
-        position: (27.0677, 28.3457, -27.3447),
-    },
-    Vertex {
-        position: (12.795, 34.3417, -6.19841),
-    },
-    Vertex {
-        position: (22.4646, 32.6095, -10.3125),
-    },
-    Vertex {
-        position: (31.1507, 30.8773, -14.0083),
-    },
-    Vertex {
-        position: (34.9202, 28.3457, -15.6121),
-    },
-];
-
-pub const NORMALS: [Normal; 531] = [
-    Normal {
-        normal: (0.0, 0.0, 0.0),
-    }, // dummy vector because in the original model indices
-    // start at 1
-    Normal {
-        normal: (-0.966742, -0.255752, 0.0),
-    },
-    Normal {
-        normal: (-0.966824, 0.255443, 0.0),
-    },
-    Normal {
-        normal: (-0.092052, 0.995754, 0.0),
-    },
-    Normal {
-        normal: (0.68205, 0.731305, 0.0),
-    },
-    Normal {
-        normal: (0.870301, 0.492521, -0.0),
-    },
-    Normal {
-        normal: (-0.893014, -0.256345, -0.369882),
-    },
-    Normal {
-        normal: (-0.893437, 0.255997, -0.369102),
-    },
-    Normal {
-        normal: (-0.0838771, 0.995843, -0.0355068),
-    },
-    Normal {
-        normal: (0.629724, 0.73186, 0.260439),
-    },
-    Normal {
-        normal: (0.803725, 0.49337, 0.332584),
-    },
-    Normal {
-        normal: (-0.683407, -0.256729, -0.683407),
-    },
-    Normal {
-        normal: (-0.683531, 0.256067, -0.683531),
-    },
-    Normal {
-        normal: (-0.0649249, 0.995776, -0.0649248),
-    },
-    Normal {
-        normal: (0.481398, 0.732469, 0.481398),
-    },
-    Normal {
-        normal: (0.614804, 0.493997, 0.614804),
-    },
-    Normal {
-        normal: (-0.369882, -0.256345, -0.893014),
-    },
-    Normal {
-        normal: (-0.369102, 0.255997, -0.893437),
-    },
-    Normal {
-        normal: (-0.0355067, 0.995843, -0.0838772),
-    },
-    Normal {
-        normal: (0.260439, 0.73186, 0.629724),
-    },
-    Normal {
-        normal: (0.332584, 0.49337, 0.803725),
-    },
-    Normal {
-        normal: (-0.00284834, -0.257863, -0.966177),
-    },
-    Normal {
-        normal: (-0.00192311, 0.254736, -0.967009),
-    },
-    Normal {
-        normal: (-0.000266114, 0.995734, -0.0922702),
-    },
-    Normal {
-        normal: (0.0, 0.731295, 0.682061),
-    },
-    Normal {
-        normal: (0.0, 0.492521, 0.870301),
-    },
-    Normal {
-        normal: (0.379058, -0.3593, -0.852771),
-    },
-    Normal {
-        normal: (0.37711, 0.149086, -0.914091),
-    },
-    Normal {
-        normal: (0.0275022, 0.992081, -0.122551),
-    },
-    Normal {
-        normal: (-0.26101, 0.726762, 0.635367),
-    },
-    Normal {
-        normal: (-0.332485, 0.492546, 0.804271),
-    },
-    Normal {
-        normal: (0.663548, -0.410791, -0.625264),
-    },
-    Normal {
-        normal: (0.712664, 0.0737216, -0.697621),
-    },
-    Normal {
-        normal: (0.0997268, 0.987509, -0.121984),
-    },
-    Normal {
-        normal: (-0.48732, 0.723754, 0.488568),
-    },
-    Normal {
-        normal: (-0.615242, 0.492602, 0.615484),
-    },
-    Normal {
-        normal: (0.880028, -0.332908, -0.338709),
-    },
-    Normal {
-        normal: (0.917276, 0.167113, -0.361493),
-    },
-    Normal {
-        normal: (0.113584, 0.992365, -0.0480695),
-    },
-    Normal {
-        normal: (-0.63415, 0.727508, 0.261889),
-    },
-    Normal {
-        normal: (-0.804126, 0.492634, 0.332705),
-    },
-    Normal {
-        normal: (0.96669, -0.255738, 0.0104537),
-    },
-    Normal {
-        normal: (0.967442, 0.252962, 0.00810329),
-    },
-    Normal {
-        normal: (0.0934365, 0.995624, 0.00128063),
-    },
-    Normal {
-        normal: (-0.682167, 0.731196, -0.00034353),
-    },
-    Normal {
-        normal: (-0.870322, 0.492483, -0.0),
-    },
-    Normal {
-        normal: (0.893014, -0.256345, 0.369882),
-    },
-    Normal {
-        normal: (0.893437, 0.255997, 0.369102),
-    },
-    Normal {
-        normal: (0.0838768, 0.995843, 0.0355066),
-    },
-    Normal {
-        normal: (-0.629724, 0.73186, -0.260439),
-    },
-    Normal {
-        normal: (-0.803725, 0.49337, -0.332584),
-    },
-    Normal {
-        normal: (0.683407, -0.256729, 0.683407),
-    },
-    Normal {
-        normal: (0.683531, 0.256067, 0.683531),
-    },
-    Normal {
-        normal: (0.0649249, 0.995776, 0.0649249),
-    },
-    Normal {
-        normal: (-0.481398, 0.732469, -0.481398),
-    },
-    Normal {
-        normal: (-0.614804, 0.493997, -0.614804),
-    },
-    Normal {
-        normal: (0.369882, -0.256345, 0.893014),
-    },
-    Normal {
-        normal: (0.369102, 0.255997, 0.893437),
-    },
-    Normal {
-        normal: (0.0355067, 0.995843, 0.083877),
-    },
-    Normal {
-        normal: (-0.260439, 0.73186, -0.629724),
-    },
-    Normal {
-        normal: (-0.332584, 0.49337, -0.803725),
-    },
-    Normal {
-        normal: (0.0, -0.255752, 0.966742),
-    },
-    Normal {
-        normal: (0.0, 0.255443, 0.966824),
-    },
-    Normal {
-        normal: (0.0, 0.995754, 0.092052),
-    },
-    Normal {
-        normal: (0.0, 0.731305, -0.68205),
-    },
-    Normal {
-        normal: (-0.0, 0.492521, -0.870301),
-    },
-    Normal {
-        normal: (-0.369882, -0.256345, 0.893014),
-    },
-    Normal {
-        normal: (-0.369102, 0.255996, 0.893437),
-    },
-    Normal {
-        normal: (-0.0355068, 0.995843, 0.0838771),
-    },
-    Normal {
-        normal: (0.260439, 0.73186, -0.629724),
-    },
-    Normal {
-        normal: (0.332584, 0.49337, -0.803725),
-    },
-    Normal {
-        normal: (-0.683407, -0.256729, 0.683407),
-    },
-    Normal {
-        normal: (-0.683531, 0.256067, 0.683531),
-    },
-    Normal {
-        normal: (-0.0649249, 0.995776, 0.064925),
-    },
-    Normal {
-        normal: (0.481398, 0.732469, -0.481398),
-    },
-    Normal {
-        normal: (0.614804, 0.493997, -0.614804),
-    },
-    Normal {
-        normal: (-0.893014, -0.256345, 0.369882),
-    },
-    Normal {
-        normal: (-0.893437, 0.255997, 0.369102),
-    },
-    Normal {
-        normal: (-0.0838767, 0.995843, 0.0355066),
-    },
-    Normal {
-        normal: (0.629724, 0.73186, -0.260439),
-    },
-    Normal {
-        normal: (0.803725, 0.49337, -0.332584),
-    },
-    Normal {
-        normal: (0.915321, 0.402725, 0.0),
-    },
-    Normal {
-        normal: (0.941808, 0.336151, -0.0),
-    },
-    Normal {
-        normal: (0.97869, 0.205342, 0.0),
-    },
-    Normal {
-        normal: (0.997804, -0.0662397, 0.0),
-    },
-    Normal {
-        normal: (0.845438, 0.403546, 0.349835),
-    },
-    Normal {
-        normal: (0.869996, 0.336859, 0.360047),
-    },
-    Normal {
-        normal: (0.904193, 0.205791, 0.37428),
-    },
-    Normal {
-        normal: (0.921879, -0.0663697, 0.381752),
-    },
-    Normal {
-        normal: (0.646802, 0.404096, 0.646802),
-    },
-    Normal {
-        normal: (0.665655, 0.337351, 0.665655),
-    },
-    Normal {
-        normal: (0.691923, 0.20612, 0.691923),
-    },
-    Normal {
-        normal: (0.705542, -0.0664796, 0.705543),
-    },
-    Normal {
-        normal: (0.349835, 0.403546, 0.845438),
-    },
-    Normal {
-        normal: (0.360047, 0.336859, 0.869996),
-    },
-    Normal {
-        normal: (0.37428, 0.205791, 0.904193),
-    },
-    Normal {
-        normal: (0.381752, -0.0663697, 0.921879),
-    },
-    Normal {
-        normal: (-0.0, 0.402725, 0.915321),
-    },
-    Normal {
-        normal: (0.0, 0.336151, 0.941808),
-    },
-    Normal {
-        normal: (-0.0, 0.205342, 0.97869),
-    },
-    Normal {
-        normal: (-0.0, -0.0662397, 0.997804),
-    },
-    Normal {
-        normal: (-0.349835, 0.403546, 0.845438),
-    },
-    Normal {
-        normal: (-0.360047, 0.336859, 0.869996),
-    },
-    Normal {
-        normal: (-0.37428, 0.205791, 0.904193),
-    },
-    Normal {
-        normal: (-0.381752, -0.0663697, 0.921879),
-    },
-    Normal {
-        normal: (-0.646802, 0.404096, 0.646802),
-    },
-    Normal {
-        normal: (-0.665655, 0.337351, 0.665655),
-    },
-    Normal {
-        normal: (-0.691923, 0.20612, 0.691923),
-    },
-    Normal {
-        normal: (-0.705543, -0.0664796, 0.705543),
-    },
-    Normal {
-        normal: (-0.845438, 0.403546, 0.349835),
-    },
-    Normal {
-        normal: (-0.869996, 0.336859, 0.360047),
-    },
-    Normal {
-        normal: (-0.904193, 0.205791, 0.37428),
-    },
-    Normal {
-        normal: (-0.921879, -0.0663697, 0.381752),
-    },
-    Normal {
-        normal: (-0.915321, 0.402725, -0.0),
-    },
-    Normal {
-        normal: (-0.941808, 0.336151, -0.0),
-    },
-    Normal {
-        normal: (-0.97869, 0.205342, -0.0),
-    },
-    Normal {
-        normal: (-0.997804, -0.0662397, -0.0),
-    },
-    Normal {
-        normal: (-0.845438, 0.403546, -0.349835),
-    },
-    Normal {
-        normal: (-0.869996, 0.336859, -0.360047),
-    },
-    Normal {
-        normal: (-0.904193, 0.205791, -0.37428),
-    },
-    Normal {
-        normal: (-0.921879, -0.0663697, -0.381752),
-    },
-    Normal {
-        normal: (-0.646802, 0.404096, -0.646802),
-    },
-    Normal {
-        normal: (-0.665655, 0.337351, -0.665655),
-    },
-    Normal {
-        normal: (-0.691923, 0.20612, -0.691923),
-    },
-    Normal {
-        normal: (-0.705542, -0.0664796, -0.705543),
-    },
-    Normal {
-        normal: (-0.349835, 0.403546, -0.845438),
-    },
-    Normal {
-        normal: (-0.360047, 0.336859, -0.869996),
-    },
-    Normal {
-        normal: (-0.37428, 0.205791, -0.904193),
-    },
-    Normal {
-        normal: (-0.381752, -0.0663697, -0.921879),
-    },
-    Normal {
-        normal: (0.0, 0.402725, -0.915321),
-    },
-    Normal {
-        normal: (-0.0, 0.336151, -0.941808),
-    },
-    Normal {
-        normal: (0.0, 0.205342, -0.97869),
-    },
-    Normal {
-        normal: (0.0, -0.0662397, -0.997804),
-    },
-    Normal {
-        normal: (0.349835, 0.403546, -0.845438),
-    },
-    Normal {
-        normal: (0.360047, 0.336859, -0.869996),
-    },
-    Normal {
-        normal: (0.37428, 0.205791, -0.904193),
-    },
-    Normal {
-        normal: (0.381752, -0.0663697, -0.921879),
-    },
-    Normal {
-        normal: (0.646802, 0.404096, -0.646802),
-    },
-    Normal {
-        normal: (0.665655, 0.337351, -0.665655),
-    },
-    Normal {
-        normal: (0.691923, 0.20612, -0.691923),
-    },
-    Normal {
-        normal: (0.705543, -0.0664796, -0.705542),
-    },
-    Normal {
-        normal: (0.845438, 0.403546, -0.349835),
-    },
-    Normal {
-        normal: (0.869996, 0.336859, -0.360047),
-    },
-    Normal {
-        normal: (0.904193, 0.205791, -0.37428),
-    },
-    Normal {
-        normal: (0.921879, -0.0663697, -0.381752),
-    },
-    Normal {
-        normal: (0.900182, -0.435513, -0.0),
-    },
-    Normal {
-        normal: (0.729611, -0.683863, -0.0),
-    },
-    Normal {
-        normal: (0.693951, -0.720022, -0.0),
-    },
-    Normal {
-        normal: (0.79395, -0.607984, 0.0),
-    },
-    Normal {
-        normal: (0.831437, -0.43618, 0.344179),
-    },
-    Normal {
-        normal: (0.673512, -0.684665, 0.278594),
-    },
-    Normal {
-        normal: (0.640399, -0.720924, 0.264874),
-    },
-    Normal {
-        normal: (0.732949, -0.608996, 0.303166),
-    },
-    Normal {
-        normal: (0.636092, -0.436777, 0.636092),
-    },
-    Normal {
-        normal: (0.514965, -0.685289, 0.514965),
-    },
-    Normal {
-        normal: (0.489651, -0.721446, 0.489651),
-    },
-    Normal {
-        normal: (0.560555, -0.609554, 0.560555),
-    },
-    Normal {
-        normal: (0.344179, -0.43618, 0.831437),
-    },
-    Normal {
-        normal: (0.278594, -0.684665, 0.673512),
-    },
-    Normal {
-        normal: (0.264874, -0.720924, 0.640399),
-    },
-    Normal {
-        normal: (0.303166, -0.608996, 0.732949),
-    },
-    Normal {
-        normal: (0.0, -0.435513, 0.900182),
-    },
-    Normal {
-        normal: (-0.0, -0.683863, 0.729611),
-    },
-    Normal {
-        normal: (0.0, -0.720022, 0.693951),
-    },
-    Normal {
-        normal: (-0.0, -0.607984, 0.79395),
-    },
-    Normal {
-        normal: (-0.344179, -0.43618, 0.831437),
-    },
-    Normal {
-        normal: (-0.278594, -0.684665, 0.673512),
-    },
-    Normal {
-        normal: (-0.264874, -0.720924, 0.640399),
-    },
-    Normal {
-        normal: (-0.303166, -0.608996, 0.732949),
-    },
-    Normal {
-        normal: (-0.636092, -0.436777, 0.636092),
-    },
-    Normal {
-        normal: (-0.514965, -0.685289, 0.514965),
-    },
-    Normal {
-        normal: (-0.489651, -0.721446, 0.489651),
-    },
-    Normal {
-        normal: (-0.560555, -0.609554, 0.560555),
-    },
-    Normal {
-        normal: (-0.831437, -0.43618, 0.344179),
-    },
-    Normal {
-        normal: (-0.673512, -0.684665, 0.278595),
-    },
-    Normal {
-        normal: (-0.640399, -0.720924, 0.264874),
-    },
-    Normal {
-        normal: (-0.732949, -0.608996, 0.303166),
-    },
-    Normal {
-        normal: (-0.900182, -0.435513, -0.0),
-    },
-    Normal {
-        normal: (-0.729611, -0.683863, -0.0),
-    },
-    Normal {
-        normal: (-0.693951, -0.720022, 0.0),
-    },
-    Normal {
-        normal: (-0.79395, -0.607983, -0.0),
-    },
-    Normal {
-        normal: (-0.831437, -0.43618, -0.344179),
-    },
-    Normal {
-        normal: (-0.673512, -0.684665, -0.278594),
-    },
-    Normal {
-        normal: (-0.640399, -0.720924, -0.264874),
-    },
-    Normal {
-        normal: (-0.732949, -0.608996, -0.303166),
-    },
-    Normal {
-        normal: (-0.636092, -0.436777, -0.636092),
-    },
-    Normal {
-        normal: (-0.514965, -0.685289, -0.514965),
-    },
-    Normal {
-        normal: (-0.489651, -0.721446, -0.489651),
-    },
-    Normal {
-        normal: (-0.560555, -0.609554, -0.560555),
-    },
-    Normal {
-        normal: (-0.344179, -0.43618, -0.831437),
-    },
-    Normal {
-        normal: (-0.278594, -0.684665, -0.673512),
-    },
-    Normal {
-        normal: (-0.264874, -0.720924, -0.640399),
-    },
-    Normal {
-        normal: (-0.303166, -0.608996, -0.732949),
-    },
-    Normal {
-        normal: (-0.0, -0.435513, -0.900182),
-    },
-    Normal {
-        normal: (0.0, -0.683863, -0.729611),
-    },
-    Normal {
-        normal: (-0.0, -0.720022, -0.693951),
-    },
-    Normal {
-        normal: (0.0, -0.607984, -0.79395),
-    },
-    Normal {
-        normal: (0.344179, -0.43618, -0.831437),
-    },
-    Normal {
-        normal: (0.278594, -0.684665, -0.673512),
-    },
-    Normal {
-        normal: (0.264874, -0.720924, -0.640399),
-    },
-    Normal {
-        normal: (0.303167, -0.608996, -0.732949),
-    },
-    Normal {
-        normal: (0.636092, -0.436777, -0.636092),
-    },
-    Normal {
-        normal: (0.514965, -0.685289, -0.514965),
-    },
-    Normal {
-        normal: (0.489651, -0.721446, -0.489651),
-    },
-    Normal {
-        normal: (0.560555, -0.609554, -0.560555),
-    },
-    Normal {
-        normal: (0.831437, -0.43618, -0.344179),
-    },
-    Normal {
-        normal: (0.673512, -0.684665, -0.278595),
-    },
-    Normal {
-        normal: (0.640399, -0.720924, -0.264874),
-    },
-    Normal {
-        normal: (0.732949, -0.608996, -0.303166),
-    },
-    Normal {
-        normal: (0.62386, -0.781536, 0.0),
-    },
-    Normal {
-        normal: (0.177291, -0.984159, -0.0),
-    },
-    Normal {
-        normal: (0.0492072, -0.998789, 0.0),
-    },
-    Normal {
-        normal: (0.0, -1.0, -0.0),
-    },
-    Normal {
-        normal: (0.576229, -0.781801, 0.238217),
-    },
-    Normal {
-        normal: (0.163629, -0.984208, 0.0675273),
-    },
-    Normal {
-        normal: (0.0454217, -0.998792, 0.0187357),
-    },
-    Normal {
-        normal: (0.440416, -0.782348, 0.440416),
-    },
-    Normal {
-        normal: (0.124903, -0.984276, 0.124903),
-    },
-    Normal {
-        normal: (0.0346621, -0.998798, 0.0346621),
-    },
-    Normal {
-        normal: (0.238217, -0.781801, 0.576229),
-    },
-    Normal {
-        normal: (0.0675273, -0.984208, 0.163629),
-    },
-    Normal {
-        normal: (0.0187357, -0.998792, 0.0454217),
-    },
-    Normal {
-        normal: (-0.0, -0.781536, 0.62386),
-    },
-    Normal {
-        normal: (0.0, -0.984159, 0.177291),
-    },
-    Normal {
-        normal: (-0.0, -0.998789, 0.0492072),
-    },
-    Normal {
-        normal: (-0.238216, -0.781801, 0.576229),
-    },
-    Normal {
-        normal: (-0.0675273, -0.984208, 0.163629),
-    },
-    Normal {
-        normal: (-0.0187357, -0.998792, 0.0454217),
-    },
-    Normal {
-        normal: (-0.440416, -0.782348, 0.440416),
-    },
-    Normal {
-        normal: (-0.124903, -0.984276, 0.124903),
-    },
-    Normal {
-        normal: (-0.0346621, -0.998798, 0.0346621),
-    },
-    Normal {
-        normal: (-0.576229, -0.781801, 0.238217),
-    },
-    Normal {
-        normal: (-0.163629, -0.984208, 0.0675273),
-    },
-    Normal {
-        normal: (-0.0454217, -0.998792, 0.0187357),
-    },
-    Normal {
-        normal: (-0.62386, -0.781536, -0.0),
-    },
-    Normal {
-        normal: (-0.177291, -0.984159, 0.0),
-    },
-    Normal {
-        normal: (-0.0492072, -0.998789, -0.0),
-    },
-    Normal {
-        normal: (-0.576229, -0.781801, -0.238217),
-    },
-    Normal {
-        normal: (-0.163629, -0.984208, -0.0675273),
-    },
-    Normal {
-        normal: (-0.0454217, -0.998792, -0.0187357),
-    },
-    Normal {
-        normal: (-0.440416, -0.782348, -0.440416),
-    },
-    Normal {
-        normal: (-0.124903, -0.984276, -0.124903),
-    },
-    Normal {
-        normal: (-0.0346621, -0.998798, -0.0346621),
-    },
-    Normal {
-        normal: (-0.238217, -0.781801, -0.576229),
-    },
-    Normal {
-        normal: (-0.0675273, -0.984208, -0.163629),
-    },
-    Normal {
-        normal: (-0.0187357, -0.998792, -0.0454217),
-    },
-    Normal {
-        normal: (0.0, -0.781536, -0.62386),
-    },
-    Normal {
-        normal: (-0.0, -0.984159, -0.177291),
-    },
-    Normal {
-        normal: (0.0, -0.998789, -0.0492072),
-    },
-    Normal {
-        normal: (0.238217, -0.781801, -0.576229),
-    },
-    Normal {
-        normal: (0.0675273, -0.984208, -0.163629),
-    },
-    Normal {
-        normal: (0.0187357, -0.998792, -0.0454217),
-    },
-    Normal {
-        normal: (0.440416, -0.782348, -0.440416),
-    },
-    Normal {
-        normal: (0.124903, -0.984276, -0.124903),
-    },
-    Normal {
-        normal: (0.0346621, -0.998798, -0.0346621),
-    },
-    Normal {
-        normal: (0.576229, -0.781801, -0.238217),
-    },
-    Normal {
-        normal: (0.163629, -0.984208, -0.0675273),
-    },
-    Normal {
-        normal: (0.0454217, -0.998792, -0.0187357),
-    },
-    Normal {
-        normal: (0.00778619, -0.99997, -0.000215809),
-    },
-    Normal {
-        normal: (0.0391385, -0.999233, -0.000988567),
-    },
-    Normal {
-        normal: (0.179511, -0.983746, -0.00436856),
-    },
-    Normal {
-        normal: (0.6123, -0.790556, -0.0104598),
-    },
-    Normal {
-        normal: (0.986152, -0.165707, -0.00666949),
-    },
-    Normal {
-        normal: (0.00703893, -0.812495, 0.582926),
-    },
-    Normal {
-        normal: (0.0361273, -0.837257, 0.545614),
-    },
-    Normal {
-        normal: (0.161845, -0.810421, 0.563048),
-    },
-    Normal {
-        normal: (0.482365, -0.595148, 0.642746),
-    },
-    Normal {
-        normal: (0.73872, -0.114593, 0.664199),
-    },
-    Normal {
-        normal: (-0.00190867, 0.162121, 0.986769),
-    },
-    Normal {
-        normal: (0.0027616, 0.0171073, 0.99985),
-    },
-    Normal {
-        normal: (0.0105326, 0.0733989, 0.997247),
-    },
-    Normal {
-        normal: (-0.0660406, 0.130069, 0.989303),
-    },
-    Normal {
-        normal: (-0.0944272, 0.0165946, 0.995393),
-    },
-    Normal {
-        normal: (-0.009203, 0.871509, 0.490293),
-    },
-    Normal {
-        normal: (-0.0486064, 0.840609, 0.539457),
-    },
-    Normal {
-        normal: (-0.223298, 0.802881, 0.552739),
-    },
-    Normal {
-        normal: (-0.596365, 0.559971, 0.575135),
-    },
-    Normal {
-        normal: (-0.803337, 0.0682361, 0.591602),
-    },
-    Normal {
-        normal: (-0.0105609, 0.999944, 0.000103364),
-    },
-    Normal {
-        normal: (-0.0587986, 0.99827, 0.000709759),
-    },
-    Normal {
-        normal: (-0.28071, 0.959787, 0.00326876),
-    },
-    Normal {
-        normal: (-0.749723, 0.661738, 0.0042684),
-    },
-    Normal {
-        normal: (-0.997351, 0.0727144, 0.00205923),
-    },
-    Normal {
-        normal: (-0.00879197, 0.871493, -0.49033),
-    },
-    Normal {
-        normal: (-0.0464937, 0.841178, -0.538756),
-    },
-    Normal {
-        normal: (-0.217909, 0.806807, -0.549161),
-    },
-    Normal {
-        normal: (-0.597291, 0.560026, -0.574121),
-    },
-    Normal {
-        normal: (-0.804, 0.0629127, -0.591291),
-    },
-    Normal {
-        normal: (-0.00180555, 0.161691, -0.98684),
-    },
-    Normal {
-        normal: (0.00203087, 0.014555, -0.999892),
-    },
-    Normal {
-        normal: (0.00921499, 0.0600698, -0.998152),
-    },
-    Normal {
-        normal: (-0.0593333, 0.113865, -0.991723),
-    },
-    Normal {
-        normal: (-0.0868992, 0.0122903, -0.996141),
-    },
-    Normal {
-        normal: (0.00641779, -0.812379, -0.583094),
-    },
-    Normal {
-        normal: (0.0337833, -0.837512, -0.545373),
-    },
-    Normal {
-        normal: (0.157112, -0.811947, -0.56219),
-    },
-    Normal {
-        normal: (0.484407, -0.589365, -0.646528),
-    },
-    Normal {
-        normal: (0.73887, -0.10132, -0.666187),
-    },
-    Normal {
-        normal: (0.946512, 0.32265, -0.0033571),
-    },
-    Normal {
-        normal: (0.82583, 0.56387, -0.00745213),
-    },
-    Normal {
-        normal: (0.650011, 0.759893, -0.00693681),
-    },
-    Normal {
-        normal: (0.532429, 0.846458, -0.00524544),
-    },
-    Normal {
-        normal: (0.725608, 0.259351, 0.637362),
-    },
-    Normal {
-        normal: (0.645945, 0.461988, 0.607719),
-    },
-    Normal {
-        normal: (0.531614, 0.63666, 0.558615),
-    },
-    Normal {
-        normal: (0.424964, 0.681717, 0.59554),
-    },
-    Normal {
-        normal: (-0.0495616, -0.019755, 0.998576),
-    },
-    Normal {
-        normal: (-0.0378162, -0.0356243, 0.99865),
-    },
-    Normal {
-        normal: (-0.0379139, -0.0365122, 0.998614),
-    },
-    Normal {
-        normal: (-0.168854, -0.297946, 0.93953),
-    },
-    Normal {
-        normal: (-0.742342, -0.299166, 0.599523),
-    },
-    Normal {
-        normal: (-0.619602, -0.529406, 0.579503),
-    },
-    Normal {
-        normal: (-0.483708, -0.685761, 0.543837),
-    },
-    Normal {
-        normal: (-0.445293, -0.794355, 0.413176),
-    },
-    Normal {
-        normal: (-0.926513, -0.376257, 0.00199587),
-    },
-    Normal {
-        normal: (-0.75392, -0.656952, 0.00431723),
-    },
-    Normal {
-        normal: (-0.566224, -0.824244, 0.00346105),
-    },
-    Normal {
-        normal: (-0.481804, -0.876277, 0.00185047),
-    },
-    Normal {
-        normal: (-0.744675, -0.294424, -0.598977),
-    },
-    Normal {
-        normal: (-0.621949, -0.528114, -0.578165),
-    },
-    Normal {
-        normal: (-0.481171, -0.68834, -0.542828),
-    },
-    Normal {
-        normal: (-0.438055, -0.797035, -0.415744),
-    },
-    Normal {
-        normal: (-0.0443368, -0.0170558, -0.998871),
-    },
-    Normal {
-        normal: (-0.0261761, -0.0281665, -0.99926),
-    },
-    Normal {
-        normal: (-0.0252939, -0.0283323, -0.999278),
-    },
-    Normal {
-        normal: (-0.157482, -0.289392, -0.944167),
-    },
-    Normal {
-        normal: (0.728244, 0.25241, -0.637142),
-    },
-    Normal {
-        normal: (0.647055, 0.459725, -0.608254),
-    },
-    Normal {
-        normal: (0.522994, 0.640657, -0.562171),
-    },
-    Normal {
-        normal: (0.409978, 0.682857, -0.604669),
-    },
-    Normal {
-        normal: (-0.230787, 0.972982, -0.00652338),
-    },
-    Normal {
-        normal: (-0.548936, 0.835863, -0.00151111),
-    },
-    Normal {
-        normal: (-0.875671, 0.482807, 0.00989278),
-    },
-    Normal {
-        normal: (-0.877554, 0.479097, 0.0190923),
-    },
-    Normal {
-        normal: (-0.69619, 0.717439, 0.024497),
-    },
-    Normal {
-        normal: (-0.152878, 0.687211, 0.71019),
-    },
-    Normal {
-        normal: (-0.316721, 0.63775, 0.702113),
-    },
-    Normal {
-        normal: (-0.601067, 0.471452, 0.64533),
-    },
-    Normal {
-        normal: (-0.635889, 0.44609, 0.6298),
-    },
-    Normal {
-        normal: (-0.435746, 0.601008, 0.670011),
-    },
-    Normal {
-        normal: (0.111112, -0.0850694, 0.99016),
-    },
-    Normal {
-        normal: (0.22331, 0.00654036, 0.974726),
-    },
-    Normal {
-        normal: (0.190097, 0.154964, 0.969458),
-    },
-    Normal {
-        normal: (0.00527077, 0.189482, 0.98187),
-    },
-    Normal {
-        normal: (-0.0117518, 0.246688, 0.969024),
-    },
-    Normal {
-        normal: (0.343906, -0.722796, 0.599412),
-    },
-    Normal {
-        normal: (0.572489, -0.567656, 0.591627),
-    },
-    Normal {
-        normal: (0.787436, -0.256459, 0.560512),
-    },
-    Normal {
-        normal: (0.647097, -0.306374, 0.698141),
-    },
-    Normal {
-        normal: (0.427528, -0.499343, 0.753576),
-    },
-    Normal {
-        normal: (0.410926, -0.911668, 0.00128446),
-    },
-    Normal {
-        normal: (0.67152, -0.740986, -0.000899122),
-    },
-    Normal {
-        normal: (0.922026, -0.38706, -0.00725269),
-    },
-    Normal {
-        normal: (0.84691, -0.531556, -0.0138542),
-    },
-    Normal {
-        normal: (0.535925, -0.8442, -0.0105045),
-    },
-    Normal {
-        normal: (0.341188, -0.722822, -0.600931),
-    },
-    Normal {
-        normal: (0.578664, -0.561139, -0.591838),
-    },
-    Normal {
-        normal: (0.784869, -0.25102, -0.566542),
-    },
-    Normal {
-        normal: (0.642681, -0.302257, -0.70399),
-    },
-    Normal {
-        normal: (0.418589, -0.500042, -0.758117),
-    },
-    Normal {
-        normal: (0.115806, -0.0791394, -0.990114),
-    },
-    Normal {
-        normal: (0.232811, 0.0125652, -0.972441),
-    },
-    Normal {
-        normal: (0.206662, 0.153601, -0.96628),
-    },
-    Normal {
-        normal: (0.0244996, 0.161443, -0.986578),
-    },
-    Normal {
-        normal: (0.00338193, 0.211115, -0.977455),
-    },
-    Normal {
-        normal: (-0.134912, 0.687491, -0.713551),
-    },
-    Normal {
-        normal: (-0.31954, 0.633073, -0.705062),
-    },
-    Normal {
-        normal: (-0.603902, 0.461442, -0.649903),
-    },
-    Normal {
-        normal: (-0.631816, 0.437169, -0.640072),
-    },
-    Normal {
-        normal: (-0.424306, 0.612706, -0.66675),
-    },
-    Normal {
-        normal: (-0.4258, 0.904753, 0.0108049),
-    },
-    Normal {
-        normal: (0.0220472, 0.999756, 0.00162273),
-    },
-    Normal {
-        normal: (0.999599, 0.0258705, 0.0115556),
-    },
-    Normal {
-        normal: (0.709585, -0.704553, 0.00967183),
-    },
-    Normal {
-        normal: (-0.259858, 0.791936, 0.552549),
-    },
-    Normal {
-        normal: (0.00953916, 0.99972, -0.0216718),
-    },
-    Normal {
-        normal: (0.410156, 0.332912, -0.849083),
-    },
-    Normal {
-        normal: (0.541523, -0.54862, -0.637),
-    },
-    Normal {
-        normal: (0.0463104, 0.455224, 0.889172),
-    },
-    Normal {
-        normal: (-0.0106883, 0.988794, 0.148901),
-    },
-    Normal {
-        normal: (-0.0443756, 0.682947, -0.729118),
-    },
-    Normal {
-        normal: (0.122825, 0.00923214, -0.992385),
-    },
-    Normal {
-        normal: (0.481839, -0.180439, 0.85748),
-    },
-    Normal {
-        normal: (0.455272, 0.736752, 0.499925),
-    },
-    Normal {
-        normal: (-0.220542, 0.907193, -0.358276),
-    },
-    Normal {
-        normal: (-0.23592, 0.657249, -0.715797),
-    },
-    Normal {
-        normal: (0.728092, -0.685302, -0.0155853),
-    },
-    Normal {
-        normal: (0.888739, 0.45811, -0.0166791),
-    },
-    Normal {
-        normal: (-0.260097, 0.965582, 0.000800195),
-    },
-    Normal {
-        normal: (-0.371612, 0.928378, -0.00441745),
-    },
-    Normal {
-        normal: (0.480166, -0.17836, -0.858853),
-    },
-    Normal {
-        normal: (0.488103, 0.716801, -0.497947),
-    },
-    Normal {
-        normal: (-0.222004, 0.905399, 0.361893),
-    },
-    Normal {
-        normal: (-0.235405, 0.66318, 0.710477),
-    },
-    Normal {
-        normal: (0.0587203, 0.437704, -0.8972),
-    },
-    Normal {
-        normal: (0.00132612, 0.986459, -0.164003),
-    },
-    Normal {
-        normal: (-0.0441901, 0.681677, 0.730317),
-    },
-    Normal {
-        normal: (0.138801, -0.0341896, 0.98973),
-    },
-    Normal {
-        normal: (-0.25889, 0.797206, -0.54538),
-    },
-    Normal {
-        normal: (0.0122703, 0.999739, 0.0192865),
-    },
-    Normal {
-        normal: (0.39863, 0.35489, 0.845663),
-    },
-    Normal {
-        normal: (0.537564, -0.5814, 0.610737),
-    },
-    Normal {
-        normal: (-0.0, 1.0, 0.0),
-    },
-    Normal {
-        normal: (0.82454, 0.565804, 0.0),
-    },
-    Normal {
-        normal: (0.917701, -0.397272, 0.0),
-    },
-    Normal {
-        normal: (0.935269, -0.353939, 0.000112842),
-    },
-    Normal {
-        normal: (0.780712, 0.624891, 0.0),
-    },
-    Normal {
-        normal: (0.762641, 0.565035, 0.314825),
-    },
-    Normal {
-        normal: (0.847982, -0.397998, 0.350034),
-    },
-    Normal {
-        normal: (0.864141, -0.355261, 0.356441),
-    },
-    Normal {
-        normal: (0.720991, 0.625625, 0.297933),
-    },
-    Normal {
-        normal: (0.583357, 0.565165, 0.583338),
-    },
-    Normal {
-        normal: (0.648485, -0.398726, 0.648448),
-    },
-    Normal {
-        normal: (0.660872, -0.355894, 0.660748),
-    },
-    Normal {
-        normal: (0.551862, 0.62529, 0.55178),
-    },
-    Normal {
-        normal: (0.314824, 0.565051, 0.762629),
-    },
-    Normal {
-        normal: (0.350045, -0.397976, 0.847988),
-    },
-    Normal {
-        normal: (0.356474, -0.3552, 0.864153),
-    },
-    Normal {
-        normal: (0.297983, 0.625515, 0.721067),
-    },
-    Normal {
-        normal: (-0.0, 0.565804, 0.82454),
-    },
-    Normal {
-        normal: (-0.0, -0.397272, 0.917701),
-    },
-    Normal {
-        normal: (-0.000112839, -0.353939, 0.935269),
-    },
-    Normal {
-        normal: (-0.0, 0.624891, 0.780712),
-    },
-    Normal {
-        normal: (-0.314825, 0.565035, 0.762641),
-    },
-    Normal {
-        normal: (-0.350034, -0.397998, 0.847982),
-    },
-    Normal {
-        normal: (-0.356441, -0.355261, 0.864141),
-    },
-    Normal {
-        normal: (-0.297933, 0.625625, 0.720991),
-    },
-    Normal {
-        normal: (-0.583338, 0.565165, 0.583357),
-    },
-    Normal {
-        normal: (-0.648448, -0.398726, 0.648485),
-    },
-    Normal {
-        normal: (-0.660748, -0.355894, 0.660872),
-    },
-    Normal {
-        normal: (-0.55178, 0.62529, 0.551862),
-    },
-    Normal {
-        normal: (-0.762629, 0.565051, 0.314824),
-    },
-    Normal {
-        normal: (-0.847988, -0.397976, 0.350045),
-    },
-    Normal {
-        normal: (-0.864153, -0.3552, 0.356474),
-    },
-    Normal {
-        normal: (-0.721067, 0.625515, 0.297983),
-    },
-    Normal {
-        normal: (-0.82454, 0.565804, -0.0),
-    },
-    Normal {
-        normal: (-0.917701, -0.397272, -0.0),
-    },
-    Normal {
-        normal: (-0.935269, -0.353939, -0.000112839),
-    },
-    Normal {
-        normal: (-0.780712, 0.624891, -0.0),
-    },
-    Normal {
-        normal: (-0.76264, 0.565035, -0.314825),
-    },
-    Normal {
-        normal: (-0.847982, -0.397998, -0.350034),
-    },
-    Normal {
-        normal: (-0.864141, -0.355261, -0.356441),
-    },
-    Normal {
-        normal: (-0.720991, 0.625625, -0.297933),
-    },
-    Normal {
-        normal: (-0.583357, 0.565165, -0.583338),
-    },
-    Normal {
-        normal: (-0.648485, -0.398726, -0.648448),
-    },
-    Normal {
-        normal: (-0.660872, -0.355894, -0.660748),
-    },
-    Normal {
-        normal: (-0.551862, 0.62529, -0.55178),
-    },
-    Normal {
-        normal: (-0.314824, 0.565051, -0.762629),
-    },
-    Normal {
-        normal: (-0.350045, -0.397976, -0.847988),
-    },
-    Normal {
-        normal: (-0.356474, -0.3552, -0.864153),
-    },
-    Normal {
-        normal: (-0.297983, 0.625515, -0.721067),
-    },
-    Normal {
-        normal: (0.0, 0.565804, -0.82454),
-    },
-    Normal {
-        normal: (0.0, -0.397272, -0.917701),
-    },
-    Normal {
-        normal: (0.000112839, -0.353939, -0.935269),
-    },
-    Normal {
-        normal: (0.0, 0.624891, -0.780712),
-    },
-    Normal {
-        normal: (0.314825, 0.565035, -0.762641),
-    },
-    Normal {
-        normal: (0.350034, -0.397998, -0.847982),
-    },
-    Normal {
-        normal: (0.356441, -0.355261, -0.864141),
-    },
-    Normal {
-        normal: (0.297933, 0.625625, -0.720991),
-    },
-    Normal {
-        normal: (0.583338, 0.565165, -0.583357),
-    },
-    Normal {
-        normal: (0.648448, -0.398726, -0.648485),
-    },
-    Normal {
-        normal: (0.660748, -0.355894, -0.660872),
-    },
-    Normal {
-        normal: (0.55178, 0.62529, -0.551862),
-    },
-    Normal {
-        normal: (0.762629, 0.565051, -0.314824),
-    },
-    Normal {
-        normal: (0.847988, -0.397976, -0.350045),
-    },
-    Normal {
-        normal: (0.864153, -0.3552, -0.356474),
-    },
-    Normal {
-        normal: (0.721067, 0.625515, -0.297983),
-    },
-    Normal {
-        normal: (0.236584, 0.971611, 0.0),
-    },
-    Normal {
-        normal: (0.173084, 0.984907, -0.0),
-    },
-    Normal {
-        normal: (0.379703, 0.925108, 0.0),
-    },
-    Normal {
-        normal: (0.526673, 0.850068, 0.0),
-    },
-    Normal {
-        normal: (0.217978, 0.971775, 0.0902162),
-    },
-    Normal {
-        normal: (0.15959, 0.984977, 0.0659615),
-    },
-    Normal {
-        normal: (0.350498, 0.925312, 0.14474),
-    },
-    Normal {
-        normal: (0.48559, 0.850653, 0.201474),
-    },
-    Normal {
-        normal: (0.166631, 0.971838, 0.166631),
-    },
-    Normal {
-        normal: (0.121908, 0.985026, 0.121908),
-    },
-    Normal {
-        normal: (0.267668, 0.925585, 0.267668),
-    },
-    Normal {
-        normal: (0.371315, 0.851029, 0.371315),
-    },
-    Normal {
-        normal: (0.0902162, 0.971775, 0.217978),
-    },
-    Normal {
-        normal: (0.0659615, 0.984977, 0.15959),
-    },
-    Normal {
-        normal: (0.14474, 0.925312, 0.350498),
-    },
-    Normal {
-        normal: (0.201474, 0.850653, 0.48559),
-    },
-    Normal {
-        normal: (-0.0, 0.971611, 0.236584),
-    },
-    Normal {
-        normal: (0.0, 0.984907, 0.173084),
-    },
-    Normal {
-        normal: (0.0, 0.925108, 0.379703),
-    },
-    Normal {
-        normal: (0.0, 0.850068, 0.526673),
-    },
-    Normal {
-        normal: (-0.0902162, 0.971775, 0.217978),
-    },
-    Normal {
-        normal: (-0.0659615, 0.984977, 0.15959),
-    },
-    Normal {
-        normal: (-0.14474, 0.925312, 0.350498),
-    },
-    Normal {
-        normal: (-0.201474, 0.850653, 0.48559),
-    },
-    Normal {
-        normal: (-0.166631, 0.971838, 0.166631),
-    },
-    Normal {
-        normal: (-0.121908, 0.985026, 0.121908),
-    },
-    Normal {
-        normal: (-0.267668, 0.925585, 0.267668),
-    },
-    Normal {
-        normal: (-0.371315, 0.851029, 0.371315),
-    },
-    Normal {
-        normal: (-0.217978, 0.971775, 0.0902162),
-    },
-    Normal {
-        normal: (-0.15959, 0.984977, 0.0659615),
-    },
-    Normal {
-        normal: (-0.350498, 0.925312, 0.14474),
-    },
-    Normal {
-        normal: (-0.48559, 0.850653, 0.201474),
-    },
-    Normal {
-        normal: (-0.236583, 0.971611, -0.0),
-    },
-    Normal {
-        normal: (-0.173084, 0.984907, 0.0),
-    },
-    Normal {
-        normal: (-0.379703, 0.925108, -0.0),
-    },
-    Normal {
-        normal: (-0.526673, 0.850068, 0.0),
-    },
-    Normal {
-        normal: (-0.217978, 0.971775, -0.0902162),
-    },
-    Normal {
-        normal: (-0.15959, 0.984977, -0.0659615),
-    },
-    Normal {
-        normal: (-0.350498, 0.925312, -0.14474),
-    },
-    Normal {
-        normal: (-0.48559, 0.850653, -0.201474),
-    },
-    Normal {
-        normal: (-0.166631, 0.971838, -0.166631),
-    },
-    Normal {
-        normal: (-0.121908, 0.985026, -0.121908),
-    },
-    Normal {
-        normal: (-0.267668, 0.925585, -0.267668),
-    },
-    Normal {
-        normal: (-0.371315, 0.851029, -0.371315),
-    },
-    Normal {
-        normal: (-0.0902162, 0.971775, -0.217978),
-    },
-    Normal {
-        normal: (-0.0659615, 0.984977, -0.15959),
-    },
-    Normal {
-        normal: (-0.14474, 0.925312, -0.350498),
-    },
-    Normal {
-        normal: (-0.201474, 0.850653, -0.485589),
-    },
-    Normal {
-        normal: (0.0, 0.971611, -0.236584),
-    },
-    Normal {
-        normal: (-0.0, 0.984907, -0.173084),
-    },
-    Normal {
-        normal: (-0.0, 0.925108, -0.379703),
-    },
-    Normal {
-        normal: (-0.0, 0.850068, -0.526673),
-    },
-    Normal {
-        normal: (0.0902162, 0.971775, -0.217978),
-    },
-    Normal {
-        normal: (0.0659615, 0.984977, -0.15959),
-    },
-    Normal {
-        normal: (0.14474, 0.925312, -0.350498),
-    },
-    Normal {
-        normal: (0.201474, 0.850653, -0.48559),
-    },
-    Normal {
-        normal: (0.166631, 0.971838, -0.166631),
-    },
-    Normal {
-        normal: (0.121908, 0.985026, -0.121908),
-    },
-    Normal {
-        normal: (0.267668, 0.925585, -0.267668),
-    },
-    Normal {
-        normal: (0.371315, 0.851029, -0.371315),
-    },
-    Normal {
-        normal: (0.217978, 0.971775, -0.0902162),
-    },
-    Normal {
-        normal: (0.15959, 0.984977, -0.0659615),
-    },
-    Normal {
-        normal: (0.350498, 0.925312, -0.14474),
-    },
-    Normal {
-        normal: (0.48559, 0.850653, -0.201474),
-    },
-];
-
-pub const INDICES: [u16; 3072] = [
-    7, 6, 1, 1, 2, 7, 8, 7, 2, 2, 3, 8, 9, 8, 3, 3, 4, 9, 10, 9, 4, 4, 5, 10, 12, 11, 6, 6, 7, 12,
-    13, 12, 7, 7, 8, 13, 14, 13, 8, 8, 9, 14, 15, 14, 9, 9, 10, 15, 17, 16, 11, 11, 12, 17, 18, 17,
-    12, 12, 13, 18, 19, 18, 13, 13, 14, 19, 20, 19, 14, 14, 15, 20, 22, 21, 16, 16, 17, 22, 23, 22,
-    17, 17, 18, 23, 24, 23, 18, 18, 19, 24, 25, 24, 19, 19, 20, 25, 27, 26, 21, 21, 22, 27, 28, 27,
-    22, 22, 23, 28, 29, 28, 23, 23, 24, 29, 30, 29, 24, 24, 25, 30, 32, 31, 26, 26, 27, 32, 33, 32,
-    27, 27, 28, 33, 34, 33, 28, 28, 29, 34, 35, 34, 29, 29, 30, 35, 37, 36, 31, 31, 32, 37, 38, 37,
-    32, 32, 33, 38, 39, 38, 33, 33, 34, 39, 40, 39, 34, 34, 35, 40, 42, 41, 36, 36, 37, 42, 43, 42,
-    37, 37, 38, 43, 44, 43, 38, 38, 39, 44, 45, 44, 39, 39, 40, 45, 47, 46, 41, 41, 42, 47, 48, 47,
-    42, 42, 43, 48, 49, 48, 43, 43, 44, 49, 50, 49, 44, 44, 45, 50, 52, 51, 46, 46, 47, 52, 53, 52,
-    47, 47, 48, 53, 54, 53, 48, 48, 49, 54, 55, 54, 49, 49, 50, 55, 57, 56, 51, 51, 52, 57, 58, 57,
-    52, 52, 53, 58, 59, 58, 53, 53, 54, 59, 60, 59, 54, 54, 55, 60, 62, 61, 56, 56, 57, 62, 63, 62,
-    57, 57, 58, 63, 64, 63, 58, 58, 59, 64, 65, 64, 59, 59, 60, 65, 67, 66, 61, 61, 62, 67, 68, 67,
-    62, 62, 63, 68, 69, 68, 63, 63, 64, 69, 70, 69, 64, 64, 65, 70, 72, 71, 66, 66, 67, 72, 73, 72,
-    67, 67, 68, 73, 74, 73, 68, 68, 69, 74, 75, 74, 69, 69, 70, 75, 77, 76, 71, 71, 72, 77, 78, 77,
-    72, 72, 73, 78, 79, 78, 73, 73, 74, 79, 80, 79, 74, 74, 75, 80, 2, 1, 76, 76, 77, 2, 3, 2, 77,
-    77, 78, 3, 4, 3, 78, 78, 79, 4, 5, 4, 79, 79, 80, 5, 85, 10, 5, 5, 81, 85, 86, 85, 81, 81, 82,
-    86, 87, 86, 82, 82, 83, 87, 88, 87, 83, 83, 84, 88, 89, 15, 10, 10, 85, 89, 90, 89, 85, 85, 86,
-    90, 91, 90, 86, 86, 87, 91, 92, 91, 87, 87, 88, 92, 93, 20, 15, 15, 89, 93, 94, 93, 89, 89, 90,
-    94, 95, 94, 90, 90, 91, 95, 96, 95, 91, 91, 92, 96, 97, 25, 20, 20, 93, 97, 98, 97, 93, 93, 94,
-    98, 99, 98, 94, 94, 95, 99, 100, 99, 95, 95, 96, 100, 101, 30, 25, 25, 97, 101, 102, 101, 97,
-    97, 98, 102, 103, 102, 98, 98, 99, 103, 104, 103, 99, 99, 100, 104, 105, 35, 30, 30, 101, 105,
-    106, 105, 101, 101, 102, 106, 107, 106, 102, 102, 103, 107, 108, 107, 103, 103, 104, 108, 109,
-    40, 35, 35, 105, 109, 110, 109, 105, 105, 106, 110, 111, 110, 106, 106, 107, 111, 112, 111,
-    107, 107, 108, 112, 113, 45, 40, 40, 109, 113, 114, 113, 109, 109, 110, 114, 115, 114, 110,
-    110, 111, 115, 116, 115, 111, 111, 112, 116, 117, 50, 45, 45, 113, 117, 118, 117, 113, 113,
-    114, 118, 119, 118, 114, 114, 115, 119, 120, 119, 115, 115, 116, 120, 121, 55, 50, 50, 117,
-    121, 122, 121, 117, 117, 118, 122, 123, 122, 118, 118, 119, 123, 124, 123, 119, 119, 120, 124,
-    125, 60, 55, 55, 121, 125, 126, 125, 121, 121, 122, 126, 127, 126, 122, 122, 123, 127, 128,
-    127, 123, 123, 124, 128, 129, 65, 60, 60, 125, 129, 130, 129, 125, 125, 126, 130, 131, 130,
-    126, 126, 127, 131, 132, 131, 127, 127, 128, 132, 133, 70, 65, 65, 129, 133, 134, 133, 129,
-    129, 130, 134, 135, 134, 130, 130, 131, 135, 136, 135, 131, 131, 132, 136, 137, 75, 70, 70,
-    133, 137, 138, 137, 133, 133, 134, 138, 139, 138, 134, 134, 135, 139, 140, 139, 135, 135, 136,
-    140, 141, 80, 75, 75, 137, 141, 142, 141, 137, 137, 138, 142, 143, 142, 138, 138, 139, 143,
-    144, 143, 139, 139, 140, 144, 81, 5, 80, 80, 141, 81, 82, 81, 141, 141, 142, 82, 83, 82, 142,
-    142, 143, 83, 84, 83, 143, 143, 144, 84, 149, 88, 84, 84, 145, 149, 150, 149, 145, 145, 146,
-    150, 151, 150, 146, 146, 147, 151, 152, 151, 147, 147, 148, 152, 153, 92, 88, 88, 149, 153,
-    154, 153, 149, 149, 150, 154, 155, 154, 150, 150, 151, 155, 156, 155, 151, 151, 152, 156, 157,
-    96, 92, 92, 153, 157, 158, 157, 153, 153, 154, 158, 159, 158, 154, 154, 155, 159, 160, 159,
-    155, 155, 156, 160, 161, 100, 96, 96, 157, 161, 162, 161, 157, 157, 158, 162, 163, 162, 158,
-    158, 159, 163, 164, 163, 159, 159, 160, 164, 165, 104, 100, 100, 161, 165, 166, 165, 161, 161,
-    162, 166, 167, 166, 162, 162, 163, 167, 168, 167, 163, 163, 164, 168, 169, 108, 104, 104, 165,
-    169, 170, 169, 165, 165, 166, 170, 171, 170, 166, 166, 167, 171, 172, 171, 167, 167, 168, 172,
-    173, 112, 108, 108, 169, 173, 174, 173, 169, 169, 170, 174, 175, 174, 170, 170, 171, 175, 176,
-    175, 171, 171, 172, 176, 177, 116, 112, 112, 173, 177, 178, 177, 173, 173, 174, 178, 179, 178,
-    174, 174, 175, 179, 180, 179, 175, 175, 176, 180, 181, 120, 116, 116, 177, 181, 182, 181, 177,
-    177, 178, 182, 183, 182, 178, 178, 179, 183, 184, 183, 179, 179, 180, 184, 185, 124, 120, 120,
-    181, 185, 186, 185, 181, 181, 182, 186, 187, 186, 182, 182, 183, 187, 188, 187, 183, 183, 184,
-    188, 189, 128, 124, 124, 185, 189, 190, 189, 185, 185, 186, 190, 191, 190, 186, 186, 187, 191,
-    192, 191, 187, 187, 188, 192, 193, 132, 128, 128, 189, 193, 194, 193, 189, 189, 190, 194, 195,
-    194, 190, 190, 191, 195, 196, 195, 191, 191, 192, 196, 197, 136, 132, 132, 193, 197, 198, 197,
-    193, 193, 194, 198, 199, 198, 194, 194, 195, 199, 200, 199, 195, 195, 196, 200, 201, 140, 136,
-    136, 197, 201, 202, 201, 197, 197, 198, 202, 203, 202, 198, 198, 199, 203, 204, 203, 199, 199,
-    200, 204, 205, 144, 140, 140, 201, 205, 206, 205, 201, 201, 202, 206, 207, 206, 202, 202, 203,
-    207, 208, 207, 203, 203, 204, 208, 145, 84, 144, 144, 205, 145, 146, 145, 205, 205, 206, 146,
-    147, 146, 206, 206, 207, 147, 148, 147, 207, 207, 208, 148, 213, 152, 148, 148, 209, 213, 214,
-    213, 209, 209, 210, 214, 215, 214, 210, 210, 211, 215, 212, 215, 211, 211, 212, 212, 216, 156,
-    152, 152, 213, 216, 217, 216, 213, 213, 214, 217, 218, 217, 214, 214, 215, 218, 212, 218, 215,
-    215, 212, 212, 219, 160, 156, 156, 216, 219, 220, 219, 216, 216, 217, 220, 221, 220, 217, 217,
-    218, 221, 212, 221, 218, 218, 212, 212, 222, 164, 160, 160, 219, 222, 223, 222, 219, 219, 220,
-    223, 224, 223, 220, 220, 221, 224, 212, 224, 221, 221, 212, 212, 225, 168, 164, 164, 222, 225,
-    226, 225, 222, 222, 223, 226, 227, 226, 223, 223, 224, 227, 212, 227, 224, 224, 212, 212, 228,
-    172, 168, 168, 225, 228, 229, 228, 225, 225, 226, 229, 230, 229, 226, 226, 227, 230, 212, 230,
-    227, 227, 212, 212, 231, 176, 172, 172, 228, 231, 232, 231, 228, 228, 229, 232, 233, 232, 229,
-    229, 230, 233, 212, 233, 230, 230, 212, 212, 234, 180, 176, 176, 231, 234, 235, 234, 231, 231,
-    232, 235, 236, 235, 232, 232, 233, 236, 212, 236, 233, 233, 212, 212, 237, 184, 180, 180, 234,
-    237, 238, 237, 234, 234, 235, 238, 239, 238, 235, 235, 236, 239, 212, 239, 236, 236, 212, 212,
-    240, 188, 184, 184, 237, 240, 241, 240, 237, 237, 238, 241, 242, 241, 238, 238, 239, 242, 212,
-    242, 239, 239, 212, 212, 243, 192, 188, 188, 240, 243, 244, 243, 240, 240, 241, 244, 245, 244,
-    241, 241, 242, 245, 212, 245, 242, 242, 212, 212, 246, 196, 192, 192, 243, 246, 247, 246, 243,
-    243, 244, 247, 248, 247, 244, 244, 245, 248, 212, 248, 245, 245, 212, 212, 249, 200, 196, 196,
-    246, 249, 250, 249, 246, 246, 247, 250, 251, 250, 247, 247, 248, 251, 212, 251, 248, 248, 212,
-    212, 252, 204, 200, 200, 249, 252, 253, 252, 249, 249, 250, 253, 254, 253, 250, 250, 251, 254,
-    212, 254, 251, 251, 212, 212, 255, 208, 204, 204, 252, 255, 256, 255, 252, 252, 253, 256, 257,
-    256, 253, 253, 254, 257, 212, 257, 254, 254, 212, 212, 209, 148, 208, 208, 255, 209, 210, 209,
-    255, 255, 256, 210, 211, 210, 256, 256, 257, 211, 212, 211, 257, 257, 212, 212, 264, 263, 258,
-    258, 259, 264, 265, 264, 259, 259, 260, 265, 266, 265, 260, 260, 261, 266, 267, 266, 261, 261,
-    262, 267, 269, 268, 263, 263, 264, 269, 270, 269, 264, 264, 265, 270, 271, 270, 265, 265, 266,
-    271, 272, 271, 266, 266, 267, 272, 274, 273, 268, 268, 269, 274, 275, 274, 269, 269, 270, 275,
-    276, 275, 270, 270, 271, 276, 277, 276, 271, 271, 272, 277, 279, 278, 273, 273, 274, 279, 280,
-    279, 274, 274, 275, 280, 281, 280, 275, 275, 276, 281, 282, 281, 276, 276, 277, 282, 284, 283,
-    278, 278, 279, 284, 285, 284, 279, 279, 280, 285, 286, 285, 280, 280, 281, 286, 287, 286, 281,
-    281, 282, 287, 289, 288, 283, 283, 284, 289, 290, 289, 284, 284, 285, 290, 291, 290, 285, 285,
-    286, 291, 292, 291, 286, 286, 287, 292, 294, 293, 288, 288, 289, 294, 295, 294, 289, 289, 290,
-    295, 296, 295, 290, 290, 291, 296, 297, 296, 291, 291, 292, 297, 259, 258, 293, 293, 294, 259,
-    260, 259, 294, 294, 295, 260, 261, 260, 295, 295, 296, 261, 262, 261, 296, 296, 297, 262, 302,
-    267, 262, 262, 298, 302, 303, 302, 298, 298, 299, 303, 304, 303, 299, 299, 300, 304, 305, 304,
-    300, 300, 301, 305, 306, 272, 267, 267, 302, 306, 307, 306, 302, 302, 303, 307, 308, 307, 303,
-    303, 304, 308, 309, 308, 304, 304, 305, 309, 310, 277, 272, 272, 306, 310, 311, 310, 306, 306,
-    307, 311, 312, 311, 307, 307, 308, 312, 313, 312, 308, 308, 309, 313, 314, 282, 277, 277, 310,
-    314, 315, 314, 310, 310, 311, 315, 316, 315, 311, 311, 312, 316, 317, 316, 312, 312, 313, 317,
-    318, 287, 282, 282, 314, 318, 319, 318, 314, 314, 315, 319, 320, 319, 315, 315, 316, 320, 321,
-    320, 316, 316, 317, 321, 322, 292, 287, 287, 318, 322, 323, 322, 318, 318, 319, 323, 324, 323,
-    319, 319, 320, 324, 325, 324, 320, 320, 321, 325, 326, 297, 292, 292, 322, 326, 327, 326, 322,
-    322, 323, 327, 328, 327, 323, 323, 324, 328, 329, 328, 324, 324, 325, 329, 298, 262, 297, 297,
-    326, 298, 299, 298, 326, 326, 327, 299, 300, 299, 327, 327, 328, 300, 301, 300, 328, 328, 329,
-    301, 336, 335, 330, 330, 331, 336, 337, 336, 331, 331, 332, 337, 338, 337, 332, 332, 333, 338,
-    339, 338, 333, 333, 334, 339, 341, 340, 335, 335, 336, 341, 342, 341, 336, 336, 337, 342, 343,
-    342, 337, 337, 338, 343, 344, 343, 338, 338, 339, 344, 346, 345, 340, 340, 341, 346, 347, 346,
-    341, 341, 342, 347, 348, 347, 342, 342, 343, 348, 349, 348, 343, 343, 344, 349, 351, 350, 345,
-    345, 346, 351, 352, 351, 346, 346, 347, 352, 353, 352, 347, 347, 348, 353, 354, 353, 348, 348,
-    349, 354, 356, 355, 350, 350, 351, 356, 357, 356, 351, 351, 352, 357, 358, 357, 352, 352, 353,
-    358, 359, 358, 353, 353, 354, 359, 361, 360, 355, 355, 356, 361, 362, 361, 356, 356, 357, 362,
-    363, 362, 357, 357, 358, 363, 364, 363, 358, 358, 359, 364, 366, 365, 360, 360, 361, 366, 367,
-    366, 361, 361, 362, 367, 368, 367, 362, 362, 363, 368, 369, 368, 363, 363, 364, 369, 331, 330,
-    365, 365, 366, 331, 332, 331, 366, 366, 367, 332, 333, 332, 367, 367, 368, 333, 334, 333, 368,
-    368, 369, 334, 374, 339, 334, 334, 370, 374, 375, 374, 370, 370, 371, 375, 376, 375, 371, 371,
-    372, 376, 377, 376, 372, 372, 373, 377, 378, 344, 339, 339, 374, 378, 379, 378, 374, 374, 375,
-    379, 380, 379, 375, 375, 376, 380, 381, 380, 376, 376, 377, 381, 382, 349, 344, 344, 378, 382,
-    383, 382, 378, 378, 379, 383, 384, 383, 379, 379, 380, 384, 385, 384, 380, 380, 381, 385, 386,
-    354, 349, 349, 382, 386, 387, 386, 382, 382, 383, 387, 388, 387, 383, 383, 384, 388, 389, 388,
-    384, 384, 385, 389, 390, 359, 354, 354, 386, 390, 391, 390, 386, 386, 387, 391, 392, 391, 387,
-    387, 388, 392, 393, 392, 388, 388, 389, 393, 394, 364, 359, 359, 390, 394, 395, 394, 390, 390,
-    391, 395, 396, 395, 391, 391, 392, 396, 397, 396, 392, 392, 393, 397, 398, 369, 364, 364, 394,
-    398, 399, 398, 394, 394, 395, 399, 400, 399, 395, 395, 396, 400, 401, 400, 396, 396, 397, 401,
-    370, 334, 369, 369, 398, 370, 371, 370, 398, 398, 399, 371, 372, 371, 399, 399, 400, 372, 373,
-    372, 400, 400, 401, 373, 407, 402, 402, 402, 403, 407, 408, 407, 403, 403, 404, 408, 409, 408,
-    404, 404, 405, 409, 410, 409, 405, 405, 406, 410, 411, 402, 402, 402, 407, 411, 412, 411, 407,
-    407, 408, 412, 413, 412, 408, 408, 409, 413, 414, 413, 409, 409, 410, 414, 415, 402, 402, 402,
-    411, 415, 416, 415, 411, 411, 412, 416, 417, 416, 412, 412, 413, 417, 418, 417, 413, 413, 414,
-    418, 419, 402, 402, 402, 415, 419, 420, 419, 415, 415, 416, 420, 421, 420, 416, 416, 417, 421,
-    422, 421, 417, 417, 418, 422, 423, 402, 402, 402, 419, 423, 424, 423, 419, 419, 420, 424, 425,
-    424, 420, 420, 421, 425, 426, 425, 421, 421, 422, 426, 427, 402, 402, 402, 423, 427, 428, 427,
-    423, 423, 424, 428, 429, 428, 424, 424, 425, 429, 430, 429, 425, 425, 426, 430, 431, 402, 402,
-    402, 427, 431, 432, 431, 427, 427, 428, 432, 433, 432, 428, 428, 429, 433, 434, 433, 429, 429,
-    430, 434, 435, 402, 402, 402, 431, 435, 436, 435, 431, 431, 432, 436, 437, 436, 432, 432, 433,
-    437, 438, 437, 433, 433, 434, 438, 439, 402, 402, 402, 435, 439, 440, 439, 435, 435, 436, 440,
-    441, 440, 436, 436, 437, 441, 442, 441, 437, 437, 438, 442, 443, 402, 402, 402, 439, 443, 444,
-    443, 439, 439, 440, 444, 445, 444, 440, 440, 441, 445, 446, 445, 441, 441, 442, 446, 447, 402,
-    402, 402, 443, 447, 448, 447, 443, 443, 444, 448, 449, 448, 444, 444, 445, 449, 450, 449, 445,
-    445, 446, 450, 451, 402, 402, 402, 447, 451, 452, 451, 447, 447, 448, 452, 453, 452, 448, 448,
-    449, 453, 454, 453, 449, 449, 450, 454, 455, 402, 402, 402, 451, 455, 456, 455, 451, 451, 452,
-    456, 457, 456, 452, 452, 453, 457, 458, 457, 453, 453, 454, 458, 459, 402, 402, 402, 455, 459,
-    460, 459, 455, 455, 456, 460, 461, 460, 456, 456, 457, 461, 462, 461, 457, 457, 458, 462, 463,
-    402, 402, 402, 459, 463, 464, 463, 459, 459, 460, 464, 465, 464, 460, 460, 461, 465, 466, 465,
-    461, 461, 462, 466, 403, 402, 402, 402, 463, 403, 404, 403, 463, 463, 464, 404, 405, 404, 464,
-    464, 465, 405, 406, 405, 465, 465, 466, 406, 471, 410, 406, 406, 467, 471, 472, 471, 467, 467,
-    468, 472, 473, 472, 468, 468, 469, 473, 474, 473, 469, 469, 470, 474, 475, 414, 410, 410, 471,
-    475, 476, 475, 471, 471, 472, 476, 477, 476, 472, 472, 473, 477, 478, 477, 473, 473, 474, 478,
-    479, 418, 414, 414, 475, 479, 480, 479, 475, 475, 476, 480, 481, 480, 476, 476, 477, 481, 482,
-    481, 477, 477, 478, 482, 483, 422, 418, 418, 479, 483, 484, 483, 479, 479, 480, 484, 485, 484,
-    480, 480, 481, 485, 486, 485, 481, 481, 482, 486, 487, 426, 422, 422, 483, 487, 488, 487, 483,
-    483, 484, 488, 489, 488, 484, 484, 485, 489, 490, 489, 485, 485, 486, 490, 491, 430, 426, 426,
-    487, 491, 492, 491, 487, 487, 488, 492, 493, 492, 488, 488, 489, 493, 494, 493, 489, 489, 490,
-    494, 495, 434, 430, 430, 491, 495, 496, 495, 491, 491, 492, 496, 497, 496, 492, 492, 493, 497,
-    498, 497, 493, 493, 494, 498, 499, 438, 434, 434, 495, 499, 500, 499, 495, 495, 496, 500, 501,
-    500, 496, 496, 497, 501, 502, 501, 497, 497, 498, 502, 503, 442, 438, 438, 499, 503, 504, 503,
-    499, 499, 500, 504, 505, 504, 500, 500, 501, 505, 506, 505, 501, 501, 502, 506, 507, 446, 442,
-    442, 503, 507, 508, 507, 503, 503, 504, 508, 509, 508, 504, 504, 505, 509, 510, 509, 505, 505,
-    506, 510, 511, 450, 446, 446, 507, 511, 512, 511, 507, 507, 508, 512, 513, 512, 508, 508, 509,
-    513, 514, 513, 509, 509, 510, 514, 515, 454, 450, 450, 511, 515, 516, 515, 511, 511, 512, 516,
-    517, 516, 512, 512, 513, 517, 518, 517, 513, 513, 514, 518, 519, 458, 454, 454, 515, 519, 520,
-    519, 515, 515, 516, 520, 521, 520, 516, 516, 517, 521, 522, 521, 517, 517, 518, 522, 523, 462,
-    458, 458, 519, 523, 524, 523, 519, 519, 520, 524, 525, 524, 520, 520, 521, 525, 526, 525, 521,
-    521, 522, 526, 527, 466, 462, 462, 523, 527, 528, 527, 523, 523, 524, 528, 529, 528, 524, 524,
-    525, 529, 530, 529, 525, 525, 526, 530, 467, 406, 466, 466, 527, 467, 468, 467, 527, 527, 528,
-    468, 469, 468, 528, 528, 529, 469, 470, 469, 529, 529, 530, 470u16,
-];
diff --git a/examples/wgpu/wgpu_instancing/shaders/fs.wgsl b/examples/wgpu/wgpu_instancing/shaders/fs.wgsl
deleted file mode 100644
index 306d23040..000000000
--- a/examples/wgpu/wgpu_instancing/shaders/fs.wgsl
+++ /dev/null
@@ -1,15 +0,0 @@
-struct FragmentOutput {
-    @location(0) f_color: vec4<f32>,
-};
-
-@fragment
-fn main(
-    @location(0) normal: vec3<f32>,
-    @location(1) color: vec3<f32>,
-) -> FragmentOutput {
-    let light: vec3<f32> = vec3<f32>(0.0, 0.0, 1.0);
-    let brightness: f32 = dot(normalize(normal), normalize(light));
-    let dark_color: vec3<f32> = vec3<f32>(0.1, 0.1, 0.1) * color;
-    let out_color = vec4<f32>(mix(dark_color, color, vec3<f32>(brightness)), 1.0);
-    return FragmentOutput(out_color);
-}
diff --git a/examples/wgpu/wgpu_instancing/shaders/vs.wgsl b/examples/wgpu/wgpu_instancing/shaders/vs.wgsl
deleted file mode 100644
index dbf944694..000000000
--- a/examples/wgpu/wgpu_instancing/shaders/vs.wgsl
+++ /dev/null
@@ -1,48 +0,0 @@
-struct Data {
-    world: mat4x4<f32>,
-    view: mat4x4<f32>,
-    proj: mat4x4<f32>,
-};
-
-struct VertexOutput {
-    @location(0) out_normal: vec3<f32>,
-    @location(1) out_color: vec3<f32>,
-    @builtin(position) out_pos: vec4<f32>,
-};
-
-@group(0) @binding(0)
-var<uniform> uniforms: Data;
-
-fn custom_inverse(m: mat3x3<f32>) -> mat3x3<f32> {
-    let determinant: f32 = determinant(m);
-    let invdet: f32 = 1.0 / determinant;
-    var minv: mat3x3<f32>;
-    minv[0][0] = (m[1][1] * m[2][2] - m[2][1] * m[1][2]) * invdet;
-    minv[0][1] = (m[0][2] * m[2][1] - m[0][1] * m[2][2]) * invdet;
-    minv[0][2] = (m[0][1] * m[1][2] - m[0][2] * m[1][1]) * invdet;
-    minv[1][0] = (m[1][2] * m[2][0] - m[1][0] * m[2][2]) * invdet;
-    minv[1][1] = (m[0][0] * m[2][2] - m[0][2] * m[2][0]) * invdet;
-    minv[1][2] = (m[1][0] * m[0][2] - m[0][0] * m[1][2]) * invdet;
-    minv[2][0] = (m[1][0] * m[2][1] - m[2][0] * m[1][1]) * invdet;
-    minv[2][1] = (m[2][0] * m[0][1] - m[0][0] * m[2][1]) * invdet;
-    minv[2][2] = (m[0][0] * m[1][1] - m[1][0] * m[0][1]) * invdet;
-    return minv;
-}
-
-@vertex
-fn main(
-    @location(0) pos: vec3<f32>,
-    @location(1) normal: vec3<f32>,
-    @location(2) mat0: vec4<f32>,
-    @location(3) mat1: vec4<f32>,
-    @location(4) mat2: vec4<f32>,
-    @location(5) mat3: vec4<f32>,
-    @location(6) color: vec3<f32>,
-) -> VertexOutput {
-    let instance_transform: mat4x4<f32> = mat4x4<f32>(mat0, mat1, mat2, mat3);
-    let worldview: mat4x4<f32> = uniforms.view * uniforms.world * instance_transform;
-    let wv3: mat3x3<f32> = mat3x3<f32>(worldview[0].xyz, worldview[1].xyz, worldview[2].xyz);
-    let out_normal: vec3<f32> = transpose(custom_inverse(wv3)) * normal;
-    let out_pos: vec4<f32> = uniforms.proj * worldview * vec4<f32>(pos, 1.0);
-    return VertexOutput(out_normal, color, out_pos);
-}
diff --git a/examples/wgpu/wgpu_instancing/wgpu_instancing.rs b/examples/wgpu/wgpu_instancing/wgpu_instancing.rs
deleted file mode 100644
index 1cd053031..000000000
--- a/examples/wgpu/wgpu_instancing/wgpu_instancing.rs
+++ /dev/null
@@ -1,492 +0,0 @@
-use nannou::prelude::*;
-use std::cell::RefCell;
-
-mod data;
-
-/* Generates vertices on a subdivided isocahedron, normalized to 1.
- * It is used for creating a sphere for which the vertices are spread more
- * regularly than it would be with for instance polar coordinates (which is the case for UV map).
- * See https://en.wikipedia.org/wiki/Geodesic_polyhedron
- */
-fn make_geodesic_isocahedron(subdivisions: usize) -> Vec<Vec3> {
-    let sqrt5 = 5f32.sqrt();
-    let phi = (1f32 + sqrt5) * 0.5f32;
-    let ratio = (10f32 + (2f32 * sqrt5)).sqrt() / (4f32 * phi);
-    let a = (1f32 / ratio) * 0.5f32;
-    let b = (1f32 / ratio) / (2f32 * phi);
-
-    let mut points = vec![
-        vec3(0f32, b, -a),
-        vec3(b, a, 0f32),
-        vec3(-b, a, 0f32),
-        vec3(0f32, b, a),
-        vec3(0f32, -b, a),
-        vec3(-a, 0f32, b),
-        vec3(0f32, -b, -a),
-        vec3(a, 0f32, -b),
-        vec3(a, 0f32, b),
-        vec3(-a, 0f32, -b),
-        vec3(b, -a, 0f32),
-        vec3(-b, -a, 0f32),
-    ];
-
-    let triangles = vec![
-        [0, 1, 2],
-        [3, 2, 1],
-        [3, 4, 5],
-        [3, 8, 4],
-        [0, 6, 7],
-        [0, 9, 6],
-        [4, 10, 11],
-        [6, 11, 10],
-        [2, 5, 9],
-        [11, 9, 5],
-        [1, 7, 8],
-        [10, 8, 7],
-        [3, 5, 2],
-        [3, 1, 8],
-        [0, 2, 9],
-        [0, 7, 1],
-        [6, 9, 11],
-        [6, 10, 7],
-        [4, 11, 5],
-        [4, 8, 10],
-    ];
-
-    let missing_edges = vec![
-        [1, 2],
-        [4, 5],
-        [6, 7],
-        [10, 11],
-        [5, 9],
-        [9, 2],
-        [5, 11],
-        [7, 8],
-        [8, 1],
-        [7, 10],
-    ];
-
-    points.reserve(
-        triangles.len() * subdivisions * (subdivisions + 1) / 2
-            + missing_edges.len() * subdivisions,
-    );
-
-    for indices in triangles.iter() {
-        let p0 = points[indices[0]];
-        let p1 = points[indices[1]];
-        let p2 = points[indices[2]];
-
-        let step0 = (p1 - p0) / (subdivisions + 1) as f32;
-        let step1 = (p2 - p0) / (subdivisions + 1) as f32;
-
-        for i in 1..subdivisions + 1 {
-            for j in 0..subdivisions + 1 - i {
-                let pt = p0 + i as f32 * step0 + j as f32 * step1;
-                points.push(pt.normalize());
-            }
-        }
-    }
-
-    for edge in missing_edges.iter() {
-        let p0 = points[edge[0]];
-        let p1 = points[edge[1]];
-        let step = (p1 - p0) / (subdivisions + 1) as f32;
-        for i in 1..subdivisions + 1 {
-            let pt = p0 + i as f32 * step;
-            points.push(pt.normalize());
-        }
-    }
-
-    points
-}
-
-struct Model {
-    graphics: RefCell<Graphics>,
-    sphere: Vec<Vec3>,
-}
-
-struct Graphics {
-    vertex_buffer: wgpu::Buffer,
-    normal_buffer: wgpu::Buffer,
-    index_buffer: wgpu::Buffer,
-    uniform_buffer: wgpu::Buffer,
-    depth_texture: wgpu::Texture,
-    depth_texture_view: wgpu::TextureView,
-    bind_group: wgpu::BindGroup,
-    render_pipeline: wgpu::RenderPipeline,
-}
-
-// The vertex type that we will use to represent a point on our triangle.
-#[repr(C)]
-#[derive(Clone, Copy)]
-pub struct Vertex {
-    position: (f32, f32, f32),
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct Normal {
-    normal: (f32, f32, f32),
-}
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug)]
-pub struct Uniforms {
-    world: Mat4,
-    view: Mat4,
-    proj: Mat4,
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct Instance {
-    transformation: Mat4,
-    color: [f32; 3],
-}
-
-const DEPTH_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Depth32Float;
-
-fn main() {
-    nannou::app(model).run();
-}
-
-fn model(app: &App) -> Model {
-    let w_id = app.new_window().size(1024, 576).view(view).build().unwrap();
-
-    // The gpu device associated with the window's swapchain
-    let window = app.window(w_id).unwrap();
-    let device = window.device();
-    let format = Frame::TEXTURE_FORMAT;
-    let msaa_samples = window.msaa_samples();
-    let (win_w, win_h) = window.inner_size_pixels();
-
-    // Load shader modules.
-    let vs_desc = wgpu::include_wgsl!("shaders/vs.wgsl");
-    let fs_desc = wgpu::include_wgsl!("shaders/fs.wgsl");
-    let vs_mod = device.create_shader_module(vs_desc);
-    let fs_mod = device.create_shader_module(fs_desc);
-
-    // Create the vertex, normal and index buffers.
-    let vertices_bytes = vertices_as_bytes(&data::VERTICES);
-    let normals_bytes = normals_as_bytes(&data::NORMALS);
-    let indices_bytes = indices_as_bytes(&data::INDICES);
-    let vertex_usage = wgpu::BufferUsages::VERTEX;
-    let index_usage = wgpu::BufferUsages::INDEX;
-    let vertex_buffer = device.create_buffer_init(&BufferInitDescriptor {
-        label: None,
-        contents: vertices_bytes,
-        usage: vertex_usage,
-    });
-    let normal_buffer = device.create_buffer_init(&BufferInitDescriptor {
-        label: None,
-        contents: normals_bytes,
-        usage: vertex_usage,
-    });
-    let index_buffer = device.create_buffer_init(&BufferInitDescriptor {
-        label: None,
-        contents: indices_bytes,
-        usage: index_usage,
-    });
-
-    let sphere = make_geodesic_isocahedron(10);
-    println!("Number of points on the sphere: {}", sphere.len());
-
-    // Create the depth texture.
-    let depth_texture = create_depth_texture(device, [win_w, win_h], DEPTH_FORMAT, msaa_samples);
-    let depth_texture_view = depth_texture.view().build();
-
-    // Create the uniform buffer.
-    let uniforms = create_uniforms(0.0, [win_w, win_h]);
-    let uniforms_bytes = uniforms_as_bytes(&uniforms);
-    let usage = wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST;
-    let uniform_buffer = device.create_buffer_init(&BufferInitDescriptor {
-        label: None,
-        contents: uniforms_bytes,
-        usage,
-    });
-
-    // Create the render pipeline.
-    let bind_group_layout = create_bind_group_layout(device);
-    let bind_group = create_bind_group(device, &bind_group_layout, &uniform_buffer);
-    let pipeline_layout = create_pipeline_layout(device, &bind_group_layout);
-    let render_pipeline = create_render_pipeline(
-        device,
-        &pipeline_layout,
-        &vs_mod,
-        &fs_mod,
-        format,
-        DEPTH_FORMAT,
-        msaa_samples,
-    );
-
-    let graphics = RefCell::new(Graphics {
-        vertex_buffer,
-        normal_buffer,
-        index_buffer,
-        uniform_buffer,
-        depth_texture,
-        depth_texture_view,
-        bind_group,
-        render_pipeline,
-    });
-
-    Model { graphics, sphere }
-}
-
-fn make_instance(
-    orientation: Vec3,
-    offset: f32,
-    local_rotation: f32,
-    scale: f32,
-    color: [f32; 3],
-) -> Instance {
-    let scale_m = Mat4::from_scale(Vec3::splat(scale));
-    let local_rotation_m = Mat4::from_rotation_y(local_rotation);
-    let orientation_m = {
-        let up = Vec3::Y;
-        let cosine = orientation.dot(up);
-        if cosine > 0.999 {
-            Mat4::IDENTITY
-        } else if cosine < -0.999 {
-            Mat4::from_axis_angle(Vec3::X, std::f32::consts::PI)
-        } else {
-            Mat4::from_axis_angle(
-                up.cross(orientation).normalize(),
-                up.angle_between(orientation),
-            )
-        }
-    };
-
-    let translation_m = Mat4::from_translation(offset * orientation);
-
-    Instance {
-        transformation: translation_m * orientation_m * local_rotation_m * scale_m,
-        color,
-    }
-}
-
-fn special_color(index: usize) -> [f32; 3] {
-    let value = 1.5f32 * (index as f32).sin() + 1f32;
-    if value < 1f32 {
-        [0.6f32, 0.6f32, 0.0f32]
-    } else if value < 2f32 {
-        [0.6f32, 0.0f32, 0.6f32]
-    } else {
-        [0.0f32, 0.6f32, 0.6f32]
-    }
-}
-
-fn view(app: &App, model: &Model, frame: Frame) {
-    let mut g = model.graphics.borrow_mut();
-
-    // If the window has changed size, recreate our depth texture to match.
-    let depth_size = g.depth_texture.size();
-    let frame_size = frame.texture_size();
-    let device = frame.device_queue_pair().device();
-    if frame_size != depth_size {
-        let depth_format = g.depth_texture.format();
-        let sample_count = frame.texture_msaa_samples();
-        g.depth_texture = create_depth_texture(device, frame_size, depth_format, sample_count);
-        g.depth_texture_view = g.depth_texture.view().build();
-    }
-
-    let inner_sphere_instance_rotation = app.time;
-    let outer_sphere_instance_rotation = 0.2f32 * app.time;
-    let inner_sphere_radius = 35f32;
-    let outer_sphere_radius = 50f32;
-    let inner_sphere_scale = 0.04f32;
-    let outer_sphere_scale = 0.03f32;
-
-    let instances: Vec<_> = model
-        .sphere
-        .iter()
-        .map(|direction| {
-            make_instance(
-                direction.clone(),
-                outer_sphere_radius,
-                outer_sphere_instance_rotation,
-                outer_sphere_scale,
-                [1f32, 1f32, 1f32],
-            )
-        })
-        .chain(model.sphere.iter().enumerate().map(|(i, direction)| {
-            make_instance(
-                direction.clone(),
-                inner_sphere_radius + 2f32 * (i as f32 + app.time).sin().pow(4f32),
-                inner_sphere_instance_rotation,
-                inner_sphere_scale,
-                special_color(i),
-            )
-        }))
-        .collect();
-
-    let instances_bytes = instances_as_bytes(&instances);
-    let usage = wgpu::BufferUsages::VERTEX;
-    let instance_buffer = device.create_buffer_init(&BufferInitDescriptor {
-        label: None,
-        contents: instances_bytes,
-        usage,
-    });
-
-    // Update the uniforms (rotate around the teapot).
-    let world_rotation = 0.05f32 * app.time;
-    let uniforms = create_uniforms(world_rotation, frame_size);
-    let uniforms_size = std::mem::size_of::<Uniforms>() as wgpu::BufferAddress;
-    let uniforms_bytes = uniforms_as_bytes(&uniforms);
-    let usage = wgpu::BufferUsages::COPY_SRC;
-    let new_uniform_buffer = device.create_buffer_init(&BufferInitDescriptor {
-        label: None,
-        contents: uniforms_bytes,
-        usage,
-    });
-
-    let mut encoder = frame.command_encoder();
-    encoder.copy_buffer_to_buffer(&new_uniform_buffer, 0, &g.uniform_buffer, 0, uniforms_size);
-    let mut render_pass = wgpu::RenderPassBuilder::new()
-        .color_attachment(frame.texture_view(), |color| color)
-        // We'll use a depth texture to assist with the order of rendering fragments based on depth.
-        .depth_stencil_attachment(&g.depth_texture_view, |depth| depth)
-        .begin(&mut encoder);
-    render_pass.set_bind_group(0, &g.bind_group, &[]);
-    render_pass.set_pipeline(&g.render_pipeline);
-    render_pass.set_vertex_buffer(0, g.vertex_buffer.slice(..));
-    render_pass.set_vertex_buffer(1, g.normal_buffer.slice(..));
-    render_pass.set_vertex_buffer(2, instance_buffer.slice(..));
-    render_pass.set_index_buffer(g.index_buffer.slice(..), wgpu::IndexFormat::Uint16);
-    let index_range = 0..data::INDICES.len() as u32;
-    let start_vertex = 0;
-    let instance_range = 0..instances.len() as u32;
-    render_pass.draw_indexed(index_range, start_vertex, instance_range);
-}
-
-fn create_uniforms(world_rotation: f32, [w, h]: [u32; 2]) -> Uniforms {
-    let world_rotation = Mat4::from_rotation_y(world_rotation);
-    let aspect_ratio = w as f32 / h as f32;
-    let fov_y = std::f32::consts::FRAC_PI_2;
-    let near = 0.01;
-    let far = 100.0;
-    let proj = Mat4::perspective_rh_gl(fov_y, aspect_ratio, near, far);
-    let eye = pt3(0.3, 0.3, 1.0);
-    let target = Point3::ZERO;
-    let up = Vec3::Y;
-    let view = Mat4::look_at_rh(eye, target, up);
-    let world_scale = Mat4::from_scale(Vec3::splat(0.015));
-    Uniforms {
-        world: world_rotation,
-        view: (view * world_scale).into(),
-        proj: proj.into(),
-    }
-}
-
-fn create_depth_texture(
-    device: &wgpu::Device,
-    size: [u32; 2],
-    depth_format: wgpu::TextureFormat,
-    sample_count: u32,
-) -> wgpu::Texture {
-    wgpu::TextureBuilder::new()
-        .size(size)
-        .format(depth_format)
-        .usage(wgpu::TextureUsages::RENDER_ATTACHMENT)
-        .sample_count(sample_count)
-        .build(device)
-}
-
-fn create_bind_group_layout(device: &wgpu::Device) -> wgpu::BindGroupLayout {
-    wgpu::BindGroupLayoutBuilder::new()
-        .uniform_buffer(wgpu::ShaderStages::VERTEX, false)
-        .build(device)
-}
-
-fn create_bind_group(
-    device: &wgpu::Device,
-    layout: &wgpu::BindGroupLayout,
-    uniform_buffer: &wgpu::Buffer,
-) -> wgpu::BindGroup {
-    wgpu::BindGroupBuilder::new()
-        .buffer::<Uniforms>(uniform_buffer, 0..1)
-        .build(device, layout)
-}
-
-fn create_pipeline_layout(
-    device: &wgpu::Device,
-    bind_group_layout: &wgpu::BindGroupLayout,
-) -> wgpu::PipelineLayout {
-    let desc = wgpu::PipelineLayoutDescriptor {
-        label: None,
-        bind_group_layouts: &[&bind_group_layout],
-        push_constant_ranges: &[],
-    };
-    device.create_pipeline_layout(&desc)
-}
-
-fn create_render_pipeline(
-    device: &wgpu::Device,
-    layout: &wgpu::PipelineLayout,
-    vs_mod: &wgpu::ShaderModule,
-    fs_mod: &wgpu::ShaderModule,
-    dst_format: wgpu::TextureFormat,
-    depth_format: wgpu::TextureFormat,
-    sample_count: u32,
-) -> wgpu::RenderPipeline {
-    wgpu::RenderPipelineBuilder::from_layout(layout, vs_mod)
-        .fragment_shader(&fs_mod)
-        .color_format(dst_format)
-        .color_blend(wgpu::BlendComponent::REPLACE)
-        .alpha_blend(wgpu::BlendComponent::REPLACE)
-        .add_vertex_buffer::<Vertex>(&wgpu::vertex_attr_array![0 => Float32x3])
-        .add_vertex_buffer::<Normal>(&wgpu::vertex_attr_array![1 => Float32x3])
-        // TODO: this can use the macro again when https://github.com/gfx-rs/wgpu/issues/836 is fixed
-        .add_instance_buffer::<Instance>(&[
-            wgpu::VertexAttribute {
-                shader_location: 2,
-                format: wgpu::VertexFormat::Float32x4,
-                offset: std::mem::size_of::<[f32; 4]>() as u64 * 0,
-            },
-            wgpu::VertexAttribute {
-                shader_location: 3,
-                format: wgpu::VertexFormat::Float32x4,
-                offset: std::mem::size_of::<[f32; 4]>() as u64 * 1,
-            },
-            wgpu::VertexAttribute {
-                shader_location: 4,
-                format: wgpu::VertexFormat::Float32x4,
-                offset: std::mem::size_of::<[f32; 4]>() as u64 * 2,
-            },
-            wgpu::VertexAttribute {
-                shader_location: 5,
-                format: wgpu::VertexFormat::Float32x4,
-                offset: std::mem::size_of::<[f32; 4]>() as u64 * 3,
-            },
-            wgpu::VertexAttribute {
-                shader_location: 6,
-                format: wgpu::VertexFormat::Float32x4,
-                offset: std::mem::size_of::<[f32; 4]>() as u64 * 4,
-            },
-        ])
-        .depth_format(depth_format)
-        .sample_count(sample_count)
-        .build(device)
-}
-
-// See the `nannou::wgpu::bytes` documentation for why the following are necessary.
-
-fn vertices_as_bytes(data: &[Vertex]) -> &[u8] {
-    unsafe { wgpu::bytes::from_slice(data) }
-}
-
-fn normals_as_bytes(data: &[Normal]) -> &[u8] {
-    unsafe { wgpu::bytes::from_slice(data) }
-}
-
-fn indices_as_bytes(data: &[u16]) -> &[u8] {
-    unsafe { wgpu::bytes::from_slice(data) }
-}
-
-fn uniforms_as_bytes(uniforms: &Uniforms) -> &[u8] {
-    unsafe { wgpu::bytes::from(uniforms) }
-}
-
-fn instances_as_bytes(data: &[Instance]) -> &[u8] {
-    unsafe { wgpu::bytes::from_slice(data) }
-}
diff --git a/examples/wgpu/wgpu_teapot/data.rs b/examples/wgpu/wgpu_teapot/data.rs
deleted file mode 100644
index 61aefab11..000000000
--- a/examples/wgpu/wgpu_teapot/data.rs
+++ /dev/null
@@ -1,3354 +0,0 @@
-use crate::{Normal, Vertex};
-
-pub const VERTICES: [Vertex; 531] = [
-    Vertex {
-        position: (0.0, 0.0, 0.0),
-    }, // dummy vector because in the original model indices
-    // start at 1
-    Vertex {
-        position: (40.6266, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (40.0714, 30.4443, -1.10804),
-    },
-    Vertex {
-        position: (40.7155, 31.1438, -1.10804),
-    },
-    Vertex {
-        position: (42.0257, 30.4443, -1.10804),
-    },
-    Vertex {
-        position: (43.4692, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (37.5425, 28.3457, 14.5117),
-    },
-    Vertex {
-        position: (37.0303, 30.4443, 14.2938),
-    },
-    Vertex {
-        position: (37.6244, 31.1438, 14.5466),
-    },
-    Vertex {
-        position: (38.8331, 30.4443, 15.0609),
-    },
-    Vertex {
-        position: (40.1647, 28.3457, 15.6274),
-    },
-    Vertex {
-        position: (29.0859, 28.3457, 27.1468),
-    },
-    Vertex {
-        position: (28.6917, 30.4443, 26.7527),
-    },
-    Vertex {
-        position: (29.149, 31.1438, 27.2099),
-    },
-    Vertex {
-        position: (30.0792, 30.4443, 28.1402),
-    },
-    Vertex {
-        position: (31.1041, 28.3457, 29.165),
-    },
-    Vertex {
-        position: (16.4508, 28.3457, 35.6034),
-    },
-    Vertex {
-        position: (16.2329, 30.4443, 35.0912),
-    },
-    Vertex {
-        position: (16.4857, 31.1438, 35.6853),
-    },
-    Vertex {
-        position: (16.9999, 30.4443, 36.894),
-    },
-    Vertex {
-        position: (17.5665, 28.3457, 38.2256),
-    },
-    Vertex {
-        position: (0.831025, 28.3457, 38.6876),
-    },
-    Vertex {
-        position: (0.831025, 30.4443, 38.1324),
-    },
-    Vertex {
-        position: (0.831025, 31.1438, 38.7764),
-    },
-    Vertex {
-        position: (0.831025, 30.4443, 40.0866),
-    },
-    Vertex {
-        position: (0.831025, 28.3457, 41.5301),
-    },
-    Vertex {
-        position: (-15.868, 28.3457, 35.6034),
-    },
-    Vertex {
-        position: (-15.0262, 30.4443, 35.0912),
-    },
-    Vertex {
-        position: (-14.9585, 31.1438, 35.6853),
-    },
-    Vertex {
-        position: (-15.3547, 30.4443, 36.894),
-    },
-    Vertex {
-        position: (-15.9044, 28.3457, 38.2256),
-    },
-    Vertex {
-        position: (-28.3832, 28.3457, 27.1468),
-    },
-    Vertex {
-        position: (-27.4344, 30.4443, 26.7527),
-    },
-    Vertex {
-        position: (-27.6068, 31.1438, 27.2099),
-    },
-    Vertex {
-        position: (-28.4322, 30.4443, 28.1402),
-    },
-    Vertex {
-        position: (-29.4421, 28.3457, 29.165),
-    },
-    Vertex {
-        position: (-36.2402, 28.3457, 14.5117),
-    },
-    Vertex {
-        position: (-35.52, 30.4443, 14.2938),
-    },
-    Vertex {
-        position: (-36.0073, 31.1438, 14.5466),
-    },
-    Vertex {
-        position: (-37.1767, 30.4443, 15.0609),
-    },
-    Vertex {
-        position: (-38.5027, 28.3457, 15.6274),
-    },
-    Vertex {
-        position: (-38.9646, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (-38.4094, 30.4443, -1.10804),
-    },
-    Vertex {
-        position: (-39.0534, 31.1438, -1.10804),
-    },
-    Vertex {
-        position: (-40.3636, 30.4443, -1.10804),
-    },
-    Vertex {
-        position: (-41.8071, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (-35.8804, 28.3457, -16.7278),
-    },
-    Vertex {
-        position: (-35.3683, 30.4443, -16.5099),
-    },
-    Vertex {
-        position: (-35.9624, 31.1438, -16.7627),
-    },
-    Vertex {
-        position: (-37.1711, 30.4443, -17.2769),
-    },
-    Vertex {
-        position: (-38.5027, 28.3457, -17.8435),
-    },
-    Vertex {
-        position: (-27.4238, 28.3457, -29.3629),
-    },
-    Vertex {
-        position: (-27.0297, 30.4443, -28.9687),
-    },
-    Vertex {
-        position: (-27.4869, 31.1438, -29.426),
-    },
-    Vertex {
-        position: (-28.4172, 30.4443, -30.3562),
-    },
-    Vertex {
-        position: (-29.4421, 28.3457, -31.3811),
-    },
-    Vertex {
-        position: (-14.7887, 28.3457, -37.8195),
-    },
-    Vertex {
-        position: (-14.5708, 30.4443, -37.3073),
-    },
-    Vertex {
-        position: (-14.8236, 31.1438, -37.9014),
-    },
-    Vertex {
-        position: (-15.3379, 30.4443, -39.1101),
-    },
-    Vertex {
-        position: (-15.9044, 28.3457, -40.4417),
-    },
-    Vertex {
-        position: (0.831025, 28.3457, -40.9036),
-    },
-    Vertex {
-        position: (0.831025, 30.4443, -40.3484),
-    },
-    Vertex {
-        position: (0.831025, 31.1438, -40.9925),
-    },
-    Vertex {
-        position: (0.831025, 30.4443, -42.3027),
-    },
-    Vertex {
-        position: (0.831025, 28.3457, -43.7462),
-    },
-    Vertex {
-        position: (16.4508, 28.3457, -37.8195),
-    },
-    Vertex {
-        position: (16.2329, 30.4443, -37.3073),
-    },
-    Vertex {
-        position: (16.4857, 31.1438, -37.9014),
-    },
-    Vertex {
-        position: (16.9999, 30.4443, -39.1101),
-    },
-    Vertex {
-        position: (17.5665, 28.3457, -40.4417),
-    },
-    Vertex {
-        position: (29.0859, 28.3457, -29.3629),
-    },
-    Vertex {
-        position: (28.6917, 30.4443, -28.9687),
-    },
-    Vertex {
-        position: (29.149, 31.1438, -29.426),
-    },
-    Vertex {
-        position: (30.0792, 30.4443, -30.3562),
-    },
-    Vertex {
-        position: (31.1041, 28.3457, -31.3811),
-    },
-    Vertex {
-        position: (37.5425, 28.3457, -16.7278),
-    },
-    Vertex {
-        position: (37.0303, 30.4443, -16.5099),
-    },
-    Vertex {
-        position: (37.6244, 31.1438, -16.7627),
-    },
-    Vertex {
-        position: (38.8331, 30.4443, -17.2769),
-    },
-    Vertex {
-        position: (40.1647, 28.3457, -17.8435),
-    },
-    Vertex {
-        position: (48.6879, 17.1865, -1.10804),
-    },
-    Vertex {
-        position: (53.2404, 6.22714, -1.10804),
-    },
-    Vertex {
-        position: (56.4605, -4.33246, -1.10804),
-    },
-    Vertex {
-        position: (57.6819, -14.2925, -1.10804),
-    },
-    Vertex {
-        position: (44.979, 17.1865, 17.6758),
-    },
-    Vertex {
-        position: (49.1787, 6.22714, 19.4626),
-    },
-    Vertex {
-        position: (52.1492, -4.33246, 20.7265),
-    },
-    Vertex {
-        position: (53.2759, -14.2925, 21.2059),
-    },
-    Vertex {
-        position: (34.8094, 17.1865, 32.8703),
-    },
-    Vertex {
-        position: (38.0417, 6.22714, 36.1026),
-    },
-    Vertex {
-        position: (40.3279, -4.33246, 38.3889),
-    },
-    Vertex {
-        position: (41.1951, -14.2925, 39.2561),
-    },
-    Vertex {
-        position: (19.6148, 17.1865, 43.0399),
-    },
-    Vertex {
-        position: (21.4017, 6.22714, 47.2396),
-    },
-    Vertex {
-        position: (22.6656, -4.33246, 50.2101),
-    },
-    Vertex {
-        position: (23.145, -14.2925, 51.3369),
-    },
-    Vertex {
-        position: (0.831025, 17.1865, 46.7488),
-    },
-    Vertex {
-        position: (0.831025, 6.22714, 51.3013),
-    },
-    Vertex {
-        position: (0.831025, -4.33246, 54.5214),
-    },
-    Vertex {
-        position: (0.831025, -14.2925, 55.7428),
-    },
-    Vertex {
-        position: (-17.9528, 17.1865, 43.0399),
-    },
-    Vertex {
-        position: (-19.7397, 6.22714, 47.2396),
-    },
-    Vertex {
-        position: (-21.0035, -4.33246, 50.2101),
-    },
-    Vertex {
-        position: (-21.4829, -14.2925, 51.3369),
-    },
-    Vertex {
-        position: (-33.1474, 17.1865, 32.8703),
-    },
-    Vertex {
-        position: (-36.3796, 6.22714, 36.1026),
-    },
-    Vertex {
-        position: (-38.6659, -4.33246, 38.3889),
-    },
-    Vertex {
-        position: (-39.5331, -14.2925, 39.2561),
-    },
-    Vertex {
-        position: (-43.3169, 17.1865, 17.6758),
-    },
-    Vertex {
-        position: (-47.5166, 6.22714, 19.4626),
-    },
-    Vertex {
-        position: (-50.4871, -4.33246, 20.7265),
-    },
-    Vertex {
-        position: (-51.6139, -14.2925, 21.2059),
-    },
-    Vertex {
-        position: (-47.0258, 17.1865, -1.10804),
-    },
-    Vertex {
-        position: (-51.5784, 6.22714, -1.10804),
-    },
-    Vertex {
-        position: (-54.7984, -4.33246, -1.10804),
-    },
-    Vertex {
-        position: (-56.0198, -14.2925, -1.10804),
-    },
-    Vertex {
-        position: (-43.3169, 17.1865, -19.8919),
-    },
-    Vertex {
-        position: (-47.5166, 6.22714, -21.6787),
-    },
-    Vertex {
-        position: (-50.4871, -4.33246, -22.9426),
-    },
-    Vertex {
-        position: (-51.6139, -14.2925, -23.422),
-    },
-    Vertex {
-        position: (-33.1474, 17.1865, -35.0864),
-    },
-    Vertex {
-        position: (-36.3796, 6.22714, -38.3187),
-    },
-    Vertex {
-        position: (-38.6659, -4.33246, -40.6049),
-    },
-    Vertex {
-        position: (-39.5331, -14.2925, -41.4721),
-    },
-    Vertex {
-        position: (-17.9528, 17.1865, -45.256),
-    },
-    Vertex {
-        position: (-19.7397, 6.22714, -49.4557),
-    },
-    Vertex {
-        position: (-21.0035, -4.33246, -52.4262),
-    },
-    Vertex {
-        position: (-21.4829, -14.2925, -53.5529),
-    },
-    Vertex {
-        position: (0.831025, 17.1865, -48.9649),
-    },
-    Vertex {
-        position: (0.831025, 6.22714, -53.5174),
-    },
-    Vertex {
-        position: (0.831025, -4.33246, -56.7375),
-    },
-    Vertex {
-        position: (0.831025, -14.2925, -57.9589),
-    },
-    Vertex {
-        position: (19.6148, 17.1865, -45.256),
-    },
-    Vertex {
-        position: (21.4017, 6.22714, -49.4557),
-    },
-    Vertex {
-        position: (22.6656, -4.33246, -52.4262),
-    },
-    Vertex {
-        position: (23.145, -14.2925, -53.5529),
-    },
-    Vertex {
-        position: (34.8094, 17.1865, -35.0864),
-    },
-    Vertex {
-        position: (38.0417, 6.22714, -38.3187),
-    },
-    Vertex {
-        position: (40.3279, -4.33246, -40.6049),
-    },
-    Vertex {
-        position: (41.1951, -14.2925, -41.4721),
-    },
-    Vertex {
-        position: (44.979, 17.1865, -19.8919),
-    },
-    Vertex {
-        position: (49.1787, 6.22714, -21.6787),
-    },
-    Vertex {
-        position: (52.1492, -4.33246, -22.9426),
-    },
-    Vertex {
-        position: (53.2759, -14.2925, -23.422),
-    },
-    Vertex {
-        position: (55.4611, -22.7202, -1.10804),
-    },
-    Vertex {
-        position: (50.5755, -28.9493, -1.10804),
-    },
-    Vertex {
-        position: (45.6899, -33.1798, -1.10804),
-    },
-    Vertex {
-        position: (43.4692, -35.6115, -1.10804),
-    },
-    Vertex {
-        position: (51.2273, -22.7202, 20.3343),
-    },
-    Vertex {
-        position: (46.7203, -28.9493, 18.4167),
-    },
-    Vertex {
-        position: (42.2133, -33.1798, 16.4991),
-    },
-    Vertex {
-        position: (40.1647, -35.6115, 15.6274),
-    },
-    Vertex {
-        position: (39.6184, -22.7202, 37.6793),
-    },
-    Vertex {
-        position: (36.1496, -28.9493, 34.2106),
-    },
-    Vertex {
-        position: (32.6808, -33.1798, 30.7418),
-    },
-    Vertex {
-        position: (31.1041, -35.6115, 29.165),
-    },
-    Vertex {
-        position: (22.2733, -22.7202, 49.2882),
-    },
-    Vertex {
-        position: (20.3557, -28.9493, 44.7813),
-    },
-    Vertex {
-        position: (18.4381, -33.1798, 40.2743),
-    },
-    Vertex {
-        position: (17.5665, -35.6115, 38.2256),
-    },
-    Vertex {
-        position: (0.831025, -22.7202, 53.5221),
-    },
-    Vertex {
-        position: (0.831025, -28.9493, 48.6365),
-    },
-    Vertex {
-        position: (0.831025, -33.1798, 43.7508),
-    },
-    Vertex {
-        position: (0.831025, -35.6115, 41.5301),
-    },
-    Vertex {
-        position: (-20.6113, -22.7202, 49.2882),
-    },
-    Vertex {
-        position: (-18.6937, -28.9493, 44.7813),
-    },
-    Vertex {
-        position: (-16.7761, -33.1798, 40.2743),
-    },
-    Vertex {
-        position: (-15.9044, -35.6115, 38.2256),
-    },
-    Vertex {
-        position: (-37.9564, -22.7202, 37.6793),
-    },
-    Vertex {
-        position: (-34.4876, -28.9493, 34.2106),
-    },
-    Vertex {
-        position: (-31.0188, -33.1798, 30.7418),
-    },
-    Vertex {
-        position: (-29.4421, -35.6115, 29.165),
-    },
-    Vertex {
-        position: (-49.5653, -22.7202, 20.3343),
-    },
-    Vertex {
-        position: (-45.0583, -28.9493, 18.4167),
-    },
-    Vertex {
-        position: (-40.5513, -33.1798, 16.4991),
-    },
-    Vertex {
-        position: (-38.5027, -35.6115, 15.6274),
-    },
-    Vertex {
-        position: (-53.7991, -22.7202, -1.10804),
-    },
-    Vertex {
-        position: (-48.9135, -28.9493, -1.10804),
-    },
-    Vertex {
-        position: (-44.0279, -33.1798, -1.10804),
-    },
-    Vertex {
-        position: (-41.8071, -35.6115, -1.10804),
-    },
-    Vertex {
-        position: (-49.5653, -22.7202, -22.5504),
-    },
-    Vertex {
-        position: (-45.0583, -28.9493, -20.6327),
-    },
-    Vertex {
-        position: (-40.5513, -33.1798, -18.7151),
-    },
-    Vertex {
-        position: (-38.5027, -35.6115, -17.8435),
-    },
-    Vertex {
-        position: (-37.9564, -22.7202, -39.8954),
-    },
-    Vertex {
-        position: (-34.4876, -28.9493, -36.4266),
-    },
-    Vertex {
-        position: (-31.0188, -33.1798, -32.9578),
-    },
-    Vertex {
-        position: (-29.4421, -35.6115, -31.3811),
-    },
-    Vertex {
-        position: (-20.6113, -22.7202, -51.5043),
-    },
-    Vertex {
-        position: (-18.6937, -28.9493, -46.9973),
-    },
-    Vertex {
-        position: (-16.7761, -33.1798, -42.4903),
-    },
-    Vertex {
-        position: (-15.9044, -35.6115, -40.4417),
-    },
-    Vertex {
-        position: (0.831025, -22.7202, -55.7382),
-    },
-    Vertex {
-        position: (0.831025, -28.9493, -50.8525),
-    },
-    Vertex {
-        position: (0.831025, -33.1798, -45.9669),
-    },
-    Vertex {
-        position: (0.831025, -35.6115, -43.7462),
-    },
-    Vertex {
-        position: (22.2733, -22.7202, -51.5043),
-    },
-    Vertex {
-        position: (20.3557, -28.9493, -46.9973),
-    },
-    Vertex {
-        position: (18.4381, -33.1798, -42.4903),
-    },
-    Vertex {
-        position: (17.5665, -35.6115, -40.4417),
-    },
-    Vertex {
-        position: (39.6184, -22.7202, -39.8954),
-    },
-    Vertex {
-        position: (36.1496, -28.9493, -36.4266),
-    },
-    Vertex {
-        position: (32.6808, -33.1798, -32.9578),
-    },
-    Vertex {
-        position: (31.1041, -35.6115, -31.3811),
-    },
-    Vertex {
-        position: (51.2273, -22.7202, -22.5504),
-    },
-    Vertex {
-        position: (46.7203, -28.9493, -20.6327),
-    },
-    Vertex {
-        position: (42.2133, -33.1798, -18.7151),
-    },
-    Vertex {
-        position: (40.1647, -35.6115, -17.8435),
-    },
-    Vertex {
-        position: (42.5031, -37.1772, -1.10804),
-    },
-    Vertex {
-        position: (37.3399, -38.5429, -1.10804),
-    },
-    Vertex {
-        position: (24.5818, -39.5089, -1.10804),
-    },
-    Vertex {
-        position: (0.831025, -39.8754, -1.10804),
-    },
-    Vertex {
-        position: (39.2736, -37.1772, 15.2483),
-    },
-    Vertex {
-        position: (34.5105, -38.5429, 13.2217),
-    },
-    Vertex {
-        position: (22.7411, -39.5089, 8.21414),
-    },
-    Vertex {
-        position: (30.4182, -37.1772, 28.4792),
-    },
-    Vertex {
-        position: (26.7523, -38.5429, 24.8133),
-    },
-    Vertex {
-        position: (17.6941, -39.5089, 15.755),
-    },
-    Vertex {
-        position: (17.1873, -37.1772, 37.3345),
-    },
-    Vertex {
-        position: (15.1608, -38.5429, 32.5714),
-    },
-    Vertex {
-        position: (10.1532, -39.5089, 20.8021),
-    },
-    Vertex {
-        position: (0.831025, -37.1772, 40.5641),
-    },
-    Vertex {
-        position: (0.831025, -38.5429, 35.4009),
-    },
-    Vertex {
-        position: (0.831025, -39.5089, 22.6427),
-    },
-    Vertex {
-        position: (-15.5253, -37.1772, 37.3345),
-    },
-    Vertex {
-        position: (-13.4987, -38.5429, 32.5714),
-    },
-    Vertex {
-        position: (-8.49115, -39.5089, 20.8021),
-    },
-    Vertex {
-        position: (-28.7562, -37.1772, 28.4792),
-    },
-    Vertex {
-        position: (-25.0903, -38.5429, 24.8133),
-    },
-    Vertex {
-        position: (-16.032, -39.5089, 15.755),
-    },
-    Vertex {
-        position: (-37.6115, -37.1772, 15.2483),
-    },
-    Vertex {
-        position: (-32.8484, -38.5429, 13.2217),
-    },
-    Vertex {
-        position: (-21.0791, -39.5089, 8.21414),
-    },
-    Vertex {
-        position: (-40.8411, -37.1772, -1.10804),
-    },
-    Vertex {
-        position: (-35.6779, -38.5429, -1.10804),
-    },
-    Vertex {
-        position: (-22.9198, -39.5089, -1.10804),
-    },
-    Vertex {
-        position: (-37.6115, -37.1772, -17.4643),
-    },
-    Vertex {
-        position: (-32.8484, -38.5429, -15.4378),
-    },
-    Vertex {
-        position: (-21.0791, -39.5089, -10.4302),
-    },
-    Vertex {
-        position: (-28.7562, -37.1772, -30.6952),
-    },
-    Vertex {
-        position: (-25.0903, -38.5429, -27.0294),
-    },
-    Vertex {
-        position: (-16.032, -39.5089, -17.9711),
-    },
-    Vertex {
-        position: (-15.5253, -37.1772, -39.5506),
-    },
-    Vertex {
-        position: (-13.4987, -38.5429, -34.7875),
-    },
-    Vertex {
-        position: (-8.49115, -39.5089, -23.0181),
-    },
-    Vertex {
-        position: (0.831025, -37.1772, -42.7802),
-    },
-    Vertex {
-        position: (0.831025, -38.5429, -37.6169),
-    },
-    Vertex {
-        position: (0.831025, -39.5089, -24.8588),
-    },
-    Vertex {
-        position: (17.1873, -37.1772, -39.5506),
-    },
-    Vertex {
-        position: (15.1608, -38.5429, -34.7875),
-    },
-    Vertex {
-        position: (10.1532, -39.5089, -23.0181),
-    },
-    Vertex {
-        position: (30.4182, -37.1772, -30.6952),
-    },
-    Vertex {
-        position: (26.7523, -38.5429, -27.0294),
-    },
-    Vertex {
-        position: (17.6941, -39.5089, -17.9711),
-    },
-    Vertex {
-        position: (39.2736, -37.1772, -17.4643),
-    },
-    Vertex {
-        position: (34.5105, -38.5429, -15.4378),
-    },
-    Vertex {
-        position: (22.7411, -39.5089, -10.4302),
-    },
-    Vertex {
-        position: (-44.6497, 17.6861, -1.10804),
-    },
-    Vertex {
-        position: (-57.9297, 17.5862, -1.10804),
-    },
-    Vertex {
-        position: (-67.7453, 16.8867, -1.10804),
-    },
-    Vertex {
-        position: (-73.8301, 14.9879, -1.10804),
-    },
-    Vertex {
-        position: (-75.9176, 11.2904, -1.10804),
-    },
-    Vertex {
-        position: (-44.2055, 18.6855, 3.68876),
-    },
-    Vertex {
-        position: (-58.3252, 18.5699, 3.68876),
-    },
-    Vertex {
-        position: (-68.6891, 17.7611, 3.68876),
-    },
-    Vertex {
-        position: (-75.0724, 15.5657, 3.68876),
-    },
-    Vertex {
-        position: (-77.2501, 11.2904, 3.68876),
-    },
-    Vertex {
-        position: (-43.2284, 20.884, 5.28769),
-    },
-    Vertex {
-        position: (-59.1955, 20.7341, 5.28769),
-    },
-    Vertex {
-        position: (-70.7655, 19.6848, 5.28769),
-    },
-    Vertex {
-        position: (-77.8053, 16.8367, 5.28769),
-    },
-    Vertex {
-        position: (-80.1814, 11.2904, 5.28769),
-    },
-    Vertex {
-        position: (-42.2513, 23.0825, 3.68876),
-    },
-    Vertex {
-        position: (-60.0657, 22.8983, 3.68876),
-    },
-    Vertex {
-        position: (-72.8419, 21.6085, 3.68876),
-    },
-    Vertex {
-        position: (-80.5381, 18.1077, 3.68876),
-    },
-    Vertex {
-        position: (-83.1128, 11.2904, 3.68876),
-    },
-    Vertex {
-        position: (-41.8071, 24.0819, -1.10804),
-    },
-    Vertex {
-        position: (-60.4613, 23.882, -1.10804),
-    },
-    Vertex {
-        position: (-73.7857, 22.4829, -1.10804),
-    },
-    Vertex {
-        position: (-81.7804, 18.6855, -1.10804),
-    },
-    Vertex {
-        position: (-84.4453, 11.2904, -1.10804),
-    },
-    Vertex {
-        position: (-42.2513, 23.0825, -5.90483),
-    },
-    Vertex {
-        position: (-60.0657, 22.8983, -5.90483),
-    },
-    Vertex {
-        position: (-72.8419, 21.6085, -5.90483),
-    },
-    Vertex {
-        position: (-80.5381, 18.1077, -5.90483),
-    },
-    Vertex {
-        position: (-83.1128, 11.2904, -5.90483),
-    },
-    Vertex {
-        position: (-43.2284, 20.884, -7.50376),
-    },
-    Vertex {
-        position: (-59.1955, 20.7341, -7.50376),
-    },
-    Vertex {
-        position: (-70.7655, 19.6848, -7.50376),
-    },
-    Vertex {
-        position: (-77.8053, 16.8367, -7.50376),
-    },
-    Vertex {
-        position: (-80.1814, 11.2904, -7.50376),
-    },
-    Vertex {
-        position: (-44.2055, 18.6855, -5.90483),
-    },
-    Vertex {
-        position: (-58.3252, 18.5699, -5.90483),
-    },
-    Vertex {
-        position: (-68.6891, 17.7611, -5.90483),
-    },
-    Vertex {
-        position: (-75.0724, 15.5657, -5.90483),
-    },
-    Vertex {
-        position: (-77.2501, 11.2904, -5.90483),
-    },
-    Vertex {
-        position: (-74.8073, 5.4943, -1.10804),
-    },
-    Vertex {
-        position: (-71.2985, -1.50103, -1.10804),
-    },
-    Vertex {
-        position: (-65.1248, -8.49634, -1.10804),
-    },
-    Vertex {
-        position: (-56.0198, -14.2925, -1.10804),
-    },
-    Vertex {
-        position: (-76.0183, 4.93477, 3.68876),
-    },
-    Vertex {
-        position: (-72.159, -2.35462, 3.68876),
-    },
-    Vertex {
-        position: (-65.4267, -9.55033, 3.68876),
-    },
-    Vertex {
-        position: (-55.5757, -15.6249, 3.68876),
-    },
-    Vertex {
-        position: (-78.6824, 3.70383, 5.28769),
-    },
-    Vertex {
-        position: (-74.0522, -4.23253, 5.28769),
-    },
-    Vertex {
-        position: (-66.0909, -11.8691, 5.28769),
-    },
-    Vertex {
-        position: (-54.5986, -18.5563, 5.28769),
-    },
-    Vertex {
-        position: (-81.3466, 2.47288, 3.68876),
-    },
-    Vertex {
-        position: (-75.9454, -6.11044, 3.68876),
-    },
-    Vertex {
-        position: (-66.755, -14.1878, 3.68876),
-    },
-    Vertex {
-        position: (-53.6214, -21.4877, 3.68876),
-    },
-    Vertex {
-        position: (-82.5576, 1.91336, -1.10804),
-    },
-    Vertex {
-        position: (-76.8059, -6.96404, -1.10804),
-    },
-    Vertex {
-        position: (-67.0569, -15.2418, -1.10804),
-    },
-    Vertex {
-        position: (-53.1773, -22.8201, -1.10804),
-    },
-    Vertex {
-        position: (-81.3466, 2.47288, -5.90483),
-    },
-    Vertex {
-        position: (-75.9454, -6.11044, -5.90483),
-    },
-    Vertex {
-        position: (-66.755, -14.1878, -5.90483),
-    },
-    Vertex {
-        position: (-53.6214, -21.4877, -5.90483),
-    },
-    Vertex {
-        position: (-78.6824, 3.70383, -7.50376),
-    },
-    Vertex {
-        position: (-74.0522, -4.23253, -7.50376),
-    },
-    Vertex {
-        position: (-66.0909, -11.8691, -7.50376),
-    },
-    Vertex {
-        position: (-54.5986, -18.5563, -7.50376),
-    },
-    Vertex {
-        position: (-76.0183, 4.93477, -5.90483),
-    },
-    Vertex {
-        position: (-72.159, -2.35462, -5.90483),
-    },
-    Vertex {
-        position: (-65.4267, -9.55033, -5.90483),
-    },
-    Vertex {
-        position: (-55.5757, -15.6249, -5.90483),
-    },
-    Vertex {
-        position: (49.1543, 0.630882, -1.10804),
-    },
-    Vertex {
-        position: (62.7896, 3.76212, -1.10804),
-    },
-    Vertex {
-        position: (68.6967, 11.2904, -1.10804),
-    },
-    Vertex {
-        position: (71.939, 20.4176, -1.10804),
-    },
-    Vertex {
-        position: (77.5797, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (49.1543, -3.03333, 9.4449),
-    },
-    Vertex {
-        position: (63.8305, 1.04519, 8.42059),
-    },
-    Vertex {
-        position: (70.0292, 9.70814, 6.1671),
-    },
-    Vertex {
-        position: (73.5629, 19.8451, 3.91361),
-    },
-    Vertex {
-        position: (80.2446, 28.3457, 2.88929),
-    },
-    Vertex {
-        position: (49.1543, -11.0946, 12.9626),
-    },
-    Vertex {
-        position: (66.1207, -4.93206, 11.5968),
-    },
-    Vertex {
-        position: (72.9605, 6.22714, 8.59214),
-    },
-    Vertex {
-        position: (77.1355, 18.5855, 5.58749),
-    },
-    Vertex {
-        position: (86.1073, 28.3457, 4.22173),
-    },
-    Vertex {
-        position: (49.1543, -19.1559, 9.4449),
-    },
-    Vertex {
-        position: (68.4108, -10.9093, 8.42059),
-    },
-    Vertex {
-        position: (75.8919, 2.74614, 6.1671),
-    },
-    Vertex {
-        position: (80.7081, 17.326, 3.91361),
-    },
-    Vertex {
-        position: (91.97, 28.3457, 2.88929),
-    },
-    Vertex {
-        position: (49.1543, -22.8201, -1.10804),
-    },
-    Vertex {
-        position: (69.4518, -13.6262, -1.10804),
-    },
-    Vertex {
-        position: (77.2244, 1.16386, -1.10804),
-    },
-    Vertex {
-        position: (82.3321, 16.7534, -1.10804),
-    },
-    Vertex {
-        position: (94.6349, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (49.1543, -19.1559, -11.661),
-    },
-    Vertex {
-        position: (68.4108, -10.9093, -10.6367),
-    },
-    Vertex {
-        position: (75.8919, 2.74614, -8.38317),
-    },
-    Vertex {
-        position: (80.7081, 17.326, -6.12968),
-    },
-    Vertex {
-        position: (91.97, 28.3457, -5.10536),
-    },
-    Vertex {
-        position: (49.1543, -11.0946, -15.1786),
-    },
-    Vertex {
-        position: (66.1207, -4.93206, -13.8129),
-    },
-    Vertex {
-        position: (72.9605, 6.22714, -10.8082),
-    },
-    Vertex {
-        position: (77.1355, 18.5855, -7.80356),
-    },
-    Vertex {
-        position: (86.1073, 28.3457, -6.4378),
-    },
-    Vertex {
-        position: (49.1543, -3.03333, -11.661),
-    },
-    Vertex {
-        position: (63.8305, 1.04519, -10.6367),
-    },
-    Vertex {
-        position: (70.0292, 9.70814, -8.38317),
-    },
-    Vertex {
-        position: (73.5629, 19.8451, -6.12968),
-    },
-    Vertex {
-        position: (80.2446, 28.3457, -5.10536),
-    },
-    Vertex {
-        position: (79.6227, 29.5449, -1.10804),
-    },
-    Vertex {
-        position: (81.1329, 29.9446, -1.10804),
-    },
-    Vertex {
-        position: (81.577, 29.5449, -1.10804),
-    },
-    Vertex {
-        position: (80.4222, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (82.4767, 29.6034, 2.63946),
-    },
-    Vertex {
-        position: (83.8116, 30.0383, 2.08983),
-    },
-    Vertex {
-        position: (83.8515, 29.6268, 1.54019),
-    },
-    Vertex {
-        position: (82.1988, 28.3457, 1.29036),
-    },
-    Vertex {
-        position: (88.7555, 29.7322, 3.88862),
-    },
-    Vertex {
-        position: (89.7049, 30.2444, 3.15578),
-    },
-    Vertex {
-        position: (88.8555, 29.8072, 2.42294),
-    },
-    Vertex {
-        position: (86.1073, 28.3457, 2.08983),
-    },
-    Vertex {
-        position: (95.0343, 29.8611, 2.63946),
-    },
-    Vertex {
-        position: (95.5982, 30.4505, 2.08983),
-    },
-    Vertex {
-        position: (93.8594, 29.9875, 1.54019),
-    },
-    Vertex {
-        position: (90.0158, 28.3457, 1.29036),
-    },
-    Vertex {
-        position: (97.8883, 29.9196, -1.10804),
-    },
-    Vertex {
-        position: (98.2769, 30.5442, -1.10804),
-    },
-    Vertex {
-        position: (96.1339, 30.0695, -1.10804),
-    },
-    Vertex {
-        position: (91.7924, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (95.0343, 29.8611, -4.85553),
-    },
-    Vertex {
-        position: (95.5982, 30.4505, -4.3059),
-    },
-    Vertex {
-        position: (93.8594, 29.9875, -3.75626),
-    },
-    Vertex {
-        position: (90.0158, 28.3457, -3.50643),
-    },
-    Vertex {
-        position: (88.7555, 29.7322, -6.10469),
-    },
-    Vertex {
-        position: (89.7049, 30.2444, -5.37185),
-    },
-    Vertex {
-        position: (88.8555, 29.8072, -4.63901),
-    },
-    Vertex {
-        position: (86.1073, 28.3457, -4.3059),
-    },
-    Vertex {
-        position: (82.4767, 29.6034, -4.85553),
-    },
-    Vertex {
-        position: (83.8116, 30.0383, -4.3059),
-    },
-    Vertex {
-        position: (83.8515, 29.6268, -3.75626),
-    },
-    Vertex {
-        position: (82.1988, 28.3457, -3.50643),
-    },
-    Vertex {
-        position: (0.831025, 49.6647, -1.10804),
-    },
-    Vertex {
-        position: (10.5134, 48.2657, -1.10804),
-    },
-    Vertex {
-        position: (10.0693, 44.868, -1.10804),
-    },
-    Vertex {
-        position: (6.42728, 40.6708, -1.10804),
-    },
-    Vertex {
-        position: (6.51611, 36.8733, -1.10804),
-    },
-    Vertex {
-        position: (9.76642, 48.2657, 2.70243),
-    },
-    Vertex {
-        position: (9.35632, 44.868, 2.52698),
-    },
-    Vertex {
-        position: (5.9947, 40.6708, 1.09187),
-    },
-    Vertex {
-        position: (6.07552, 36.8733, 1.12336),
-    },
-    Vertex {
-        position: (7.71453, 48.2657, 5.77547),
-    },
-    Vertex {
-        position: (7.39819, 44.868, 5.45913),
-    },
-    Vertex {
-        position: (4.80736, 40.6708, 2.8683),
-    },
-    Vertex {
-        position: (4.86744, 36.8733, 2.92838),
-    },
-    Vertex {
-        position: (4.64149, 48.2657, 7.82736),
-    },
-    Vertex {
-        position: (4.46604, 44.868, 7.41726),
-    },
-    Vertex {
-        position: (3.03093, 40.6708, 4.05564),
-    },
-    Vertex {
-        position: (3.06242, 36.8733, 4.13646),
-    },
-    Vertex {
-        position: (0.831025, 48.2657, 8.57438),
-    },
-    Vertex {
-        position: (0.831025, 44.868, 8.13023),
-    },
-    Vertex {
-        position: (0.831025, 40.6708, 4.48822),
-    },
-    Vertex {
-        position: (0.831025, 36.8733, 4.57705),
-    },
-    Vertex {
-        position: (-2.97944, 48.2657, 7.82736),
-    },
-    Vertex {
-        position: (-2.80399, 44.868, 7.41726),
-    },
-    Vertex {
-        position: (-1.36888, 40.6708, 4.05564),
-    },
-    Vertex {
-        position: (-1.40037, 36.8733, 4.13646),
-    },
-    Vertex {
-        position: (-6.05248, 48.2657, 5.77547),
-    },
-    Vertex {
-        position: (-5.73614, 44.868, 5.45913),
-    },
-    Vertex {
-        position: (-3.14531, 40.6708, 2.8683),
-    },
-    Vertex {
-        position: (-3.20539, 36.8733, 2.92838),
-    },
-    Vertex {
-        position: (-8.10437, 48.2657, 2.70243),
-    },
-    Vertex {
-        position: (-7.69427, 44.868, 2.52698),
-    },
-    Vertex {
-        position: (-4.33265, 40.6708, 1.09187),
-    },
-    Vertex {
-        position: (-4.41347, 36.8733, 1.12336),
-    },
-    Vertex {
-        position: (-8.85139, 48.2657, -1.10804),
-    },
-    Vertex {
-        position: (-8.40724, 44.868, -1.10804),
-    },
-    Vertex {
-        position: (-4.76523, 40.6708, -1.10804),
-    },
-    Vertex {
-        position: (-4.85406, 36.8733, -1.10804),
-    },
-    Vertex {
-        position: (-8.10437, 48.2657, -4.9185),
-    },
-    Vertex {
-        position: (-7.69427, 44.868, -4.74305),
-    },
-    Vertex {
-        position: (-4.33265, 40.6708, -3.30794),
-    },
-    Vertex {
-        position: (-4.41347, 36.8733, -3.33943),
-    },
-    Vertex {
-        position: (-6.05248, 48.2657, -7.99154),
-    },
-    Vertex {
-        position: (-5.73614, 44.868, -7.6752),
-    },
-    Vertex {
-        position: (-3.14531, 40.6708, -5.08437),
-    },
-    Vertex {
-        position: (-3.20539, 36.8733, -5.14445),
-    },
-    Vertex {
-        position: (-2.97944, 48.2657, -10.0434),
-    },
-    Vertex {
-        position: (-2.80399, 44.868, -9.63333),
-    },
-    Vertex {
-        position: (-1.36888, 40.6708, -6.27171),
-    },
-    Vertex {
-        position: (-1.40037, 36.8733, -6.35253),
-    },
-    Vertex {
-        position: (0.831025, 48.2657, -10.7904),
-    },
-    Vertex {
-        position: (0.831025, 44.868, -10.3463),
-    },
-    Vertex {
-        position: (0.831025, 40.6708, -6.70429),
-    },
-    Vertex {
-        position: (0.831025, 36.8733, -6.79312),
-    },
-    Vertex {
-        position: (4.64149, 48.2657, -10.0434),
-    },
-    Vertex {
-        position: (4.46604, 44.868, -9.63333),
-    },
-    Vertex {
-        position: (3.03093, 40.6708, -6.27171),
-    },
-    Vertex {
-        position: (3.06242, 36.8733, -6.35253),
-    },
-    Vertex {
-        position: (7.71453, 48.2657, -7.99154),
-    },
-    Vertex {
-        position: (7.39819, 44.868, -7.6752),
-    },
-    Vertex {
-        position: (4.80736, 40.6708, -5.08437),
-    },
-    Vertex {
-        position: (4.86744, 36.8733, -5.14445),
-    },
-    Vertex {
-        position: (9.76642, 48.2657, -4.9185),
-    },
-    Vertex {
-        position: (9.35632, 44.868, -4.74305),
-    },
-    Vertex {
-        position: (5.9947, 40.6708, -3.30794),
-    },
-    Vertex {
-        position: (6.07552, 36.8733, -3.33943),
-    },
-    Vertex {
-        position: (13.8001, 34.3417, -1.10804),
-    },
-    Vertex {
-        position: (24.282, 32.6095, -1.10804),
-    },
-    Vertex {
-        position: (33.6979, 30.8773, -1.10804),
-    },
-    Vertex {
-        position: (37.7841, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (12.795, 34.3417, 3.98234),
-    },
-    Vertex {
-        position: (22.4646, 32.6095, 8.09647),
-    },
-    Vertex {
-        position: (31.1507, 30.8773, 11.7922),
-    },
-    Vertex {
-        position: (34.9202, 28.3457, 13.396),
-    },
-    Vertex {
-        position: (10.0391, 34.3417, 8.10003),
-    },
-    Vertex {
-        position: (17.4812, 32.6095, 15.5422),
-    },
-    Vertex {
-        position: (24.1665, 30.8773, 22.2275),
-    },
-    Vertex {
-        position: (27.0677, 28.3457, 25.1286),
-    },
-    Vertex {
-        position: (5.9214, 34.3417, 10.856),
-    },
-    Vertex {
-        position: (10.0355, 32.6095, 20.5255),
-    },
-    Vertex {
-        position: (13.7313, 30.8773, 29.2117),
-    },
-    Vertex {
-        position: (15.3351, 28.3457, 32.9812),
-    },
-    Vertex {
-        position: (0.831025, 34.3417, 11.8611),
-    },
-    Vertex {
-        position: (0.831025, 32.6095, 22.3429),
-    },
-    Vertex {
-        position: (0.831025, 30.8773, 31.7589),
-    },
-    Vertex {
-        position: (0.831025, 28.3457, 35.845),
-    },
-    Vertex {
-        position: (-4.25935, 34.3417, 10.856),
-    },
-    Vertex {
-        position: (-8.37348, 32.6095, 20.5255),
-    },
-    Vertex {
-        position: (-12.0692, 30.8773, 29.2117),
-    },
-    Vertex {
-        position: (-13.673, 28.3457, 32.9812),
-    },
-    Vertex {
-        position: (-8.37704, 34.3417, 8.10003),
-    },
-    Vertex {
-        position: (-15.8192, 32.6095, 15.5422),
-    },
-    Vertex {
-        position: (-22.5045, 30.8773, 22.2275),
-    },
-    Vertex {
-        position: (-25.4056, 28.3457, 25.1286),
-    },
-    Vertex {
-        position: (-11.133, 34.3417, 3.98234),
-    },
-    Vertex {
-        position: (-20.8025, 32.6095, 8.09647),
-    },
-    Vertex {
-        position: (-29.4887, 30.8773, 11.7922),
-    },
-    Vertex {
-        position: (-33.2582, 28.3457, 13.396),
-    },
-    Vertex {
-        position: (-12.1381, 34.3417, -1.10804),
-    },
-    Vertex {
-        position: (-22.62, 32.6095, -1.10804),
-    },
-    Vertex {
-        position: (-32.0359, 30.8773, -1.10804),
-    },
-    Vertex {
-        position: (-36.122, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (-11.133, 34.3417, -6.19841),
-    },
-    Vertex {
-        position: (-20.8025, 32.6095, -10.3125),
-    },
-    Vertex {
-        position: (-29.4887, 30.8773, -14.0083),
-    },
-    Vertex {
-        position: (-33.2582, 28.3457, -15.6121),
-    },
-    Vertex {
-        position: (-8.37704, 34.3417, -10.3161),
-    },
-    Vertex {
-        position: (-15.8192, 32.6095, -17.7582),
-    },
-    Vertex {
-        position: (-22.5045, 30.8773, -24.4435),
-    },
-    Vertex {
-        position: (-25.4056, 28.3457, -27.3447),
-    },
-    Vertex {
-        position: (-4.25935, 34.3417, -13.072),
-    },
-    Vertex {
-        position: (-8.37348, 32.6095, -22.7416),
-    },
-    Vertex {
-        position: (-12.0692, 30.8773, -31.4277),
-    },
-    Vertex {
-        position: (-13.673, 28.3457, -35.1972),
-    },
-    Vertex {
-        position: (0.831025, 34.3417, -14.0771),
-    },
-    Vertex {
-        position: (0.831025, 32.6095, -24.559),
-    },
-    Vertex {
-        position: (0.831025, 30.8773, -33.9749),
-    },
-    Vertex {
-        position: (0.831025, 28.3457, -38.0611),
-    },
-    Vertex {
-        position: (5.9214, 34.3417, -13.072),
-    },
-    Vertex {
-        position: (10.0355, 32.6095, -22.7416),
-    },
-    Vertex {
-        position: (13.7313, 30.8773, -31.4277),
-    },
-    Vertex {
-        position: (15.3351, 28.3457, -35.1972),
-    },
-    Vertex {
-        position: (10.0391, 34.3417, -10.3161),
-    },
-    Vertex {
-        position: (17.4812, 32.6095, -17.7582),
-    },
-    Vertex {
-        position: (24.1665, 30.8773, -24.4435),
-    },
-    Vertex {
-        position: (27.0677, 28.3457, -27.3447),
-    },
-    Vertex {
-        position: (12.795, 34.3417, -6.19841),
-    },
-    Vertex {
-        position: (22.4646, 32.6095, -10.3125),
-    },
-    Vertex {
-        position: (31.1507, 30.8773, -14.0083),
-    },
-    Vertex {
-        position: (34.9202, 28.3457, -15.6121),
-    },
-];
-
-pub const NORMALS: [Normal; 531] = [
-    Normal {
-        normal: (0.0, 0.0, 0.0),
-    }, // dummy vector because in the original model indices
-    // start at 1
-    Normal {
-        normal: (-0.966742, -0.255752, 0.0),
-    },
-    Normal {
-        normal: (-0.966824, 0.255443, 0.0),
-    },
-    Normal {
-        normal: (-0.092052, 0.995754, 0.0),
-    },
-    Normal {
-        normal: (0.68205, 0.731305, 0.0),
-    },
-    Normal {
-        normal: (0.870301, 0.492521, -0.0),
-    },
-    Normal {
-        normal: (-0.893014, -0.256345, -0.369882),
-    },
-    Normal {
-        normal: (-0.893437, 0.255997, -0.369102),
-    },
-    Normal {
-        normal: (-0.0838771, 0.995843, -0.0355068),
-    },
-    Normal {
-        normal: (0.629724, 0.73186, 0.260439),
-    },
-    Normal {
-        normal: (0.803725, 0.49337, 0.332584),
-    },
-    Normal {
-        normal: (-0.683407, -0.256729, -0.683407),
-    },
-    Normal {
-        normal: (-0.683531, 0.256067, -0.683531),
-    },
-    Normal {
-        normal: (-0.0649249, 0.995776, -0.0649248),
-    },
-    Normal {
-        normal: (0.481398, 0.732469, 0.481398),
-    },
-    Normal {
-        normal: (0.614804, 0.493997, 0.614804),
-    },
-    Normal {
-        normal: (-0.369882, -0.256345, -0.893014),
-    },
-    Normal {
-        normal: (-0.369102, 0.255997, -0.893437),
-    },
-    Normal {
-        normal: (-0.0355067, 0.995843, -0.0838772),
-    },
-    Normal {
-        normal: (0.260439, 0.73186, 0.629724),
-    },
-    Normal {
-        normal: (0.332584, 0.49337, 0.803725),
-    },
-    Normal {
-        normal: (-0.00284834, -0.257863, -0.966177),
-    },
-    Normal {
-        normal: (-0.00192311, 0.254736, -0.967009),
-    },
-    Normal {
-        normal: (-0.000266114, 0.995734, -0.0922702),
-    },
-    Normal {
-        normal: (0.0, 0.731295, 0.682061),
-    },
-    Normal {
-        normal: (0.0, 0.492521, 0.870301),
-    },
-    Normal {
-        normal: (0.379058, -0.3593, -0.852771),
-    },
-    Normal {
-        normal: (0.37711, 0.149086, -0.914091),
-    },
-    Normal {
-        normal: (0.0275022, 0.992081, -0.122551),
-    },
-    Normal {
-        normal: (-0.26101, 0.726762, 0.635367),
-    },
-    Normal {
-        normal: (-0.332485, 0.492546, 0.804271),
-    },
-    Normal {
-        normal: (0.663548, -0.410791, -0.625264),
-    },
-    Normal {
-        normal: (0.712664, 0.0737216, -0.697621),
-    },
-    Normal {
-        normal: (0.0997268, 0.987509, -0.121984),
-    },
-    Normal {
-        normal: (-0.48732, 0.723754, 0.488568),
-    },
-    Normal {
-        normal: (-0.615242, 0.492602, 0.615484),
-    },
-    Normal {
-        normal: (0.880028, -0.332908, -0.338709),
-    },
-    Normal {
-        normal: (0.917276, 0.167113, -0.361493),
-    },
-    Normal {
-        normal: (0.113584, 0.992365, -0.0480695),
-    },
-    Normal {
-        normal: (-0.63415, 0.727508, 0.261889),
-    },
-    Normal {
-        normal: (-0.804126, 0.492634, 0.332705),
-    },
-    Normal {
-        normal: (0.96669, -0.255738, 0.0104537),
-    },
-    Normal {
-        normal: (0.967442, 0.252962, 0.00810329),
-    },
-    Normal {
-        normal: (0.0934365, 0.995624, 0.00128063),
-    },
-    Normal {
-        normal: (-0.682167, 0.731196, -0.00034353),
-    },
-    Normal {
-        normal: (-0.870322, 0.492483, -0.0),
-    },
-    Normal {
-        normal: (0.893014, -0.256345, 0.369882),
-    },
-    Normal {
-        normal: (0.893437, 0.255997, 0.369102),
-    },
-    Normal {
-        normal: (0.0838768, 0.995843, 0.0355066),
-    },
-    Normal {
-        normal: (-0.629724, 0.73186, -0.260439),
-    },
-    Normal {
-        normal: (-0.803725, 0.49337, -0.332584),
-    },
-    Normal {
-        normal: (0.683407, -0.256729, 0.683407),
-    },
-    Normal {
-        normal: (0.683531, 0.256067, 0.683531),
-    },
-    Normal {
-        normal: (0.0649249, 0.995776, 0.0649249),
-    },
-    Normal {
-        normal: (-0.481398, 0.732469, -0.481398),
-    },
-    Normal {
-        normal: (-0.614804, 0.493997, -0.614804),
-    },
-    Normal {
-        normal: (0.369882, -0.256345, 0.893014),
-    },
-    Normal {
-        normal: (0.369102, 0.255997, 0.893437),
-    },
-    Normal {
-        normal: (0.0355067, 0.995843, 0.083877),
-    },
-    Normal {
-        normal: (-0.260439, 0.73186, -0.629724),
-    },
-    Normal {
-        normal: (-0.332584, 0.49337, -0.803725),
-    },
-    Normal {
-        normal: (0.0, -0.255752, 0.966742),
-    },
-    Normal {
-        normal: (0.0, 0.255443, 0.966824),
-    },
-    Normal {
-        normal: (0.0, 0.995754, 0.092052),
-    },
-    Normal {
-        normal: (0.0, 0.731305, -0.68205),
-    },
-    Normal {
-        normal: (-0.0, 0.492521, -0.870301),
-    },
-    Normal {
-        normal: (-0.369882, -0.256345, 0.893014),
-    },
-    Normal {
-        normal: (-0.369102, 0.255996, 0.893437),
-    },
-    Normal {
-        normal: (-0.0355068, 0.995843, 0.0838771),
-    },
-    Normal {
-        normal: (0.260439, 0.73186, -0.629724),
-    },
-    Normal {
-        normal: (0.332584, 0.49337, -0.803725),
-    },
-    Normal {
-        normal: (-0.683407, -0.256729, 0.683407),
-    },
-    Normal {
-        normal: (-0.683531, 0.256067, 0.683531),
-    },
-    Normal {
-        normal: (-0.0649249, 0.995776, 0.064925),
-    },
-    Normal {
-        normal: (0.481398, 0.732469, -0.481398),
-    },
-    Normal {
-        normal: (0.614804, 0.493997, -0.614804),
-    },
-    Normal {
-        normal: (-0.893014, -0.256345, 0.369882),
-    },
-    Normal {
-        normal: (-0.893437, 0.255997, 0.369102),
-    },
-    Normal {
-        normal: (-0.0838767, 0.995843, 0.0355066),
-    },
-    Normal {
-        normal: (0.629724, 0.73186, -0.260439),
-    },
-    Normal {
-        normal: (0.803725, 0.49337, -0.332584),
-    },
-    Normal {
-        normal: (0.915321, 0.402725, 0.0),
-    },
-    Normal {
-        normal: (0.941808, 0.336151, -0.0),
-    },
-    Normal {
-        normal: (0.97869, 0.205342, 0.0),
-    },
-    Normal {
-        normal: (0.997804, -0.0662397, 0.0),
-    },
-    Normal {
-        normal: (0.845438, 0.403546, 0.349835),
-    },
-    Normal {
-        normal: (0.869996, 0.336859, 0.360047),
-    },
-    Normal {
-        normal: (0.904193, 0.205791, 0.37428),
-    },
-    Normal {
-        normal: (0.921879, -0.0663697, 0.381752),
-    },
-    Normal {
-        normal: (0.646802, 0.404096, 0.646802),
-    },
-    Normal {
-        normal: (0.665655, 0.337351, 0.665655),
-    },
-    Normal {
-        normal: (0.691923, 0.20612, 0.691923),
-    },
-    Normal {
-        normal: (0.705542, -0.0664796, 0.705543),
-    },
-    Normal {
-        normal: (0.349835, 0.403546, 0.845438),
-    },
-    Normal {
-        normal: (0.360047, 0.336859, 0.869996),
-    },
-    Normal {
-        normal: (0.37428, 0.205791, 0.904193),
-    },
-    Normal {
-        normal: (0.381752, -0.0663697, 0.921879),
-    },
-    Normal {
-        normal: (-0.0, 0.402725, 0.915321),
-    },
-    Normal {
-        normal: (0.0, 0.336151, 0.941808),
-    },
-    Normal {
-        normal: (-0.0, 0.205342, 0.97869),
-    },
-    Normal {
-        normal: (-0.0, -0.0662397, 0.997804),
-    },
-    Normal {
-        normal: (-0.349835, 0.403546, 0.845438),
-    },
-    Normal {
-        normal: (-0.360047, 0.336859, 0.869996),
-    },
-    Normal {
-        normal: (-0.37428, 0.205791, 0.904193),
-    },
-    Normal {
-        normal: (-0.381752, -0.0663697, 0.921879),
-    },
-    Normal {
-        normal: (-0.646802, 0.404096, 0.646802),
-    },
-    Normal {
-        normal: (-0.665655, 0.337351, 0.665655),
-    },
-    Normal {
-        normal: (-0.691923, 0.20612, 0.691923),
-    },
-    Normal {
-        normal: (-0.705543, -0.0664796, 0.705543),
-    },
-    Normal {
-        normal: (-0.845438, 0.403546, 0.349835),
-    },
-    Normal {
-        normal: (-0.869996, 0.336859, 0.360047),
-    },
-    Normal {
-        normal: (-0.904193, 0.205791, 0.37428),
-    },
-    Normal {
-        normal: (-0.921879, -0.0663697, 0.381752),
-    },
-    Normal {
-        normal: (-0.915321, 0.402725, -0.0),
-    },
-    Normal {
-        normal: (-0.941808, 0.336151, -0.0),
-    },
-    Normal {
-        normal: (-0.97869, 0.205342, -0.0),
-    },
-    Normal {
-        normal: (-0.997804, -0.0662397, -0.0),
-    },
-    Normal {
-        normal: (-0.845438, 0.403546, -0.349835),
-    },
-    Normal {
-        normal: (-0.869996, 0.336859, -0.360047),
-    },
-    Normal {
-        normal: (-0.904193, 0.205791, -0.37428),
-    },
-    Normal {
-        normal: (-0.921879, -0.0663697, -0.381752),
-    },
-    Normal {
-        normal: (-0.646802, 0.404096, -0.646802),
-    },
-    Normal {
-        normal: (-0.665655, 0.337351, -0.665655),
-    },
-    Normal {
-        normal: (-0.691923, 0.20612, -0.691923),
-    },
-    Normal {
-        normal: (-0.705542, -0.0664796, -0.705543),
-    },
-    Normal {
-        normal: (-0.349835, 0.403546, -0.845438),
-    },
-    Normal {
-        normal: (-0.360047, 0.336859, -0.869996),
-    },
-    Normal {
-        normal: (-0.37428, 0.205791, -0.904193),
-    },
-    Normal {
-        normal: (-0.381752, -0.0663697, -0.921879),
-    },
-    Normal {
-        normal: (0.0, 0.402725, -0.915321),
-    },
-    Normal {
-        normal: (-0.0, 0.336151, -0.941808),
-    },
-    Normal {
-        normal: (0.0, 0.205342, -0.97869),
-    },
-    Normal {
-        normal: (0.0, -0.0662397, -0.997804),
-    },
-    Normal {
-        normal: (0.349835, 0.403546, -0.845438),
-    },
-    Normal {
-        normal: (0.360047, 0.336859, -0.869996),
-    },
-    Normal {
-        normal: (0.37428, 0.205791, -0.904193),
-    },
-    Normal {
-        normal: (0.381752, -0.0663697, -0.921879),
-    },
-    Normal {
-        normal: (0.646802, 0.404096, -0.646802),
-    },
-    Normal {
-        normal: (0.665655, 0.337351, -0.665655),
-    },
-    Normal {
-        normal: (0.691923, 0.20612, -0.691923),
-    },
-    Normal {
-        normal: (0.705543, -0.0664796, -0.705542),
-    },
-    Normal {
-        normal: (0.845438, 0.403546, -0.349835),
-    },
-    Normal {
-        normal: (0.869996, 0.336859, -0.360047),
-    },
-    Normal {
-        normal: (0.904193, 0.205791, -0.37428),
-    },
-    Normal {
-        normal: (0.921879, -0.0663697, -0.381752),
-    },
-    Normal {
-        normal: (0.900182, -0.435513, -0.0),
-    },
-    Normal {
-        normal: (0.729611, -0.683863, -0.0),
-    },
-    Normal {
-        normal: (0.693951, -0.720022, -0.0),
-    },
-    Normal {
-        normal: (0.79395, -0.607984, 0.0),
-    },
-    Normal {
-        normal: (0.831437, -0.43618, 0.344179),
-    },
-    Normal {
-        normal: (0.673512, -0.684665, 0.278594),
-    },
-    Normal {
-        normal: (0.640399, -0.720924, 0.264874),
-    },
-    Normal {
-        normal: (0.732949, -0.608996, 0.303166),
-    },
-    Normal {
-        normal: (0.636092, -0.436777, 0.636092),
-    },
-    Normal {
-        normal: (0.514965, -0.685289, 0.514965),
-    },
-    Normal {
-        normal: (0.489651, -0.721446, 0.489651),
-    },
-    Normal {
-        normal: (0.560555, -0.609554, 0.560555),
-    },
-    Normal {
-        normal: (0.344179, -0.43618, 0.831437),
-    },
-    Normal {
-        normal: (0.278594, -0.684665, 0.673512),
-    },
-    Normal {
-        normal: (0.264874, -0.720924, 0.640399),
-    },
-    Normal {
-        normal: (0.303166, -0.608996, 0.732949),
-    },
-    Normal {
-        normal: (0.0, -0.435513, 0.900182),
-    },
-    Normal {
-        normal: (-0.0, -0.683863, 0.729611),
-    },
-    Normal {
-        normal: (0.0, -0.720022, 0.693951),
-    },
-    Normal {
-        normal: (-0.0, -0.607984, 0.79395),
-    },
-    Normal {
-        normal: (-0.344179, -0.43618, 0.831437),
-    },
-    Normal {
-        normal: (-0.278594, -0.684665, 0.673512),
-    },
-    Normal {
-        normal: (-0.264874, -0.720924, 0.640399),
-    },
-    Normal {
-        normal: (-0.303166, -0.608996, 0.732949),
-    },
-    Normal {
-        normal: (-0.636092, -0.436777, 0.636092),
-    },
-    Normal {
-        normal: (-0.514965, -0.685289, 0.514965),
-    },
-    Normal {
-        normal: (-0.489651, -0.721446, 0.489651),
-    },
-    Normal {
-        normal: (-0.560555, -0.609554, 0.560555),
-    },
-    Normal {
-        normal: (-0.831437, -0.43618, 0.344179),
-    },
-    Normal {
-        normal: (-0.673512, -0.684665, 0.278595),
-    },
-    Normal {
-        normal: (-0.640399, -0.720924, 0.264874),
-    },
-    Normal {
-        normal: (-0.732949, -0.608996, 0.303166),
-    },
-    Normal {
-        normal: (-0.900182, -0.435513, -0.0),
-    },
-    Normal {
-        normal: (-0.729611, -0.683863, -0.0),
-    },
-    Normal {
-        normal: (-0.693951, -0.720022, 0.0),
-    },
-    Normal {
-        normal: (-0.79395, -0.607983, -0.0),
-    },
-    Normal {
-        normal: (-0.831437, -0.43618, -0.344179),
-    },
-    Normal {
-        normal: (-0.673512, -0.684665, -0.278594),
-    },
-    Normal {
-        normal: (-0.640399, -0.720924, -0.264874),
-    },
-    Normal {
-        normal: (-0.732949, -0.608996, -0.303166),
-    },
-    Normal {
-        normal: (-0.636092, -0.436777, -0.636092),
-    },
-    Normal {
-        normal: (-0.514965, -0.685289, -0.514965),
-    },
-    Normal {
-        normal: (-0.489651, -0.721446, -0.489651),
-    },
-    Normal {
-        normal: (-0.560555, -0.609554, -0.560555),
-    },
-    Normal {
-        normal: (-0.344179, -0.43618, -0.831437),
-    },
-    Normal {
-        normal: (-0.278594, -0.684665, -0.673512),
-    },
-    Normal {
-        normal: (-0.264874, -0.720924, -0.640399),
-    },
-    Normal {
-        normal: (-0.303166, -0.608996, -0.732949),
-    },
-    Normal {
-        normal: (-0.0, -0.435513, -0.900182),
-    },
-    Normal {
-        normal: (0.0, -0.683863, -0.729611),
-    },
-    Normal {
-        normal: (-0.0, -0.720022, -0.693951),
-    },
-    Normal {
-        normal: (0.0, -0.607984, -0.79395),
-    },
-    Normal {
-        normal: (0.344179, -0.43618, -0.831437),
-    },
-    Normal {
-        normal: (0.278594, -0.684665, -0.673512),
-    },
-    Normal {
-        normal: (0.264874, -0.720924, -0.640399),
-    },
-    Normal {
-        normal: (0.303167, -0.608996, -0.732949),
-    },
-    Normal {
-        normal: (0.636092, -0.436777, -0.636092),
-    },
-    Normal {
-        normal: (0.514965, -0.685289, -0.514965),
-    },
-    Normal {
-        normal: (0.489651, -0.721446, -0.489651),
-    },
-    Normal {
-        normal: (0.560555, -0.609554, -0.560555),
-    },
-    Normal {
-        normal: (0.831437, -0.43618, -0.344179),
-    },
-    Normal {
-        normal: (0.673512, -0.684665, -0.278595),
-    },
-    Normal {
-        normal: (0.640399, -0.720924, -0.264874),
-    },
-    Normal {
-        normal: (0.732949, -0.608996, -0.303166),
-    },
-    Normal {
-        normal: (0.62386, -0.781536, 0.0),
-    },
-    Normal {
-        normal: (0.177291, -0.984159, -0.0),
-    },
-    Normal {
-        normal: (0.0492072, -0.998789, 0.0),
-    },
-    Normal {
-        normal: (0.0, -1.0, -0.0),
-    },
-    Normal {
-        normal: (0.576229, -0.781801, 0.238217),
-    },
-    Normal {
-        normal: (0.163629, -0.984208, 0.0675273),
-    },
-    Normal {
-        normal: (0.0454217, -0.998792, 0.0187357),
-    },
-    Normal {
-        normal: (0.440416, -0.782348, 0.440416),
-    },
-    Normal {
-        normal: (0.124903, -0.984276, 0.124903),
-    },
-    Normal {
-        normal: (0.0346621, -0.998798, 0.0346621),
-    },
-    Normal {
-        normal: (0.238217, -0.781801, 0.576229),
-    },
-    Normal {
-        normal: (0.0675273, -0.984208, 0.163629),
-    },
-    Normal {
-        normal: (0.0187357, -0.998792, 0.0454217),
-    },
-    Normal {
-        normal: (-0.0, -0.781536, 0.62386),
-    },
-    Normal {
-        normal: (0.0, -0.984159, 0.177291),
-    },
-    Normal {
-        normal: (-0.0, -0.998789, 0.0492072),
-    },
-    Normal {
-        normal: (-0.238216, -0.781801, 0.576229),
-    },
-    Normal {
-        normal: (-0.0675273, -0.984208, 0.163629),
-    },
-    Normal {
-        normal: (-0.0187357, -0.998792, 0.0454217),
-    },
-    Normal {
-        normal: (-0.440416, -0.782348, 0.440416),
-    },
-    Normal {
-        normal: (-0.124903, -0.984276, 0.124903),
-    },
-    Normal {
-        normal: (-0.0346621, -0.998798, 0.0346621),
-    },
-    Normal {
-        normal: (-0.576229, -0.781801, 0.238217),
-    },
-    Normal {
-        normal: (-0.163629, -0.984208, 0.0675273),
-    },
-    Normal {
-        normal: (-0.0454217, -0.998792, 0.0187357),
-    },
-    Normal {
-        normal: (-0.62386, -0.781536, -0.0),
-    },
-    Normal {
-        normal: (-0.177291, -0.984159, 0.0),
-    },
-    Normal {
-        normal: (-0.0492072, -0.998789, -0.0),
-    },
-    Normal {
-        normal: (-0.576229, -0.781801, -0.238217),
-    },
-    Normal {
-        normal: (-0.163629, -0.984208, -0.0675273),
-    },
-    Normal {
-        normal: (-0.0454217, -0.998792, -0.0187357),
-    },
-    Normal {
-        normal: (-0.440416, -0.782348, -0.440416),
-    },
-    Normal {
-        normal: (-0.124903, -0.984276, -0.124903),
-    },
-    Normal {
-        normal: (-0.0346621, -0.998798, -0.0346621),
-    },
-    Normal {
-        normal: (-0.238217, -0.781801, -0.576229),
-    },
-    Normal {
-        normal: (-0.0675273, -0.984208, -0.163629),
-    },
-    Normal {
-        normal: (-0.0187357, -0.998792, -0.0454217),
-    },
-    Normal {
-        normal: (0.0, -0.781536, -0.62386),
-    },
-    Normal {
-        normal: (-0.0, -0.984159, -0.177291),
-    },
-    Normal {
-        normal: (0.0, -0.998789, -0.0492072),
-    },
-    Normal {
-        normal: (0.238217, -0.781801, -0.576229),
-    },
-    Normal {
-        normal: (0.0675273, -0.984208, -0.163629),
-    },
-    Normal {
-        normal: (0.0187357, -0.998792, -0.0454217),
-    },
-    Normal {
-        normal: (0.440416, -0.782348, -0.440416),
-    },
-    Normal {
-        normal: (0.124903, -0.984276, -0.124903),
-    },
-    Normal {
-        normal: (0.0346621, -0.998798, -0.0346621),
-    },
-    Normal {
-        normal: (0.576229, -0.781801, -0.238217),
-    },
-    Normal {
-        normal: (0.163629, -0.984208, -0.0675273),
-    },
-    Normal {
-        normal: (0.0454217, -0.998792, -0.0187357),
-    },
-    Normal {
-        normal: (0.00778619, -0.99997, -0.000215809),
-    },
-    Normal {
-        normal: (0.0391385, -0.999233, -0.000988567),
-    },
-    Normal {
-        normal: (0.179511, -0.983746, -0.00436856),
-    },
-    Normal {
-        normal: (0.6123, -0.790556, -0.0104598),
-    },
-    Normal {
-        normal: (0.986152, -0.165707, -0.00666949),
-    },
-    Normal {
-        normal: (0.00703893, -0.812495, 0.582926),
-    },
-    Normal {
-        normal: (0.0361273, -0.837257, 0.545614),
-    },
-    Normal {
-        normal: (0.161845, -0.810421, 0.563048),
-    },
-    Normal {
-        normal: (0.482365, -0.595148, 0.642746),
-    },
-    Normal {
-        normal: (0.73872, -0.114593, 0.664199),
-    },
-    Normal {
-        normal: (-0.00190867, 0.162121, 0.986769),
-    },
-    Normal {
-        normal: (0.0027616, 0.0171073, 0.99985),
-    },
-    Normal {
-        normal: (0.0105326, 0.0733989, 0.997247),
-    },
-    Normal {
-        normal: (-0.0660406, 0.130069, 0.989303),
-    },
-    Normal {
-        normal: (-0.0944272, 0.0165946, 0.995393),
-    },
-    Normal {
-        normal: (-0.009203, 0.871509, 0.490293),
-    },
-    Normal {
-        normal: (-0.0486064, 0.840609, 0.539457),
-    },
-    Normal {
-        normal: (-0.223298, 0.802881, 0.552739),
-    },
-    Normal {
-        normal: (-0.596365, 0.559971, 0.575135),
-    },
-    Normal {
-        normal: (-0.803337, 0.0682361, 0.591602),
-    },
-    Normal {
-        normal: (-0.0105609, 0.999944, 0.000103364),
-    },
-    Normal {
-        normal: (-0.0587986, 0.99827, 0.000709759),
-    },
-    Normal {
-        normal: (-0.28071, 0.959787, 0.00326876),
-    },
-    Normal {
-        normal: (-0.749723, 0.661738, 0.0042684),
-    },
-    Normal {
-        normal: (-0.997351, 0.0727144, 0.00205923),
-    },
-    Normal {
-        normal: (-0.00879197, 0.871493, -0.49033),
-    },
-    Normal {
-        normal: (-0.0464937, 0.841178, -0.538756),
-    },
-    Normal {
-        normal: (-0.217909, 0.806807, -0.549161),
-    },
-    Normal {
-        normal: (-0.597291, 0.560026, -0.574121),
-    },
-    Normal {
-        normal: (-0.804, 0.0629127, -0.591291),
-    },
-    Normal {
-        normal: (-0.00180555, 0.161691, -0.98684),
-    },
-    Normal {
-        normal: (0.00203087, 0.014555, -0.999892),
-    },
-    Normal {
-        normal: (0.00921499, 0.0600698, -0.998152),
-    },
-    Normal {
-        normal: (-0.0593333, 0.113865, -0.991723),
-    },
-    Normal {
-        normal: (-0.0868992, 0.0122903, -0.996141),
-    },
-    Normal {
-        normal: (0.00641779, -0.812379, -0.583094),
-    },
-    Normal {
-        normal: (0.0337833, -0.837512, -0.545373),
-    },
-    Normal {
-        normal: (0.157112, -0.811947, -0.56219),
-    },
-    Normal {
-        normal: (0.484407, -0.589365, -0.646528),
-    },
-    Normal {
-        normal: (0.73887, -0.10132, -0.666187),
-    },
-    Normal {
-        normal: (0.946512, 0.32265, -0.0033571),
-    },
-    Normal {
-        normal: (0.82583, 0.56387, -0.00745213),
-    },
-    Normal {
-        normal: (0.650011, 0.759893, -0.00693681),
-    },
-    Normal {
-        normal: (0.532429, 0.846458, -0.00524544),
-    },
-    Normal {
-        normal: (0.725608, 0.259351, 0.637362),
-    },
-    Normal {
-        normal: (0.645945, 0.461988, 0.607719),
-    },
-    Normal {
-        normal: (0.531614, 0.63666, 0.558615),
-    },
-    Normal {
-        normal: (0.424964, 0.681717, 0.59554),
-    },
-    Normal {
-        normal: (-0.0495616, -0.019755, 0.998576),
-    },
-    Normal {
-        normal: (-0.0378162, -0.0356243, 0.99865),
-    },
-    Normal {
-        normal: (-0.0379139, -0.0365122, 0.998614),
-    },
-    Normal {
-        normal: (-0.168854, -0.297946, 0.93953),
-    },
-    Normal {
-        normal: (-0.742342, -0.299166, 0.599523),
-    },
-    Normal {
-        normal: (-0.619602, -0.529406, 0.579503),
-    },
-    Normal {
-        normal: (-0.483708, -0.685761, 0.543837),
-    },
-    Normal {
-        normal: (-0.445293, -0.794355, 0.413176),
-    },
-    Normal {
-        normal: (-0.926513, -0.376257, 0.00199587),
-    },
-    Normal {
-        normal: (-0.75392, -0.656952, 0.00431723),
-    },
-    Normal {
-        normal: (-0.566224, -0.824244, 0.00346105),
-    },
-    Normal {
-        normal: (-0.481804, -0.876277, 0.00185047),
-    },
-    Normal {
-        normal: (-0.744675, -0.294424, -0.598977),
-    },
-    Normal {
-        normal: (-0.621949, -0.528114, -0.578165),
-    },
-    Normal {
-        normal: (-0.481171, -0.68834, -0.542828),
-    },
-    Normal {
-        normal: (-0.438055, -0.797035, -0.415744),
-    },
-    Normal {
-        normal: (-0.0443368, -0.0170558, -0.998871),
-    },
-    Normal {
-        normal: (-0.0261761, -0.0281665, -0.99926),
-    },
-    Normal {
-        normal: (-0.0252939, -0.0283323, -0.999278),
-    },
-    Normal {
-        normal: (-0.157482, -0.289392, -0.944167),
-    },
-    Normal {
-        normal: (0.728244, 0.25241, -0.637142),
-    },
-    Normal {
-        normal: (0.647055, 0.459725, -0.608254),
-    },
-    Normal {
-        normal: (0.522994, 0.640657, -0.562171),
-    },
-    Normal {
-        normal: (0.409978, 0.682857, -0.604669),
-    },
-    Normal {
-        normal: (-0.230787, 0.972982, -0.00652338),
-    },
-    Normal {
-        normal: (-0.548936, 0.835863, -0.00151111),
-    },
-    Normal {
-        normal: (-0.875671, 0.482807, 0.00989278),
-    },
-    Normal {
-        normal: (-0.877554, 0.479097, 0.0190923),
-    },
-    Normal {
-        normal: (-0.69619, 0.717439, 0.024497),
-    },
-    Normal {
-        normal: (-0.152878, 0.687211, 0.71019),
-    },
-    Normal {
-        normal: (-0.316721, 0.63775, 0.702113),
-    },
-    Normal {
-        normal: (-0.601067, 0.471452, 0.64533),
-    },
-    Normal {
-        normal: (-0.635889, 0.44609, 0.6298),
-    },
-    Normal {
-        normal: (-0.435746, 0.601008, 0.670011),
-    },
-    Normal {
-        normal: (0.111112, -0.0850694, 0.99016),
-    },
-    Normal {
-        normal: (0.22331, 0.00654036, 0.974726),
-    },
-    Normal {
-        normal: (0.190097, 0.154964, 0.969458),
-    },
-    Normal {
-        normal: (0.00527077, 0.189482, 0.98187),
-    },
-    Normal {
-        normal: (-0.0117518, 0.246688, 0.969024),
-    },
-    Normal {
-        normal: (0.343906, -0.722796, 0.599412),
-    },
-    Normal {
-        normal: (0.572489, -0.567656, 0.591627),
-    },
-    Normal {
-        normal: (0.787436, -0.256459, 0.560512),
-    },
-    Normal {
-        normal: (0.647097, -0.306374, 0.698141),
-    },
-    Normal {
-        normal: (0.427528, -0.499343, 0.753576),
-    },
-    Normal {
-        normal: (0.410926, -0.911668, 0.00128446),
-    },
-    Normal {
-        normal: (0.67152, -0.740986, -0.000899122),
-    },
-    Normal {
-        normal: (0.922026, -0.38706, -0.00725269),
-    },
-    Normal {
-        normal: (0.84691, -0.531556, -0.0138542),
-    },
-    Normal {
-        normal: (0.535925, -0.8442, -0.0105045),
-    },
-    Normal {
-        normal: (0.341188, -0.722822, -0.600931),
-    },
-    Normal {
-        normal: (0.578664, -0.561139, -0.591838),
-    },
-    Normal {
-        normal: (0.784869, -0.25102, -0.566542),
-    },
-    Normal {
-        normal: (0.642681, -0.302257, -0.70399),
-    },
-    Normal {
-        normal: (0.418589, -0.500042, -0.758117),
-    },
-    Normal {
-        normal: (0.115806, -0.0791394, -0.990114),
-    },
-    Normal {
-        normal: (0.232811, 0.0125652, -0.972441),
-    },
-    Normal {
-        normal: (0.206662, 0.153601, -0.96628),
-    },
-    Normal {
-        normal: (0.0244996, 0.161443, -0.986578),
-    },
-    Normal {
-        normal: (0.00338193, 0.211115, -0.977455),
-    },
-    Normal {
-        normal: (-0.134912, 0.687491, -0.713551),
-    },
-    Normal {
-        normal: (-0.31954, 0.633073, -0.705062),
-    },
-    Normal {
-        normal: (-0.603902, 0.461442, -0.649903),
-    },
-    Normal {
-        normal: (-0.631816, 0.437169, -0.640072),
-    },
-    Normal {
-        normal: (-0.424306, 0.612706, -0.66675),
-    },
-    Normal {
-        normal: (-0.4258, 0.904753, 0.0108049),
-    },
-    Normal {
-        normal: (0.0220472, 0.999756, 0.00162273),
-    },
-    Normal {
-        normal: (0.999599, 0.0258705, 0.0115556),
-    },
-    Normal {
-        normal: (0.709585, -0.704553, 0.00967183),
-    },
-    Normal {
-        normal: (-0.259858, 0.791936, 0.552549),
-    },
-    Normal {
-        normal: (0.00953916, 0.99972, -0.0216718),
-    },
-    Normal {
-        normal: (0.410156, 0.332912, -0.849083),
-    },
-    Normal {
-        normal: (0.541523, -0.54862, -0.637),
-    },
-    Normal {
-        normal: (0.0463104, 0.455224, 0.889172),
-    },
-    Normal {
-        normal: (-0.0106883, 0.988794, 0.148901),
-    },
-    Normal {
-        normal: (-0.0443756, 0.682947, -0.729118),
-    },
-    Normal {
-        normal: (0.122825, 0.00923214, -0.992385),
-    },
-    Normal {
-        normal: (0.481839, -0.180439, 0.85748),
-    },
-    Normal {
-        normal: (0.455272, 0.736752, 0.499925),
-    },
-    Normal {
-        normal: (-0.220542, 0.907193, -0.358276),
-    },
-    Normal {
-        normal: (-0.23592, 0.657249, -0.715797),
-    },
-    Normal {
-        normal: (0.728092, -0.685302, -0.0155853),
-    },
-    Normal {
-        normal: (0.888739, 0.45811, -0.0166791),
-    },
-    Normal {
-        normal: (-0.260097, 0.965582, 0.000800195),
-    },
-    Normal {
-        normal: (-0.371612, 0.928378, -0.00441745),
-    },
-    Normal {
-        normal: (0.480166, -0.17836, -0.858853),
-    },
-    Normal {
-        normal: (0.488103, 0.716801, -0.497947),
-    },
-    Normal {
-        normal: (-0.222004, 0.905399, 0.361893),
-    },
-    Normal {
-        normal: (-0.235405, 0.66318, 0.710477),
-    },
-    Normal {
-        normal: (0.0587203, 0.437704, -0.8972),
-    },
-    Normal {
-        normal: (0.00132612, 0.986459, -0.164003),
-    },
-    Normal {
-        normal: (-0.0441901, 0.681677, 0.730317),
-    },
-    Normal {
-        normal: (0.138801, -0.0341896, 0.98973),
-    },
-    Normal {
-        normal: (-0.25889, 0.797206, -0.54538),
-    },
-    Normal {
-        normal: (0.0122703, 0.999739, 0.0192865),
-    },
-    Normal {
-        normal: (0.39863, 0.35489, 0.845663),
-    },
-    Normal {
-        normal: (0.537564, -0.5814, 0.610737),
-    },
-    Normal {
-        normal: (-0.0, 1.0, 0.0),
-    },
-    Normal {
-        normal: (0.82454, 0.565804, 0.0),
-    },
-    Normal {
-        normal: (0.917701, -0.397272, 0.0),
-    },
-    Normal {
-        normal: (0.935269, -0.353939, 0.000112842),
-    },
-    Normal {
-        normal: (0.780712, 0.624891, 0.0),
-    },
-    Normal {
-        normal: (0.762641, 0.565035, 0.314825),
-    },
-    Normal {
-        normal: (0.847982, -0.397998, 0.350034),
-    },
-    Normal {
-        normal: (0.864141, -0.355261, 0.356441),
-    },
-    Normal {
-        normal: (0.720991, 0.625625, 0.297933),
-    },
-    Normal {
-        normal: (0.583357, 0.565165, 0.583338),
-    },
-    Normal {
-        normal: (0.648485, -0.398726, 0.648448),
-    },
-    Normal {
-        normal: (0.660872, -0.355894, 0.660748),
-    },
-    Normal {
-        normal: (0.551862, 0.62529, 0.55178),
-    },
-    Normal {
-        normal: (0.314824, 0.565051, 0.762629),
-    },
-    Normal {
-        normal: (0.350045, -0.397976, 0.847988),
-    },
-    Normal {
-        normal: (0.356474, -0.3552, 0.864153),
-    },
-    Normal {
-        normal: (0.297983, 0.625515, 0.721067),
-    },
-    Normal {
-        normal: (-0.0, 0.565804, 0.82454),
-    },
-    Normal {
-        normal: (-0.0, -0.397272, 0.917701),
-    },
-    Normal {
-        normal: (-0.000112839, -0.353939, 0.935269),
-    },
-    Normal {
-        normal: (-0.0, 0.624891, 0.780712),
-    },
-    Normal {
-        normal: (-0.314825, 0.565035, 0.762641),
-    },
-    Normal {
-        normal: (-0.350034, -0.397998, 0.847982),
-    },
-    Normal {
-        normal: (-0.356441, -0.355261, 0.864141),
-    },
-    Normal {
-        normal: (-0.297933, 0.625625, 0.720991),
-    },
-    Normal {
-        normal: (-0.583338, 0.565165, 0.583357),
-    },
-    Normal {
-        normal: (-0.648448, -0.398726, 0.648485),
-    },
-    Normal {
-        normal: (-0.660748, -0.355894, 0.660872),
-    },
-    Normal {
-        normal: (-0.55178, 0.62529, 0.551862),
-    },
-    Normal {
-        normal: (-0.762629, 0.565051, 0.314824),
-    },
-    Normal {
-        normal: (-0.847988, -0.397976, 0.350045),
-    },
-    Normal {
-        normal: (-0.864153, -0.3552, 0.356474),
-    },
-    Normal {
-        normal: (-0.721067, 0.625515, 0.297983),
-    },
-    Normal {
-        normal: (-0.82454, 0.565804, -0.0),
-    },
-    Normal {
-        normal: (-0.917701, -0.397272, -0.0),
-    },
-    Normal {
-        normal: (-0.935269, -0.353939, -0.000112839),
-    },
-    Normal {
-        normal: (-0.780712, 0.624891, -0.0),
-    },
-    Normal {
-        normal: (-0.76264, 0.565035, -0.314825),
-    },
-    Normal {
-        normal: (-0.847982, -0.397998, -0.350034),
-    },
-    Normal {
-        normal: (-0.864141, -0.355261, -0.356441),
-    },
-    Normal {
-        normal: (-0.720991, 0.625625, -0.297933),
-    },
-    Normal {
-        normal: (-0.583357, 0.565165, -0.583338),
-    },
-    Normal {
-        normal: (-0.648485, -0.398726, -0.648448),
-    },
-    Normal {
-        normal: (-0.660872, -0.355894, -0.660748),
-    },
-    Normal {
-        normal: (-0.551862, 0.62529, -0.55178),
-    },
-    Normal {
-        normal: (-0.314824, 0.565051, -0.762629),
-    },
-    Normal {
-        normal: (-0.350045, -0.397976, -0.847988),
-    },
-    Normal {
-        normal: (-0.356474, -0.3552, -0.864153),
-    },
-    Normal {
-        normal: (-0.297983, 0.625515, -0.721067),
-    },
-    Normal {
-        normal: (0.0, 0.565804, -0.82454),
-    },
-    Normal {
-        normal: (0.0, -0.397272, -0.917701),
-    },
-    Normal {
-        normal: (0.000112839, -0.353939, -0.935269),
-    },
-    Normal {
-        normal: (0.0, 0.624891, -0.780712),
-    },
-    Normal {
-        normal: (0.314825, 0.565035, -0.762641),
-    },
-    Normal {
-        normal: (0.350034, -0.397998, -0.847982),
-    },
-    Normal {
-        normal: (0.356441, -0.355261, -0.864141),
-    },
-    Normal {
-        normal: (0.297933, 0.625625, -0.720991),
-    },
-    Normal {
-        normal: (0.583338, 0.565165, -0.583357),
-    },
-    Normal {
-        normal: (0.648448, -0.398726, -0.648485),
-    },
-    Normal {
-        normal: (0.660748, -0.355894, -0.660872),
-    },
-    Normal {
-        normal: (0.55178, 0.62529, -0.551862),
-    },
-    Normal {
-        normal: (0.762629, 0.565051, -0.314824),
-    },
-    Normal {
-        normal: (0.847988, -0.397976, -0.350045),
-    },
-    Normal {
-        normal: (0.864153, -0.3552, -0.356474),
-    },
-    Normal {
-        normal: (0.721067, 0.625515, -0.297983),
-    },
-    Normal {
-        normal: (0.236584, 0.971611, 0.0),
-    },
-    Normal {
-        normal: (0.173084, 0.984907, -0.0),
-    },
-    Normal {
-        normal: (0.379703, 0.925108, 0.0),
-    },
-    Normal {
-        normal: (0.526673, 0.850068, 0.0),
-    },
-    Normal {
-        normal: (0.217978, 0.971775, 0.0902162),
-    },
-    Normal {
-        normal: (0.15959, 0.984977, 0.0659615),
-    },
-    Normal {
-        normal: (0.350498, 0.925312, 0.14474),
-    },
-    Normal {
-        normal: (0.48559, 0.850653, 0.201474),
-    },
-    Normal {
-        normal: (0.166631, 0.971838, 0.166631),
-    },
-    Normal {
-        normal: (0.121908, 0.985026, 0.121908),
-    },
-    Normal {
-        normal: (0.267668, 0.925585, 0.267668),
-    },
-    Normal {
-        normal: (0.371315, 0.851029, 0.371315),
-    },
-    Normal {
-        normal: (0.0902162, 0.971775, 0.217978),
-    },
-    Normal {
-        normal: (0.0659615, 0.984977, 0.15959),
-    },
-    Normal {
-        normal: (0.14474, 0.925312, 0.350498),
-    },
-    Normal {
-        normal: (0.201474, 0.850653, 0.48559),
-    },
-    Normal {
-        normal: (-0.0, 0.971611, 0.236584),
-    },
-    Normal {
-        normal: (0.0, 0.984907, 0.173084),
-    },
-    Normal {
-        normal: (0.0, 0.925108, 0.379703),
-    },
-    Normal {
-        normal: (0.0, 0.850068, 0.526673),
-    },
-    Normal {
-        normal: (-0.0902162, 0.971775, 0.217978),
-    },
-    Normal {
-        normal: (-0.0659615, 0.984977, 0.15959),
-    },
-    Normal {
-        normal: (-0.14474, 0.925312, 0.350498),
-    },
-    Normal {
-        normal: (-0.201474, 0.850653, 0.48559),
-    },
-    Normal {
-        normal: (-0.166631, 0.971838, 0.166631),
-    },
-    Normal {
-        normal: (-0.121908, 0.985026, 0.121908),
-    },
-    Normal {
-        normal: (-0.267668, 0.925585, 0.267668),
-    },
-    Normal {
-        normal: (-0.371315, 0.851029, 0.371315),
-    },
-    Normal {
-        normal: (-0.217978, 0.971775, 0.0902162),
-    },
-    Normal {
-        normal: (-0.15959, 0.984977, 0.0659615),
-    },
-    Normal {
-        normal: (-0.350498, 0.925312, 0.14474),
-    },
-    Normal {
-        normal: (-0.48559, 0.850653, 0.201474),
-    },
-    Normal {
-        normal: (-0.236583, 0.971611, -0.0),
-    },
-    Normal {
-        normal: (-0.173084, 0.984907, 0.0),
-    },
-    Normal {
-        normal: (-0.379703, 0.925108, -0.0),
-    },
-    Normal {
-        normal: (-0.526673, 0.850068, 0.0),
-    },
-    Normal {
-        normal: (-0.217978, 0.971775, -0.0902162),
-    },
-    Normal {
-        normal: (-0.15959, 0.984977, -0.0659615),
-    },
-    Normal {
-        normal: (-0.350498, 0.925312, -0.14474),
-    },
-    Normal {
-        normal: (-0.48559, 0.850653, -0.201474),
-    },
-    Normal {
-        normal: (-0.166631, 0.971838, -0.166631),
-    },
-    Normal {
-        normal: (-0.121908, 0.985026, -0.121908),
-    },
-    Normal {
-        normal: (-0.267668, 0.925585, -0.267668),
-    },
-    Normal {
-        normal: (-0.371315, 0.851029, -0.371315),
-    },
-    Normal {
-        normal: (-0.0902162, 0.971775, -0.217978),
-    },
-    Normal {
-        normal: (-0.0659615, 0.984977, -0.15959),
-    },
-    Normal {
-        normal: (-0.14474, 0.925312, -0.350498),
-    },
-    Normal {
-        normal: (-0.201474, 0.850653, -0.485589),
-    },
-    Normal {
-        normal: (0.0, 0.971611, -0.236584),
-    },
-    Normal {
-        normal: (-0.0, 0.984907, -0.173084),
-    },
-    Normal {
-        normal: (-0.0, 0.925108, -0.379703),
-    },
-    Normal {
-        normal: (-0.0, 0.850068, -0.526673),
-    },
-    Normal {
-        normal: (0.0902162, 0.971775, -0.217978),
-    },
-    Normal {
-        normal: (0.0659615, 0.984977, -0.15959),
-    },
-    Normal {
-        normal: (0.14474, 0.925312, -0.350498),
-    },
-    Normal {
-        normal: (0.201474, 0.850653, -0.48559),
-    },
-    Normal {
-        normal: (0.166631, 0.971838, -0.166631),
-    },
-    Normal {
-        normal: (0.121908, 0.985026, -0.121908),
-    },
-    Normal {
-        normal: (0.267668, 0.925585, -0.267668),
-    },
-    Normal {
-        normal: (0.371315, 0.851029, -0.371315),
-    },
-    Normal {
-        normal: (0.217978, 0.971775, -0.0902162),
-    },
-    Normal {
-        normal: (0.15959, 0.984977, -0.0659615),
-    },
-    Normal {
-        normal: (0.350498, 0.925312, -0.14474),
-    },
-    Normal {
-        normal: (0.48559, 0.850653, -0.201474),
-    },
-];
-
-pub const INDICES: [u16; 3072] = [
-    7, 6, 1, 1, 2, 7, 8, 7, 2, 2, 3, 8, 9, 8, 3, 3, 4, 9, 10, 9, 4, 4, 5, 10, 12, 11, 6, 6, 7, 12,
-    13, 12, 7, 7, 8, 13, 14, 13, 8, 8, 9, 14, 15, 14, 9, 9, 10, 15, 17, 16, 11, 11, 12, 17, 18, 17,
-    12, 12, 13, 18, 19, 18, 13, 13, 14, 19, 20, 19, 14, 14, 15, 20, 22, 21, 16, 16, 17, 22, 23, 22,
-    17, 17, 18, 23, 24, 23, 18, 18, 19, 24, 25, 24, 19, 19, 20, 25, 27, 26, 21, 21, 22, 27, 28, 27,
-    22, 22, 23, 28, 29, 28, 23, 23, 24, 29, 30, 29, 24, 24, 25, 30, 32, 31, 26, 26, 27, 32, 33, 32,
-    27, 27, 28, 33, 34, 33, 28, 28, 29, 34, 35, 34, 29, 29, 30, 35, 37, 36, 31, 31, 32, 37, 38, 37,
-    32, 32, 33, 38, 39, 38, 33, 33, 34, 39, 40, 39, 34, 34, 35, 40, 42, 41, 36, 36, 37, 42, 43, 42,
-    37, 37, 38, 43, 44, 43, 38, 38, 39, 44, 45, 44, 39, 39, 40, 45, 47, 46, 41, 41, 42, 47, 48, 47,
-    42, 42, 43, 48, 49, 48, 43, 43, 44, 49, 50, 49, 44, 44, 45, 50, 52, 51, 46, 46, 47, 52, 53, 52,
-    47, 47, 48, 53, 54, 53, 48, 48, 49, 54, 55, 54, 49, 49, 50, 55, 57, 56, 51, 51, 52, 57, 58, 57,
-    52, 52, 53, 58, 59, 58, 53, 53, 54, 59, 60, 59, 54, 54, 55, 60, 62, 61, 56, 56, 57, 62, 63, 62,
-    57, 57, 58, 63, 64, 63, 58, 58, 59, 64, 65, 64, 59, 59, 60, 65, 67, 66, 61, 61, 62, 67, 68, 67,
-    62, 62, 63, 68, 69, 68, 63, 63, 64, 69, 70, 69, 64, 64, 65, 70, 72, 71, 66, 66, 67, 72, 73, 72,
-    67, 67, 68, 73, 74, 73, 68, 68, 69, 74, 75, 74, 69, 69, 70, 75, 77, 76, 71, 71, 72, 77, 78, 77,
-    72, 72, 73, 78, 79, 78, 73, 73, 74, 79, 80, 79, 74, 74, 75, 80, 2, 1, 76, 76, 77, 2, 3, 2, 77,
-    77, 78, 3, 4, 3, 78, 78, 79, 4, 5, 4, 79, 79, 80, 5, 85, 10, 5, 5, 81, 85, 86, 85, 81, 81, 82,
-    86, 87, 86, 82, 82, 83, 87, 88, 87, 83, 83, 84, 88, 89, 15, 10, 10, 85, 89, 90, 89, 85, 85, 86,
-    90, 91, 90, 86, 86, 87, 91, 92, 91, 87, 87, 88, 92, 93, 20, 15, 15, 89, 93, 94, 93, 89, 89, 90,
-    94, 95, 94, 90, 90, 91, 95, 96, 95, 91, 91, 92, 96, 97, 25, 20, 20, 93, 97, 98, 97, 93, 93, 94,
-    98, 99, 98, 94, 94, 95, 99, 100, 99, 95, 95, 96, 100, 101, 30, 25, 25, 97, 101, 102, 101, 97,
-    97, 98, 102, 103, 102, 98, 98, 99, 103, 104, 103, 99, 99, 100, 104, 105, 35, 30, 30, 101, 105,
-    106, 105, 101, 101, 102, 106, 107, 106, 102, 102, 103, 107, 108, 107, 103, 103, 104, 108, 109,
-    40, 35, 35, 105, 109, 110, 109, 105, 105, 106, 110, 111, 110, 106, 106, 107, 111, 112, 111,
-    107, 107, 108, 112, 113, 45, 40, 40, 109, 113, 114, 113, 109, 109, 110, 114, 115, 114, 110,
-    110, 111, 115, 116, 115, 111, 111, 112, 116, 117, 50, 45, 45, 113, 117, 118, 117, 113, 113,
-    114, 118, 119, 118, 114, 114, 115, 119, 120, 119, 115, 115, 116, 120, 121, 55, 50, 50, 117,
-    121, 122, 121, 117, 117, 118, 122, 123, 122, 118, 118, 119, 123, 124, 123, 119, 119, 120, 124,
-    125, 60, 55, 55, 121, 125, 126, 125, 121, 121, 122, 126, 127, 126, 122, 122, 123, 127, 128,
-    127, 123, 123, 124, 128, 129, 65, 60, 60, 125, 129, 130, 129, 125, 125, 126, 130, 131, 130,
-    126, 126, 127, 131, 132, 131, 127, 127, 128, 132, 133, 70, 65, 65, 129, 133, 134, 133, 129,
-    129, 130, 134, 135, 134, 130, 130, 131, 135, 136, 135, 131, 131, 132, 136, 137, 75, 70, 70,
-    133, 137, 138, 137, 133, 133, 134, 138, 139, 138, 134, 134, 135, 139, 140, 139, 135, 135, 136,
-    140, 141, 80, 75, 75, 137, 141, 142, 141, 137, 137, 138, 142, 143, 142, 138, 138, 139, 143,
-    144, 143, 139, 139, 140, 144, 81, 5, 80, 80, 141, 81, 82, 81, 141, 141, 142, 82, 83, 82, 142,
-    142, 143, 83, 84, 83, 143, 143, 144, 84, 149, 88, 84, 84, 145, 149, 150, 149, 145, 145, 146,
-    150, 151, 150, 146, 146, 147, 151, 152, 151, 147, 147, 148, 152, 153, 92, 88, 88, 149, 153,
-    154, 153, 149, 149, 150, 154, 155, 154, 150, 150, 151, 155, 156, 155, 151, 151, 152, 156, 157,
-    96, 92, 92, 153, 157, 158, 157, 153, 153, 154, 158, 159, 158, 154, 154, 155, 159, 160, 159,
-    155, 155, 156, 160, 161, 100, 96, 96, 157, 161, 162, 161, 157, 157, 158, 162, 163, 162, 158,
-    158, 159, 163, 164, 163, 159, 159, 160, 164, 165, 104, 100, 100, 161, 165, 166, 165, 161, 161,
-    162, 166, 167, 166, 162, 162, 163, 167, 168, 167, 163, 163, 164, 168, 169, 108, 104, 104, 165,
-    169, 170, 169, 165, 165, 166, 170, 171, 170, 166, 166, 167, 171, 172, 171, 167, 167, 168, 172,
-    173, 112, 108, 108, 169, 173, 174, 173, 169, 169, 170, 174, 175, 174, 170, 170, 171, 175, 176,
-    175, 171, 171, 172, 176, 177, 116, 112, 112, 173, 177, 178, 177, 173, 173, 174, 178, 179, 178,
-    174, 174, 175, 179, 180, 179, 175, 175, 176, 180, 181, 120, 116, 116, 177, 181, 182, 181, 177,
-    177, 178, 182, 183, 182, 178, 178, 179, 183, 184, 183, 179, 179, 180, 184, 185, 124, 120, 120,
-    181, 185, 186, 185, 181, 181, 182, 186, 187, 186, 182, 182, 183, 187, 188, 187, 183, 183, 184,
-    188, 189, 128, 124, 124, 185, 189, 190, 189, 185, 185, 186, 190, 191, 190, 186, 186, 187, 191,
-    192, 191, 187, 187, 188, 192, 193, 132, 128, 128, 189, 193, 194, 193, 189, 189, 190, 194, 195,
-    194, 190, 190, 191, 195, 196, 195, 191, 191, 192, 196, 197, 136, 132, 132, 193, 197, 198, 197,
-    193, 193, 194, 198, 199, 198, 194, 194, 195, 199, 200, 199, 195, 195, 196, 200, 201, 140, 136,
-    136, 197, 201, 202, 201, 197, 197, 198, 202, 203, 202, 198, 198, 199, 203, 204, 203, 199, 199,
-    200, 204, 205, 144, 140, 140, 201, 205, 206, 205, 201, 201, 202, 206, 207, 206, 202, 202, 203,
-    207, 208, 207, 203, 203, 204, 208, 145, 84, 144, 144, 205, 145, 146, 145, 205, 205, 206, 146,
-    147, 146, 206, 206, 207, 147, 148, 147, 207, 207, 208, 148, 213, 152, 148, 148, 209, 213, 214,
-    213, 209, 209, 210, 214, 215, 214, 210, 210, 211, 215, 212, 215, 211, 211, 212, 212, 216, 156,
-    152, 152, 213, 216, 217, 216, 213, 213, 214, 217, 218, 217, 214, 214, 215, 218, 212, 218, 215,
-    215, 212, 212, 219, 160, 156, 156, 216, 219, 220, 219, 216, 216, 217, 220, 221, 220, 217, 217,
-    218, 221, 212, 221, 218, 218, 212, 212, 222, 164, 160, 160, 219, 222, 223, 222, 219, 219, 220,
-    223, 224, 223, 220, 220, 221, 224, 212, 224, 221, 221, 212, 212, 225, 168, 164, 164, 222, 225,
-    226, 225, 222, 222, 223, 226, 227, 226, 223, 223, 224, 227, 212, 227, 224, 224, 212, 212, 228,
-    172, 168, 168, 225, 228, 229, 228, 225, 225, 226, 229, 230, 229, 226, 226, 227, 230, 212, 230,
-    227, 227, 212, 212, 231, 176, 172, 172, 228, 231, 232, 231, 228, 228, 229, 232, 233, 232, 229,
-    229, 230, 233, 212, 233, 230, 230, 212, 212, 234, 180, 176, 176, 231, 234, 235, 234, 231, 231,
-    232, 235, 236, 235, 232, 232, 233, 236, 212, 236, 233, 233, 212, 212, 237, 184, 180, 180, 234,
-    237, 238, 237, 234, 234, 235, 238, 239, 238, 235, 235, 236, 239, 212, 239, 236, 236, 212, 212,
-    240, 188, 184, 184, 237, 240, 241, 240, 237, 237, 238, 241, 242, 241, 238, 238, 239, 242, 212,
-    242, 239, 239, 212, 212, 243, 192, 188, 188, 240, 243, 244, 243, 240, 240, 241, 244, 245, 244,
-    241, 241, 242, 245, 212, 245, 242, 242, 212, 212, 246, 196, 192, 192, 243, 246, 247, 246, 243,
-    243, 244, 247, 248, 247, 244, 244, 245, 248, 212, 248, 245, 245, 212, 212, 249, 200, 196, 196,
-    246, 249, 250, 249, 246, 246, 247, 250, 251, 250, 247, 247, 248, 251, 212, 251, 248, 248, 212,
-    212, 252, 204, 200, 200, 249, 252, 253, 252, 249, 249, 250, 253, 254, 253, 250, 250, 251, 254,
-    212, 254, 251, 251, 212, 212, 255, 208, 204, 204, 252, 255, 256, 255, 252, 252, 253, 256, 257,
-    256, 253, 253, 254, 257, 212, 257, 254, 254, 212, 212, 209, 148, 208, 208, 255, 209, 210, 209,
-    255, 255, 256, 210, 211, 210, 256, 256, 257, 211, 212, 211, 257, 257, 212, 212, 264, 263, 258,
-    258, 259, 264, 265, 264, 259, 259, 260, 265, 266, 265, 260, 260, 261, 266, 267, 266, 261, 261,
-    262, 267, 269, 268, 263, 263, 264, 269, 270, 269, 264, 264, 265, 270, 271, 270, 265, 265, 266,
-    271, 272, 271, 266, 266, 267, 272, 274, 273, 268, 268, 269, 274, 275, 274, 269, 269, 270, 275,
-    276, 275, 270, 270, 271, 276, 277, 276, 271, 271, 272, 277, 279, 278, 273, 273, 274, 279, 280,
-    279, 274, 274, 275, 280, 281, 280, 275, 275, 276, 281, 282, 281, 276, 276, 277, 282, 284, 283,
-    278, 278, 279, 284, 285, 284, 279, 279, 280, 285, 286, 285, 280, 280, 281, 286, 287, 286, 281,
-    281, 282, 287, 289, 288, 283, 283, 284, 289, 290, 289, 284, 284, 285, 290, 291, 290, 285, 285,
-    286, 291, 292, 291, 286, 286, 287, 292, 294, 293, 288, 288, 289, 294, 295, 294, 289, 289, 290,
-    295, 296, 295, 290, 290, 291, 296, 297, 296, 291, 291, 292, 297, 259, 258, 293, 293, 294, 259,
-    260, 259, 294, 294, 295, 260, 261, 260, 295, 295, 296, 261, 262, 261, 296, 296, 297, 262, 302,
-    267, 262, 262, 298, 302, 303, 302, 298, 298, 299, 303, 304, 303, 299, 299, 300, 304, 305, 304,
-    300, 300, 301, 305, 306, 272, 267, 267, 302, 306, 307, 306, 302, 302, 303, 307, 308, 307, 303,
-    303, 304, 308, 309, 308, 304, 304, 305, 309, 310, 277, 272, 272, 306, 310, 311, 310, 306, 306,
-    307, 311, 312, 311, 307, 307, 308, 312, 313, 312, 308, 308, 309, 313, 314, 282, 277, 277, 310,
-    314, 315, 314, 310, 310, 311, 315, 316, 315, 311, 311, 312, 316, 317, 316, 312, 312, 313, 317,
-    318, 287, 282, 282, 314, 318, 319, 318, 314, 314, 315, 319, 320, 319, 315, 315, 316, 320, 321,
-    320, 316, 316, 317, 321, 322, 292, 287, 287, 318, 322, 323, 322, 318, 318, 319, 323, 324, 323,
-    319, 319, 320, 324, 325, 324, 320, 320, 321, 325, 326, 297, 292, 292, 322, 326, 327, 326, 322,
-    322, 323, 327, 328, 327, 323, 323, 324, 328, 329, 328, 324, 324, 325, 329, 298, 262, 297, 297,
-    326, 298, 299, 298, 326, 326, 327, 299, 300, 299, 327, 327, 328, 300, 301, 300, 328, 328, 329,
-    301, 336, 335, 330, 330, 331, 336, 337, 336, 331, 331, 332, 337, 338, 337, 332, 332, 333, 338,
-    339, 338, 333, 333, 334, 339, 341, 340, 335, 335, 336, 341, 342, 341, 336, 336, 337, 342, 343,
-    342, 337, 337, 338, 343, 344, 343, 338, 338, 339, 344, 346, 345, 340, 340, 341, 346, 347, 346,
-    341, 341, 342, 347, 348, 347, 342, 342, 343, 348, 349, 348, 343, 343, 344, 349, 351, 350, 345,
-    345, 346, 351, 352, 351, 346, 346, 347, 352, 353, 352, 347, 347, 348, 353, 354, 353, 348, 348,
-    349, 354, 356, 355, 350, 350, 351, 356, 357, 356, 351, 351, 352, 357, 358, 357, 352, 352, 353,
-    358, 359, 358, 353, 353, 354, 359, 361, 360, 355, 355, 356, 361, 362, 361, 356, 356, 357, 362,
-    363, 362, 357, 357, 358, 363, 364, 363, 358, 358, 359, 364, 366, 365, 360, 360, 361, 366, 367,
-    366, 361, 361, 362, 367, 368, 367, 362, 362, 363, 368, 369, 368, 363, 363, 364, 369, 331, 330,
-    365, 365, 366, 331, 332, 331, 366, 366, 367, 332, 333, 332, 367, 367, 368, 333, 334, 333, 368,
-    368, 369, 334, 374, 339, 334, 334, 370, 374, 375, 374, 370, 370, 371, 375, 376, 375, 371, 371,
-    372, 376, 377, 376, 372, 372, 373, 377, 378, 344, 339, 339, 374, 378, 379, 378, 374, 374, 375,
-    379, 380, 379, 375, 375, 376, 380, 381, 380, 376, 376, 377, 381, 382, 349, 344, 344, 378, 382,
-    383, 382, 378, 378, 379, 383, 384, 383, 379, 379, 380, 384, 385, 384, 380, 380, 381, 385, 386,
-    354, 349, 349, 382, 386, 387, 386, 382, 382, 383, 387, 388, 387, 383, 383, 384, 388, 389, 388,
-    384, 384, 385, 389, 390, 359, 354, 354, 386, 390, 391, 390, 386, 386, 387, 391, 392, 391, 387,
-    387, 388, 392, 393, 392, 388, 388, 389, 393, 394, 364, 359, 359, 390, 394, 395, 394, 390, 390,
-    391, 395, 396, 395, 391, 391, 392, 396, 397, 396, 392, 392, 393, 397, 398, 369, 364, 364, 394,
-    398, 399, 398, 394, 394, 395, 399, 400, 399, 395, 395, 396, 400, 401, 400, 396, 396, 397, 401,
-    370, 334, 369, 369, 398, 370, 371, 370, 398, 398, 399, 371, 372, 371, 399, 399, 400, 372, 373,
-    372, 400, 400, 401, 373, 407, 402, 402, 402, 403, 407, 408, 407, 403, 403, 404, 408, 409, 408,
-    404, 404, 405, 409, 410, 409, 405, 405, 406, 410, 411, 402, 402, 402, 407, 411, 412, 411, 407,
-    407, 408, 412, 413, 412, 408, 408, 409, 413, 414, 413, 409, 409, 410, 414, 415, 402, 402, 402,
-    411, 415, 416, 415, 411, 411, 412, 416, 417, 416, 412, 412, 413, 417, 418, 417, 413, 413, 414,
-    418, 419, 402, 402, 402, 415, 419, 420, 419, 415, 415, 416, 420, 421, 420, 416, 416, 417, 421,
-    422, 421, 417, 417, 418, 422, 423, 402, 402, 402, 419, 423, 424, 423, 419, 419, 420, 424, 425,
-    424, 420, 420, 421, 425, 426, 425, 421, 421, 422, 426, 427, 402, 402, 402, 423, 427, 428, 427,
-    423, 423, 424, 428, 429, 428, 424, 424, 425, 429, 430, 429, 425, 425, 426, 430, 431, 402, 402,
-    402, 427, 431, 432, 431, 427, 427, 428, 432, 433, 432, 428, 428, 429, 433, 434, 433, 429, 429,
-    430, 434, 435, 402, 402, 402, 431, 435, 436, 435, 431, 431, 432, 436, 437, 436, 432, 432, 433,
-    437, 438, 437, 433, 433, 434, 438, 439, 402, 402, 402, 435, 439, 440, 439, 435, 435, 436, 440,
-    441, 440, 436, 436, 437, 441, 442, 441, 437, 437, 438, 442, 443, 402, 402, 402, 439, 443, 444,
-    443, 439, 439, 440, 444, 445, 444, 440, 440, 441, 445, 446, 445, 441, 441, 442, 446, 447, 402,
-    402, 402, 443, 447, 448, 447, 443, 443, 444, 448, 449, 448, 444, 444, 445, 449, 450, 449, 445,
-    445, 446, 450, 451, 402, 402, 402, 447, 451, 452, 451, 447, 447, 448, 452, 453, 452, 448, 448,
-    449, 453, 454, 453, 449, 449, 450, 454, 455, 402, 402, 402, 451, 455, 456, 455, 451, 451, 452,
-    456, 457, 456, 452, 452, 453, 457, 458, 457, 453, 453, 454, 458, 459, 402, 402, 402, 455, 459,
-    460, 459, 455, 455, 456, 460, 461, 460, 456, 456, 457, 461, 462, 461, 457, 457, 458, 462, 463,
-    402, 402, 402, 459, 463, 464, 463, 459, 459, 460, 464, 465, 464, 460, 460, 461, 465, 466, 465,
-    461, 461, 462, 466, 403, 402, 402, 402, 463, 403, 404, 403, 463, 463, 464, 404, 405, 404, 464,
-    464, 465, 405, 406, 405, 465, 465, 466, 406, 471, 410, 406, 406, 467, 471, 472, 471, 467, 467,
-    468, 472, 473, 472, 468, 468, 469, 473, 474, 473, 469, 469, 470, 474, 475, 414, 410, 410, 471,
-    475, 476, 475, 471, 471, 472, 476, 477, 476, 472, 472, 473, 477, 478, 477, 473, 473, 474, 478,
-    479, 418, 414, 414, 475, 479, 480, 479, 475, 475, 476, 480, 481, 480, 476, 476, 477, 481, 482,
-    481, 477, 477, 478, 482, 483, 422, 418, 418, 479, 483, 484, 483, 479, 479, 480, 484, 485, 484,
-    480, 480, 481, 485, 486, 485, 481, 481, 482, 486, 487, 426, 422, 422, 483, 487, 488, 487, 483,
-    483, 484, 488, 489, 488, 484, 484, 485, 489, 490, 489, 485, 485, 486, 490, 491, 430, 426, 426,
-    487, 491, 492, 491, 487, 487, 488, 492, 493, 492, 488, 488, 489, 493, 494, 493, 489, 489, 490,
-    494, 495, 434, 430, 430, 491, 495, 496, 495, 491, 491, 492, 496, 497, 496, 492, 492, 493, 497,
-    498, 497, 493, 493, 494, 498, 499, 438, 434, 434, 495, 499, 500, 499, 495, 495, 496, 500, 501,
-    500, 496, 496, 497, 501, 502, 501, 497, 497, 498, 502, 503, 442, 438, 438, 499, 503, 504, 503,
-    499, 499, 500, 504, 505, 504, 500, 500, 501, 505, 506, 505, 501, 501, 502, 506, 507, 446, 442,
-    442, 503, 507, 508, 507, 503, 503, 504, 508, 509, 508, 504, 504, 505, 509, 510, 509, 505, 505,
-    506, 510, 511, 450, 446, 446, 507, 511, 512, 511, 507, 507, 508, 512, 513, 512, 508, 508, 509,
-    513, 514, 513, 509, 509, 510, 514, 515, 454, 450, 450, 511, 515, 516, 515, 511, 511, 512, 516,
-    517, 516, 512, 512, 513, 517, 518, 517, 513, 513, 514, 518, 519, 458, 454, 454, 515, 519, 520,
-    519, 515, 515, 516, 520, 521, 520, 516, 516, 517, 521, 522, 521, 517, 517, 518, 522, 523, 462,
-    458, 458, 519, 523, 524, 523, 519, 519, 520, 524, 525, 524, 520, 520, 521, 525, 526, 525, 521,
-    521, 522, 526, 527, 466, 462, 462, 523, 527, 528, 527, 523, 523, 524, 528, 529, 528, 524, 524,
-    525, 529, 530, 529, 525, 525, 526, 530, 467, 406, 466, 466, 527, 467, 468, 467, 527, 527, 528,
-    468, 469, 468, 528, 528, 529, 469, 470, 469, 529, 529, 530, 470u16,
-];
diff --git a/examples/wgpu/wgpu_teapot/shaders/fs.wgsl b/examples/wgpu/wgpu_teapot/shaders/fs.wgsl
deleted file mode 100644
index 6a5079bbc..000000000
--- a/examples/wgpu/wgpu_teapot/shaders/fs.wgsl
+++ /dev/null
@@ -1,9 +0,0 @@
-@fragment
-fn main(@location(0) normal: vec3<f32>) -> @location(0) vec4<f32> {
-    let light: vec3<f32> = vec3<f32>(0.0, 0.0, 1.0);
-    let color: vec3<f32> = vec3<f32>(1.0);
-    let brightness: f32 = dot(normalize(normal), normalize(light));
-    let dark_color: vec3<f32> = vec3<f32>(0.1) * color;
-    let out_color = vec4<f32>(mix(dark_color, color, vec3<f32>(brightness)), 1.0);
-    return out_color;
-}
diff --git a/examples/wgpu/wgpu_teapot/shaders/vs.wgsl b/examples/wgpu/wgpu_teapot/shaders/vs.wgsl
deleted file mode 100644
index 856e1f018..000000000
--- a/examples/wgpu/wgpu_teapot/shaders/vs.wgsl
+++ /dev/null
@@ -1,41 +0,0 @@
-struct Data {
-    world: mat4x4<f32>,
-    view: mat4x4<f32>,
-    proj: mat4x4<f32>,
-};
-
-struct VertexOutput {
-    @location(0) normal: vec3<f32>,
-    @builtin(position) pos: vec4<f32>,
-};
-
-@group(0) @binding(0)
-var<uniform> uniforms: Data;
-
-fn custom_inverse(m: mat3x3<f32>) -> mat3x3<f32> {
-    let determinant: f32 = determinant(m);
-    let invdet: f32 = 1.0 / determinant;
-    var minv: mat3x3<f32>;
-    minv[0][0] = (m[1][1] * m[2][2] - m[2][1] * m[1][2]) * invdet;
-    minv[0][1] = (m[0][2] * m[2][1] - m[0][1] * m[2][2]) * invdet;
-    minv[0][2] = (m[0][1] * m[1][2] - m[0][2] * m[1][1]) * invdet;
-    minv[1][0] = (m[1][2] * m[2][0] - m[1][0] * m[2][2]) * invdet;
-    minv[1][1] = (m[0][0] * m[2][2] - m[0][2] * m[2][0]) * invdet;
-    minv[1][2] = (m[1][0] * m[0][2] - m[0][0] * m[1][2]) * invdet;
-    minv[2][0] = (m[1][0] * m[2][1] - m[2][0] * m[1][1]) * invdet;
-    minv[2][1] = (m[2][0] * m[0][1] - m[0][0] * m[2][1]) * invdet;
-    minv[2][2] = (m[0][0] * m[1][1] - m[1][0] * m[0][1]) * invdet;
-    return minv;
-}
-
-@vertex
-fn main(
-    @location(0) pos: vec3<f32>,
-    @location(1) normal: vec3<f32>,
-) -> VertexOutput {
-    let worldview: mat4x4<f32> = uniforms.view * uniforms.world;
-    let wv3: mat3x3<f32> = mat3x3<f32>(worldview[0].xyz, worldview[1].xyz, worldview[2].xyz);
-    let out_normal: vec3<f32> = transpose(custom_inverse(wv3)) * normal;
-    let out_pos: vec4<f32> = uniforms.proj * worldview * vec4<f32>(pos, 1.0);
-    return VertexOutput(out_normal, out_pos);
-}
diff --git a/examples/wgpu/wgpu_teapot/wgpu_teapot.rs b/examples/wgpu/wgpu_teapot/wgpu_teapot.rs
deleted file mode 100644
index 65dedd173..000000000
--- a/examples/wgpu/wgpu_teapot/wgpu_teapot.rs
+++ /dev/null
@@ -1,270 +0,0 @@
-use nannou::prelude::*;
-use std::cell::RefCell;
-
-mod data;
-
-struct Model {
-    graphics: RefCell<Graphics>,
-}
-
-struct Graphics {
-    vertex_buffer: wgpu::Buffer,
-    normal_buffer: wgpu::Buffer,
-    index_buffer: wgpu::Buffer,
-    uniform_buffer: wgpu::Buffer,
-    depth_texture: wgpu::Texture,
-    depth_texture_view: wgpu::TextureView,
-    bind_group: wgpu::BindGroup,
-    render_pipeline: wgpu::RenderPipeline,
-}
-
-// The vertex type that we will use to represent a point on our triangle.
-#[repr(C)]
-#[derive(Clone, Copy)]
-pub struct Vertex {
-    position: (f32, f32, f32),
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct Normal {
-    normal: (f32, f32, f32),
-}
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug)]
-pub struct Uniforms {
-    world: Mat4,
-    view: Mat4,
-    proj: Mat4,
-}
-
-const DEPTH_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Depth32Float;
-
-fn main() {
-    nannou::app(model).run();
-}
-
-fn model(app: &App) -> Model {
-    let w_id = app.new_window().size(1024, 576).view(view).build().unwrap();
-
-    // The gpu device associated with the window's swapchain
-    let window = app.window(w_id).unwrap();
-    let device = window.device();
-    let format = Frame::TEXTURE_FORMAT;
-    let msaa_samples = window.msaa_samples();
-    let (win_w, win_h) = window.inner_size_pixels();
-
-    // Load shader modules.
-    let vs_desc = wgpu::include_wgsl!("shaders/vs.wgsl");
-    let fs_desc = wgpu::include_wgsl!("shaders/fs.wgsl");
-    let vs_mod = device.create_shader_module(vs_desc);
-    let fs_mod = device.create_shader_module(fs_desc);
-
-    // Create the vertex, normal and index buffers.
-    let vertices_bytes = vertices_as_bytes(&data::VERTICES);
-    let normals_bytes = normals_as_bytes(&data::NORMALS);
-    let indices_bytes = indices_as_bytes(&data::INDICES);
-    let vertex_usage = wgpu::BufferUsages::VERTEX;
-    let index_usage = wgpu::BufferUsages::INDEX;
-    let vertex_buffer = device.create_buffer_init(&BufferInitDescriptor {
-        label: None,
-        contents: vertices_bytes,
-        usage: vertex_usage,
-    });
-    let normal_buffer = device.create_buffer_init(&BufferInitDescriptor {
-        label: None,
-        contents: normals_bytes,
-        usage: vertex_usage,
-    });
-    let index_buffer = device.create_buffer_init(&BufferInitDescriptor {
-        label: None,
-        contents: indices_bytes,
-        usage: index_usage,
-    });
-
-    // Create the depth texture.
-    let depth_texture = create_depth_texture(device, [win_w, win_h], DEPTH_FORMAT, msaa_samples);
-    let depth_texture_view = depth_texture.view().build();
-
-    // Create the uniform buffer.
-    let uniforms = create_uniforms(0.0, [win_w, win_h]);
-    let uniforms_bytes = uniforms_as_bytes(&uniforms);
-    let usage = wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST;
-    let uniform_buffer = device.create_buffer_init(&BufferInitDescriptor {
-        label: None,
-        contents: uniforms_bytes,
-        usage,
-    });
-
-    // Create the render pipeline.
-    let bind_group_layout = create_bind_group_layout(device);
-    let bind_group = create_bind_group(device, &bind_group_layout, &uniform_buffer);
-    let pipeline_layout = create_pipeline_layout(device, &bind_group_layout);
-    let render_pipeline = create_render_pipeline(
-        device,
-        &pipeline_layout,
-        &vs_mod,
-        &fs_mod,
-        format,
-        DEPTH_FORMAT,
-        msaa_samples,
-    );
-
-    let graphics = RefCell::new(Graphics {
-        vertex_buffer,
-        normal_buffer,
-        index_buffer,
-        uniform_buffer,
-        depth_texture,
-        depth_texture_view,
-        bind_group,
-        render_pipeline,
-    });
-
-    Model { graphics }
-}
-
-fn view(app: &App, model: &Model, frame: Frame) {
-    let mut g = model.graphics.borrow_mut();
-
-    // If the window has changed size, recreate our depth texture to match.
-    let depth_size = g.depth_texture.size();
-    let frame_size = frame.texture_size();
-    let device = frame.device_queue_pair().device();
-    if frame_size != depth_size {
-        let depth_format = g.depth_texture.format();
-        let sample_count = frame.texture_msaa_samples();
-        g.depth_texture = create_depth_texture(device, frame_size, depth_format, sample_count);
-        g.depth_texture_view = g.depth_texture.view().build();
-    }
-
-    // Update the uniforms (rotate around the teapot).
-    let rotation = app.time;
-    let uniforms = create_uniforms(rotation, frame_size);
-    let uniforms_size = std::mem::size_of::<Uniforms>() as wgpu::BufferAddress;
-    let uniforms_bytes = uniforms_as_bytes(&uniforms);
-    let usage = wgpu::BufferUsages::COPY_SRC;
-    let new_uniform_buffer = device.create_buffer_init(&BufferInitDescriptor {
-        label: None,
-        contents: uniforms_bytes,
-        usage,
-    });
-
-    let mut encoder = frame.command_encoder();
-    encoder.copy_buffer_to_buffer(&new_uniform_buffer, 0, &g.uniform_buffer, 0, uniforms_size);
-    let mut render_pass = wgpu::RenderPassBuilder::new()
-        .color_attachment(frame.texture_view(), |color| color)
-        // We'll use a depth texture to assist with the order of rendering fragments based on depth.
-        .depth_stencil_attachment(&g.depth_texture_view, |depth| depth)
-        .begin(&mut encoder);
-    render_pass.set_bind_group(0, &g.bind_group, &[]);
-    render_pass.set_pipeline(&g.render_pipeline);
-    render_pass.set_vertex_buffer(0, g.vertex_buffer.slice(..));
-    render_pass.set_vertex_buffer(1, g.normal_buffer.slice(..));
-    render_pass.set_index_buffer(g.index_buffer.slice(..), wgpu::IndexFormat::Uint16);
-    let index_range = 0..data::INDICES.len() as u32;
-    let start_vertex = 0;
-    let instance_range = 0..1;
-    render_pass.draw_indexed(index_range, start_vertex, instance_range);
-}
-
-fn create_uniforms(rotation: f32, [w, h]: [u32; 2]) -> Uniforms {
-    let rotation = Mat4::from_rotation_y(rotation);
-    let aspect_ratio = w as f32 / h as f32;
-    let fov_y = std::f32::consts::FRAC_PI_2;
-    let near = 0.01;
-    let far = 100.0;
-    let proj = Mat4::perspective_rh_gl(fov_y, aspect_ratio, near, far);
-    let eye = pt3(0.3, 0.3, 1.0);
-    let target = Point3::ZERO;
-    let up = Vec3::Y;
-    let view = Mat4::look_at_rh(eye, target, up);
-    let scale = Mat4::from_scale(Vec3::splat(0.01));
-    Uniforms {
-        world: rotation,
-        view: (view * scale).into(),
-        proj: proj.into(),
-    }
-}
-
-fn create_depth_texture(
-    device: &wgpu::Device,
-    size: [u32; 2],
-    depth_format: wgpu::TextureFormat,
-    sample_count: u32,
-) -> wgpu::Texture {
-    wgpu::TextureBuilder::new()
-        .size(size)
-        .format(depth_format)
-        .usage(wgpu::TextureUsages::RENDER_ATTACHMENT)
-        .sample_count(sample_count)
-        .build(device)
-}
-
-fn create_bind_group_layout(device: &wgpu::Device) -> wgpu::BindGroupLayout {
-    wgpu::BindGroupLayoutBuilder::new()
-        .uniform_buffer(wgpu::ShaderStages::VERTEX, false)
-        .build(device)
-}
-
-fn create_bind_group(
-    device: &wgpu::Device,
-    layout: &wgpu::BindGroupLayout,
-    uniform_buffer: &wgpu::Buffer,
-) -> wgpu::BindGroup {
-    wgpu::BindGroupBuilder::new()
-        .buffer::<Uniforms>(uniform_buffer, 0..1)
-        .build(device, layout)
-}
-
-fn create_pipeline_layout(
-    device: &wgpu::Device,
-    bind_group_layout: &wgpu::BindGroupLayout,
-) -> wgpu::PipelineLayout {
-    let desc = wgpu::PipelineLayoutDescriptor {
-        label: None,
-        bind_group_layouts: &[&bind_group_layout],
-        push_constant_ranges: &[],
-    };
-    device.create_pipeline_layout(&desc)
-}
-
-fn create_render_pipeline(
-    device: &wgpu::Device,
-    layout: &wgpu::PipelineLayout,
-    vs_mod: &wgpu::ShaderModule,
-    fs_mod: &wgpu::ShaderModule,
-    dst_format: wgpu::TextureFormat,
-    depth_format: wgpu::TextureFormat,
-    sample_count: u32,
-) -> wgpu::RenderPipeline {
-    wgpu::RenderPipelineBuilder::from_layout(layout, vs_mod)
-        .fragment_shader(&fs_mod)
-        .color_format(dst_format)
-        .color_blend(wgpu::BlendComponent::REPLACE)
-        .alpha_blend(wgpu::BlendComponent::REPLACE)
-        .add_vertex_buffer::<Vertex>(&wgpu::vertex_attr_array![0 => Float32x3])
-        .add_vertex_buffer::<Normal>(&wgpu::vertex_attr_array![1 => Float32x3])
-        .depth_format(depth_format)
-        .sample_count(sample_count)
-        .build(device)
-}
-
-// See the `nannou::wgpu::bytes` documentation for why the following are necessary.
-
-fn vertices_as_bytes(data: &[Vertex]) -> &[u8] {
-    unsafe { wgpu::bytes::from_slice(data) }
-}
-
-fn normals_as_bytes(data: &[Normal]) -> &[u8] {
-    unsafe { wgpu::bytes::from_slice(data) }
-}
-
-fn indices_as_bytes(data: &[u16]) -> &[u8] {
-    unsafe { wgpu::bytes::from_slice(data) }
-}
-
-fn uniforms_as_bytes(uniforms: &Uniforms) -> &[u8] {
-    unsafe { wgpu::bytes::from(uniforms) }
-}
diff --git a/examples/wgpu/wgpu_teapot_camera/data.rs b/examples/wgpu/wgpu_teapot_camera/data.rs
deleted file mode 100644
index 61aefab11..000000000
--- a/examples/wgpu/wgpu_teapot_camera/data.rs
+++ /dev/null
@@ -1,3354 +0,0 @@
-use crate::{Normal, Vertex};
-
-pub const VERTICES: [Vertex; 531] = [
-    Vertex {
-        position: (0.0, 0.0, 0.0),
-    }, // dummy vector because in the original model indices
-    // start at 1
-    Vertex {
-        position: (40.6266, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (40.0714, 30.4443, -1.10804),
-    },
-    Vertex {
-        position: (40.7155, 31.1438, -1.10804),
-    },
-    Vertex {
-        position: (42.0257, 30.4443, -1.10804),
-    },
-    Vertex {
-        position: (43.4692, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (37.5425, 28.3457, 14.5117),
-    },
-    Vertex {
-        position: (37.0303, 30.4443, 14.2938),
-    },
-    Vertex {
-        position: (37.6244, 31.1438, 14.5466),
-    },
-    Vertex {
-        position: (38.8331, 30.4443, 15.0609),
-    },
-    Vertex {
-        position: (40.1647, 28.3457, 15.6274),
-    },
-    Vertex {
-        position: (29.0859, 28.3457, 27.1468),
-    },
-    Vertex {
-        position: (28.6917, 30.4443, 26.7527),
-    },
-    Vertex {
-        position: (29.149, 31.1438, 27.2099),
-    },
-    Vertex {
-        position: (30.0792, 30.4443, 28.1402),
-    },
-    Vertex {
-        position: (31.1041, 28.3457, 29.165),
-    },
-    Vertex {
-        position: (16.4508, 28.3457, 35.6034),
-    },
-    Vertex {
-        position: (16.2329, 30.4443, 35.0912),
-    },
-    Vertex {
-        position: (16.4857, 31.1438, 35.6853),
-    },
-    Vertex {
-        position: (16.9999, 30.4443, 36.894),
-    },
-    Vertex {
-        position: (17.5665, 28.3457, 38.2256),
-    },
-    Vertex {
-        position: (0.831025, 28.3457, 38.6876),
-    },
-    Vertex {
-        position: (0.831025, 30.4443, 38.1324),
-    },
-    Vertex {
-        position: (0.831025, 31.1438, 38.7764),
-    },
-    Vertex {
-        position: (0.831025, 30.4443, 40.0866),
-    },
-    Vertex {
-        position: (0.831025, 28.3457, 41.5301),
-    },
-    Vertex {
-        position: (-15.868, 28.3457, 35.6034),
-    },
-    Vertex {
-        position: (-15.0262, 30.4443, 35.0912),
-    },
-    Vertex {
-        position: (-14.9585, 31.1438, 35.6853),
-    },
-    Vertex {
-        position: (-15.3547, 30.4443, 36.894),
-    },
-    Vertex {
-        position: (-15.9044, 28.3457, 38.2256),
-    },
-    Vertex {
-        position: (-28.3832, 28.3457, 27.1468),
-    },
-    Vertex {
-        position: (-27.4344, 30.4443, 26.7527),
-    },
-    Vertex {
-        position: (-27.6068, 31.1438, 27.2099),
-    },
-    Vertex {
-        position: (-28.4322, 30.4443, 28.1402),
-    },
-    Vertex {
-        position: (-29.4421, 28.3457, 29.165),
-    },
-    Vertex {
-        position: (-36.2402, 28.3457, 14.5117),
-    },
-    Vertex {
-        position: (-35.52, 30.4443, 14.2938),
-    },
-    Vertex {
-        position: (-36.0073, 31.1438, 14.5466),
-    },
-    Vertex {
-        position: (-37.1767, 30.4443, 15.0609),
-    },
-    Vertex {
-        position: (-38.5027, 28.3457, 15.6274),
-    },
-    Vertex {
-        position: (-38.9646, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (-38.4094, 30.4443, -1.10804),
-    },
-    Vertex {
-        position: (-39.0534, 31.1438, -1.10804),
-    },
-    Vertex {
-        position: (-40.3636, 30.4443, -1.10804),
-    },
-    Vertex {
-        position: (-41.8071, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (-35.8804, 28.3457, -16.7278),
-    },
-    Vertex {
-        position: (-35.3683, 30.4443, -16.5099),
-    },
-    Vertex {
-        position: (-35.9624, 31.1438, -16.7627),
-    },
-    Vertex {
-        position: (-37.1711, 30.4443, -17.2769),
-    },
-    Vertex {
-        position: (-38.5027, 28.3457, -17.8435),
-    },
-    Vertex {
-        position: (-27.4238, 28.3457, -29.3629),
-    },
-    Vertex {
-        position: (-27.0297, 30.4443, -28.9687),
-    },
-    Vertex {
-        position: (-27.4869, 31.1438, -29.426),
-    },
-    Vertex {
-        position: (-28.4172, 30.4443, -30.3562),
-    },
-    Vertex {
-        position: (-29.4421, 28.3457, -31.3811),
-    },
-    Vertex {
-        position: (-14.7887, 28.3457, -37.8195),
-    },
-    Vertex {
-        position: (-14.5708, 30.4443, -37.3073),
-    },
-    Vertex {
-        position: (-14.8236, 31.1438, -37.9014),
-    },
-    Vertex {
-        position: (-15.3379, 30.4443, -39.1101),
-    },
-    Vertex {
-        position: (-15.9044, 28.3457, -40.4417),
-    },
-    Vertex {
-        position: (0.831025, 28.3457, -40.9036),
-    },
-    Vertex {
-        position: (0.831025, 30.4443, -40.3484),
-    },
-    Vertex {
-        position: (0.831025, 31.1438, -40.9925),
-    },
-    Vertex {
-        position: (0.831025, 30.4443, -42.3027),
-    },
-    Vertex {
-        position: (0.831025, 28.3457, -43.7462),
-    },
-    Vertex {
-        position: (16.4508, 28.3457, -37.8195),
-    },
-    Vertex {
-        position: (16.2329, 30.4443, -37.3073),
-    },
-    Vertex {
-        position: (16.4857, 31.1438, -37.9014),
-    },
-    Vertex {
-        position: (16.9999, 30.4443, -39.1101),
-    },
-    Vertex {
-        position: (17.5665, 28.3457, -40.4417),
-    },
-    Vertex {
-        position: (29.0859, 28.3457, -29.3629),
-    },
-    Vertex {
-        position: (28.6917, 30.4443, -28.9687),
-    },
-    Vertex {
-        position: (29.149, 31.1438, -29.426),
-    },
-    Vertex {
-        position: (30.0792, 30.4443, -30.3562),
-    },
-    Vertex {
-        position: (31.1041, 28.3457, -31.3811),
-    },
-    Vertex {
-        position: (37.5425, 28.3457, -16.7278),
-    },
-    Vertex {
-        position: (37.0303, 30.4443, -16.5099),
-    },
-    Vertex {
-        position: (37.6244, 31.1438, -16.7627),
-    },
-    Vertex {
-        position: (38.8331, 30.4443, -17.2769),
-    },
-    Vertex {
-        position: (40.1647, 28.3457, -17.8435),
-    },
-    Vertex {
-        position: (48.6879, 17.1865, -1.10804),
-    },
-    Vertex {
-        position: (53.2404, 6.22714, -1.10804),
-    },
-    Vertex {
-        position: (56.4605, -4.33246, -1.10804),
-    },
-    Vertex {
-        position: (57.6819, -14.2925, -1.10804),
-    },
-    Vertex {
-        position: (44.979, 17.1865, 17.6758),
-    },
-    Vertex {
-        position: (49.1787, 6.22714, 19.4626),
-    },
-    Vertex {
-        position: (52.1492, -4.33246, 20.7265),
-    },
-    Vertex {
-        position: (53.2759, -14.2925, 21.2059),
-    },
-    Vertex {
-        position: (34.8094, 17.1865, 32.8703),
-    },
-    Vertex {
-        position: (38.0417, 6.22714, 36.1026),
-    },
-    Vertex {
-        position: (40.3279, -4.33246, 38.3889),
-    },
-    Vertex {
-        position: (41.1951, -14.2925, 39.2561),
-    },
-    Vertex {
-        position: (19.6148, 17.1865, 43.0399),
-    },
-    Vertex {
-        position: (21.4017, 6.22714, 47.2396),
-    },
-    Vertex {
-        position: (22.6656, -4.33246, 50.2101),
-    },
-    Vertex {
-        position: (23.145, -14.2925, 51.3369),
-    },
-    Vertex {
-        position: (0.831025, 17.1865, 46.7488),
-    },
-    Vertex {
-        position: (0.831025, 6.22714, 51.3013),
-    },
-    Vertex {
-        position: (0.831025, -4.33246, 54.5214),
-    },
-    Vertex {
-        position: (0.831025, -14.2925, 55.7428),
-    },
-    Vertex {
-        position: (-17.9528, 17.1865, 43.0399),
-    },
-    Vertex {
-        position: (-19.7397, 6.22714, 47.2396),
-    },
-    Vertex {
-        position: (-21.0035, -4.33246, 50.2101),
-    },
-    Vertex {
-        position: (-21.4829, -14.2925, 51.3369),
-    },
-    Vertex {
-        position: (-33.1474, 17.1865, 32.8703),
-    },
-    Vertex {
-        position: (-36.3796, 6.22714, 36.1026),
-    },
-    Vertex {
-        position: (-38.6659, -4.33246, 38.3889),
-    },
-    Vertex {
-        position: (-39.5331, -14.2925, 39.2561),
-    },
-    Vertex {
-        position: (-43.3169, 17.1865, 17.6758),
-    },
-    Vertex {
-        position: (-47.5166, 6.22714, 19.4626),
-    },
-    Vertex {
-        position: (-50.4871, -4.33246, 20.7265),
-    },
-    Vertex {
-        position: (-51.6139, -14.2925, 21.2059),
-    },
-    Vertex {
-        position: (-47.0258, 17.1865, -1.10804),
-    },
-    Vertex {
-        position: (-51.5784, 6.22714, -1.10804),
-    },
-    Vertex {
-        position: (-54.7984, -4.33246, -1.10804),
-    },
-    Vertex {
-        position: (-56.0198, -14.2925, -1.10804),
-    },
-    Vertex {
-        position: (-43.3169, 17.1865, -19.8919),
-    },
-    Vertex {
-        position: (-47.5166, 6.22714, -21.6787),
-    },
-    Vertex {
-        position: (-50.4871, -4.33246, -22.9426),
-    },
-    Vertex {
-        position: (-51.6139, -14.2925, -23.422),
-    },
-    Vertex {
-        position: (-33.1474, 17.1865, -35.0864),
-    },
-    Vertex {
-        position: (-36.3796, 6.22714, -38.3187),
-    },
-    Vertex {
-        position: (-38.6659, -4.33246, -40.6049),
-    },
-    Vertex {
-        position: (-39.5331, -14.2925, -41.4721),
-    },
-    Vertex {
-        position: (-17.9528, 17.1865, -45.256),
-    },
-    Vertex {
-        position: (-19.7397, 6.22714, -49.4557),
-    },
-    Vertex {
-        position: (-21.0035, -4.33246, -52.4262),
-    },
-    Vertex {
-        position: (-21.4829, -14.2925, -53.5529),
-    },
-    Vertex {
-        position: (0.831025, 17.1865, -48.9649),
-    },
-    Vertex {
-        position: (0.831025, 6.22714, -53.5174),
-    },
-    Vertex {
-        position: (0.831025, -4.33246, -56.7375),
-    },
-    Vertex {
-        position: (0.831025, -14.2925, -57.9589),
-    },
-    Vertex {
-        position: (19.6148, 17.1865, -45.256),
-    },
-    Vertex {
-        position: (21.4017, 6.22714, -49.4557),
-    },
-    Vertex {
-        position: (22.6656, -4.33246, -52.4262),
-    },
-    Vertex {
-        position: (23.145, -14.2925, -53.5529),
-    },
-    Vertex {
-        position: (34.8094, 17.1865, -35.0864),
-    },
-    Vertex {
-        position: (38.0417, 6.22714, -38.3187),
-    },
-    Vertex {
-        position: (40.3279, -4.33246, -40.6049),
-    },
-    Vertex {
-        position: (41.1951, -14.2925, -41.4721),
-    },
-    Vertex {
-        position: (44.979, 17.1865, -19.8919),
-    },
-    Vertex {
-        position: (49.1787, 6.22714, -21.6787),
-    },
-    Vertex {
-        position: (52.1492, -4.33246, -22.9426),
-    },
-    Vertex {
-        position: (53.2759, -14.2925, -23.422),
-    },
-    Vertex {
-        position: (55.4611, -22.7202, -1.10804),
-    },
-    Vertex {
-        position: (50.5755, -28.9493, -1.10804),
-    },
-    Vertex {
-        position: (45.6899, -33.1798, -1.10804),
-    },
-    Vertex {
-        position: (43.4692, -35.6115, -1.10804),
-    },
-    Vertex {
-        position: (51.2273, -22.7202, 20.3343),
-    },
-    Vertex {
-        position: (46.7203, -28.9493, 18.4167),
-    },
-    Vertex {
-        position: (42.2133, -33.1798, 16.4991),
-    },
-    Vertex {
-        position: (40.1647, -35.6115, 15.6274),
-    },
-    Vertex {
-        position: (39.6184, -22.7202, 37.6793),
-    },
-    Vertex {
-        position: (36.1496, -28.9493, 34.2106),
-    },
-    Vertex {
-        position: (32.6808, -33.1798, 30.7418),
-    },
-    Vertex {
-        position: (31.1041, -35.6115, 29.165),
-    },
-    Vertex {
-        position: (22.2733, -22.7202, 49.2882),
-    },
-    Vertex {
-        position: (20.3557, -28.9493, 44.7813),
-    },
-    Vertex {
-        position: (18.4381, -33.1798, 40.2743),
-    },
-    Vertex {
-        position: (17.5665, -35.6115, 38.2256),
-    },
-    Vertex {
-        position: (0.831025, -22.7202, 53.5221),
-    },
-    Vertex {
-        position: (0.831025, -28.9493, 48.6365),
-    },
-    Vertex {
-        position: (0.831025, -33.1798, 43.7508),
-    },
-    Vertex {
-        position: (0.831025, -35.6115, 41.5301),
-    },
-    Vertex {
-        position: (-20.6113, -22.7202, 49.2882),
-    },
-    Vertex {
-        position: (-18.6937, -28.9493, 44.7813),
-    },
-    Vertex {
-        position: (-16.7761, -33.1798, 40.2743),
-    },
-    Vertex {
-        position: (-15.9044, -35.6115, 38.2256),
-    },
-    Vertex {
-        position: (-37.9564, -22.7202, 37.6793),
-    },
-    Vertex {
-        position: (-34.4876, -28.9493, 34.2106),
-    },
-    Vertex {
-        position: (-31.0188, -33.1798, 30.7418),
-    },
-    Vertex {
-        position: (-29.4421, -35.6115, 29.165),
-    },
-    Vertex {
-        position: (-49.5653, -22.7202, 20.3343),
-    },
-    Vertex {
-        position: (-45.0583, -28.9493, 18.4167),
-    },
-    Vertex {
-        position: (-40.5513, -33.1798, 16.4991),
-    },
-    Vertex {
-        position: (-38.5027, -35.6115, 15.6274),
-    },
-    Vertex {
-        position: (-53.7991, -22.7202, -1.10804),
-    },
-    Vertex {
-        position: (-48.9135, -28.9493, -1.10804),
-    },
-    Vertex {
-        position: (-44.0279, -33.1798, -1.10804),
-    },
-    Vertex {
-        position: (-41.8071, -35.6115, -1.10804),
-    },
-    Vertex {
-        position: (-49.5653, -22.7202, -22.5504),
-    },
-    Vertex {
-        position: (-45.0583, -28.9493, -20.6327),
-    },
-    Vertex {
-        position: (-40.5513, -33.1798, -18.7151),
-    },
-    Vertex {
-        position: (-38.5027, -35.6115, -17.8435),
-    },
-    Vertex {
-        position: (-37.9564, -22.7202, -39.8954),
-    },
-    Vertex {
-        position: (-34.4876, -28.9493, -36.4266),
-    },
-    Vertex {
-        position: (-31.0188, -33.1798, -32.9578),
-    },
-    Vertex {
-        position: (-29.4421, -35.6115, -31.3811),
-    },
-    Vertex {
-        position: (-20.6113, -22.7202, -51.5043),
-    },
-    Vertex {
-        position: (-18.6937, -28.9493, -46.9973),
-    },
-    Vertex {
-        position: (-16.7761, -33.1798, -42.4903),
-    },
-    Vertex {
-        position: (-15.9044, -35.6115, -40.4417),
-    },
-    Vertex {
-        position: (0.831025, -22.7202, -55.7382),
-    },
-    Vertex {
-        position: (0.831025, -28.9493, -50.8525),
-    },
-    Vertex {
-        position: (0.831025, -33.1798, -45.9669),
-    },
-    Vertex {
-        position: (0.831025, -35.6115, -43.7462),
-    },
-    Vertex {
-        position: (22.2733, -22.7202, -51.5043),
-    },
-    Vertex {
-        position: (20.3557, -28.9493, -46.9973),
-    },
-    Vertex {
-        position: (18.4381, -33.1798, -42.4903),
-    },
-    Vertex {
-        position: (17.5665, -35.6115, -40.4417),
-    },
-    Vertex {
-        position: (39.6184, -22.7202, -39.8954),
-    },
-    Vertex {
-        position: (36.1496, -28.9493, -36.4266),
-    },
-    Vertex {
-        position: (32.6808, -33.1798, -32.9578),
-    },
-    Vertex {
-        position: (31.1041, -35.6115, -31.3811),
-    },
-    Vertex {
-        position: (51.2273, -22.7202, -22.5504),
-    },
-    Vertex {
-        position: (46.7203, -28.9493, -20.6327),
-    },
-    Vertex {
-        position: (42.2133, -33.1798, -18.7151),
-    },
-    Vertex {
-        position: (40.1647, -35.6115, -17.8435),
-    },
-    Vertex {
-        position: (42.5031, -37.1772, -1.10804),
-    },
-    Vertex {
-        position: (37.3399, -38.5429, -1.10804),
-    },
-    Vertex {
-        position: (24.5818, -39.5089, -1.10804),
-    },
-    Vertex {
-        position: (0.831025, -39.8754, -1.10804),
-    },
-    Vertex {
-        position: (39.2736, -37.1772, 15.2483),
-    },
-    Vertex {
-        position: (34.5105, -38.5429, 13.2217),
-    },
-    Vertex {
-        position: (22.7411, -39.5089, 8.21414),
-    },
-    Vertex {
-        position: (30.4182, -37.1772, 28.4792),
-    },
-    Vertex {
-        position: (26.7523, -38.5429, 24.8133),
-    },
-    Vertex {
-        position: (17.6941, -39.5089, 15.755),
-    },
-    Vertex {
-        position: (17.1873, -37.1772, 37.3345),
-    },
-    Vertex {
-        position: (15.1608, -38.5429, 32.5714),
-    },
-    Vertex {
-        position: (10.1532, -39.5089, 20.8021),
-    },
-    Vertex {
-        position: (0.831025, -37.1772, 40.5641),
-    },
-    Vertex {
-        position: (0.831025, -38.5429, 35.4009),
-    },
-    Vertex {
-        position: (0.831025, -39.5089, 22.6427),
-    },
-    Vertex {
-        position: (-15.5253, -37.1772, 37.3345),
-    },
-    Vertex {
-        position: (-13.4987, -38.5429, 32.5714),
-    },
-    Vertex {
-        position: (-8.49115, -39.5089, 20.8021),
-    },
-    Vertex {
-        position: (-28.7562, -37.1772, 28.4792),
-    },
-    Vertex {
-        position: (-25.0903, -38.5429, 24.8133),
-    },
-    Vertex {
-        position: (-16.032, -39.5089, 15.755),
-    },
-    Vertex {
-        position: (-37.6115, -37.1772, 15.2483),
-    },
-    Vertex {
-        position: (-32.8484, -38.5429, 13.2217),
-    },
-    Vertex {
-        position: (-21.0791, -39.5089, 8.21414),
-    },
-    Vertex {
-        position: (-40.8411, -37.1772, -1.10804),
-    },
-    Vertex {
-        position: (-35.6779, -38.5429, -1.10804),
-    },
-    Vertex {
-        position: (-22.9198, -39.5089, -1.10804),
-    },
-    Vertex {
-        position: (-37.6115, -37.1772, -17.4643),
-    },
-    Vertex {
-        position: (-32.8484, -38.5429, -15.4378),
-    },
-    Vertex {
-        position: (-21.0791, -39.5089, -10.4302),
-    },
-    Vertex {
-        position: (-28.7562, -37.1772, -30.6952),
-    },
-    Vertex {
-        position: (-25.0903, -38.5429, -27.0294),
-    },
-    Vertex {
-        position: (-16.032, -39.5089, -17.9711),
-    },
-    Vertex {
-        position: (-15.5253, -37.1772, -39.5506),
-    },
-    Vertex {
-        position: (-13.4987, -38.5429, -34.7875),
-    },
-    Vertex {
-        position: (-8.49115, -39.5089, -23.0181),
-    },
-    Vertex {
-        position: (0.831025, -37.1772, -42.7802),
-    },
-    Vertex {
-        position: (0.831025, -38.5429, -37.6169),
-    },
-    Vertex {
-        position: (0.831025, -39.5089, -24.8588),
-    },
-    Vertex {
-        position: (17.1873, -37.1772, -39.5506),
-    },
-    Vertex {
-        position: (15.1608, -38.5429, -34.7875),
-    },
-    Vertex {
-        position: (10.1532, -39.5089, -23.0181),
-    },
-    Vertex {
-        position: (30.4182, -37.1772, -30.6952),
-    },
-    Vertex {
-        position: (26.7523, -38.5429, -27.0294),
-    },
-    Vertex {
-        position: (17.6941, -39.5089, -17.9711),
-    },
-    Vertex {
-        position: (39.2736, -37.1772, -17.4643),
-    },
-    Vertex {
-        position: (34.5105, -38.5429, -15.4378),
-    },
-    Vertex {
-        position: (22.7411, -39.5089, -10.4302),
-    },
-    Vertex {
-        position: (-44.6497, 17.6861, -1.10804),
-    },
-    Vertex {
-        position: (-57.9297, 17.5862, -1.10804),
-    },
-    Vertex {
-        position: (-67.7453, 16.8867, -1.10804),
-    },
-    Vertex {
-        position: (-73.8301, 14.9879, -1.10804),
-    },
-    Vertex {
-        position: (-75.9176, 11.2904, -1.10804),
-    },
-    Vertex {
-        position: (-44.2055, 18.6855, 3.68876),
-    },
-    Vertex {
-        position: (-58.3252, 18.5699, 3.68876),
-    },
-    Vertex {
-        position: (-68.6891, 17.7611, 3.68876),
-    },
-    Vertex {
-        position: (-75.0724, 15.5657, 3.68876),
-    },
-    Vertex {
-        position: (-77.2501, 11.2904, 3.68876),
-    },
-    Vertex {
-        position: (-43.2284, 20.884, 5.28769),
-    },
-    Vertex {
-        position: (-59.1955, 20.7341, 5.28769),
-    },
-    Vertex {
-        position: (-70.7655, 19.6848, 5.28769),
-    },
-    Vertex {
-        position: (-77.8053, 16.8367, 5.28769),
-    },
-    Vertex {
-        position: (-80.1814, 11.2904, 5.28769),
-    },
-    Vertex {
-        position: (-42.2513, 23.0825, 3.68876),
-    },
-    Vertex {
-        position: (-60.0657, 22.8983, 3.68876),
-    },
-    Vertex {
-        position: (-72.8419, 21.6085, 3.68876),
-    },
-    Vertex {
-        position: (-80.5381, 18.1077, 3.68876),
-    },
-    Vertex {
-        position: (-83.1128, 11.2904, 3.68876),
-    },
-    Vertex {
-        position: (-41.8071, 24.0819, -1.10804),
-    },
-    Vertex {
-        position: (-60.4613, 23.882, -1.10804),
-    },
-    Vertex {
-        position: (-73.7857, 22.4829, -1.10804),
-    },
-    Vertex {
-        position: (-81.7804, 18.6855, -1.10804),
-    },
-    Vertex {
-        position: (-84.4453, 11.2904, -1.10804),
-    },
-    Vertex {
-        position: (-42.2513, 23.0825, -5.90483),
-    },
-    Vertex {
-        position: (-60.0657, 22.8983, -5.90483),
-    },
-    Vertex {
-        position: (-72.8419, 21.6085, -5.90483),
-    },
-    Vertex {
-        position: (-80.5381, 18.1077, -5.90483),
-    },
-    Vertex {
-        position: (-83.1128, 11.2904, -5.90483),
-    },
-    Vertex {
-        position: (-43.2284, 20.884, -7.50376),
-    },
-    Vertex {
-        position: (-59.1955, 20.7341, -7.50376),
-    },
-    Vertex {
-        position: (-70.7655, 19.6848, -7.50376),
-    },
-    Vertex {
-        position: (-77.8053, 16.8367, -7.50376),
-    },
-    Vertex {
-        position: (-80.1814, 11.2904, -7.50376),
-    },
-    Vertex {
-        position: (-44.2055, 18.6855, -5.90483),
-    },
-    Vertex {
-        position: (-58.3252, 18.5699, -5.90483),
-    },
-    Vertex {
-        position: (-68.6891, 17.7611, -5.90483),
-    },
-    Vertex {
-        position: (-75.0724, 15.5657, -5.90483),
-    },
-    Vertex {
-        position: (-77.2501, 11.2904, -5.90483),
-    },
-    Vertex {
-        position: (-74.8073, 5.4943, -1.10804),
-    },
-    Vertex {
-        position: (-71.2985, -1.50103, -1.10804),
-    },
-    Vertex {
-        position: (-65.1248, -8.49634, -1.10804),
-    },
-    Vertex {
-        position: (-56.0198, -14.2925, -1.10804),
-    },
-    Vertex {
-        position: (-76.0183, 4.93477, 3.68876),
-    },
-    Vertex {
-        position: (-72.159, -2.35462, 3.68876),
-    },
-    Vertex {
-        position: (-65.4267, -9.55033, 3.68876),
-    },
-    Vertex {
-        position: (-55.5757, -15.6249, 3.68876),
-    },
-    Vertex {
-        position: (-78.6824, 3.70383, 5.28769),
-    },
-    Vertex {
-        position: (-74.0522, -4.23253, 5.28769),
-    },
-    Vertex {
-        position: (-66.0909, -11.8691, 5.28769),
-    },
-    Vertex {
-        position: (-54.5986, -18.5563, 5.28769),
-    },
-    Vertex {
-        position: (-81.3466, 2.47288, 3.68876),
-    },
-    Vertex {
-        position: (-75.9454, -6.11044, 3.68876),
-    },
-    Vertex {
-        position: (-66.755, -14.1878, 3.68876),
-    },
-    Vertex {
-        position: (-53.6214, -21.4877, 3.68876),
-    },
-    Vertex {
-        position: (-82.5576, 1.91336, -1.10804),
-    },
-    Vertex {
-        position: (-76.8059, -6.96404, -1.10804),
-    },
-    Vertex {
-        position: (-67.0569, -15.2418, -1.10804),
-    },
-    Vertex {
-        position: (-53.1773, -22.8201, -1.10804),
-    },
-    Vertex {
-        position: (-81.3466, 2.47288, -5.90483),
-    },
-    Vertex {
-        position: (-75.9454, -6.11044, -5.90483),
-    },
-    Vertex {
-        position: (-66.755, -14.1878, -5.90483),
-    },
-    Vertex {
-        position: (-53.6214, -21.4877, -5.90483),
-    },
-    Vertex {
-        position: (-78.6824, 3.70383, -7.50376),
-    },
-    Vertex {
-        position: (-74.0522, -4.23253, -7.50376),
-    },
-    Vertex {
-        position: (-66.0909, -11.8691, -7.50376),
-    },
-    Vertex {
-        position: (-54.5986, -18.5563, -7.50376),
-    },
-    Vertex {
-        position: (-76.0183, 4.93477, -5.90483),
-    },
-    Vertex {
-        position: (-72.159, -2.35462, -5.90483),
-    },
-    Vertex {
-        position: (-65.4267, -9.55033, -5.90483),
-    },
-    Vertex {
-        position: (-55.5757, -15.6249, -5.90483),
-    },
-    Vertex {
-        position: (49.1543, 0.630882, -1.10804),
-    },
-    Vertex {
-        position: (62.7896, 3.76212, -1.10804),
-    },
-    Vertex {
-        position: (68.6967, 11.2904, -1.10804),
-    },
-    Vertex {
-        position: (71.939, 20.4176, -1.10804),
-    },
-    Vertex {
-        position: (77.5797, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (49.1543, -3.03333, 9.4449),
-    },
-    Vertex {
-        position: (63.8305, 1.04519, 8.42059),
-    },
-    Vertex {
-        position: (70.0292, 9.70814, 6.1671),
-    },
-    Vertex {
-        position: (73.5629, 19.8451, 3.91361),
-    },
-    Vertex {
-        position: (80.2446, 28.3457, 2.88929),
-    },
-    Vertex {
-        position: (49.1543, -11.0946, 12.9626),
-    },
-    Vertex {
-        position: (66.1207, -4.93206, 11.5968),
-    },
-    Vertex {
-        position: (72.9605, 6.22714, 8.59214),
-    },
-    Vertex {
-        position: (77.1355, 18.5855, 5.58749),
-    },
-    Vertex {
-        position: (86.1073, 28.3457, 4.22173),
-    },
-    Vertex {
-        position: (49.1543, -19.1559, 9.4449),
-    },
-    Vertex {
-        position: (68.4108, -10.9093, 8.42059),
-    },
-    Vertex {
-        position: (75.8919, 2.74614, 6.1671),
-    },
-    Vertex {
-        position: (80.7081, 17.326, 3.91361),
-    },
-    Vertex {
-        position: (91.97, 28.3457, 2.88929),
-    },
-    Vertex {
-        position: (49.1543, -22.8201, -1.10804),
-    },
-    Vertex {
-        position: (69.4518, -13.6262, -1.10804),
-    },
-    Vertex {
-        position: (77.2244, 1.16386, -1.10804),
-    },
-    Vertex {
-        position: (82.3321, 16.7534, -1.10804),
-    },
-    Vertex {
-        position: (94.6349, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (49.1543, -19.1559, -11.661),
-    },
-    Vertex {
-        position: (68.4108, -10.9093, -10.6367),
-    },
-    Vertex {
-        position: (75.8919, 2.74614, -8.38317),
-    },
-    Vertex {
-        position: (80.7081, 17.326, -6.12968),
-    },
-    Vertex {
-        position: (91.97, 28.3457, -5.10536),
-    },
-    Vertex {
-        position: (49.1543, -11.0946, -15.1786),
-    },
-    Vertex {
-        position: (66.1207, -4.93206, -13.8129),
-    },
-    Vertex {
-        position: (72.9605, 6.22714, -10.8082),
-    },
-    Vertex {
-        position: (77.1355, 18.5855, -7.80356),
-    },
-    Vertex {
-        position: (86.1073, 28.3457, -6.4378),
-    },
-    Vertex {
-        position: (49.1543, -3.03333, -11.661),
-    },
-    Vertex {
-        position: (63.8305, 1.04519, -10.6367),
-    },
-    Vertex {
-        position: (70.0292, 9.70814, -8.38317),
-    },
-    Vertex {
-        position: (73.5629, 19.8451, -6.12968),
-    },
-    Vertex {
-        position: (80.2446, 28.3457, -5.10536),
-    },
-    Vertex {
-        position: (79.6227, 29.5449, -1.10804),
-    },
-    Vertex {
-        position: (81.1329, 29.9446, -1.10804),
-    },
-    Vertex {
-        position: (81.577, 29.5449, -1.10804),
-    },
-    Vertex {
-        position: (80.4222, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (82.4767, 29.6034, 2.63946),
-    },
-    Vertex {
-        position: (83.8116, 30.0383, 2.08983),
-    },
-    Vertex {
-        position: (83.8515, 29.6268, 1.54019),
-    },
-    Vertex {
-        position: (82.1988, 28.3457, 1.29036),
-    },
-    Vertex {
-        position: (88.7555, 29.7322, 3.88862),
-    },
-    Vertex {
-        position: (89.7049, 30.2444, 3.15578),
-    },
-    Vertex {
-        position: (88.8555, 29.8072, 2.42294),
-    },
-    Vertex {
-        position: (86.1073, 28.3457, 2.08983),
-    },
-    Vertex {
-        position: (95.0343, 29.8611, 2.63946),
-    },
-    Vertex {
-        position: (95.5982, 30.4505, 2.08983),
-    },
-    Vertex {
-        position: (93.8594, 29.9875, 1.54019),
-    },
-    Vertex {
-        position: (90.0158, 28.3457, 1.29036),
-    },
-    Vertex {
-        position: (97.8883, 29.9196, -1.10804),
-    },
-    Vertex {
-        position: (98.2769, 30.5442, -1.10804),
-    },
-    Vertex {
-        position: (96.1339, 30.0695, -1.10804),
-    },
-    Vertex {
-        position: (91.7924, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (95.0343, 29.8611, -4.85553),
-    },
-    Vertex {
-        position: (95.5982, 30.4505, -4.3059),
-    },
-    Vertex {
-        position: (93.8594, 29.9875, -3.75626),
-    },
-    Vertex {
-        position: (90.0158, 28.3457, -3.50643),
-    },
-    Vertex {
-        position: (88.7555, 29.7322, -6.10469),
-    },
-    Vertex {
-        position: (89.7049, 30.2444, -5.37185),
-    },
-    Vertex {
-        position: (88.8555, 29.8072, -4.63901),
-    },
-    Vertex {
-        position: (86.1073, 28.3457, -4.3059),
-    },
-    Vertex {
-        position: (82.4767, 29.6034, -4.85553),
-    },
-    Vertex {
-        position: (83.8116, 30.0383, -4.3059),
-    },
-    Vertex {
-        position: (83.8515, 29.6268, -3.75626),
-    },
-    Vertex {
-        position: (82.1988, 28.3457, -3.50643),
-    },
-    Vertex {
-        position: (0.831025, 49.6647, -1.10804),
-    },
-    Vertex {
-        position: (10.5134, 48.2657, -1.10804),
-    },
-    Vertex {
-        position: (10.0693, 44.868, -1.10804),
-    },
-    Vertex {
-        position: (6.42728, 40.6708, -1.10804),
-    },
-    Vertex {
-        position: (6.51611, 36.8733, -1.10804),
-    },
-    Vertex {
-        position: (9.76642, 48.2657, 2.70243),
-    },
-    Vertex {
-        position: (9.35632, 44.868, 2.52698),
-    },
-    Vertex {
-        position: (5.9947, 40.6708, 1.09187),
-    },
-    Vertex {
-        position: (6.07552, 36.8733, 1.12336),
-    },
-    Vertex {
-        position: (7.71453, 48.2657, 5.77547),
-    },
-    Vertex {
-        position: (7.39819, 44.868, 5.45913),
-    },
-    Vertex {
-        position: (4.80736, 40.6708, 2.8683),
-    },
-    Vertex {
-        position: (4.86744, 36.8733, 2.92838),
-    },
-    Vertex {
-        position: (4.64149, 48.2657, 7.82736),
-    },
-    Vertex {
-        position: (4.46604, 44.868, 7.41726),
-    },
-    Vertex {
-        position: (3.03093, 40.6708, 4.05564),
-    },
-    Vertex {
-        position: (3.06242, 36.8733, 4.13646),
-    },
-    Vertex {
-        position: (0.831025, 48.2657, 8.57438),
-    },
-    Vertex {
-        position: (0.831025, 44.868, 8.13023),
-    },
-    Vertex {
-        position: (0.831025, 40.6708, 4.48822),
-    },
-    Vertex {
-        position: (0.831025, 36.8733, 4.57705),
-    },
-    Vertex {
-        position: (-2.97944, 48.2657, 7.82736),
-    },
-    Vertex {
-        position: (-2.80399, 44.868, 7.41726),
-    },
-    Vertex {
-        position: (-1.36888, 40.6708, 4.05564),
-    },
-    Vertex {
-        position: (-1.40037, 36.8733, 4.13646),
-    },
-    Vertex {
-        position: (-6.05248, 48.2657, 5.77547),
-    },
-    Vertex {
-        position: (-5.73614, 44.868, 5.45913),
-    },
-    Vertex {
-        position: (-3.14531, 40.6708, 2.8683),
-    },
-    Vertex {
-        position: (-3.20539, 36.8733, 2.92838),
-    },
-    Vertex {
-        position: (-8.10437, 48.2657, 2.70243),
-    },
-    Vertex {
-        position: (-7.69427, 44.868, 2.52698),
-    },
-    Vertex {
-        position: (-4.33265, 40.6708, 1.09187),
-    },
-    Vertex {
-        position: (-4.41347, 36.8733, 1.12336),
-    },
-    Vertex {
-        position: (-8.85139, 48.2657, -1.10804),
-    },
-    Vertex {
-        position: (-8.40724, 44.868, -1.10804),
-    },
-    Vertex {
-        position: (-4.76523, 40.6708, -1.10804),
-    },
-    Vertex {
-        position: (-4.85406, 36.8733, -1.10804),
-    },
-    Vertex {
-        position: (-8.10437, 48.2657, -4.9185),
-    },
-    Vertex {
-        position: (-7.69427, 44.868, -4.74305),
-    },
-    Vertex {
-        position: (-4.33265, 40.6708, -3.30794),
-    },
-    Vertex {
-        position: (-4.41347, 36.8733, -3.33943),
-    },
-    Vertex {
-        position: (-6.05248, 48.2657, -7.99154),
-    },
-    Vertex {
-        position: (-5.73614, 44.868, -7.6752),
-    },
-    Vertex {
-        position: (-3.14531, 40.6708, -5.08437),
-    },
-    Vertex {
-        position: (-3.20539, 36.8733, -5.14445),
-    },
-    Vertex {
-        position: (-2.97944, 48.2657, -10.0434),
-    },
-    Vertex {
-        position: (-2.80399, 44.868, -9.63333),
-    },
-    Vertex {
-        position: (-1.36888, 40.6708, -6.27171),
-    },
-    Vertex {
-        position: (-1.40037, 36.8733, -6.35253),
-    },
-    Vertex {
-        position: (0.831025, 48.2657, -10.7904),
-    },
-    Vertex {
-        position: (0.831025, 44.868, -10.3463),
-    },
-    Vertex {
-        position: (0.831025, 40.6708, -6.70429),
-    },
-    Vertex {
-        position: (0.831025, 36.8733, -6.79312),
-    },
-    Vertex {
-        position: (4.64149, 48.2657, -10.0434),
-    },
-    Vertex {
-        position: (4.46604, 44.868, -9.63333),
-    },
-    Vertex {
-        position: (3.03093, 40.6708, -6.27171),
-    },
-    Vertex {
-        position: (3.06242, 36.8733, -6.35253),
-    },
-    Vertex {
-        position: (7.71453, 48.2657, -7.99154),
-    },
-    Vertex {
-        position: (7.39819, 44.868, -7.6752),
-    },
-    Vertex {
-        position: (4.80736, 40.6708, -5.08437),
-    },
-    Vertex {
-        position: (4.86744, 36.8733, -5.14445),
-    },
-    Vertex {
-        position: (9.76642, 48.2657, -4.9185),
-    },
-    Vertex {
-        position: (9.35632, 44.868, -4.74305),
-    },
-    Vertex {
-        position: (5.9947, 40.6708, -3.30794),
-    },
-    Vertex {
-        position: (6.07552, 36.8733, -3.33943),
-    },
-    Vertex {
-        position: (13.8001, 34.3417, -1.10804),
-    },
-    Vertex {
-        position: (24.282, 32.6095, -1.10804),
-    },
-    Vertex {
-        position: (33.6979, 30.8773, -1.10804),
-    },
-    Vertex {
-        position: (37.7841, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (12.795, 34.3417, 3.98234),
-    },
-    Vertex {
-        position: (22.4646, 32.6095, 8.09647),
-    },
-    Vertex {
-        position: (31.1507, 30.8773, 11.7922),
-    },
-    Vertex {
-        position: (34.9202, 28.3457, 13.396),
-    },
-    Vertex {
-        position: (10.0391, 34.3417, 8.10003),
-    },
-    Vertex {
-        position: (17.4812, 32.6095, 15.5422),
-    },
-    Vertex {
-        position: (24.1665, 30.8773, 22.2275),
-    },
-    Vertex {
-        position: (27.0677, 28.3457, 25.1286),
-    },
-    Vertex {
-        position: (5.9214, 34.3417, 10.856),
-    },
-    Vertex {
-        position: (10.0355, 32.6095, 20.5255),
-    },
-    Vertex {
-        position: (13.7313, 30.8773, 29.2117),
-    },
-    Vertex {
-        position: (15.3351, 28.3457, 32.9812),
-    },
-    Vertex {
-        position: (0.831025, 34.3417, 11.8611),
-    },
-    Vertex {
-        position: (0.831025, 32.6095, 22.3429),
-    },
-    Vertex {
-        position: (0.831025, 30.8773, 31.7589),
-    },
-    Vertex {
-        position: (0.831025, 28.3457, 35.845),
-    },
-    Vertex {
-        position: (-4.25935, 34.3417, 10.856),
-    },
-    Vertex {
-        position: (-8.37348, 32.6095, 20.5255),
-    },
-    Vertex {
-        position: (-12.0692, 30.8773, 29.2117),
-    },
-    Vertex {
-        position: (-13.673, 28.3457, 32.9812),
-    },
-    Vertex {
-        position: (-8.37704, 34.3417, 8.10003),
-    },
-    Vertex {
-        position: (-15.8192, 32.6095, 15.5422),
-    },
-    Vertex {
-        position: (-22.5045, 30.8773, 22.2275),
-    },
-    Vertex {
-        position: (-25.4056, 28.3457, 25.1286),
-    },
-    Vertex {
-        position: (-11.133, 34.3417, 3.98234),
-    },
-    Vertex {
-        position: (-20.8025, 32.6095, 8.09647),
-    },
-    Vertex {
-        position: (-29.4887, 30.8773, 11.7922),
-    },
-    Vertex {
-        position: (-33.2582, 28.3457, 13.396),
-    },
-    Vertex {
-        position: (-12.1381, 34.3417, -1.10804),
-    },
-    Vertex {
-        position: (-22.62, 32.6095, -1.10804),
-    },
-    Vertex {
-        position: (-32.0359, 30.8773, -1.10804),
-    },
-    Vertex {
-        position: (-36.122, 28.3457, -1.10804),
-    },
-    Vertex {
-        position: (-11.133, 34.3417, -6.19841),
-    },
-    Vertex {
-        position: (-20.8025, 32.6095, -10.3125),
-    },
-    Vertex {
-        position: (-29.4887, 30.8773, -14.0083),
-    },
-    Vertex {
-        position: (-33.2582, 28.3457, -15.6121),
-    },
-    Vertex {
-        position: (-8.37704, 34.3417, -10.3161),
-    },
-    Vertex {
-        position: (-15.8192, 32.6095, -17.7582),
-    },
-    Vertex {
-        position: (-22.5045, 30.8773, -24.4435),
-    },
-    Vertex {
-        position: (-25.4056, 28.3457, -27.3447),
-    },
-    Vertex {
-        position: (-4.25935, 34.3417, -13.072),
-    },
-    Vertex {
-        position: (-8.37348, 32.6095, -22.7416),
-    },
-    Vertex {
-        position: (-12.0692, 30.8773, -31.4277),
-    },
-    Vertex {
-        position: (-13.673, 28.3457, -35.1972),
-    },
-    Vertex {
-        position: (0.831025, 34.3417, -14.0771),
-    },
-    Vertex {
-        position: (0.831025, 32.6095, -24.559),
-    },
-    Vertex {
-        position: (0.831025, 30.8773, -33.9749),
-    },
-    Vertex {
-        position: (0.831025, 28.3457, -38.0611),
-    },
-    Vertex {
-        position: (5.9214, 34.3417, -13.072),
-    },
-    Vertex {
-        position: (10.0355, 32.6095, -22.7416),
-    },
-    Vertex {
-        position: (13.7313, 30.8773, -31.4277),
-    },
-    Vertex {
-        position: (15.3351, 28.3457, -35.1972),
-    },
-    Vertex {
-        position: (10.0391, 34.3417, -10.3161),
-    },
-    Vertex {
-        position: (17.4812, 32.6095, -17.7582),
-    },
-    Vertex {
-        position: (24.1665, 30.8773, -24.4435),
-    },
-    Vertex {
-        position: (27.0677, 28.3457, -27.3447),
-    },
-    Vertex {
-        position: (12.795, 34.3417, -6.19841),
-    },
-    Vertex {
-        position: (22.4646, 32.6095, -10.3125),
-    },
-    Vertex {
-        position: (31.1507, 30.8773, -14.0083),
-    },
-    Vertex {
-        position: (34.9202, 28.3457, -15.6121),
-    },
-];
-
-pub const NORMALS: [Normal; 531] = [
-    Normal {
-        normal: (0.0, 0.0, 0.0),
-    }, // dummy vector because in the original model indices
-    // start at 1
-    Normal {
-        normal: (-0.966742, -0.255752, 0.0),
-    },
-    Normal {
-        normal: (-0.966824, 0.255443, 0.0),
-    },
-    Normal {
-        normal: (-0.092052, 0.995754, 0.0),
-    },
-    Normal {
-        normal: (0.68205, 0.731305, 0.0),
-    },
-    Normal {
-        normal: (0.870301, 0.492521, -0.0),
-    },
-    Normal {
-        normal: (-0.893014, -0.256345, -0.369882),
-    },
-    Normal {
-        normal: (-0.893437, 0.255997, -0.369102),
-    },
-    Normal {
-        normal: (-0.0838771, 0.995843, -0.0355068),
-    },
-    Normal {
-        normal: (0.629724, 0.73186, 0.260439),
-    },
-    Normal {
-        normal: (0.803725, 0.49337, 0.332584),
-    },
-    Normal {
-        normal: (-0.683407, -0.256729, -0.683407),
-    },
-    Normal {
-        normal: (-0.683531, 0.256067, -0.683531),
-    },
-    Normal {
-        normal: (-0.0649249, 0.995776, -0.0649248),
-    },
-    Normal {
-        normal: (0.481398, 0.732469, 0.481398),
-    },
-    Normal {
-        normal: (0.614804, 0.493997, 0.614804),
-    },
-    Normal {
-        normal: (-0.369882, -0.256345, -0.893014),
-    },
-    Normal {
-        normal: (-0.369102, 0.255997, -0.893437),
-    },
-    Normal {
-        normal: (-0.0355067, 0.995843, -0.0838772),
-    },
-    Normal {
-        normal: (0.260439, 0.73186, 0.629724),
-    },
-    Normal {
-        normal: (0.332584, 0.49337, 0.803725),
-    },
-    Normal {
-        normal: (-0.00284834, -0.257863, -0.966177),
-    },
-    Normal {
-        normal: (-0.00192311, 0.254736, -0.967009),
-    },
-    Normal {
-        normal: (-0.000266114, 0.995734, -0.0922702),
-    },
-    Normal {
-        normal: (0.0, 0.731295, 0.682061),
-    },
-    Normal {
-        normal: (0.0, 0.492521, 0.870301),
-    },
-    Normal {
-        normal: (0.379058, -0.3593, -0.852771),
-    },
-    Normal {
-        normal: (0.37711, 0.149086, -0.914091),
-    },
-    Normal {
-        normal: (0.0275022, 0.992081, -0.122551),
-    },
-    Normal {
-        normal: (-0.26101, 0.726762, 0.635367),
-    },
-    Normal {
-        normal: (-0.332485, 0.492546, 0.804271),
-    },
-    Normal {
-        normal: (0.663548, -0.410791, -0.625264),
-    },
-    Normal {
-        normal: (0.712664, 0.0737216, -0.697621),
-    },
-    Normal {
-        normal: (0.0997268, 0.987509, -0.121984),
-    },
-    Normal {
-        normal: (-0.48732, 0.723754, 0.488568),
-    },
-    Normal {
-        normal: (-0.615242, 0.492602, 0.615484),
-    },
-    Normal {
-        normal: (0.880028, -0.332908, -0.338709),
-    },
-    Normal {
-        normal: (0.917276, 0.167113, -0.361493),
-    },
-    Normal {
-        normal: (0.113584, 0.992365, -0.0480695),
-    },
-    Normal {
-        normal: (-0.63415, 0.727508, 0.261889),
-    },
-    Normal {
-        normal: (-0.804126, 0.492634, 0.332705),
-    },
-    Normal {
-        normal: (0.96669, -0.255738, 0.0104537),
-    },
-    Normal {
-        normal: (0.967442, 0.252962, 0.00810329),
-    },
-    Normal {
-        normal: (0.0934365, 0.995624, 0.00128063),
-    },
-    Normal {
-        normal: (-0.682167, 0.731196, -0.00034353),
-    },
-    Normal {
-        normal: (-0.870322, 0.492483, -0.0),
-    },
-    Normal {
-        normal: (0.893014, -0.256345, 0.369882),
-    },
-    Normal {
-        normal: (0.893437, 0.255997, 0.369102),
-    },
-    Normal {
-        normal: (0.0838768, 0.995843, 0.0355066),
-    },
-    Normal {
-        normal: (-0.629724, 0.73186, -0.260439),
-    },
-    Normal {
-        normal: (-0.803725, 0.49337, -0.332584),
-    },
-    Normal {
-        normal: (0.683407, -0.256729, 0.683407),
-    },
-    Normal {
-        normal: (0.683531, 0.256067, 0.683531),
-    },
-    Normal {
-        normal: (0.0649249, 0.995776, 0.0649249),
-    },
-    Normal {
-        normal: (-0.481398, 0.732469, -0.481398),
-    },
-    Normal {
-        normal: (-0.614804, 0.493997, -0.614804),
-    },
-    Normal {
-        normal: (0.369882, -0.256345, 0.893014),
-    },
-    Normal {
-        normal: (0.369102, 0.255997, 0.893437),
-    },
-    Normal {
-        normal: (0.0355067, 0.995843, 0.083877),
-    },
-    Normal {
-        normal: (-0.260439, 0.73186, -0.629724),
-    },
-    Normal {
-        normal: (-0.332584, 0.49337, -0.803725),
-    },
-    Normal {
-        normal: (0.0, -0.255752, 0.966742),
-    },
-    Normal {
-        normal: (0.0, 0.255443, 0.966824),
-    },
-    Normal {
-        normal: (0.0, 0.995754, 0.092052),
-    },
-    Normal {
-        normal: (0.0, 0.731305, -0.68205),
-    },
-    Normal {
-        normal: (-0.0, 0.492521, -0.870301),
-    },
-    Normal {
-        normal: (-0.369882, -0.256345, 0.893014),
-    },
-    Normal {
-        normal: (-0.369102, 0.255996, 0.893437),
-    },
-    Normal {
-        normal: (-0.0355068, 0.995843, 0.0838771),
-    },
-    Normal {
-        normal: (0.260439, 0.73186, -0.629724),
-    },
-    Normal {
-        normal: (0.332584, 0.49337, -0.803725),
-    },
-    Normal {
-        normal: (-0.683407, -0.256729, 0.683407),
-    },
-    Normal {
-        normal: (-0.683531, 0.256067, 0.683531),
-    },
-    Normal {
-        normal: (-0.0649249, 0.995776, 0.064925),
-    },
-    Normal {
-        normal: (0.481398, 0.732469, -0.481398),
-    },
-    Normal {
-        normal: (0.614804, 0.493997, -0.614804),
-    },
-    Normal {
-        normal: (-0.893014, -0.256345, 0.369882),
-    },
-    Normal {
-        normal: (-0.893437, 0.255997, 0.369102),
-    },
-    Normal {
-        normal: (-0.0838767, 0.995843, 0.0355066),
-    },
-    Normal {
-        normal: (0.629724, 0.73186, -0.260439),
-    },
-    Normal {
-        normal: (0.803725, 0.49337, -0.332584),
-    },
-    Normal {
-        normal: (0.915321, 0.402725, 0.0),
-    },
-    Normal {
-        normal: (0.941808, 0.336151, -0.0),
-    },
-    Normal {
-        normal: (0.97869, 0.205342, 0.0),
-    },
-    Normal {
-        normal: (0.997804, -0.0662397, 0.0),
-    },
-    Normal {
-        normal: (0.845438, 0.403546, 0.349835),
-    },
-    Normal {
-        normal: (0.869996, 0.336859, 0.360047),
-    },
-    Normal {
-        normal: (0.904193, 0.205791, 0.37428),
-    },
-    Normal {
-        normal: (0.921879, -0.0663697, 0.381752),
-    },
-    Normal {
-        normal: (0.646802, 0.404096, 0.646802),
-    },
-    Normal {
-        normal: (0.665655, 0.337351, 0.665655),
-    },
-    Normal {
-        normal: (0.691923, 0.20612, 0.691923),
-    },
-    Normal {
-        normal: (0.705542, -0.0664796, 0.705543),
-    },
-    Normal {
-        normal: (0.349835, 0.403546, 0.845438),
-    },
-    Normal {
-        normal: (0.360047, 0.336859, 0.869996),
-    },
-    Normal {
-        normal: (0.37428, 0.205791, 0.904193),
-    },
-    Normal {
-        normal: (0.381752, -0.0663697, 0.921879),
-    },
-    Normal {
-        normal: (-0.0, 0.402725, 0.915321),
-    },
-    Normal {
-        normal: (0.0, 0.336151, 0.941808),
-    },
-    Normal {
-        normal: (-0.0, 0.205342, 0.97869),
-    },
-    Normal {
-        normal: (-0.0, -0.0662397, 0.997804),
-    },
-    Normal {
-        normal: (-0.349835, 0.403546, 0.845438),
-    },
-    Normal {
-        normal: (-0.360047, 0.336859, 0.869996),
-    },
-    Normal {
-        normal: (-0.37428, 0.205791, 0.904193),
-    },
-    Normal {
-        normal: (-0.381752, -0.0663697, 0.921879),
-    },
-    Normal {
-        normal: (-0.646802, 0.404096, 0.646802),
-    },
-    Normal {
-        normal: (-0.665655, 0.337351, 0.665655),
-    },
-    Normal {
-        normal: (-0.691923, 0.20612, 0.691923),
-    },
-    Normal {
-        normal: (-0.705543, -0.0664796, 0.705543),
-    },
-    Normal {
-        normal: (-0.845438, 0.403546, 0.349835),
-    },
-    Normal {
-        normal: (-0.869996, 0.336859, 0.360047),
-    },
-    Normal {
-        normal: (-0.904193, 0.205791, 0.37428),
-    },
-    Normal {
-        normal: (-0.921879, -0.0663697, 0.381752),
-    },
-    Normal {
-        normal: (-0.915321, 0.402725, -0.0),
-    },
-    Normal {
-        normal: (-0.941808, 0.336151, -0.0),
-    },
-    Normal {
-        normal: (-0.97869, 0.205342, -0.0),
-    },
-    Normal {
-        normal: (-0.997804, -0.0662397, -0.0),
-    },
-    Normal {
-        normal: (-0.845438, 0.403546, -0.349835),
-    },
-    Normal {
-        normal: (-0.869996, 0.336859, -0.360047),
-    },
-    Normal {
-        normal: (-0.904193, 0.205791, -0.37428),
-    },
-    Normal {
-        normal: (-0.921879, -0.0663697, -0.381752),
-    },
-    Normal {
-        normal: (-0.646802, 0.404096, -0.646802),
-    },
-    Normal {
-        normal: (-0.665655, 0.337351, -0.665655),
-    },
-    Normal {
-        normal: (-0.691923, 0.20612, -0.691923),
-    },
-    Normal {
-        normal: (-0.705542, -0.0664796, -0.705543),
-    },
-    Normal {
-        normal: (-0.349835, 0.403546, -0.845438),
-    },
-    Normal {
-        normal: (-0.360047, 0.336859, -0.869996),
-    },
-    Normal {
-        normal: (-0.37428, 0.205791, -0.904193),
-    },
-    Normal {
-        normal: (-0.381752, -0.0663697, -0.921879),
-    },
-    Normal {
-        normal: (0.0, 0.402725, -0.915321),
-    },
-    Normal {
-        normal: (-0.0, 0.336151, -0.941808),
-    },
-    Normal {
-        normal: (0.0, 0.205342, -0.97869),
-    },
-    Normal {
-        normal: (0.0, -0.0662397, -0.997804),
-    },
-    Normal {
-        normal: (0.349835, 0.403546, -0.845438),
-    },
-    Normal {
-        normal: (0.360047, 0.336859, -0.869996),
-    },
-    Normal {
-        normal: (0.37428, 0.205791, -0.904193),
-    },
-    Normal {
-        normal: (0.381752, -0.0663697, -0.921879),
-    },
-    Normal {
-        normal: (0.646802, 0.404096, -0.646802),
-    },
-    Normal {
-        normal: (0.665655, 0.337351, -0.665655),
-    },
-    Normal {
-        normal: (0.691923, 0.20612, -0.691923),
-    },
-    Normal {
-        normal: (0.705543, -0.0664796, -0.705542),
-    },
-    Normal {
-        normal: (0.845438, 0.403546, -0.349835),
-    },
-    Normal {
-        normal: (0.869996, 0.336859, -0.360047),
-    },
-    Normal {
-        normal: (0.904193, 0.205791, -0.37428),
-    },
-    Normal {
-        normal: (0.921879, -0.0663697, -0.381752),
-    },
-    Normal {
-        normal: (0.900182, -0.435513, -0.0),
-    },
-    Normal {
-        normal: (0.729611, -0.683863, -0.0),
-    },
-    Normal {
-        normal: (0.693951, -0.720022, -0.0),
-    },
-    Normal {
-        normal: (0.79395, -0.607984, 0.0),
-    },
-    Normal {
-        normal: (0.831437, -0.43618, 0.344179),
-    },
-    Normal {
-        normal: (0.673512, -0.684665, 0.278594),
-    },
-    Normal {
-        normal: (0.640399, -0.720924, 0.264874),
-    },
-    Normal {
-        normal: (0.732949, -0.608996, 0.303166),
-    },
-    Normal {
-        normal: (0.636092, -0.436777, 0.636092),
-    },
-    Normal {
-        normal: (0.514965, -0.685289, 0.514965),
-    },
-    Normal {
-        normal: (0.489651, -0.721446, 0.489651),
-    },
-    Normal {
-        normal: (0.560555, -0.609554, 0.560555),
-    },
-    Normal {
-        normal: (0.344179, -0.43618, 0.831437),
-    },
-    Normal {
-        normal: (0.278594, -0.684665, 0.673512),
-    },
-    Normal {
-        normal: (0.264874, -0.720924, 0.640399),
-    },
-    Normal {
-        normal: (0.303166, -0.608996, 0.732949),
-    },
-    Normal {
-        normal: (0.0, -0.435513, 0.900182),
-    },
-    Normal {
-        normal: (-0.0, -0.683863, 0.729611),
-    },
-    Normal {
-        normal: (0.0, -0.720022, 0.693951),
-    },
-    Normal {
-        normal: (-0.0, -0.607984, 0.79395),
-    },
-    Normal {
-        normal: (-0.344179, -0.43618, 0.831437),
-    },
-    Normal {
-        normal: (-0.278594, -0.684665, 0.673512),
-    },
-    Normal {
-        normal: (-0.264874, -0.720924, 0.640399),
-    },
-    Normal {
-        normal: (-0.303166, -0.608996, 0.732949),
-    },
-    Normal {
-        normal: (-0.636092, -0.436777, 0.636092),
-    },
-    Normal {
-        normal: (-0.514965, -0.685289, 0.514965),
-    },
-    Normal {
-        normal: (-0.489651, -0.721446, 0.489651),
-    },
-    Normal {
-        normal: (-0.560555, -0.609554, 0.560555),
-    },
-    Normal {
-        normal: (-0.831437, -0.43618, 0.344179),
-    },
-    Normal {
-        normal: (-0.673512, -0.684665, 0.278595),
-    },
-    Normal {
-        normal: (-0.640399, -0.720924, 0.264874),
-    },
-    Normal {
-        normal: (-0.732949, -0.608996, 0.303166),
-    },
-    Normal {
-        normal: (-0.900182, -0.435513, -0.0),
-    },
-    Normal {
-        normal: (-0.729611, -0.683863, -0.0),
-    },
-    Normal {
-        normal: (-0.693951, -0.720022, 0.0),
-    },
-    Normal {
-        normal: (-0.79395, -0.607983, -0.0),
-    },
-    Normal {
-        normal: (-0.831437, -0.43618, -0.344179),
-    },
-    Normal {
-        normal: (-0.673512, -0.684665, -0.278594),
-    },
-    Normal {
-        normal: (-0.640399, -0.720924, -0.264874),
-    },
-    Normal {
-        normal: (-0.732949, -0.608996, -0.303166),
-    },
-    Normal {
-        normal: (-0.636092, -0.436777, -0.636092),
-    },
-    Normal {
-        normal: (-0.514965, -0.685289, -0.514965),
-    },
-    Normal {
-        normal: (-0.489651, -0.721446, -0.489651),
-    },
-    Normal {
-        normal: (-0.560555, -0.609554, -0.560555),
-    },
-    Normal {
-        normal: (-0.344179, -0.43618, -0.831437),
-    },
-    Normal {
-        normal: (-0.278594, -0.684665, -0.673512),
-    },
-    Normal {
-        normal: (-0.264874, -0.720924, -0.640399),
-    },
-    Normal {
-        normal: (-0.303166, -0.608996, -0.732949),
-    },
-    Normal {
-        normal: (-0.0, -0.435513, -0.900182),
-    },
-    Normal {
-        normal: (0.0, -0.683863, -0.729611),
-    },
-    Normal {
-        normal: (-0.0, -0.720022, -0.693951),
-    },
-    Normal {
-        normal: (0.0, -0.607984, -0.79395),
-    },
-    Normal {
-        normal: (0.344179, -0.43618, -0.831437),
-    },
-    Normal {
-        normal: (0.278594, -0.684665, -0.673512),
-    },
-    Normal {
-        normal: (0.264874, -0.720924, -0.640399),
-    },
-    Normal {
-        normal: (0.303167, -0.608996, -0.732949),
-    },
-    Normal {
-        normal: (0.636092, -0.436777, -0.636092),
-    },
-    Normal {
-        normal: (0.514965, -0.685289, -0.514965),
-    },
-    Normal {
-        normal: (0.489651, -0.721446, -0.489651),
-    },
-    Normal {
-        normal: (0.560555, -0.609554, -0.560555),
-    },
-    Normal {
-        normal: (0.831437, -0.43618, -0.344179),
-    },
-    Normal {
-        normal: (0.673512, -0.684665, -0.278595),
-    },
-    Normal {
-        normal: (0.640399, -0.720924, -0.264874),
-    },
-    Normal {
-        normal: (0.732949, -0.608996, -0.303166),
-    },
-    Normal {
-        normal: (0.62386, -0.781536, 0.0),
-    },
-    Normal {
-        normal: (0.177291, -0.984159, -0.0),
-    },
-    Normal {
-        normal: (0.0492072, -0.998789, 0.0),
-    },
-    Normal {
-        normal: (0.0, -1.0, -0.0),
-    },
-    Normal {
-        normal: (0.576229, -0.781801, 0.238217),
-    },
-    Normal {
-        normal: (0.163629, -0.984208, 0.0675273),
-    },
-    Normal {
-        normal: (0.0454217, -0.998792, 0.0187357),
-    },
-    Normal {
-        normal: (0.440416, -0.782348, 0.440416),
-    },
-    Normal {
-        normal: (0.124903, -0.984276, 0.124903),
-    },
-    Normal {
-        normal: (0.0346621, -0.998798, 0.0346621),
-    },
-    Normal {
-        normal: (0.238217, -0.781801, 0.576229),
-    },
-    Normal {
-        normal: (0.0675273, -0.984208, 0.163629),
-    },
-    Normal {
-        normal: (0.0187357, -0.998792, 0.0454217),
-    },
-    Normal {
-        normal: (-0.0, -0.781536, 0.62386),
-    },
-    Normal {
-        normal: (0.0, -0.984159, 0.177291),
-    },
-    Normal {
-        normal: (-0.0, -0.998789, 0.0492072),
-    },
-    Normal {
-        normal: (-0.238216, -0.781801, 0.576229),
-    },
-    Normal {
-        normal: (-0.0675273, -0.984208, 0.163629),
-    },
-    Normal {
-        normal: (-0.0187357, -0.998792, 0.0454217),
-    },
-    Normal {
-        normal: (-0.440416, -0.782348, 0.440416),
-    },
-    Normal {
-        normal: (-0.124903, -0.984276, 0.124903),
-    },
-    Normal {
-        normal: (-0.0346621, -0.998798, 0.0346621),
-    },
-    Normal {
-        normal: (-0.576229, -0.781801, 0.238217),
-    },
-    Normal {
-        normal: (-0.163629, -0.984208, 0.0675273),
-    },
-    Normal {
-        normal: (-0.0454217, -0.998792, 0.0187357),
-    },
-    Normal {
-        normal: (-0.62386, -0.781536, -0.0),
-    },
-    Normal {
-        normal: (-0.177291, -0.984159, 0.0),
-    },
-    Normal {
-        normal: (-0.0492072, -0.998789, -0.0),
-    },
-    Normal {
-        normal: (-0.576229, -0.781801, -0.238217),
-    },
-    Normal {
-        normal: (-0.163629, -0.984208, -0.0675273),
-    },
-    Normal {
-        normal: (-0.0454217, -0.998792, -0.0187357),
-    },
-    Normal {
-        normal: (-0.440416, -0.782348, -0.440416),
-    },
-    Normal {
-        normal: (-0.124903, -0.984276, -0.124903),
-    },
-    Normal {
-        normal: (-0.0346621, -0.998798, -0.0346621),
-    },
-    Normal {
-        normal: (-0.238217, -0.781801, -0.576229),
-    },
-    Normal {
-        normal: (-0.0675273, -0.984208, -0.163629),
-    },
-    Normal {
-        normal: (-0.0187357, -0.998792, -0.0454217),
-    },
-    Normal {
-        normal: (0.0, -0.781536, -0.62386),
-    },
-    Normal {
-        normal: (-0.0, -0.984159, -0.177291),
-    },
-    Normal {
-        normal: (0.0, -0.998789, -0.0492072),
-    },
-    Normal {
-        normal: (0.238217, -0.781801, -0.576229),
-    },
-    Normal {
-        normal: (0.0675273, -0.984208, -0.163629),
-    },
-    Normal {
-        normal: (0.0187357, -0.998792, -0.0454217),
-    },
-    Normal {
-        normal: (0.440416, -0.782348, -0.440416),
-    },
-    Normal {
-        normal: (0.124903, -0.984276, -0.124903),
-    },
-    Normal {
-        normal: (0.0346621, -0.998798, -0.0346621),
-    },
-    Normal {
-        normal: (0.576229, -0.781801, -0.238217),
-    },
-    Normal {
-        normal: (0.163629, -0.984208, -0.0675273),
-    },
-    Normal {
-        normal: (0.0454217, -0.998792, -0.0187357),
-    },
-    Normal {
-        normal: (0.00778619, -0.99997, -0.000215809),
-    },
-    Normal {
-        normal: (0.0391385, -0.999233, -0.000988567),
-    },
-    Normal {
-        normal: (0.179511, -0.983746, -0.00436856),
-    },
-    Normal {
-        normal: (0.6123, -0.790556, -0.0104598),
-    },
-    Normal {
-        normal: (0.986152, -0.165707, -0.00666949),
-    },
-    Normal {
-        normal: (0.00703893, -0.812495, 0.582926),
-    },
-    Normal {
-        normal: (0.0361273, -0.837257, 0.545614),
-    },
-    Normal {
-        normal: (0.161845, -0.810421, 0.563048),
-    },
-    Normal {
-        normal: (0.482365, -0.595148, 0.642746),
-    },
-    Normal {
-        normal: (0.73872, -0.114593, 0.664199),
-    },
-    Normal {
-        normal: (-0.00190867, 0.162121, 0.986769),
-    },
-    Normal {
-        normal: (0.0027616, 0.0171073, 0.99985),
-    },
-    Normal {
-        normal: (0.0105326, 0.0733989, 0.997247),
-    },
-    Normal {
-        normal: (-0.0660406, 0.130069, 0.989303),
-    },
-    Normal {
-        normal: (-0.0944272, 0.0165946, 0.995393),
-    },
-    Normal {
-        normal: (-0.009203, 0.871509, 0.490293),
-    },
-    Normal {
-        normal: (-0.0486064, 0.840609, 0.539457),
-    },
-    Normal {
-        normal: (-0.223298, 0.802881, 0.552739),
-    },
-    Normal {
-        normal: (-0.596365, 0.559971, 0.575135),
-    },
-    Normal {
-        normal: (-0.803337, 0.0682361, 0.591602),
-    },
-    Normal {
-        normal: (-0.0105609, 0.999944, 0.000103364),
-    },
-    Normal {
-        normal: (-0.0587986, 0.99827, 0.000709759),
-    },
-    Normal {
-        normal: (-0.28071, 0.959787, 0.00326876),
-    },
-    Normal {
-        normal: (-0.749723, 0.661738, 0.0042684),
-    },
-    Normal {
-        normal: (-0.997351, 0.0727144, 0.00205923),
-    },
-    Normal {
-        normal: (-0.00879197, 0.871493, -0.49033),
-    },
-    Normal {
-        normal: (-0.0464937, 0.841178, -0.538756),
-    },
-    Normal {
-        normal: (-0.217909, 0.806807, -0.549161),
-    },
-    Normal {
-        normal: (-0.597291, 0.560026, -0.574121),
-    },
-    Normal {
-        normal: (-0.804, 0.0629127, -0.591291),
-    },
-    Normal {
-        normal: (-0.00180555, 0.161691, -0.98684),
-    },
-    Normal {
-        normal: (0.00203087, 0.014555, -0.999892),
-    },
-    Normal {
-        normal: (0.00921499, 0.0600698, -0.998152),
-    },
-    Normal {
-        normal: (-0.0593333, 0.113865, -0.991723),
-    },
-    Normal {
-        normal: (-0.0868992, 0.0122903, -0.996141),
-    },
-    Normal {
-        normal: (0.00641779, -0.812379, -0.583094),
-    },
-    Normal {
-        normal: (0.0337833, -0.837512, -0.545373),
-    },
-    Normal {
-        normal: (0.157112, -0.811947, -0.56219),
-    },
-    Normal {
-        normal: (0.484407, -0.589365, -0.646528),
-    },
-    Normal {
-        normal: (0.73887, -0.10132, -0.666187),
-    },
-    Normal {
-        normal: (0.946512, 0.32265, -0.0033571),
-    },
-    Normal {
-        normal: (0.82583, 0.56387, -0.00745213),
-    },
-    Normal {
-        normal: (0.650011, 0.759893, -0.00693681),
-    },
-    Normal {
-        normal: (0.532429, 0.846458, -0.00524544),
-    },
-    Normal {
-        normal: (0.725608, 0.259351, 0.637362),
-    },
-    Normal {
-        normal: (0.645945, 0.461988, 0.607719),
-    },
-    Normal {
-        normal: (0.531614, 0.63666, 0.558615),
-    },
-    Normal {
-        normal: (0.424964, 0.681717, 0.59554),
-    },
-    Normal {
-        normal: (-0.0495616, -0.019755, 0.998576),
-    },
-    Normal {
-        normal: (-0.0378162, -0.0356243, 0.99865),
-    },
-    Normal {
-        normal: (-0.0379139, -0.0365122, 0.998614),
-    },
-    Normal {
-        normal: (-0.168854, -0.297946, 0.93953),
-    },
-    Normal {
-        normal: (-0.742342, -0.299166, 0.599523),
-    },
-    Normal {
-        normal: (-0.619602, -0.529406, 0.579503),
-    },
-    Normal {
-        normal: (-0.483708, -0.685761, 0.543837),
-    },
-    Normal {
-        normal: (-0.445293, -0.794355, 0.413176),
-    },
-    Normal {
-        normal: (-0.926513, -0.376257, 0.00199587),
-    },
-    Normal {
-        normal: (-0.75392, -0.656952, 0.00431723),
-    },
-    Normal {
-        normal: (-0.566224, -0.824244, 0.00346105),
-    },
-    Normal {
-        normal: (-0.481804, -0.876277, 0.00185047),
-    },
-    Normal {
-        normal: (-0.744675, -0.294424, -0.598977),
-    },
-    Normal {
-        normal: (-0.621949, -0.528114, -0.578165),
-    },
-    Normal {
-        normal: (-0.481171, -0.68834, -0.542828),
-    },
-    Normal {
-        normal: (-0.438055, -0.797035, -0.415744),
-    },
-    Normal {
-        normal: (-0.0443368, -0.0170558, -0.998871),
-    },
-    Normal {
-        normal: (-0.0261761, -0.0281665, -0.99926),
-    },
-    Normal {
-        normal: (-0.0252939, -0.0283323, -0.999278),
-    },
-    Normal {
-        normal: (-0.157482, -0.289392, -0.944167),
-    },
-    Normal {
-        normal: (0.728244, 0.25241, -0.637142),
-    },
-    Normal {
-        normal: (0.647055, 0.459725, -0.608254),
-    },
-    Normal {
-        normal: (0.522994, 0.640657, -0.562171),
-    },
-    Normal {
-        normal: (0.409978, 0.682857, -0.604669),
-    },
-    Normal {
-        normal: (-0.230787, 0.972982, -0.00652338),
-    },
-    Normal {
-        normal: (-0.548936, 0.835863, -0.00151111),
-    },
-    Normal {
-        normal: (-0.875671, 0.482807, 0.00989278),
-    },
-    Normal {
-        normal: (-0.877554, 0.479097, 0.0190923),
-    },
-    Normal {
-        normal: (-0.69619, 0.717439, 0.024497),
-    },
-    Normal {
-        normal: (-0.152878, 0.687211, 0.71019),
-    },
-    Normal {
-        normal: (-0.316721, 0.63775, 0.702113),
-    },
-    Normal {
-        normal: (-0.601067, 0.471452, 0.64533),
-    },
-    Normal {
-        normal: (-0.635889, 0.44609, 0.6298),
-    },
-    Normal {
-        normal: (-0.435746, 0.601008, 0.670011),
-    },
-    Normal {
-        normal: (0.111112, -0.0850694, 0.99016),
-    },
-    Normal {
-        normal: (0.22331, 0.00654036, 0.974726),
-    },
-    Normal {
-        normal: (0.190097, 0.154964, 0.969458),
-    },
-    Normal {
-        normal: (0.00527077, 0.189482, 0.98187),
-    },
-    Normal {
-        normal: (-0.0117518, 0.246688, 0.969024),
-    },
-    Normal {
-        normal: (0.343906, -0.722796, 0.599412),
-    },
-    Normal {
-        normal: (0.572489, -0.567656, 0.591627),
-    },
-    Normal {
-        normal: (0.787436, -0.256459, 0.560512),
-    },
-    Normal {
-        normal: (0.647097, -0.306374, 0.698141),
-    },
-    Normal {
-        normal: (0.427528, -0.499343, 0.753576),
-    },
-    Normal {
-        normal: (0.410926, -0.911668, 0.00128446),
-    },
-    Normal {
-        normal: (0.67152, -0.740986, -0.000899122),
-    },
-    Normal {
-        normal: (0.922026, -0.38706, -0.00725269),
-    },
-    Normal {
-        normal: (0.84691, -0.531556, -0.0138542),
-    },
-    Normal {
-        normal: (0.535925, -0.8442, -0.0105045),
-    },
-    Normal {
-        normal: (0.341188, -0.722822, -0.600931),
-    },
-    Normal {
-        normal: (0.578664, -0.561139, -0.591838),
-    },
-    Normal {
-        normal: (0.784869, -0.25102, -0.566542),
-    },
-    Normal {
-        normal: (0.642681, -0.302257, -0.70399),
-    },
-    Normal {
-        normal: (0.418589, -0.500042, -0.758117),
-    },
-    Normal {
-        normal: (0.115806, -0.0791394, -0.990114),
-    },
-    Normal {
-        normal: (0.232811, 0.0125652, -0.972441),
-    },
-    Normal {
-        normal: (0.206662, 0.153601, -0.96628),
-    },
-    Normal {
-        normal: (0.0244996, 0.161443, -0.986578),
-    },
-    Normal {
-        normal: (0.00338193, 0.211115, -0.977455),
-    },
-    Normal {
-        normal: (-0.134912, 0.687491, -0.713551),
-    },
-    Normal {
-        normal: (-0.31954, 0.633073, -0.705062),
-    },
-    Normal {
-        normal: (-0.603902, 0.461442, -0.649903),
-    },
-    Normal {
-        normal: (-0.631816, 0.437169, -0.640072),
-    },
-    Normal {
-        normal: (-0.424306, 0.612706, -0.66675),
-    },
-    Normal {
-        normal: (-0.4258, 0.904753, 0.0108049),
-    },
-    Normal {
-        normal: (0.0220472, 0.999756, 0.00162273),
-    },
-    Normal {
-        normal: (0.999599, 0.0258705, 0.0115556),
-    },
-    Normal {
-        normal: (0.709585, -0.704553, 0.00967183),
-    },
-    Normal {
-        normal: (-0.259858, 0.791936, 0.552549),
-    },
-    Normal {
-        normal: (0.00953916, 0.99972, -0.0216718),
-    },
-    Normal {
-        normal: (0.410156, 0.332912, -0.849083),
-    },
-    Normal {
-        normal: (0.541523, -0.54862, -0.637),
-    },
-    Normal {
-        normal: (0.0463104, 0.455224, 0.889172),
-    },
-    Normal {
-        normal: (-0.0106883, 0.988794, 0.148901),
-    },
-    Normal {
-        normal: (-0.0443756, 0.682947, -0.729118),
-    },
-    Normal {
-        normal: (0.122825, 0.00923214, -0.992385),
-    },
-    Normal {
-        normal: (0.481839, -0.180439, 0.85748),
-    },
-    Normal {
-        normal: (0.455272, 0.736752, 0.499925),
-    },
-    Normal {
-        normal: (-0.220542, 0.907193, -0.358276),
-    },
-    Normal {
-        normal: (-0.23592, 0.657249, -0.715797),
-    },
-    Normal {
-        normal: (0.728092, -0.685302, -0.0155853),
-    },
-    Normal {
-        normal: (0.888739, 0.45811, -0.0166791),
-    },
-    Normal {
-        normal: (-0.260097, 0.965582, 0.000800195),
-    },
-    Normal {
-        normal: (-0.371612, 0.928378, -0.00441745),
-    },
-    Normal {
-        normal: (0.480166, -0.17836, -0.858853),
-    },
-    Normal {
-        normal: (0.488103, 0.716801, -0.497947),
-    },
-    Normal {
-        normal: (-0.222004, 0.905399, 0.361893),
-    },
-    Normal {
-        normal: (-0.235405, 0.66318, 0.710477),
-    },
-    Normal {
-        normal: (0.0587203, 0.437704, -0.8972),
-    },
-    Normal {
-        normal: (0.00132612, 0.986459, -0.164003),
-    },
-    Normal {
-        normal: (-0.0441901, 0.681677, 0.730317),
-    },
-    Normal {
-        normal: (0.138801, -0.0341896, 0.98973),
-    },
-    Normal {
-        normal: (-0.25889, 0.797206, -0.54538),
-    },
-    Normal {
-        normal: (0.0122703, 0.999739, 0.0192865),
-    },
-    Normal {
-        normal: (0.39863, 0.35489, 0.845663),
-    },
-    Normal {
-        normal: (0.537564, -0.5814, 0.610737),
-    },
-    Normal {
-        normal: (-0.0, 1.0, 0.0),
-    },
-    Normal {
-        normal: (0.82454, 0.565804, 0.0),
-    },
-    Normal {
-        normal: (0.917701, -0.397272, 0.0),
-    },
-    Normal {
-        normal: (0.935269, -0.353939, 0.000112842),
-    },
-    Normal {
-        normal: (0.780712, 0.624891, 0.0),
-    },
-    Normal {
-        normal: (0.762641, 0.565035, 0.314825),
-    },
-    Normal {
-        normal: (0.847982, -0.397998, 0.350034),
-    },
-    Normal {
-        normal: (0.864141, -0.355261, 0.356441),
-    },
-    Normal {
-        normal: (0.720991, 0.625625, 0.297933),
-    },
-    Normal {
-        normal: (0.583357, 0.565165, 0.583338),
-    },
-    Normal {
-        normal: (0.648485, -0.398726, 0.648448),
-    },
-    Normal {
-        normal: (0.660872, -0.355894, 0.660748),
-    },
-    Normal {
-        normal: (0.551862, 0.62529, 0.55178),
-    },
-    Normal {
-        normal: (0.314824, 0.565051, 0.762629),
-    },
-    Normal {
-        normal: (0.350045, -0.397976, 0.847988),
-    },
-    Normal {
-        normal: (0.356474, -0.3552, 0.864153),
-    },
-    Normal {
-        normal: (0.297983, 0.625515, 0.721067),
-    },
-    Normal {
-        normal: (-0.0, 0.565804, 0.82454),
-    },
-    Normal {
-        normal: (-0.0, -0.397272, 0.917701),
-    },
-    Normal {
-        normal: (-0.000112839, -0.353939, 0.935269),
-    },
-    Normal {
-        normal: (-0.0, 0.624891, 0.780712),
-    },
-    Normal {
-        normal: (-0.314825, 0.565035, 0.762641),
-    },
-    Normal {
-        normal: (-0.350034, -0.397998, 0.847982),
-    },
-    Normal {
-        normal: (-0.356441, -0.355261, 0.864141),
-    },
-    Normal {
-        normal: (-0.297933, 0.625625, 0.720991),
-    },
-    Normal {
-        normal: (-0.583338, 0.565165, 0.583357),
-    },
-    Normal {
-        normal: (-0.648448, -0.398726, 0.648485),
-    },
-    Normal {
-        normal: (-0.660748, -0.355894, 0.660872),
-    },
-    Normal {
-        normal: (-0.55178, 0.62529, 0.551862),
-    },
-    Normal {
-        normal: (-0.762629, 0.565051, 0.314824),
-    },
-    Normal {
-        normal: (-0.847988, -0.397976, 0.350045),
-    },
-    Normal {
-        normal: (-0.864153, -0.3552, 0.356474),
-    },
-    Normal {
-        normal: (-0.721067, 0.625515, 0.297983),
-    },
-    Normal {
-        normal: (-0.82454, 0.565804, -0.0),
-    },
-    Normal {
-        normal: (-0.917701, -0.397272, -0.0),
-    },
-    Normal {
-        normal: (-0.935269, -0.353939, -0.000112839),
-    },
-    Normal {
-        normal: (-0.780712, 0.624891, -0.0),
-    },
-    Normal {
-        normal: (-0.76264, 0.565035, -0.314825),
-    },
-    Normal {
-        normal: (-0.847982, -0.397998, -0.350034),
-    },
-    Normal {
-        normal: (-0.864141, -0.355261, -0.356441),
-    },
-    Normal {
-        normal: (-0.720991, 0.625625, -0.297933),
-    },
-    Normal {
-        normal: (-0.583357, 0.565165, -0.583338),
-    },
-    Normal {
-        normal: (-0.648485, -0.398726, -0.648448),
-    },
-    Normal {
-        normal: (-0.660872, -0.355894, -0.660748),
-    },
-    Normal {
-        normal: (-0.551862, 0.62529, -0.55178),
-    },
-    Normal {
-        normal: (-0.314824, 0.565051, -0.762629),
-    },
-    Normal {
-        normal: (-0.350045, -0.397976, -0.847988),
-    },
-    Normal {
-        normal: (-0.356474, -0.3552, -0.864153),
-    },
-    Normal {
-        normal: (-0.297983, 0.625515, -0.721067),
-    },
-    Normal {
-        normal: (0.0, 0.565804, -0.82454),
-    },
-    Normal {
-        normal: (0.0, -0.397272, -0.917701),
-    },
-    Normal {
-        normal: (0.000112839, -0.353939, -0.935269),
-    },
-    Normal {
-        normal: (0.0, 0.624891, -0.780712),
-    },
-    Normal {
-        normal: (0.314825, 0.565035, -0.762641),
-    },
-    Normal {
-        normal: (0.350034, -0.397998, -0.847982),
-    },
-    Normal {
-        normal: (0.356441, -0.355261, -0.864141),
-    },
-    Normal {
-        normal: (0.297933, 0.625625, -0.720991),
-    },
-    Normal {
-        normal: (0.583338, 0.565165, -0.583357),
-    },
-    Normal {
-        normal: (0.648448, -0.398726, -0.648485),
-    },
-    Normal {
-        normal: (0.660748, -0.355894, -0.660872),
-    },
-    Normal {
-        normal: (0.55178, 0.62529, -0.551862),
-    },
-    Normal {
-        normal: (0.762629, 0.565051, -0.314824),
-    },
-    Normal {
-        normal: (0.847988, -0.397976, -0.350045),
-    },
-    Normal {
-        normal: (0.864153, -0.3552, -0.356474),
-    },
-    Normal {
-        normal: (0.721067, 0.625515, -0.297983),
-    },
-    Normal {
-        normal: (0.236584, 0.971611, 0.0),
-    },
-    Normal {
-        normal: (0.173084, 0.984907, -0.0),
-    },
-    Normal {
-        normal: (0.379703, 0.925108, 0.0),
-    },
-    Normal {
-        normal: (0.526673, 0.850068, 0.0),
-    },
-    Normal {
-        normal: (0.217978, 0.971775, 0.0902162),
-    },
-    Normal {
-        normal: (0.15959, 0.984977, 0.0659615),
-    },
-    Normal {
-        normal: (0.350498, 0.925312, 0.14474),
-    },
-    Normal {
-        normal: (0.48559, 0.850653, 0.201474),
-    },
-    Normal {
-        normal: (0.166631, 0.971838, 0.166631),
-    },
-    Normal {
-        normal: (0.121908, 0.985026, 0.121908),
-    },
-    Normal {
-        normal: (0.267668, 0.925585, 0.267668),
-    },
-    Normal {
-        normal: (0.371315, 0.851029, 0.371315),
-    },
-    Normal {
-        normal: (0.0902162, 0.971775, 0.217978),
-    },
-    Normal {
-        normal: (0.0659615, 0.984977, 0.15959),
-    },
-    Normal {
-        normal: (0.14474, 0.925312, 0.350498),
-    },
-    Normal {
-        normal: (0.201474, 0.850653, 0.48559),
-    },
-    Normal {
-        normal: (-0.0, 0.971611, 0.236584),
-    },
-    Normal {
-        normal: (0.0, 0.984907, 0.173084),
-    },
-    Normal {
-        normal: (0.0, 0.925108, 0.379703),
-    },
-    Normal {
-        normal: (0.0, 0.850068, 0.526673),
-    },
-    Normal {
-        normal: (-0.0902162, 0.971775, 0.217978),
-    },
-    Normal {
-        normal: (-0.0659615, 0.984977, 0.15959),
-    },
-    Normal {
-        normal: (-0.14474, 0.925312, 0.350498),
-    },
-    Normal {
-        normal: (-0.201474, 0.850653, 0.48559),
-    },
-    Normal {
-        normal: (-0.166631, 0.971838, 0.166631),
-    },
-    Normal {
-        normal: (-0.121908, 0.985026, 0.121908),
-    },
-    Normal {
-        normal: (-0.267668, 0.925585, 0.267668),
-    },
-    Normal {
-        normal: (-0.371315, 0.851029, 0.371315),
-    },
-    Normal {
-        normal: (-0.217978, 0.971775, 0.0902162),
-    },
-    Normal {
-        normal: (-0.15959, 0.984977, 0.0659615),
-    },
-    Normal {
-        normal: (-0.350498, 0.925312, 0.14474),
-    },
-    Normal {
-        normal: (-0.48559, 0.850653, 0.201474),
-    },
-    Normal {
-        normal: (-0.236583, 0.971611, -0.0),
-    },
-    Normal {
-        normal: (-0.173084, 0.984907, 0.0),
-    },
-    Normal {
-        normal: (-0.379703, 0.925108, -0.0),
-    },
-    Normal {
-        normal: (-0.526673, 0.850068, 0.0),
-    },
-    Normal {
-        normal: (-0.217978, 0.971775, -0.0902162),
-    },
-    Normal {
-        normal: (-0.15959, 0.984977, -0.0659615),
-    },
-    Normal {
-        normal: (-0.350498, 0.925312, -0.14474),
-    },
-    Normal {
-        normal: (-0.48559, 0.850653, -0.201474),
-    },
-    Normal {
-        normal: (-0.166631, 0.971838, -0.166631),
-    },
-    Normal {
-        normal: (-0.121908, 0.985026, -0.121908),
-    },
-    Normal {
-        normal: (-0.267668, 0.925585, -0.267668),
-    },
-    Normal {
-        normal: (-0.371315, 0.851029, -0.371315),
-    },
-    Normal {
-        normal: (-0.0902162, 0.971775, -0.217978),
-    },
-    Normal {
-        normal: (-0.0659615, 0.984977, -0.15959),
-    },
-    Normal {
-        normal: (-0.14474, 0.925312, -0.350498),
-    },
-    Normal {
-        normal: (-0.201474, 0.850653, -0.485589),
-    },
-    Normal {
-        normal: (0.0, 0.971611, -0.236584),
-    },
-    Normal {
-        normal: (-0.0, 0.984907, -0.173084),
-    },
-    Normal {
-        normal: (-0.0, 0.925108, -0.379703),
-    },
-    Normal {
-        normal: (-0.0, 0.850068, -0.526673),
-    },
-    Normal {
-        normal: (0.0902162, 0.971775, -0.217978),
-    },
-    Normal {
-        normal: (0.0659615, 0.984977, -0.15959),
-    },
-    Normal {
-        normal: (0.14474, 0.925312, -0.350498),
-    },
-    Normal {
-        normal: (0.201474, 0.850653, -0.48559),
-    },
-    Normal {
-        normal: (0.166631, 0.971838, -0.166631),
-    },
-    Normal {
-        normal: (0.121908, 0.985026, -0.121908),
-    },
-    Normal {
-        normal: (0.267668, 0.925585, -0.267668),
-    },
-    Normal {
-        normal: (0.371315, 0.851029, -0.371315),
-    },
-    Normal {
-        normal: (0.217978, 0.971775, -0.0902162),
-    },
-    Normal {
-        normal: (0.15959, 0.984977, -0.0659615),
-    },
-    Normal {
-        normal: (0.350498, 0.925312, -0.14474),
-    },
-    Normal {
-        normal: (0.48559, 0.850653, -0.201474),
-    },
-];
-
-pub const INDICES: [u16; 3072] = [
-    7, 6, 1, 1, 2, 7, 8, 7, 2, 2, 3, 8, 9, 8, 3, 3, 4, 9, 10, 9, 4, 4, 5, 10, 12, 11, 6, 6, 7, 12,
-    13, 12, 7, 7, 8, 13, 14, 13, 8, 8, 9, 14, 15, 14, 9, 9, 10, 15, 17, 16, 11, 11, 12, 17, 18, 17,
-    12, 12, 13, 18, 19, 18, 13, 13, 14, 19, 20, 19, 14, 14, 15, 20, 22, 21, 16, 16, 17, 22, 23, 22,
-    17, 17, 18, 23, 24, 23, 18, 18, 19, 24, 25, 24, 19, 19, 20, 25, 27, 26, 21, 21, 22, 27, 28, 27,
-    22, 22, 23, 28, 29, 28, 23, 23, 24, 29, 30, 29, 24, 24, 25, 30, 32, 31, 26, 26, 27, 32, 33, 32,
-    27, 27, 28, 33, 34, 33, 28, 28, 29, 34, 35, 34, 29, 29, 30, 35, 37, 36, 31, 31, 32, 37, 38, 37,
-    32, 32, 33, 38, 39, 38, 33, 33, 34, 39, 40, 39, 34, 34, 35, 40, 42, 41, 36, 36, 37, 42, 43, 42,
-    37, 37, 38, 43, 44, 43, 38, 38, 39, 44, 45, 44, 39, 39, 40, 45, 47, 46, 41, 41, 42, 47, 48, 47,
-    42, 42, 43, 48, 49, 48, 43, 43, 44, 49, 50, 49, 44, 44, 45, 50, 52, 51, 46, 46, 47, 52, 53, 52,
-    47, 47, 48, 53, 54, 53, 48, 48, 49, 54, 55, 54, 49, 49, 50, 55, 57, 56, 51, 51, 52, 57, 58, 57,
-    52, 52, 53, 58, 59, 58, 53, 53, 54, 59, 60, 59, 54, 54, 55, 60, 62, 61, 56, 56, 57, 62, 63, 62,
-    57, 57, 58, 63, 64, 63, 58, 58, 59, 64, 65, 64, 59, 59, 60, 65, 67, 66, 61, 61, 62, 67, 68, 67,
-    62, 62, 63, 68, 69, 68, 63, 63, 64, 69, 70, 69, 64, 64, 65, 70, 72, 71, 66, 66, 67, 72, 73, 72,
-    67, 67, 68, 73, 74, 73, 68, 68, 69, 74, 75, 74, 69, 69, 70, 75, 77, 76, 71, 71, 72, 77, 78, 77,
-    72, 72, 73, 78, 79, 78, 73, 73, 74, 79, 80, 79, 74, 74, 75, 80, 2, 1, 76, 76, 77, 2, 3, 2, 77,
-    77, 78, 3, 4, 3, 78, 78, 79, 4, 5, 4, 79, 79, 80, 5, 85, 10, 5, 5, 81, 85, 86, 85, 81, 81, 82,
-    86, 87, 86, 82, 82, 83, 87, 88, 87, 83, 83, 84, 88, 89, 15, 10, 10, 85, 89, 90, 89, 85, 85, 86,
-    90, 91, 90, 86, 86, 87, 91, 92, 91, 87, 87, 88, 92, 93, 20, 15, 15, 89, 93, 94, 93, 89, 89, 90,
-    94, 95, 94, 90, 90, 91, 95, 96, 95, 91, 91, 92, 96, 97, 25, 20, 20, 93, 97, 98, 97, 93, 93, 94,
-    98, 99, 98, 94, 94, 95, 99, 100, 99, 95, 95, 96, 100, 101, 30, 25, 25, 97, 101, 102, 101, 97,
-    97, 98, 102, 103, 102, 98, 98, 99, 103, 104, 103, 99, 99, 100, 104, 105, 35, 30, 30, 101, 105,
-    106, 105, 101, 101, 102, 106, 107, 106, 102, 102, 103, 107, 108, 107, 103, 103, 104, 108, 109,
-    40, 35, 35, 105, 109, 110, 109, 105, 105, 106, 110, 111, 110, 106, 106, 107, 111, 112, 111,
-    107, 107, 108, 112, 113, 45, 40, 40, 109, 113, 114, 113, 109, 109, 110, 114, 115, 114, 110,
-    110, 111, 115, 116, 115, 111, 111, 112, 116, 117, 50, 45, 45, 113, 117, 118, 117, 113, 113,
-    114, 118, 119, 118, 114, 114, 115, 119, 120, 119, 115, 115, 116, 120, 121, 55, 50, 50, 117,
-    121, 122, 121, 117, 117, 118, 122, 123, 122, 118, 118, 119, 123, 124, 123, 119, 119, 120, 124,
-    125, 60, 55, 55, 121, 125, 126, 125, 121, 121, 122, 126, 127, 126, 122, 122, 123, 127, 128,
-    127, 123, 123, 124, 128, 129, 65, 60, 60, 125, 129, 130, 129, 125, 125, 126, 130, 131, 130,
-    126, 126, 127, 131, 132, 131, 127, 127, 128, 132, 133, 70, 65, 65, 129, 133, 134, 133, 129,
-    129, 130, 134, 135, 134, 130, 130, 131, 135, 136, 135, 131, 131, 132, 136, 137, 75, 70, 70,
-    133, 137, 138, 137, 133, 133, 134, 138, 139, 138, 134, 134, 135, 139, 140, 139, 135, 135, 136,
-    140, 141, 80, 75, 75, 137, 141, 142, 141, 137, 137, 138, 142, 143, 142, 138, 138, 139, 143,
-    144, 143, 139, 139, 140, 144, 81, 5, 80, 80, 141, 81, 82, 81, 141, 141, 142, 82, 83, 82, 142,
-    142, 143, 83, 84, 83, 143, 143, 144, 84, 149, 88, 84, 84, 145, 149, 150, 149, 145, 145, 146,
-    150, 151, 150, 146, 146, 147, 151, 152, 151, 147, 147, 148, 152, 153, 92, 88, 88, 149, 153,
-    154, 153, 149, 149, 150, 154, 155, 154, 150, 150, 151, 155, 156, 155, 151, 151, 152, 156, 157,
-    96, 92, 92, 153, 157, 158, 157, 153, 153, 154, 158, 159, 158, 154, 154, 155, 159, 160, 159,
-    155, 155, 156, 160, 161, 100, 96, 96, 157, 161, 162, 161, 157, 157, 158, 162, 163, 162, 158,
-    158, 159, 163, 164, 163, 159, 159, 160, 164, 165, 104, 100, 100, 161, 165, 166, 165, 161, 161,
-    162, 166, 167, 166, 162, 162, 163, 167, 168, 167, 163, 163, 164, 168, 169, 108, 104, 104, 165,
-    169, 170, 169, 165, 165, 166, 170, 171, 170, 166, 166, 167, 171, 172, 171, 167, 167, 168, 172,
-    173, 112, 108, 108, 169, 173, 174, 173, 169, 169, 170, 174, 175, 174, 170, 170, 171, 175, 176,
-    175, 171, 171, 172, 176, 177, 116, 112, 112, 173, 177, 178, 177, 173, 173, 174, 178, 179, 178,
-    174, 174, 175, 179, 180, 179, 175, 175, 176, 180, 181, 120, 116, 116, 177, 181, 182, 181, 177,
-    177, 178, 182, 183, 182, 178, 178, 179, 183, 184, 183, 179, 179, 180, 184, 185, 124, 120, 120,
-    181, 185, 186, 185, 181, 181, 182, 186, 187, 186, 182, 182, 183, 187, 188, 187, 183, 183, 184,
-    188, 189, 128, 124, 124, 185, 189, 190, 189, 185, 185, 186, 190, 191, 190, 186, 186, 187, 191,
-    192, 191, 187, 187, 188, 192, 193, 132, 128, 128, 189, 193, 194, 193, 189, 189, 190, 194, 195,
-    194, 190, 190, 191, 195, 196, 195, 191, 191, 192, 196, 197, 136, 132, 132, 193, 197, 198, 197,
-    193, 193, 194, 198, 199, 198, 194, 194, 195, 199, 200, 199, 195, 195, 196, 200, 201, 140, 136,
-    136, 197, 201, 202, 201, 197, 197, 198, 202, 203, 202, 198, 198, 199, 203, 204, 203, 199, 199,
-    200, 204, 205, 144, 140, 140, 201, 205, 206, 205, 201, 201, 202, 206, 207, 206, 202, 202, 203,
-    207, 208, 207, 203, 203, 204, 208, 145, 84, 144, 144, 205, 145, 146, 145, 205, 205, 206, 146,
-    147, 146, 206, 206, 207, 147, 148, 147, 207, 207, 208, 148, 213, 152, 148, 148, 209, 213, 214,
-    213, 209, 209, 210, 214, 215, 214, 210, 210, 211, 215, 212, 215, 211, 211, 212, 212, 216, 156,
-    152, 152, 213, 216, 217, 216, 213, 213, 214, 217, 218, 217, 214, 214, 215, 218, 212, 218, 215,
-    215, 212, 212, 219, 160, 156, 156, 216, 219, 220, 219, 216, 216, 217, 220, 221, 220, 217, 217,
-    218, 221, 212, 221, 218, 218, 212, 212, 222, 164, 160, 160, 219, 222, 223, 222, 219, 219, 220,
-    223, 224, 223, 220, 220, 221, 224, 212, 224, 221, 221, 212, 212, 225, 168, 164, 164, 222, 225,
-    226, 225, 222, 222, 223, 226, 227, 226, 223, 223, 224, 227, 212, 227, 224, 224, 212, 212, 228,
-    172, 168, 168, 225, 228, 229, 228, 225, 225, 226, 229, 230, 229, 226, 226, 227, 230, 212, 230,
-    227, 227, 212, 212, 231, 176, 172, 172, 228, 231, 232, 231, 228, 228, 229, 232, 233, 232, 229,
-    229, 230, 233, 212, 233, 230, 230, 212, 212, 234, 180, 176, 176, 231, 234, 235, 234, 231, 231,
-    232, 235, 236, 235, 232, 232, 233, 236, 212, 236, 233, 233, 212, 212, 237, 184, 180, 180, 234,
-    237, 238, 237, 234, 234, 235, 238, 239, 238, 235, 235, 236, 239, 212, 239, 236, 236, 212, 212,
-    240, 188, 184, 184, 237, 240, 241, 240, 237, 237, 238, 241, 242, 241, 238, 238, 239, 242, 212,
-    242, 239, 239, 212, 212, 243, 192, 188, 188, 240, 243, 244, 243, 240, 240, 241, 244, 245, 244,
-    241, 241, 242, 245, 212, 245, 242, 242, 212, 212, 246, 196, 192, 192, 243, 246, 247, 246, 243,
-    243, 244, 247, 248, 247, 244, 244, 245, 248, 212, 248, 245, 245, 212, 212, 249, 200, 196, 196,
-    246, 249, 250, 249, 246, 246, 247, 250, 251, 250, 247, 247, 248, 251, 212, 251, 248, 248, 212,
-    212, 252, 204, 200, 200, 249, 252, 253, 252, 249, 249, 250, 253, 254, 253, 250, 250, 251, 254,
-    212, 254, 251, 251, 212, 212, 255, 208, 204, 204, 252, 255, 256, 255, 252, 252, 253, 256, 257,
-    256, 253, 253, 254, 257, 212, 257, 254, 254, 212, 212, 209, 148, 208, 208, 255, 209, 210, 209,
-    255, 255, 256, 210, 211, 210, 256, 256, 257, 211, 212, 211, 257, 257, 212, 212, 264, 263, 258,
-    258, 259, 264, 265, 264, 259, 259, 260, 265, 266, 265, 260, 260, 261, 266, 267, 266, 261, 261,
-    262, 267, 269, 268, 263, 263, 264, 269, 270, 269, 264, 264, 265, 270, 271, 270, 265, 265, 266,
-    271, 272, 271, 266, 266, 267, 272, 274, 273, 268, 268, 269, 274, 275, 274, 269, 269, 270, 275,
-    276, 275, 270, 270, 271, 276, 277, 276, 271, 271, 272, 277, 279, 278, 273, 273, 274, 279, 280,
-    279, 274, 274, 275, 280, 281, 280, 275, 275, 276, 281, 282, 281, 276, 276, 277, 282, 284, 283,
-    278, 278, 279, 284, 285, 284, 279, 279, 280, 285, 286, 285, 280, 280, 281, 286, 287, 286, 281,
-    281, 282, 287, 289, 288, 283, 283, 284, 289, 290, 289, 284, 284, 285, 290, 291, 290, 285, 285,
-    286, 291, 292, 291, 286, 286, 287, 292, 294, 293, 288, 288, 289, 294, 295, 294, 289, 289, 290,
-    295, 296, 295, 290, 290, 291, 296, 297, 296, 291, 291, 292, 297, 259, 258, 293, 293, 294, 259,
-    260, 259, 294, 294, 295, 260, 261, 260, 295, 295, 296, 261, 262, 261, 296, 296, 297, 262, 302,
-    267, 262, 262, 298, 302, 303, 302, 298, 298, 299, 303, 304, 303, 299, 299, 300, 304, 305, 304,
-    300, 300, 301, 305, 306, 272, 267, 267, 302, 306, 307, 306, 302, 302, 303, 307, 308, 307, 303,
-    303, 304, 308, 309, 308, 304, 304, 305, 309, 310, 277, 272, 272, 306, 310, 311, 310, 306, 306,
-    307, 311, 312, 311, 307, 307, 308, 312, 313, 312, 308, 308, 309, 313, 314, 282, 277, 277, 310,
-    314, 315, 314, 310, 310, 311, 315, 316, 315, 311, 311, 312, 316, 317, 316, 312, 312, 313, 317,
-    318, 287, 282, 282, 314, 318, 319, 318, 314, 314, 315, 319, 320, 319, 315, 315, 316, 320, 321,
-    320, 316, 316, 317, 321, 322, 292, 287, 287, 318, 322, 323, 322, 318, 318, 319, 323, 324, 323,
-    319, 319, 320, 324, 325, 324, 320, 320, 321, 325, 326, 297, 292, 292, 322, 326, 327, 326, 322,
-    322, 323, 327, 328, 327, 323, 323, 324, 328, 329, 328, 324, 324, 325, 329, 298, 262, 297, 297,
-    326, 298, 299, 298, 326, 326, 327, 299, 300, 299, 327, 327, 328, 300, 301, 300, 328, 328, 329,
-    301, 336, 335, 330, 330, 331, 336, 337, 336, 331, 331, 332, 337, 338, 337, 332, 332, 333, 338,
-    339, 338, 333, 333, 334, 339, 341, 340, 335, 335, 336, 341, 342, 341, 336, 336, 337, 342, 343,
-    342, 337, 337, 338, 343, 344, 343, 338, 338, 339, 344, 346, 345, 340, 340, 341, 346, 347, 346,
-    341, 341, 342, 347, 348, 347, 342, 342, 343, 348, 349, 348, 343, 343, 344, 349, 351, 350, 345,
-    345, 346, 351, 352, 351, 346, 346, 347, 352, 353, 352, 347, 347, 348, 353, 354, 353, 348, 348,
-    349, 354, 356, 355, 350, 350, 351, 356, 357, 356, 351, 351, 352, 357, 358, 357, 352, 352, 353,
-    358, 359, 358, 353, 353, 354, 359, 361, 360, 355, 355, 356, 361, 362, 361, 356, 356, 357, 362,
-    363, 362, 357, 357, 358, 363, 364, 363, 358, 358, 359, 364, 366, 365, 360, 360, 361, 366, 367,
-    366, 361, 361, 362, 367, 368, 367, 362, 362, 363, 368, 369, 368, 363, 363, 364, 369, 331, 330,
-    365, 365, 366, 331, 332, 331, 366, 366, 367, 332, 333, 332, 367, 367, 368, 333, 334, 333, 368,
-    368, 369, 334, 374, 339, 334, 334, 370, 374, 375, 374, 370, 370, 371, 375, 376, 375, 371, 371,
-    372, 376, 377, 376, 372, 372, 373, 377, 378, 344, 339, 339, 374, 378, 379, 378, 374, 374, 375,
-    379, 380, 379, 375, 375, 376, 380, 381, 380, 376, 376, 377, 381, 382, 349, 344, 344, 378, 382,
-    383, 382, 378, 378, 379, 383, 384, 383, 379, 379, 380, 384, 385, 384, 380, 380, 381, 385, 386,
-    354, 349, 349, 382, 386, 387, 386, 382, 382, 383, 387, 388, 387, 383, 383, 384, 388, 389, 388,
-    384, 384, 385, 389, 390, 359, 354, 354, 386, 390, 391, 390, 386, 386, 387, 391, 392, 391, 387,
-    387, 388, 392, 393, 392, 388, 388, 389, 393, 394, 364, 359, 359, 390, 394, 395, 394, 390, 390,
-    391, 395, 396, 395, 391, 391, 392, 396, 397, 396, 392, 392, 393, 397, 398, 369, 364, 364, 394,
-    398, 399, 398, 394, 394, 395, 399, 400, 399, 395, 395, 396, 400, 401, 400, 396, 396, 397, 401,
-    370, 334, 369, 369, 398, 370, 371, 370, 398, 398, 399, 371, 372, 371, 399, 399, 400, 372, 373,
-    372, 400, 400, 401, 373, 407, 402, 402, 402, 403, 407, 408, 407, 403, 403, 404, 408, 409, 408,
-    404, 404, 405, 409, 410, 409, 405, 405, 406, 410, 411, 402, 402, 402, 407, 411, 412, 411, 407,
-    407, 408, 412, 413, 412, 408, 408, 409, 413, 414, 413, 409, 409, 410, 414, 415, 402, 402, 402,
-    411, 415, 416, 415, 411, 411, 412, 416, 417, 416, 412, 412, 413, 417, 418, 417, 413, 413, 414,
-    418, 419, 402, 402, 402, 415, 419, 420, 419, 415, 415, 416, 420, 421, 420, 416, 416, 417, 421,
-    422, 421, 417, 417, 418, 422, 423, 402, 402, 402, 419, 423, 424, 423, 419, 419, 420, 424, 425,
-    424, 420, 420, 421, 425, 426, 425, 421, 421, 422, 426, 427, 402, 402, 402, 423, 427, 428, 427,
-    423, 423, 424, 428, 429, 428, 424, 424, 425, 429, 430, 429, 425, 425, 426, 430, 431, 402, 402,
-    402, 427, 431, 432, 431, 427, 427, 428, 432, 433, 432, 428, 428, 429, 433, 434, 433, 429, 429,
-    430, 434, 435, 402, 402, 402, 431, 435, 436, 435, 431, 431, 432, 436, 437, 436, 432, 432, 433,
-    437, 438, 437, 433, 433, 434, 438, 439, 402, 402, 402, 435, 439, 440, 439, 435, 435, 436, 440,
-    441, 440, 436, 436, 437, 441, 442, 441, 437, 437, 438, 442, 443, 402, 402, 402, 439, 443, 444,
-    443, 439, 439, 440, 444, 445, 444, 440, 440, 441, 445, 446, 445, 441, 441, 442, 446, 447, 402,
-    402, 402, 443, 447, 448, 447, 443, 443, 444, 448, 449, 448, 444, 444, 445, 449, 450, 449, 445,
-    445, 446, 450, 451, 402, 402, 402, 447, 451, 452, 451, 447, 447, 448, 452, 453, 452, 448, 448,
-    449, 453, 454, 453, 449, 449, 450, 454, 455, 402, 402, 402, 451, 455, 456, 455, 451, 451, 452,
-    456, 457, 456, 452, 452, 453, 457, 458, 457, 453, 453, 454, 458, 459, 402, 402, 402, 455, 459,
-    460, 459, 455, 455, 456, 460, 461, 460, 456, 456, 457, 461, 462, 461, 457, 457, 458, 462, 463,
-    402, 402, 402, 459, 463, 464, 463, 459, 459, 460, 464, 465, 464, 460, 460, 461, 465, 466, 465,
-    461, 461, 462, 466, 403, 402, 402, 402, 463, 403, 404, 403, 463, 463, 464, 404, 405, 404, 464,
-    464, 465, 405, 406, 405, 465, 465, 466, 406, 471, 410, 406, 406, 467, 471, 472, 471, 467, 467,
-    468, 472, 473, 472, 468, 468, 469, 473, 474, 473, 469, 469, 470, 474, 475, 414, 410, 410, 471,
-    475, 476, 475, 471, 471, 472, 476, 477, 476, 472, 472, 473, 477, 478, 477, 473, 473, 474, 478,
-    479, 418, 414, 414, 475, 479, 480, 479, 475, 475, 476, 480, 481, 480, 476, 476, 477, 481, 482,
-    481, 477, 477, 478, 482, 483, 422, 418, 418, 479, 483, 484, 483, 479, 479, 480, 484, 485, 484,
-    480, 480, 481, 485, 486, 485, 481, 481, 482, 486, 487, 426, 422, 422, 483, 487, 488, 487, 483,
-    483, 484, 488, 489, 488, 484, 484, 485, 489, 490, 489, 485, 485, 486, 490, 491, 430, 426, 426,
-    487, 491, 492, 491, 487, 487, 488, 492, 493, 492, 488, 488, 489, 493, 494, 493, 489, 489, 490,
-    494, 495, 434, 430, 430, 491, 495, 496, 495, 491, 491, 492, 496, 497, 496, 492, 492, 493, 497,
-    498, 497, 493, 493, 494, 498, 499, 438, 434, 434, 495, 499, 500, 499, 495, 495, 496, 500, 501,
-    500, 496, 496, 497, 501, 502, 501, 497, 497, 498, 502, 503, 442, 438, 438, 499, 503, 504, 503,
-    499, 499, 500, 504, 505, 504, 500, 500, 501, 505, 506, 505, 501, 501, 502, 506, 507, 446, 442,
-    442, 503, 507, 508, 507, 503, 503, 504, 508, 509, 508, 504, 504, 505, 509, 510, 509, 505, 505,
-    506, 510, 511, 450, 446, 446, 507, 511, 512, 511, 507, 507, 508, 512, 513, 512, 508, 508, 509,
-    513, 514, 513, 509, 509, 510, 514, 515, 454, 450, 450, 511, 515, 516, 515, 511, 511, 512, 516,
-    517, 516, 512, 512, 513, 517, 518, 517, 513, 513, 514, 518, 519, 458, 454, 454, 515, 519, 520,
-    519, 515, 515, 516, 520, 521, 520, 516, 516, 517, 521, 522, 521, 517, 517, 518, 522, 523, 462,
-    458, 458, 519, 523, 524, 523, 519, 519, 520, 524, 525, 524, 520, 520, 521, 525, 526, 525, 521,
-    521, 522, 526, 527, 466, 462, 462, 523, 527, 528, 527, 523, 523, 524, 528, 529, 528, 524, 524,
-    525, 529, 530, 529, 525, 525, 526, 530, 467, 406, 466, 466, 527, 467, 468, 467, 527, 527, 528,
-    468, 469, 468, 528, 528, 529, 469, 470, 469, 529, 529, 530, 470u16,
-];
diff --git a/examples/wgpu/wgpu_teapot_camera/shaders/fs.wgsl b/examples/wgpu/wgpu_teapot_camera/shaders/fs.wgsl
deleted file mode 100644
index 6a5079bbc..000000000
--- a/examples/wgpu/wgpu_teapot_camera/shaders/fs.wgsl
+++ /dev/null
@@ -1,9 +0,0 @@
-@fragment
-fn main(@location(0) normal: vec3<f32>) -> @location(0) vec4<f32> {
-    let light: vec3<f32> = vec3<f32>(0.0, 0.0, 1.0);
-    let color: vec3<f32> = vec3<f32>(1.0);
-    let brightness: f32 = dot(normalize(normal), normalize(light));
-    let dark_color: vec3<f32> = vec3<f32>(0.1) * color;
-    let out_color = vec4<f32>(mix(dark_color, color, vec3<f32>(brightness)), 1.0);
-    return out_color;
-}
diff --git a/examples/wgpu/wgpu_teapot_camera/shaders/vs.wgsl b/examples/wgpu/wgpu_teapot_camera/shaders/vs.wgsl
deleted file mode 100644
index 856e1f018..000000000
--- a/examples/wgpu/wgpu_teapot_camera/shaders/vs.wgsl
+++ /dev/null
@@ -1,41 +0,0 @@
-struct Data {
-    world: mat4x4<f32>,
-    view: mat4x4<f32>,
-    proj: mat4x4<f32>,
-};
-
-struct VertexOutput {
-    @location(0) normal: vec3<f32>,
-    @builtin(position) pos: vec4<f32>,
-};
-
-@group(0) @binding(0)
-var<uniform> uniforms: Data;
-
-fn custom_inverse(m: mat3x3<f32>) -> mat3x3<f32> {
-    let determinant: f32 = determinant(m);
-    let invdet: f32 = 1.0 / determinant;
-    var minv: mat3x3<f32>;
-    minv[0][0] = (m[1][1] * m[2][2] - m[2][1] * m[1][2]) * invdet;
-    minv[0][1] = (m[0][2] * m[2][1] - m[0][1] * m[2][2]) * invdet;
-    minv[0][2] = (m[0][1] * m[1][2] - m[0][2] * m[1][1]) * invdet;
-    minv[1][0] = (m[1][2] * m[2][0] - m[1][0] * m[2][2]) * invdet;
-    minv[1][1] = (m[0][0] * m[2][2] - m[0][2] * m[2][0]) * invdet;
-    minv[1][2] = (m[1][0] * m[0][2] - m[0][0] * m[1][2]) * invdet;
-    minv[2][0] = (m[1][0] * m[2][1] - m[2][0] * m[1][1]) * invdet;
-    minv[2][1] = (m[2][0] * m[0][1] - m[0][0] * m[2][1]) * invdet;
-    minv[2][2] = (m[0][0] * m[1][1] - m[1][0] * m[0][1]) * invdet;
-    return minv;
-}
-
-@vertex
-fn main(
-    @location(0) pos: vec3<f32>,
-    @location(1) normal: vec3<f32>,
-) -> VertexOutput {
-    let worldview: mat4x4<f32> = uniforms.view * uniforms.world;
-    let wv3: mat3x3<f32> = mat3x3<f32>(worldview[0].xyz, worldview[1].xyz, worldview[2].xyz);
-    let out_normal: vec3<f32> = transpose(custom_inverse(wv3)) * normal;
-    let out_pos: vec4<f32> = uniforms.proj * worldview * vec4<f32>(pos, 1.0);
-    return VertexOutput(out_normal, out_pos);
-}
diff --git a/examples/wgpu/wgpu_teapot_camera/wgpu_teapot_camera.rs b/examples/wgpu/wgpu_teapot_camera/wgpu_teapot_camera.rs
deleted file mode 100644
index 62f34115d..000000000
--- a/examples/wgpu/wgpu_teapot_camera/wgpu_teapot_camera.rs
+++ /dev/null
@@ -1,402 +0,0 @@
-use nannou::prelude::*;
-use nannou::winit;
-use std::cell::RefCell;
-
-mod data;
-
-struct Model {
-    camera_is_active: bool,
-    graphics: RefCell<Graphics>,
-    camera: Camera,
-}
-
-struct Graphics {
-    vertex_buffer: wgpu::Buffer,
-    normal_buffer: wgpu::Buffer,
-    index_buffer: wgpu::Buffer,
-    uniform_buffer: wgpu::Buffer,
-    depth_texture: wgpu::Texture,
-    depth_texture_view: wgpu::TextureView,
-    bind_group: wgpu::BindGroup,
-    render_pipeline: wgpu::RenderPipeline,
-}
-
-// A simple first person camera.
-struct Camera {
-    // The position of the camera.
-    eye: Point3,
-    // Rotation around the x axis.
-    pitch: f32,
-    // Rotation around the y axis.
-    yaw: f32,
-}
-
-// The vertex type that we will use to represent a point on our triangle.
-#[repr(C)]
-#[derive(Clone, Copy)]
-pub struct Vertex {
-    position: (f32, f32, f32),
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct Normal {
-    normal: (f32, f32, f32),
-}
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug)]
-pub struct Uniforms {
-    world: Mat4,
-    view: Mat4,
-    proj: Mat4,
-}
-
-const DEPTH_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Depth32Float;
-
-impl Camera {
-    // Calculate the direction vector from the pitch and yaw.
-    fn direction(&self) -> Vec3 {
-        pitch_yaw_to_direction(self.pitch, self.yaw)
-    }
-
-    // The camera's "view" matrix.
-    fn view(&self) -> Mat4 {
-        let direction = self.direction();
-        let up = Vec3::Y;
-        Mat4::look_to_rh(self.eye, direction, up)
-    }
-}
-
-fn pitch_yaw_to_direction(pitch: f32, yaw: f32) -> Vec3 {
-    let xz_unit_len = pitch.cos();
-    let x = xz_unit_len * yaw.cos();
-    let y = pitch.sin();
-    let z = xz_unit_len * (-yaw).sin();
-    vec3(x, y, z)
-}
-
-fn main() {
-    nannou::app(model).event(event).update(update).run();
-}
-
-fn model(app: &App) -> Model {
-    let w_id = app
-        .new_window()
-        .size(1024, 576)
-        .key_pressed(key_pressed)
-        .view(view)
-        .build()
-        .unwrap();
-
-    let window = app.window(w_id).unwrap();
-    let camera_is_active = true;
-    if let Err(e) = window.set_cursor_grab(true) {
-        eprintln!("warning: cursor grabbing not supported: {e}");
-    }
-    window.set_cursor_visible(false);
-    let device = window.device();
-    let format = Frame::TEXTURE_FORMAT;
-    let msaa_samples = window.msaa_samples();
-    let (win_w, win_h) = window.inner_size_pixels();
-
-    let vs_desc = wgpu::include_wgsl!("shaders/vs.wgsl");
-    let fs_desc = wgpu::include_wgsl!("shaders/fs.wgsl");
-    let vs_mod = device.create_shader_module(vs_desc);
-    let fs_mod = device.create_shader_module(fs_desc);
-
-    // Create the vertex, normal and index buffers.
-    let vertices_bytes = vertices_as_bytes(&data::VERTICES);
-    let normals_bytes = normals_as_bytes(&data::NORMALS);
-    let indices_bytes = indices_as_bytes(&data::INDICES);
-    let vertex_usage = wgpu::BufferUsages::VERTEX;
-    let index_usage = wgpu::BufferUsages::INDEX;
-    let vertex_buffer = device.create_buffer_init(&BufferInitDescriptor {
-        label: None,
-        contents: vertices_bytes,
-        usage: vertex_usage,
-    });
-    let normal_buffer = device.create_buffer_init(&BufferInitDescriptor {
-        label: None,
-        contents: normals_bytes,
-        usage: vertex_usage,
-    });
-    let index_buffer = device.create_buffer_init(&BufferInitDescriptor {
-        label: None,
-        contents: indices_bytes,
-        usage: index_usage,
-    });
-
-    let depth_texture = create_depth_texture(device, [win_w, win_h], DEPTH_FORMAT, msaa_samples);
-    let depth_texture_view = depth_texture.view().build();
-
-    let eye = Point3::new(0.0, 0.0, 1.0);
-    let pitch = 0.0;
-    let yaw = std::f32::consts::PI * 0.5;
-    let camera = Camera { eye, pitch, yaw };
-
-    let uniforms = create_uniforms([win_w, win_h], camera.view());
-    let uniforms_bytes = uniforms_as_bytes(&uniforms);
-    let usage = wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST;
-    let uniform_buffer = device.create_buffer_init(&BufferInitDescriptor {
-        label: None,
-        contents: uniforms_bytes,
-        usage,
-    });
-
-    let bind_group_layout = create_bind_group_layout(device);
-    let bind_group = create_bind_group(device, &bind_group_layout, &uniform_buffer);
-    let pipeline_layout = create_pipeline_layout(device, &bind_group_layout);
-    let render_pipeline = create_render_pipeline(
-        device,
-        &pipeline_layout,
-        &vs_mod,
-        &fs_mod,
-        format,
-        DEPTH_FORMAT,
-        msaa_samples,
-    );
-
-    let graphics = RefCell::new(Graphics {
-        vertex_buffer,
-        normal_buffer,
-        index_buffer,
-        uniform_buffer,
-        depth_texture,
-        depth_texture_view,
-        bind_group,
-        render_pipeline,
-    });
-
-    println!("Use the `W`, `A`, `S`, `D`, `Q` and `E` keys to move the camera.");
-    println!("Use the mouse to orient the pitch and yaw of the camera.");
-    println!("Press the `Space` key to toggle camera mode.");
-
-    Model {
-        camera_is_active,
-        graphics,
-        camera,
-    }
-}
-
-// Move the camera based on the current key pressed and its current direction.
-fn update(app: &App, model: &mut Model, update: Update) {
-    const CAM_SPEED_HZ: f64 = 0.5;
-    if model.camera_is_active {
-        let velocity = (update.since_last.secs() * CAM_SPEED_HZ) as f32;
-        // Go forwards on W.
-        if app.keys.down.contains(&Key::W) {
-            model.camera.eye += model.camera.direction() * velocity;
-        }
-        // Go backwards on S.
-        if app.keys.down.contains(&Key::S) {
-            model.camera.eye -= model.camera.direction() * velocity;
-        }
-        // Strafe left on A.
-        if app.keys.down.contains(&Key::A) {
-            let pitch = 0.0;
-            let yaw = model.camera.yaw + std::f32::consts::PI * 0.5;
-            let direction = pitch_yaw_to_direction(pitch, yaw);
-            model.camera.eye += direction * velocity;
-        }
-        // Strafe right on D.
-        if app.keys.down.contains(&Key::D) {
-            let pitch = 0.0;
-            let yaw = model.camera.yaw - std::f32::consts::PI * 0.5;
-            let direction = pitch_yaw_to_direction(pitch, yaw);
-            model.camera.eye += direction * velocity;
-        }
-        // Float down on Q.
-        if app.keys.down.contains(&Key::Q) {
-            let pitch = model.camera.pitch - std::f32::consts::PI * 0.5;
-            let direction = pitch_yaw_to_direction(pitch, model.camera.yaw);
-            model.camera.eye += direction * velocity;
-        }
-        // Float up on E.
-        if app.keys.down.contains(&Key::E) {
-            let pitch = model.camera.pitch + std::f32::consts::PI * 0.5;
-            let direction = pitch_yaw_to_direction(pitch, model.camera.yaw);
-            model.camera.eye += direction * velocity;
-        }
-    }
-}
-
-// Use raw device motion event for camera pitch and yaw.
-// TODO: Check device ID for mouse here - not sure if possible with winit currently.
-fn event(_app: &App, model: &mut Model, event: Event) {
-    if model.camera_is_active {
-        if let Event::DeviceEvent(_device_id, event) = event {
-            if let winit::event::DeviceEvent::Motion { axis, value } = event {
-                let sensitivity = 0.004;
-                match axis {
-                    // Yaw left and right on mouse x axis movement.
-                    0 => model.camera.yaw -= (value * sensitivity) as f32,
-                    // Pitch up and down on mouse y axis movement.
-                    _ => {
-                        let max_pitch = std::f32::consts::PI * 0.5 - 0.0001;
-                        let min_pitch = -max_pitch;
-                        model.camera.pitch = (model.camera.pitch + (-value * sensitivity) as f32)
-                            .min(max_pitch)
-                            .max(min_pitch)
-                    }
-                }
-            }
-        }
-    }
-}
-
-// Toggle cursor grabbing and hiding on Space key.
-fn key_pressed(app: &App, model: &mut Model, key: Key) {
-    if let Key::Space = key {
-        let window = app.main_window();
-        if !model.camera_is_active {
-            if window.set_cursor_grab(true).is_ok() {
-                model.camera_is_active = true;
-            }
-        } else {
-            if window.set_cursor_grab(false).is_ok() {
-                model.camera_is_active = false;
-            }
-        }
-        window.set_cursor_visible(!model.camera_is_active);
-    }
-}
-
-fn view(_app: &App, model: &Model, frame: Frame) {
-    let mut g = model.graphics.borrow_mut();
-
-    // If the window has changed size, recreate our depth texture to match.
-    let depth_size = g.depth_texture.size();
-    let frame_size = frame.texture_size();
-    let device = frame.device_queue_pair().device();
-    if frame_size != depth_size {
-        let depth_format = g.depth_texture.format();
-        let sample_count = frame.texture_msaa_samples();
-        g.depth_texture = create_depth_texture(device, frame_size, depth_format, sample_count);
-        g.depth_texture_view = g.depth_texture.view().build();
-    }
-
-    // Update the uniforms (rotate around the teapot).
-    let uniforms = create_uniforms(frame_size, model.camera.view());
-    let uniforms_size = std::mem::size_of::<Uniforms>() as wgpu::BufferAddress;
-    let uniforms_bytes = uniforms_as_bytes(&uniforms);
-    let usage = wgpu::BufferUsages::COPY_SRC;
-    let new_uniform_buffer = device.create_buffer_init(&BufferInitDescriptor {
-        label: None,
-        contents: uniforms_bytes,
-        usage,
-    });
-
-    let mut encoder = frame.command_encoder();
-    encoder.copy_buffer_to_buffer(&new_uniform_buffer, 0, &g.uniform_buffer, 0, uniforms_size);
-    let mut render_pass = wgpu::RenderPassBuilder::new()
-        .color_attachment(frame.texture_view(), |color| color)
-        // We'll use a depth texture to assist with the order of rendering fragments based on depth.
-        .depth_stencil_attachment(&g.depth_texture_view, |depth| depth)
-        .begin(&mut encoder);
-    render_pass.set_bind_group(0, &g.bind_group, &[]);
-    render_pass.set_pipeline(&g.render_pipeline);
-    render_pass.set_vertex_buffer(0, g.vertex_buffer.slice(..));
-    render_pass.set_vertex_buffer(1, g.normal_buffer.slice(..));
-    render_pass.set_index_buffer(g.index_buffer.slice(..), wgpu::IndexFormat::Uint16);
-    let index_range = 0..data::INDICES.len() as u32;
-    let start_vertex = 0;
-    let instance_range = 0..1;
-    render_pass.draw_indexed(index_range, start_vertex, instance_range);
-}
-
-fn create_uniforms([w, h]: [u32; 2], view: Mat4) -> Uniforms {
-    let rotation = Mat4::from_rotation_y(0f32);
-    let aspect_ratio = w as f32 / h as f32;
-    let fov_y = std::f32::consts::FRAC_PI_2;
-    let near = 0.01;
-    let far = 100.0;
-    let proj = Mat4::perspective_rh_gl(fov_y, aspect_ratio, near, far);
-    let scale = Mat4::from_scale(Vec3::splat(0.01));
-    Uniforms {
-        world: rotation,
-        view: (view * scale).into(),
-        proj: proj.into(),
-    }
-}
-
-fn create_depth_texture(
-    device: &wgpu::Device,
-    size: [u32; 2],
-    depth_format: wgpu::TextureFormat,
-    sample_count: u32,
-) -> wgpu::Texture {
-    wgpu::TextureBuilder::new()
-        .size(size)
-        .format(depth_format)
-        .usage(wgpu::TextureUsages::RENDER_ATTACHMENT)
-        .sample_count(sample_count)
-        .build(device)
-}
-
-fn create_bind_group_layout(device: &wgpu::Device) -> wgpu::BindGroupLayout {
-    wgpu::BindGroupLayoutBuilder::new()
-        .uniform_buffer(wgpu::ShaderStages::VERTEX, false)
-        .build(device)
-}
-
-fn create_bind_group(
-    device: &wgpu::Device,
-    layout: &wgpu::BindGroupLayout,
-    uniform_buffer: &wgpu::Buffer,
-) -> wgpu::BindGroup {
-    wgpu::BindGroupBuilder::new()
-        .buffer::<Uniforms>(uniform_buffer, 0..1)
-        .build(device, layout)
-}
-
-fn create_pipeline_layout(
-    device: &wgpu::Device,
-    bind_group_layout: &wgpu::BindGroupLayout,
-) -> wgpu::PipelineLayout {
-    let desc = wgpu::PipelineLayoutDescriptor {
-        label: None,
-        bind_group_layouts: &[&bind_group_layout],
-        push_constant_ranges: &[],
-    };
-    device.create_pipeline_layout(&desc)
-}
-
-fn create_render_pipeline(
-    device: &wgpu::Device,
-    layout: &wgpu::PipelineLayout,
-    vs_mod: &wgpu::ShaderModule,
-    fs_mod: &wgpu::ShaderModule,
-    dst_format: wgpu::TextureFormat,
-    depth_format: wgpu::TextureFormat,
-    sample_count: u32,
-) -> wgpu::RenderPipeline {
-    wgpu::RenderPipelineBuilder::from_layout(layout, vs_mod)
-        .fragment_shader(&fs_mod)
-        .color_format(dst_format)
-        .color_blend(wgpu::BlendComponent::REPLACE)
-        .alpha_blend(wgpu::BlendComponent::REPLACE)
-        .add_vertex_buffer::<Vertex>(&wgpu::vertex_attr_array![0 => Float32x3])
-        .add_vertex_buffer::<Normal>(&wgpu::vertex_attr_array![1 => Float32x3])
-        .depth_format(depth_format)
-        .sample_count(sample_count)
-        .build(device)
-}
-
-// See the `nannou::wgpu::bytes` documentation for why the following are necessary.
-
-fn vertices_as_bytes(data: &[Vertex]) -> &[u8] {
-    unsafe { wgpu::bytes::from_slice(data) }
-}
-
-fn normals_as_bytes(data: &[Normal]) -> &[u8] {
-    unsafe { wgpu::bytes::from_slice(data) }
-}
-
-fn indices_as_bytes(data: &[u16]) -> &[u8] {
-    unsafe { wgpu::bytes::from_slice(data) }
-}
-
-fn uniforms_as_bytes(uniforms: &Uniforms) -> &[u8] {
-    unsafe { wgpu::bytes::from(uniforms) }
-}
diff --git a/examples/wgpu/wgpu_triangle/shaders/fs.wgsl b/examples/wgpu/wgpu_triangle/shaders/fs.wgsl
deleted file mode 100644
index cf27bb563..000000000
--- a/examples/wgpu/wgpu_triangle/shaders/fs.wgsl
+++ /dev/null
@@ -1,4 +0,0 @@
-@fragment
-fn main() -> @location(0) vec4<f32> {
-    return vec4<f32>(1.0, 0.0, 0.0, 1.0);
-}
diff --git a/examples/wgpu/wgpu_triangle/shaders/vs.wgsl b/examples/wgpu/wgpu_triangle/shaders/vs.wgsl
deleted file mode 100644
index 24ec5ee10..000000000
--- a/examples/wgpu/wgpu_triangle/shaders/vs.wgsl
+++ /dev/null
@@ -1,4 +0,0 @@
-@vertex
-fn main(@location(0) pos: vec2<f32>) -> @builtin(position) vec4<f32> {
-    return vec4<f32>(pos, 0.0, 1.0);
-}
diff --git a/examples/wgpu/wgpu_triangle/wgpu_triangle.rs b/examples/wgpu/wgpu_triangle/wgpu_triangle.rs
deleted file mode 100644
index 231ee22ed..000000000
--- a/examples/wgpu/wgpu_triangle/wgpu_triangle.rs
+++ /dev/null
@@ -1,109 +0,0 @@
-//! A simple demonstration on how to create and draw with a custom wgpu render pipeline in nannou!
-//!
-//! The aim of this example is not to show the simplest way of drawing a triangle in nannou, but
-//! rather provide a reference on how to get started creating your own rendering pipeline from
-//! scratch. While nannou's provided graphics-y APIs can do a lot of things quite efficiently,
-//! writing a custom pipeline that does only exactly what you need it to can sometimes result in
-//! better performance.
-
-use nannou::prelude::*;
-
-struct Model {
-    bind_group: wgpu::BindGroup,
-    render_pipeline: wgpu::RenderPipeline,
-    vertex_buffer: wgpu::Buffer,
-}
-
-// The vertex type that we will use to represent a point on our triangle.
-#[repr(C)]
-#[derive(Clone, Copy)]
-struct Vertex {
-    position: [f32; 2],
-}
-
-// The vertices that make up our triangle.
-const VERTICES: [Vertex; 3] = [
-    Vertex {
-        position: [-0.5, -0.25],
-    },
-    Vertex {
-        position: [0.0, 0.5],
-    },
-    Vertex {
-        position: [0.25, -0.1],
-    },
-];
-
-fn main() {
-    nannou::app(model).run();
-}
-
-fn model(app: &App) -> Model {
-    let w_id = app.new_window().size(512, 512).view(view).build().unwrap();
-
-    // The gpu device associated with the window's swapchain
-    let window = app.window(w_id).unwrap();
-    let device = window.device();
-    let format = Frame::TEXTURE_FORMAT;
-    let sample_count = window.msaa_samples();
-
-    // Load shader modules.
-    let vs_desc = wgpu::include_wgsl!("shaders/vs.wgsl");
-    let fs_desc = wgpu::include_wgsl!("shaders/fs.wgsl");
-    let vs_mod = device.create_shader_module(vs_desc);
-    let fs_mod = device.create_shader_module(fs_desc);
-
-    // Create the vertex buffer.
-    let vertices_bytes = vertices_as_bytes(&VERTICES[..]);
-    let usage = wgpu::BufferUsages::VERTEX;
-    let vertex_buffer = device.create_buffer_init(&BufferInitDescriptor {
-        label: None,
-        contents: vertices_bytes,
-        usage,
-    });
-
-    // Create the render pipeline.
-    let bind_group_layout = wgpu::BindGroupLayoutBuilder::new().build(device);
-    let bind_group = wgpu::BindGroupBuilder::new().build(device, &bind_group_layout);
-    let pipeline_layout = wgpu::create_pipeline_layout(device, None, &[&bind_group_layout], &[]);
-    let render_pipeline = wgpu::RenderPipelineBuilder::from_layout(&pipeline_layout, &vs_mod)
-        .fragment_shader(&fs_mod)
-        .color_format(format)
-        .add_vertex_buffer::<Vertex>(&wgpu::vertex_attr_array![0 => Float32x2])
-        .sample_count(sample_count)
-        .build(device);
-
-    Model {
-        bind_group,
-        vertex_buffer,
-        render_pipeline,
-    }
-}
-
-// Draw the state of your `Model` into the given `Frame` here.
-fn view(_app: &App, model: &Model, frame: Frame) {
-    // Using this we will encode commands that will be submitted to the GPU.
-    let mut encoder = frame.command_encoder();
-
-    // The render pass can be thought of a single large command consisting of sub commands. Here we
-    // begin a render pass that outputs to the frame's texture. Then we add sub-commands for
-    // setting the bind group, render pipeline, vertex buffers and then finally drawing.
-    let mut render_pass = wgpu::RenderPassBuilder::new()
-        .color_attachment(frame.texture_view(), |color| color)
-        .begin(&mut encoder);
-    render_pass.set_bind_group(0, &model.bind_group, &[]);
-    render_pass.set_pipeline(&model.render_pipeline);
-    render_pass.set_vertex_buffer(0, model.vertex_buffer.slice(..));
-
-    // We want to draw the whole range of vertices, and we're only drawing one instance of them.
-    let vertex_range = 0..VERTICES.len() as u32;
-    let instance_range = 0..1;
-    render_pass.draw(vertex_range, instance_range);
-
-    // Now we're done! The commands we added will be submitted after `view` completes.
-}
-
-// See the `nannou::wgpu::bytes` documentation for why this is necessary.
-fn vertices_as_bytes(data: &[Vertex]) -> &[u8] {
-    unsafe { wgpu::bytes::from_slice(data) }
-}
diff --git a/examples/wgpu/wgpu_triangle_raw_frame/shaders/fs.wgsl b/examples/wgpu/wgpu_triangle_raw_frame/shaders/fs.wgsl
deleted file mode 100644
index cf27bb563..000000000
--- a/examples/wgpu/wgpu_triangle_raw_frame/shaders/fs.wgsl
+++ /dev/null
@@ -1,4 +0,0 @@
-@fragment
-fn main() -> @location(0) vec4<f32> {
-    return vec4<f32>(1.0, 0.0, 0.0, 1.0);
-}
diff --git a/examples/wgpu/wgpu_triangle_raw_frame/shaders/vs.wgsl b/examples/wgpu/wgpu_triangle_raw_frame/shaders/vs.wgsl
deleted file mode 100644
index 24ec5ee10..000000000
--- a/examples/wgpu/wgpu_triangle_raw_frame/shaders/vs.wgsl
+++ /dev/null
@@ -1,4 +0,0 @@
-@vertex
-fn main(@location(0) pos: vec2<f32>) -> @builtin(position) vec4<f32> {
-    return vec4<f32>(pos, 0.0, 1.0);
-}
diff --git a/examples/wgpu/wgpu_triangle_raw_frame/wgpu_triangle_raw_frame.rs b/examples/wgpu/wgpu_triangle_raw_frame/wgpu_triangle_raw_frame.rs
deleted file mode 100644
index 390274886..000000000
--- a/examples/wgpu/wgpu_triangle_raw_frame/wgpu_triangle_raw_frame.rs
+++ /dev/null
@@ -1,94 +0,0 @@
-//! The same as the `wgpu_triangle` example, but demonstrates how to draw directly to the swap
-//! chain texture (`RawFrame`) rather than to nannou's intermediary `Frame`.
-
-use nannou::prelude::*;
-
-struct Model {
-    bind_group: wgpu::BindGroup,
-    render_pipeline: wgpu::RenderPipeline,
-    vertex_buffer: wgpu::Buffer,
-}
-
-#[repr(C)]
-#[derive(Clone, Copy)]
-struct Vertex {
-    position: [f32; 2],
-}
-
-const VERTICES: [Vertex; 3] = [
-    Vertex {
-        position: [-0.5, -0.25],
-    },
-    Vertex {
-        position: [0.0, 0.5],
-    },
-    Vertex {
-        position: [0.25, -0.1],
-    },
-];
-
-fn main() {
-    nannou::app(model).run();
-}
-
-fn model(app: &App) -> Model {
-    let w_id = app
-        .new_window()
-        .size(512, 512)
-        .raw_view(view)
-        .build()
-        .unwrap();
-
-    let window = app.window(w_id).unwrap();
-    let device = window.device();
-    // NOTE: We are drawing to the swap chain format, rather than the `Frame::TEXTURE_FORMAT`.
-    let format = window.surface_configuration().format;
-
-    let vs_desc = wgpu::include_wgsl!("shaders/vs.wgsl");
-    let fs_desc = wgpu::include_wgsl!("shaders/fs.wgsl");
-    let vs_mod = device.create_shader_module(vs_desc);
-    let fs_mod = device.create_shader_module(fs_desc);
-
-    let vertices_bytes = vertices_as_bytes(&VERTICES[..]);
-    let usage = wgpu::BufferUsages::VERTEX;
-    let vertex_buffer = device.create_buffer_init(&BufferInitDescriptor {
-        label: None,
-        contents: vertices_bytes,
-        usage,
-    });
-
-    let bind_group_layout = wgpu::BindGroupLayoutBuilder::new().build(device);
-    let bind_group = wgpu::BindGroupBuilder::new().build(device, &bind_group_layout);
-    let pipeline_layout = wgpu::create_pipeline_layout(device, None, &[&bind_group_layout], &[]);
-    let render_pipeline = wgpu::RenderPipelineBuilder::from_layout(&pipeline_layout, &vs_mod)
-        .fragment_shader(&fs_mod)
-        .color_format(format)
-        .add_vertex_buffer::<Vertex>(&wgpu::vertex_attr_array![0 => Float32x2])
-        .build(device);
-
-    Model {
-        bind_group,
-        vertex_buffer,
-        render_pipeline,
-    }
-}
-
-fn view(_app: &App, model: &Model, frame: RawFrame) {
-    let mut encoder = frame.command_encoder();
-    let mut render_pass = wgpu::RenderPassBuilder::new()
-        // NOTE: We are drawing to the swap chain texture directly rather than the intermediary
-        // texture as in `wgpu_triangle`.
-        .color_attachment(frame.swap_chain_texture(), |color| color)
-        .begin(&mut encoder);
-    render_pass.set_pipeline(&model.render_pipeline);
-    render_pass.set_bind_group(0, &model.bind_group, &[]);
-    render_pass.set_vertex_buffer(0, model.vertex_buffer.slice(..));
-    let vertex_range = 0..VERTICES.len() as u32;
-    let instance_range = 0..1;
-    render_pass.draw(vertex_range, instance_range);
-}
-
-// See the `nannou::wgpu::bytes` documentation for why this is necessary.
-fn vertices_as_bytes(data: &[Vertex]) -> &[u8] {
-    unsafe { wgpu::bytes::from_slice(data) }
-}
diff --git a/flake.lock b/flake.lock
index 88571d173..9c64b98b4 100644
--- a/flake.lock
+++ b/flake.lock
@@ -2,11 +2,11 @@
   "nodes": {
     "nixpkgs": {
       "locked": {
-        "lastModified": 1705316053,
-        "narHash": "sha256-J2Ey5mPFT8gdfL2XC0JTZvKaBw/b2pnyudEXFvl+dQM=",
+        "lastModified": 1722185531,
+        "narHash": "sha256-veKR07psFoJjINLC8RK4DiLniGGMgF3QMlS4tb74S6k=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "c3e128f3c0ecc1fb04aef9f72b3dcc2f6cecf370",
+        "rev": "52ec9ac3b12395ad677e8b62106f0b98c1f8569d",
         "type": "github"
       },
       "original": {
diff --git a/generative_design/assets/images/generative_examples/p_4_0_01.jpg b/generative_design/assets/images/generative_examples/p_4_0_01.jpg
new file mode 100644
index 000000000..8908ba58e
Binary files /dev/null and b/generative_design/assets/images/generative_examples/p_4_0_01.jpg differ
diff --git a/generative_design/assets/images/generative_examples/p_4_1_1_01.jpg b/generative_design/assets/images/generative_examples/p_4_1_1_01.jpg
new file mode 100644
index 000000000..1793d6920
Binary files /dev/null and b/generative_design/assets/images/generative_examples/p_4_1_1_01.jpg differ
diff --git a/generative_design/assets/images/generative_examples/p_4_1_2_01.png b/generative_design/assets/images/generative_examples/p_4_1_2_01.png
new file mode 100644
index 000000000..effe06671
Binary files /dev/null and b/generative_design/assets/images/generative_examples/p_4_1_2_01.png differ
diff --git a/generative_design/assets/images/generative_examples/p_4_3_1_01.png b/generative_design/assets/images/generative_examples/p_4_3_1_01.png
new file mode 100644
index 000000000..ee917f030
Binary files /dev/null and b/generative_design/assets/images/generative_examples/p_4_3_1_01.png differ
diff --git a/generative_design/assets/images/generative_examples/pic1.jpg b/generative_design/assets/images/generative_examples/pic1.jpg
new file mode 100644
index 000000000..9651ffb40
Binary files /dev/null and b/generative_design/assets/images/generative_examples/pic1.jpg differ
diff --git a/generative_design/assets/images/generative_examples/pic2.jpg b/generative_design/assets/images/generative_examples/pic2.jpg
new file mode 100644
index 000000000..89354f907
Binary files /dev/null and b/generative_design/assets/images/generative_examples/pic2.jpg differ
diff --git a/generative_design/assets/images/generative_examples/pic3.jpg b/generative_design/assets/images/generative_examples/pic3.jpg
new file mode 100644
index 000000000..07d0310d6
Binary files /dev/null and b/generative_design/assets/images/generative_examples/pic3.jpg differ
diff --git a/generative_design/assets/images/generative_examples/pic4.jpg b/generative_design/assets/images/generative_examples/pic4.jpg
new file mode 100644
index 000000000..dc11b2c2e
Binary files /dev/null and b/generative_design/assets/images/generative_examples/pic4.jpg differ
diff --git a/assets/svg/generative_examples/056.svg b/generative_design/assets/svg/generative_examples/056.svg
similarity index 100%
rename from assets/svg/generative_examples/056.svg
rename to generative_design/assets/svg/generative_examples/056.svg
diff --git a/assets/svg/generative_examples/076.svg b/generative_design/assets/svg/generative_examples/076.svg
similarity index 100%
rename from assets/svg/generative_examples/076.svg
rename to generative_design/assets/svg/generative_examples/076.svg
diff --git a/assets/svg/generative_examples/082.svg b/generative_design/assets/svg/generative_examples/082.svg
similarity index 100%
rename from assets/svg/generative_examples/082.svg
rename to generative_design/assets/svg/generative_examples/082.svg
diff --git a/assets/svg/generative_examples/096.svg b/generative_design/assets/svg/generative_examples/096.svg
similarity index 100%
rename from assets/svg/generative_examples/096.svg
rename to generative_design/assets/svg/generative_examples/096.svg
diff --git a/assets/svg/generative_examples/117.svg b/generative_design/assets/svg/generative_examples/117.svg
similarity index 100%
rename from assets/svg/generative_examples/117.svg
rename to generative_design/assets/svg/generative_examples/117.svg
diff --git a/assets/svg/generative_examples/148.svg b/generative_design/assets/svg/generative_examples/148.svg
similarity index 100%
rename from assets/svg/generative_examples/148.svg
rename to generative_design/assets/svg/generative_examples/148.svg
diff --git a/assets/svg/generative_examples/152.svg b/generative_design/assets/svg/generative_examples/152.svg
similarity index 100%
rename from assets/svg/generative_examples/152.svg
rename to generative_design/assets/svg/generative_examples/152.svg
diff --git a/assets/svg/generative_examples/157.svg b/generative_design/assets/svg/generative_examples/157.svg
similarity index 100%
rename from assets/svg/generative_examples/157.svg
rename to generative_design/assets/svg/generative_examples/157.svg
diff --git a/assets/svg/generative_examples/164.svg b/generative_design/assets/svg/generative_examples/164.svg
similarity index 100%
rename from assets/svg/generative_examples/164.svg
rename to generative_design/assets/svg/generative_examples/164.svg
diff --git a/assets/svg/generative_examples/166.svg b/generative_design/assets/svg/generative_examples/166.svg
similarity index 100%
rename from assets/svg/generative_examples/166.svg
rename to generative_design/assets/svg/generative_examples/166.svg
diff --git a/assets/svg/generative_examples/186.svg b/generative_design/assets/svg/generative_examples/186.svg
similarity index 100%
rename from assets/svg/generative_examples/186.svg
rename to generative_design/assets/svg/generative_examples/186.svg
diff --git a/assets/svg/generative_examples/198.svg b/generative_design/assets/svg/generative_examples/198.svg
similarity index 100%
rename from assets/svg/generative_examples/198.svg
rename to generative_design/assets/svg/generative_examples/198.svg
diff --git a/assets/svg/generative_examples/224.svg b/generative_design/assets/svg/generative_examples/224.svg
similarity index 100%
rename from assets/svg/generative_examples/224.svg
rename to generative_design/assets/svg/generative_examples/224.svg
diff --git a/generative_design/color/p_1_0_01.rs b/generative_design/color/p_1_0_01.rs
index f75382917..c8e1dc463 100644
--- a/generative_design/color/p_1_0_01.rs
+++ b/generative_design/color/p_1_0_01.rs
@@ -34,22 +34,15 @@ fn main() {
     nannou::sketch(view).size(720, 720).run();
 }
 
-fn view(app: &App, frame: Frame) {
+fn view(app: &App) {
     // Prepare to draw.
     let draw = app.draw();
 
-    let norm_mouse_y = (app.mouse.y / app.window_rect().h()) + 0.5;
+    let norm_mouse_y = (app.mouse().y / app.window_rect().h()) + 0.5;
     draw.background().hsl(norm_mouse_y, 1.0, 0.5);
 
     draw.rect()
-        .w_h(app.mouse.x * 2.0, app.mouse.x * 2.0)
+        .base_color(Color::WHITE)
+        .w_h(app.mouse().x * 2.0, app.mouse().x * 2.0)
         .hsv(1.0 - (norm_mouse_y), 1.0, 0.5);
-
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
-
-    if app.keys.down.contains(&Key::S) {
-        app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
-    }
 }
diff --git a/generative_design/color/p_1_1_1_01.rs b/generative_design/color/p_1_1_1_01.rs
index 4a72b793b..5718b2f96 100644
--- a/generative_design/color/p_1_1_1_01.rs
+++ b/generative_design/color/p_1_1_1_01.rs
@@ -29,15 +29,15 @@ fn main() {
     nannou::sketch(view).size(800, 400).run();
 }
 
-fn view(app: &App, frame: Frame) {
+fn view(app: &App) {
     // Begin drawing
     let draw = app.draw();
 
     draw.background().color(BLACK);
     let win_rect = app.window_rect();
 
-    let step_x = (app.mouse.x - win_rect.left()).max(5.0);
-    let step_y = (win_rect.top() - app.mouse.y).max(5.0);
+    let step_x = (app.mouse().x - win_rect.left()).max(5.0);
+    let step_y = (win_rect.top() - app.mouse().x).max(5.0);
 
     let size = vec2(step_x, step_y);
     let r = nannou::geom::Rect::from_wh(size)
@@ -55,7 +55,4 @@ fn view(app: &App, frame: Frame) {
         }
         grid_y += step_y;
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/generative_design/color/p_1_1_2_01.rs b/generative_design/color/p_1_1_2_01.rs
index e9b4b1bac..e78630109 100644
--- a/generative_design/color/p_1_1_2_01.rs
+++ b/generative_design/color/p_1_1_2_01.rs
@@ -44,8 +44,7 @@ fn model(app: &App) -> Model {
         .size(720, 720)
         .key_pressed(key_pressed)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     Model {
         segment_count: 360,
@@ -53,32 +52,32 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn key_pressed(app: &App, model: &mut Model, key: Key) {
+fn key_pressed(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::Key1 => {
+        KeyCode::Digit1 => {
             model.segment_count = 360;
         }
-        Key::Key2 => {
+        KeyCode::Digit2 => {
             model.segment_count = 45;
         }
-        Key::Key3 => {
+        KeyCode::Digit3 => {
             model.segment_count = 24;
         }
-        Key::Key4 => {
+        KeyCode::Digit4 => {
             model.segment_count = 12;
         }
-        Key::Key5 => {
+        KeyCode::Digit5 => {
             model.segment_count = 6;
         }
-        Key::S => {
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
         _other_key => {}
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
 
@@ -98,15 +97,12 @@ fn view(app: &App, model: &Model, frame: Frame) {
         let next_vy = ((angle + angle_step) as f32).to_radians().sin() * model.radius;
         points.push(pt2(next_vx, next_vy));
 
-        let mx = (app.mouse.x / app.window_rect().w()) + 0.5;
-        let my = (app.mouse.y / app.window_rect().h()) + 0.5;
+        let mx = (app.mouse().x / app.window_rect().w()) + 0.5;
+        let my = (app.mouse().x / app.window_rect().h()) + 0.5;
 
         draw.polygon()
-            .stroke(hsv(angle as f32 / 360.0, my, mx))
+            .stroke(Color::hsv(angle as f32 / 360.0, my, mx))
             .hsv(angle as f32 / 360.0, mx, my)
             .points(points);
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/generative_design/color/p_1_2_1_01.rs b/generative_design/color/p_1_2_1_01.rs
index 3e1e15fb0..5abfe3508 100644
--- a/generative_design/color/p_1_2_1_01.rs
+++ b/generative_design/color/p_1_2_1_01.rs
@@ -32,9 +32,6 @@
  */
 use nannou::prelude::*;
 
-use nannou::color::FromColor;
-use nannou::color::Mix;
-
 fn main() {
     nannou::app(model).update(update).run();
 }
@@ -42,8 +39,8 @@ fn main() {
 struct Model {
     tile_count_x: usize,
     tile_count_y: usize,
-    colours_left: Vec<Hsv>,
-    colours_right: Vec<Hsv>,
+    colours_left: Vec<Hsva>,
+    colours_right: Vec<Hsva>,
     interpolate_shortest: bool,
 }
 
@@ -53,16 +50,15 @@ fn model(app: &App) -> Model {
         .key_pressed(key_pressed)
         .mouse_released(mouse_released)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     let tile_count_x = 2;
     let tile_count_y = 10;
     let mut model = Model {
         tile_count_x,
         tile_count_y,
-        colours_left: vec![hsv(0.0, 0.0, 0.0); tile_count_y],
-        colours_right: vec![hsv(0.0, 0.0, 0.0); tile_count_y],
+        colours_left: vec![Hsva::default(); tile_count_y],
+        colours_right: vec![Hsva::default(); tile_count_y],
         interpolate_shortest: true,
     };
     shake_colors(&mut model);
@@ -70,21 +66,21 @@ fn model(app: &App) -> Model {
     model
 }
 
-fn update(app: &App, model: &mut Model, _update: Update) {
+fn update(app: &App, model: &mut Model) {
     let win = app.window_rect();
     model.tile_count_x = clamp(
-        map_range(app.mouse.x, win.left(), win.right(), 2, 100),
+        map_range(app.mouse().x, win.left(), win.right(), 2, 100),
         2,
         100,
     ) as usize;
     model.tile_count_y = clamp(
-        map_range(app.mouse.y, win.top(), win.bottom(), 2, 10),
+        map_range(app.mouse().x, win.top(), win.bottom(), 2, 10),
         2,
         10,
     ) as usize;
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(BLACK);
@@ -105,7 +101,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
             let col = if model.interpolate_shortest {
                 let c1 = cast_to_rgb(col1);
                 let c2 = cast_to_rgb(col2);
-                Hsv::from_rgb(c1.mix(&c2, amount))
+                Hsva::from(c1.mix(&c2, amount))
             } else {
                 col1.mix(&col2, amount)
             };
@@ -115,22 +111,19 @@ fn view(app: &App, model: &Model, frame: Frame) {
                 .color(col);
         }
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn cast_to_rgb(col: Hsv) -> LinSrgb {
-    let red: f32 = col.hue.into();
+fn cast_to_rgb(col: Hsva) -> LinearRgba {
+    let red: f32 = col.hue;
     let green = col.saturation;
     let blue = col.value;
-    lin_srgb(red / 360.0, green, blue)
+    LinearRgba::new(red / 360.0, green, blue, 1.0)
 }
 
 fn shake_colors(model: &mut Model) {
     for i in 0..model.tile_count_y {
-        model.colours_left[i] = hsv(random_f32() * 0.166, random_f32(), 1.0);
-        model.colours_right[i] = hsv(random_range(0.44, 0.52), 1.0, random_f32());
+        model.colours_left[i] = Hsva::new(random_f32() * 0.166, random_f32(), 1.0, 1.0);
+        model.colours_right[i] = Hsva::new(random_range(0.44, 0.52), 1.0, random_f32(), 1.0);
     }
 }
 
@@ -138,17 +131,17 @@ fn mouse_released(_app: &App, model: &mut Model, _button: MouseButton) {
     shake_colors(model);
 }
 
-fn key_pressed(app: &App, model: &mut Model, key: Key) {
+fn key_pressed(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::Key1 => {
+        KeyCode::Digit1 => {
             model.interpolate_shortest = true;
         }
-        Key::Key2 => {
+        KeyCode::Digit2 => {
             model.interpolate_shortest = false;
         }
-        Key::S => {
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
         _other_key => {}
     }
diff --git a/generative_design/color/p_1_2_2_01.rs b/generative_design/color/p_1_2_2_01.rs
index 5f3e4ff33..4c03f6e6b 100644
--- a/generative_design/color/p_1_2_2_01.rs
+++ b/generative_design/color/p_1_2_2_01.rs
@@ -66,10 +66,9 @@ fn model(app: &App) -> Model {
         .size(600, 600)
         .view(view)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
-    let assets = app.assets_path().unwrap();
+    let assets = app.assets_path();
     let img_path = assets
         .join("images")
         .join("generative_examples")
@@ -82,12 +81,12 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
     draw.background().color(WHITE);
     let win = app.window_rect();
     let tile_count = clamp(
-        map_range(app.mouse.x, win.left(), win.right(), 120, 1),
+        map_range(app.mouse().x, win.left(), win.right(), 120, 1),
         120,
         1,
     );
@@ -106,7 +105,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
             let blue = c[2] as f32 / 255.0;
             let alpha = c[3] as f32 / 255.0;
 
-            colors.push(rgba(red, green, blue, alpha));
+            colors.push(Srgba::new(red, green, blue, alpha));
         }
     }
 
@@ -127,62 +126,61 @@ fn view(app: &App, model: &Model, frame: Frame) {
             i += 1;
         }
     }
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_released(app: &App, model: &mut Model, key: Key) {
-    let assets = app.assets_path().unwrap();
+fn key_released(app: &App, model: &mut Model, key: KeyCode) {
+    let assets = app.assets_path();
     let img_path = assets.join("images").join("generative_examples");
 
     match key {
-        Key::Q => {
+        KeyCode::KeyQ => {
             model.image = image::open(img_path.join("pic1.jpg")).unwrap();
         }
-        Key::W => {
+        KeyCode::KeyW => {
             model.image = image::open(img_path.join("pic2.jpg")).unwrap();
         }
-        Key::E => {
+        KeyCode::KeyE => {
             model.image = image::open(img_path.join("pic3.jpg")).unwrap();
         }
-        Key::R => {
+        KeyCode::KeyR => {
             model.image = image::open(img_path.join("pic4.jpg")).unwrap();
         }
-        Key::Key1 => {
+        KeyCode::Digit1 => {
             model.sort_mode = None;
         }
-        Key::Key2 => {
+        KeyCode::Digit2 => {
             model.sort_mode = Some(SortMode::Hue);
         }
-        Key::Key3 => {
+        KeyCode::Digit3 => {
             model.sort_mode = Some(SortMode::Saturation);
         }
-        Key::Key4 => {
+        KeyCode::Digit4 => {
             model.sort_mode = Some(SortMode::Brightness);
         }
-        Key::Key5 => {
+        KeyCode::Digit5 => {
             model.sort_mode = Some(SortMode::Grayscale);
         }
-        Key::Key6 => {
+        KeyCode::Digit6 => {
             model.sort_mode = Some(SortMode::Red);
         }
-        Key::Key7 => {
+        KeyCode::Digit7 => {
             model.sort_mode = Some(SortMode::Green);
         }
-        Key::Key8 => {
+        KeyCode::Digit8 => {
             model.sort_mode = Some(SortMode::Blue);
         }
-        Key::Key9 => {
+        KeyCode::Digit9 => {
             model.sort_mode = Some(SortMode::Alpha);
         }
-        Key::S => {
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
         _otherkey => (),
     }
 }
 
-fn sort_colors(colors: &mut Vec<Rgba>, mode: &SortMode) {
+fn sort_colors(colors: &mut Vec<Srgba>, mode: &SortMode) {
     match mode {
         SortMode::Red => {
             colors.sort_by(|a, b| a.red.partial_cmp(&b.red).unwrap());
@@ -195,15 +193,15 @@ fn sort_colors(colors: &mut Vec<Rgba>, mode: &SortMode) {
         }
         SortMode::Hue => {
             colors.sort_by(|a, b| {
-                let a: Hsl = a.clone().into();
-                let b: Hsl = b.clone().into();
+                let a: Hsla = (*a).into();
+                let b: Hsla = (*b).into();
                 a.hue.to_radians().partial_cmp(&b.hue.to_radians()).unwrap()
             });
         }
         SortMode::Saturation => {
             colors.sort_by(|a, b| {
-                let a: Hsl = a.clone().into();
-                let b: Hsl = b.clone().into();
+                let a: Hsla = (*a).into();
+                let b: Hsla = (*b).into();
 
                 // temporary fix until conrod bug with saturation is resolved
                 if a.saturation.is_nan() && b.saturation.is_nan() {
@@ -219,14 +217,14 @@ fn sort_colors(colors: &mut Vec<Rgba>, mode: &SortMode) {
         }
         SortMode::Brightness => {
             colors.sort_by(|a, b| {
-                let a: Hsl = a.clone().into();
-                let b: Hsl = b.clone().into();
+                let a: Hsla = (*a).into();
+                let b: Hsla = (*b).into();
                 a.lightness.partial_cmp(&b.lightness).unwrap()
             });
         }
         SortMode::Grayscale => {
             colors.sort_by(|a, b| {
-                let gray = |c: &Rgba| c.red * 0.222 + c.green * 0.707 + c.blue * 0.071;
+                let gray = |c: &Srgba| c.red * 0.222 + c.green * 0.707 + c.blue * 0.071;
                 gray(a).partial_cmp(&gray(b)).unwrap()
             });
         }
diff --git a/generative_design/color/p_1_2_3_01.rs b/generative_design/color/p_1_2_3_01.rs
index c4eb0505c..edeeec85f 100644
--- a/generative_design/color/p_1_2_3_01.rs
+++ b/generative_design/color/p_1_2_3_01.rs
@@ -54,8 +54,7 @@ fn model(app: &App) -> Model {
         .size(720, 720)
         .key_pressed(key_pressed)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     Model {
         tile_count_x,
@@ -66,65 +65,65 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn key_pressed(app: &App, model: &mut Model, key: Key) {
+fn key_pressed(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::Key1 => {
+        KeyCode::Digit1 => {
             for i in 0..model.tile_count_x {
                 model.hue_values[i] = random();
                 model.saturation_values[i] = random();
                 model.brightness_values[i] = random();
             }
         }
-        Key::Key2 => {
+        KeyCode::Digit2 => {
             for i in 0..model.tile_count_x {
                 model.hue_values[i] = random();
                 model.saturation_values[i] = random();
                 model.brightness_values[i] = 1.0;
             }
         }
-        Key::Key3 => {
+        KeyCode::Digit3 => {
             for i in 0..model.tile_count_x {
                 model.hue_values[i] = random();
                 model.saturation_values[i] = 1.0;
                 model.brightness_values[i] = random();
             }
         }
-        Key::Key4 => {
+        KeyCode::Digit4 => {
             for i in 0..model.tile_count_x {
                 model.hue_values[i] = 0.0;
                 model.saturation_values[i] = 0.0;
                 model.brightness_values[i] = random();
             }
         }
-        Key::Key5 => {
+        KeyCode::Digit5 => {
             for i in 0..model.tile_count_x {
                 model.hue_values[i] = 0.54;
                 model.saturation_values[i] = 1.0;
                 model.brightness_values[i] = random();
             }
         }
-        Key::Key6 => {
+        KeyCode::Digit6 => {
             for i in 0..model.tile_count_x {
                 model.hue_values[i] = 0.54;
                 model.saturation_values[i] = random();
                 model.brightness_values[i] = 1.0;
             }
         }
-        Key::Key7 => {
+        KeyCode::Digit7 => {
             for i in 0..model.tile_count_x {
                 model.hue_values[i] = random_f32() * 0.5;
                 model.saturation_values[i] = random_f32() * 0.2 + 0.8;
                 model.brightness_values[i] = random_f32() * 0.4 + 0.5;
             }
         }
-        Key::Key8 => {
+        KeyCode::Digit8 => {
             for i in 0..model.tile_count_x {
                 model.hue_values[i] = random_f32() * 0.5 + 0.5;
                 model.saturation_values[i] = random_f32() * 0.2 + 0.8;
                 model.brightness_values[i] = random_f32() * 0.4 + 0.5;
             }
         }
-        Key::Key9 => {
+        KeyCode::Digit9 => {
             for i in 0..model.tile_count_x {
                 if i % 2 == 0 {
                     model.hue_values[i] = random();
@@ -137,7 +136,7 @@ fn key_pressed(app: &App, model: &mut Model, key: Key) {
                 }
             }
         }
-        Key::Key0 => {
+        KeyCode::Digit0 => {
             for i in 0..model.tile_count_x {
                 if i % 2 == 0 {
                     model.hue_values[i] = 0.38;
@@ -150,25 +149,25 @@ fn key_pressed(app: &App, model: &mut Model, key: Key) {
                 }
             }
         }
-        Key::S => {
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
         _other_key => {}
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
 
     // white black
-    draw.background().rgb(0.0, 0.0, 0.2);
+    draw.background().srgb(0.0, 0.0, 0.2);
     let win_rect = app.window_rect();
 
     // limit mouse coordintes to canvas
-    let mx = (app.mouse.x - win_rect.left()).max(1.0).min(win_rect.w());
-    let my = (win_rect.top() - app.mouse.y).max(1.0).min(win_rect.h());
+    let mx = (app.mouse().x - win_rect.left()).max(1.0).min(win_rect.w());
+    let my = (win_rect.top() - app.mouse().x).max(1.0).min(win_rect.h());
 
     // tile counter
     let mut counter = 0;
@@ -203,7 +202,4 @@ fn view(app: &App, model: &Model, frame: Frame) {
         }
         grid_y += 1;
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/generative_design/color/p_1_2_3_02.rs b/generative_design/color/p_1_2_3_02.rs
index b5a4d9877..29f6272fa 100644
--- a/generative_design/color/p_1_2_3_02.rs
+++ b/generative_design/color/p_1_2_3_02.rs
@@ -49,8 +49,7 @@ fn model(app: &App) -> Model {
         .view(view)
         .mouse_released(mouse_released)
         .key_pressed(key_pressed)
-        .build()
-        .unwrap();
+        .build();
 
     let color_count = 20;
 
@@ -69,7 +68,7 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(app: &App, model: &mut Model, _update: Update) {
+fn update(app: &App, model: &mut Model) {
     // Create palette
     for i in 0..model.color_count {
         if i % 2 == 0 {
@@ -88,7 +87,7 @@ fn update(app: &App, model: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
 
     if model.clicked {
@@ -128,7 +127,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
             // draw rects
             let mut sum_parts_now = 0;
             for ii in 0..parts.len() {
-                sum_parts_now += parts[ii as usize];
+                sum_parts_now += parts[ii];
 
                 let x = map_range(
                     sum_parts_now,
@@ -143,18 +142,15 @@ fn view(app: &App, model: &Model, frame: Frame) {
 
                 let index = counter % model.color_count;
                 draw.rect().x_y(x + (w / 2.0), y - (h / 2.0)).w_h(w, h).hsv(
-                    model.hue_values[index as usize],
-                    model.saturation_values[index as usize],
-                    model.brightness_values[index as usize],
+                    model.hue_values[index],
+                    model.saturation_values[index],
+                    model.brightness_values[index],
                 );
 
                 counter += 1;
             }
         }
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn mouse_released(app: &App, model: &mut Model, _button: MouseButton) {
@@ -162,9 +158,9 @@ fn mouse_released(app: &App, model: &mut Model, _button: MouseButton) {
     model.clicked_frame = app.elapsed_frames();
 }
 
-fn key_pressed(app: &App, _model: &mut Model, key: Key) {
-    if key == Key::S {
+fn key_pressed(app: &App, _model: &mut Model, key: KeyCode) {
+    if key == KeyCode::KeyS {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
 }
diff --git a/generative_design/color/p_1_2_3_03.rs b/generative_design/color/p_1_2_3_03.rs
index e09c90d41..c0ac313c1 100644
--- a/generative_design/color/p_1_2_3_03.rs
+++ b/generative_design/color/p_1_2_3_03.rs
@@ -53,8 +53,7 @@ fn model(app: &App) -> Model {
         .view(view)
         .mouse_released(mouse_released)
         .key_pressed(key_pressed)
-        .build()
-        .unwrap();
+        .build();
 
     let color_count = 20;
 
@@ -75,7 +74,7 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(app: &App, model: &mut Model, _update: Update) {
+fn update(app: &App, model: &mut Model) {
     let mut rng = StdRng::seed_from_u64(model.act_random_seed);
 
     // Create palette
@@ -96,19 +95,19 @@ fn update(app: &App, model: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
     let mut rng = StdRng::seed_from_u64(model.act_random_seed);
 
     if model.clicked {
-        frame.clear(BLACK);
+        draw.background().color(BLACK);
         // ------ area tiling ------
         // count tiles
         let mut counter = 0;
         // row count and row height
         let row_count = rng.gen_range(5..30);
-        let row_height = (app.window_rect().h() as i32 / row_count) as i32;
+        let row_height = app.window_rect().h() as i32 / row_count;
 
         // seperate each line in parts
         for i in (0..=row_count).rev() {
@@ -139,7 +138,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
             // draw rects
             let mut sum_parts_now = 0;
             for ii in 0..parts.len() {
-                sum_parts_now += parts[ii as usize];
+                sum_parts_now += parts[ii];
 
                 let x = map_range(
                     sum_parts_now,
@@ -157,10 +156,10 @@ fn view(app: &App, model: &Model, frame: Frame) {
                 let points_colored = rect.corners_iter().map(|[x, y]| {
                     let lum = map_range(y, h / 2.0, -h / 2.0, 0.0, 1.0);
 
-                    let col = hsva(
-                        model.hue_values[index as usize],
-                        model.saturation_values[index as usize],
-                        model.brightness_values[index as usize],
+                    let col = Color::hsva(
+                        model.hue_values[index],
+                        model.saturation_values[index],
+                        model.brightness_values[index],
                         model.alpha_value * lum,
                     );
                     (pt2(x, y), col)
@@ -174,9 +173,6 @@ fn view(app: &App, model: &Model, frame: Frame) {
             }
         }
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn mouse_released(app: &App, model: &mut Model, _button: MouseButton) {
@@ -185,9 +181,9 @@ fn mouse_released(app: &App, model: &mut Model, _button: MouseButton) {
     model.clicked_frame = app.elapsed_frames();
 }
 
-fn key_pressed(app: &App, _model: &mut Model, key: Key) {
-    if key == Key::S {
+fn key_pressed(app: &App, _model: &mut Model, key: KeyCode) {
+    if key == KeyCode::KeyS {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
 }
diff --git a/generative_design/color/p_1_2_3_04.rs b/generative_design/color/p_1_2_3_04.rs
index 4c98a2c1b..90e462a88 100644
--- a/generative_design/color/p_1_2_3_04.rs
+++ b/generative_design/color/p_1_2_3_04.rs
@@ -53,8 +53,7 @@ fn model(app: &App) -> Model {
         .view(view)
         .mouse_released(mouse_released)
         .key_pressed(key_pressed)
-        .build()
-        .unwrap();
+        .build();
 
     let color_count = 20;
 
@@ -75,7 +74,7 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(app: &App, model: &mut Model, _update: Update) {
+fn update(app: &App, model: &mut Model) {
     let mut rng = StdRng::seed_from_u64(model.act_random_seed);
 
     // Create palette
@@ -96,19 +95,19 @@ fn update(app: &App, model: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
     let mut rng = StdRng::seed_from_u64(model.act_random_seed);
 
     if model.clicked {
-        frame.clear(BLACK);
+        draw.background().color(BLACK);
         // ------ area tiling ------
         // count tiles
         let mut counter = 0;
         // row count and row height
         let row_count = rng.gen_range(5..30);
-        let row_height = (app.window_rect().h() as i32 / row_count) as i32;
+        let row_height = app.window_rect().h() as i32 / row_count;
 
         // seperate each line in parts
         for i in (0..=row_count).rev() {
@@ -139,7 +138,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
             // draw rects
             let mut sum_parts_now = 0;
             for ii in 0..parts.len() {
-                sum_parts_now += parts[ii as usize];
+                sum_parts_now += parts[ii];
 
                 if rng.gen::<f32>() < 0.45 {
                     let x = map_range(
@@ -158,10 +157,10 @@ fn view(app: &App, model: &Model, frame: Frame) {
                     let points_colored = rect.corners_iter().map(|[x, y]| {
                         let lum = map_range(y, h / 2.0, -h / 2.0, 0.0, 1.0);
 
-                        let col = hsva(
-                            model.hue_values[index as usize],
-                            model.saturation_values[index as usize],
-                            model.brightness_values[index as usize],
+                        let col = Color::hsva(
+                            model.hue_values[index],
+                            model.saturation_values[index],
+                            model.brightness_values[index],
                             model.alpha_value * lum,
                         );
                         (pt2(x, y), col)
@@ -175,9 +174,6 @@ fn view(app: &App, model: &Model, frame: Frame) {
             }
         }
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn mouse_released(app: &App, model: &mut Model, _button: MouseButton) {
@@ -186,9 +182,9 @@ fn mouse_released(app: &App, model: &mut Model, _button: MouseButton) {
     model.clicked_frame = app.elapsed_frames();
 }
 
-fn key_pressed(app: &App, _model: &mut Model, key: Key) {
-    if key == Key::S {
+fn key_pressed(app: &App, _model: &mut Model, key: KeyCode) {
+    if key == KeyCode::KeyS {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
 }
diff --git a/generative_design/data_trees/m_5_1_01.rs b/generative_design/data_trees/m_5_1_01.rs
index fbec49e82..b4ea87657 100644
--- a/generative_design/data_trees/m_5_1_01.rs
+++ b/generative_design/data_trees/m_5_1_01.rs
@@ -41,15 +41,14 @@ fn model(app: &App) -> Model {
         .size(800, 800)
         .view(view)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
     Model {
         recursion_level: 6,
         start_radius: 200.0,
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -60,12 +59,9 @@ fn view(app: &App, model: &Model, frame: Frame) {
         0.0,
         model.start_radius,
         model.recursion_level,
-        app.mouse.x,
-        app.mouse.y,
+        app.mouse().x,
+        app.mouse().x,
     );
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 // Recursive function
@@ -85,7 +81,7 @@ fn draw_branch(draw: &Draw, x: f32, y: f32, radius: f32, level: u8, mx: f32, my:
     draw.path()
         .stroke()
         .stroke_weight(level as f32 * 2.0)
-        .rgba(0.0, 0.5, 0.69, 0.6)
+        .srgba(0.0, 0.5, 0.69, 0.6)
         .caps_round()
         .events(arc_path.iter());
 
@@ -99,7 +95,7 @@ fn draw_branch(draw: &Draw, x: f32, y: f32, radius: f32, level: u8, mx: f32, my:
     if level > 0 {
         // left branch
         draw_branch(
-            &draw,
+            draw,
             x - radius,
             y - radius / 2.0,
             radius / 2.0,
@@ -109,7 +105,7 @@ fn draw_branch(draw: &Draw, x: f32, y: f32, radius: f32, level: u8, mx: f32, my:
         );
         // right branch
         draw_branch(
-            &draw,
+            draw,
             x + radius,
             y - radius / 2.0,
             radius / 2.0,
@@ -120,21 +116,21 @@ fn draw_branch(draw: &Draw, x: f32, y: f32, radius: f32, level: u8, mx: f32, my:
     }
 }
 
-fn key_released(app: &App, model: &mut Model, key: Key) {
+fn key_released(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::Key1 => model.recursion_level = 1,
-        Key::Key2 => model.recursion_level = 2,
-        Key::Key3 => model.recursion_level = 3,
-        Key::Key4 => model.recursion_level = 4,
-        Key::Key5 => model.recursion_level = 5,
-        Key::Key6 => model.recursion_level = 6,
-        Key::Key7 => model.recursion_level = 7,
-        Key::Key8 => model.recursion_level = 8,
-        Key::Key9 => model.recursion_level = 9,
-        Key::Key0 => model.recursion_level = 0,
-        Key::S => {
+        KeyCode::Digit1 => model.recursion_level = 1,
+        KeyCode::Digit2 => model.recursion_level = 2,
+        KeyCode::Digit3 => model.recursion_level = 3,
+        KeyCode::Digit4 => model.recursion_level = 4,
+        KeyCode::Digit5 => model.recursion_level = 5,
+        KeyCode::Digit6 => model.recursion_level = 6,
+        KeyCode::Digit7 => model.recursion_level = 7,
+        KeyCode::Digit8 => model.recursion_level = 8,
+        KeyCode::Digit9 => model.recursion_level = 9,
+        KeyCode::Digit0 => model.recursion_level = 0,
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
         _other_key => {}
     }
diff --git a/generative_design/dynamic_data_structure/m_6_1_01.rs b/generative_design/dynamic_data_structure/m_6_1_01.rs
index 23bd1024f..6343e7db9 100644
--- a/generative_design/dynamic_data_structure/m_6_1_01.rs
+++ b/generative_design/dynamic_data_structure/m_6_1_01.rs
@@ -101,8 +101,7 @@ fn model(app: &App) -> Model {
         .size(1280, 720)
         .view(view)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
     let node_count = 200;
     let nodes = create_nodes(node_count, app.window_rect());
@@ -110,7 +109,7 @@ fn model(app: &App) -> Model {
     Model { nodes, node_count }
 }
 
-fn create_nodes(node_count: usize, win: Rect) -> Vec<Node> {
+fn create_nodes(node_count: usize, win: geom::Rect) -> Vec<Node> {
     (0..node_count)
         .map(|_| {
             Node::new(
@@ -152,7 +151,7 @@ fn attract(current_node: &Node, other_node: &Node) -> Vec2 {
     }
 }
 
-fn update(_app: &App, model: &mut Model, _update: Update) {
+fn update(_app: &App, model: &mut Model) {
     for i in 0..model.nodes.len() {
         // Let all nodes repel each other
         attract_nodes(&mut model.nodes, i);
@@ -161,32 +160,29 @@ fn update(_app: &App, model: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
 
-    if frame.nth() == 0 || app.keys.down.contains(&Key::R) {
+    if app.elapsed_frames() == 0 || app.keys().just_pressed(KeyCode::KeyR) {
         draw.background().color(WHITE);
     } else {
         draw.rect()
             .wh(app.window_rect().wh())
-            .rgba(1.0, 1.0, 1.0, 0.07);
+            .srgba(1.0, 1.0, 1.0, 0.07);
     }
 
     model.nodes.iter().for_each(|node| {
         draw.ellipse().x_y(node.x, node.y).radius(5.0).color(BLACK);
     });
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_released(app: &App, model: &mut Model, key: Key) {
+fn key_released(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::R => model.nodes = create_nodes(model.node_count, app.window_rect()),
-        Key::S => {
+        KeyCode::KeyR => model.nodes = create_nodes(model.node_count, app.window_rect()),
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
         _other_key => {}
     }
diff --git a/generative_design/dynamic_data_structure/m_6_1_02.rs b/generative_design/dynamic_data_structure/m_6_1_02.rs
index b2b62be98..8312ddfb2 100644
--- a/generative_design/dynamic_data_structure/m_6_1_02.rs
+++ b/generative_design/dynamic_data_structure/m_6_1_02.rs
@@ -98,8 +98,7 @@ fn model(app: &App) -> Model {
         .size(1280, 720)
         .view(view)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
     let win = app.window_rect();
     let node_a = Node::new(
@@ -143,7 +142,7 @@ fn spring(to_node: &mut Node, from_node: &mut Node) {
     from_node.velocity += force;
 }
 
-fn update(app: &App, model: &mut Model, _update: Update) {
+fn update(app: &App, model: &mut Model) {
     // update spring
     spring(&mut model.node_a, &mut model.node_b);
 
@@ -151,13 +150,13 @@ fn update(app: &App, model: &mut Model, _update: Update) {
     model.node_a.update();
     model.node_b.update();
 
-    if app.mouse.buttons.pressed().next().is_some() {
-        model.node_a.x = app.mouse.x;
-        model.node_a.y = app.mouse.y;
+    if app.mouse_buttons().get_just_pressed().count() > 0 {
+        model.node_a.x = app.mouse().x;
+        model.node_a.y = app.mouse().x;
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -167,7 +166,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
         .start(pt2(model.node_a.x, model.node_a.y))
         .end(pt2(model.node_b.x, model.node_b.y))
         .stroke_weight(4.0)
-        .rgb(0.0, 0.5, 0.64);
+        .srgb(0.0, 0.5, 0.64);
 
     // draw nodes
     draw.ellipse()
@@ -178,14 +177,11 @@ fn view(app: &App, model: &Model, frame: Frame) {
         .x_y(model.node_b.x, model.node_b.y)
         .radius(10.0)
         .color(BLACK);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_released(app: &App, _model: &mut Model, key: Key) {
-    if key == Key::S {
+fn key_released(app: &App, _model: &mut Model, key: KeyCode) {
+    if key == KeyCode::KeyS {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
 }
diff --git a/generative_design/dynamic_data_structure/m_6_1_03.rs b/generative_design/dynamic_data_structure/m_6_1_03.rs
index 41afb65cf..f5395e91e 100644
--- a/generative_design/dynamic_data_structure/m_6_1_03.rs
+++ b/generative_design/dynamic_data_structure/m_6_1_03.rs
@@ -105,8 +105,7 @@ fn model(app: &App) -> Model {
         .view(view)
         .mouse_released(mouse_released)
         .key_pressed(key_pressed)
-        .build()
-        .unwrap();
+        .build();
 
     let node_radius = 8.0;
     let node_count = 100;
@@ -132,7 +131,7 @@ fn create_connections(node_count: usize) -> Vec<(usize, usize)> {
         .collect()
 }
 
-fn create_nodes(node_count: usize, node_radius: f32, win: Rect) -> Vec<Node> {
+fn create_nodes(node_count: usize, node_radius: f32, win: geom::Rect) -> Vec<Node> {
     (0..node_count)
         .map(|_| {
             Node::new(
@@ -197,7 +196,7 @@ fn spring(nodes: &mut Vec<Node>, spring_connection: (usize, usize)) {
     nodes[from_node].velocity += force;
 }
 
-fn update(app: &App, model: &mut Model, _update: Update) {
+fn update(app: &App, model: &mut Model) {
     for i in 0..model.nodes.len() {
         // Let all nodes repel each other
         attract_nodes(&mut model.nodes, i);
@@ -213,11 +212,12 @@ fn update(app: &App, model: &mut Model, _update: Update) {
         model.nodes[i].update();
     }
 
-    if app.mouse.buttons.pressed().next().is_some() {
+    if app.mouse_buttons().get_just_pressed().count() > 0 {
         // Ignore anything greater than this distance
         let mut max_dist = 20.0;
         for i in 0..model.nodes.len() {
-            let d = pt2(app.mouse.x, app.mouse.y).distance(pt2(model.nodes[i].x, model.nodes[i].y));
+            let d =
+                pt2(app.mouse().x, app.mouse().x).distance(pt2(model.nodes[i].x, model.nodes[i].y));
             if d < max_dist && model.selected_node.is_none() {
                 model.selected_node = Some(i);
                 max_dist = d;
@@ -226,12 +226,12 @@ fn update(app: &App, model: &mut Model, _update: Update) {
     }
 
     if model.selected_node.is_some() {
-        model.nodes[model.selected_node.unwrap()].x = app.mouse.x;
-        model.nodes[model.selected_node.unwrap()].y = app.mouse.y;
+        model.nodes[model.selected_node.unwrap()].x = app.mouse().x;
+        model.nodes[model.selected_node.unwrap()].y = app.mouse().x;
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -243,7 +243,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
             .start(pt2(model.nodes[from].x, model.nodes[from].y))
             .end(pt2(model.nodes[to].x, model.nodes[to].y))
             .stroke_weight(2.0)
-            .rgb(0.0, 0.5, 0.64);
+            .srgb(0.0, 0.5, 0.64);
     });
 
     model.nodes.iter().for_each(|node| {
@@ -254,17 +254,14 @@ fn view(app: &App, model: &Model, frame: Frame) {
             .stroke(WHITE)
             .stroke_weight(2.0);
     });
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_pressed(app: &App, model: &mut Model, key: Key) {
-    if key == Key::S {
+fn key_pressed(app: &App, model: &mut Model, key: KeyCode) {
+    if key == KeyCode::KeyS {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
-    if key == Key::R {
+    if key == KeyCode::KeyR {
         model.nodes = create_nodes(model.node_count, model.node_radius, app.window_rect());
         model.spring_connections = create_connections(model.node_count);
     }
diff --git a/generative_design/dynamic_data_structure/m_6_2_01.rs b/generative_design/dynamic_data_structure/m_6_2_01.rs
index 11b438416..5c34e3975 100644
--- a/generative_design/dynamic_data_structure/m_6_2_01.rs
+++ b/generative_design/dynamic_data_structure/m_6_2_01.rs
@@ -22,7 +22,6 @@
  * and prints them to the console
  */
 use nannou::prelude::*;
-use wikipedia;
 
 fn main() {
     nannou::app(model).update(update).run();
@@ -31,7 +30,7 @@ fn main() {
 struct Model;
 
 fn model(app: &App) -> Model {
-    app.new_window().size(400, 400).view(view).build().unwrap();
+    app.new_window().size(400, 400).view(view).build();
 
     let wiki = wikipedia::Wikipedia {
         client: wikipedia::http::default::Client::default(),
@@ -49,12 +48,6 @@ fn model(app: &App) -> Model {
     Model
 }
 
-fn update(_app: &App, _model: &mut Model, _update: Update) {}
+fn update(_app: &App, _model: &mut Model) {}
 
-fn view(app: &App, _model: &Model, frame: Frame) {
-    // Begin drawing
-    let draw = app.draw();
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
-}
+fn view(app: &App, _model: &Model) {}
diff --git a/generative_design/image/p_4_0_01.rs b/generative_design/image/p_4_0_01.rs
index 7fd1fa31e..43a8a8d4a 100644
--- a/generative_design/image/p_4_0_01.rs
+++ b/generative_design/image/p_4_0_01.rs
@@ -35,7 +35,7 @@ fn main() {
 
 struct Model {
     // Store the window ID so we can refer to this specific window later if needed.
-    texture: wgpu::Texture,
+    texture: Handle<Image>,
 }
 
 fn model(app: &App) -> Model {
@@ -44,26 +44,24 @@ fn model(app: &App) -> Model {
         .size(650, 450)
         .view(view)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
     // Load the image from disk and upload it to a GPU texture.
-    let assets = app.assets_path().unwrap();
+    let assets = app.assets_path();
     let img_path = assets
         .join("images")
         .join("generative_examples")
         .join("p_4_0_01.jpg");
-    let texture = wgpu::Texture::from_path(app, img_path).unwrap();
+    let texture = app.asset_server().load(img_path);
     Model { texture }
 }
 
 // Draw the state of your `Model` into the given `Frame` here.
-fn view(app: &App, model: &Model, frame: Frame) {
-    frame.clear(BLACK);
-
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
+    draw.background().color(BLACK);
     let win = app.window_rect();
-    let tile_count_x = map_range(app.mouse.x, win.left(), win.right(), 1.0, win.w() / 3.0);
-    let tile_count_y = map_range(app.mouse.y, win.top(), win.bottom(), 1.0, win.h() / 3.0);
+    let tile_count_x = map_range(app.mouse().x, win.left(), win.right(), 1.0, win.w() / 3.0);
+    let tile_count_y = map_range(app.mouse().x, win.top(), win.bottom(), 1.0, win.h() / 3.0);
     let step_x = win.w() / tile_count_x;
     let step_y = win.h() / tile_count_y;
 
@@ -71,16 +69,17 @@ fn view(app: &App, model: &Model, frame: Frame) {
         for grid_x in (0..win.w() as usize).step_by(step_x as usize) {
             let x = win.left() + grid_x as f32 + (step_x as f32 / 2.0);
             let y = win.top() - grid_y as f32 - (step_y as f32 / 2.0);
-            draw.texture(&model.texture).x_y(x, y).w_h(step_x, step_y);
+            draw.rect()
+                .texture(&model.texture)
+                .x_y(x, y)
+                .w_h(step_x, step_y);
         }
     }
-
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_released(app: &App, _model: &mut Model, key: Key) {
-    if key == Key::S {
+fn key_released(app: &App, _model: &mut Model, key: KeyCode) {
+    if key == KeyCode::KeyS {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
 }
diff --git a/generative_design/image/p_4_1_1_01.rs b/generative_design/image/p_4_1_1_01.rs
index 68998179b..ec693a380 100644
--- a/generative_design/image/p_4_1_1_01.rs
+++ b/generative_design/image/p_4_1_1_01.rs
@@ -17,6 +17,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use nannou::image::GenericImageView;
 /**
  * cutting and multiplying an area of the image
  *
@@ -36,12 +37,11 @@ fn main() {
 }
 
 struct Model {
-    // Store the window ID so we can refer to this specific window later if needed.
-    texture: wgpu::Texture,
+    texture: Handle<Image>,
     tile_count_x: usize,
     tile_count_y: usize,
     tile_count: usize,
-    img_tiles: Vec<Rect>,
+    img_tiles: Vec<geom::Rect>,
     tile_width: f32,
     tile_height: f32,
     crop_x: f32,
@@ -59,15 +59,14 @@ fn model(app: &App) -> Model {
         .mouse_moved(mouse_moved)
         .mouse_released(mouse_released)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
     // Load the image from disk and upload it to a GPU texture.
-    let assets = app.assets_path().unwrap();
+    let assets = app.assets_path();
     let img_path = assets
         .join("images")
         .join("generative_examples")
         .join("p_4_1_1_01.jpg");
-    let texture = wgpu::Texture::from_path(app, img_path).unwrap();
+    let texture = app.asset_server().load(img_path);
 
     let win = app.window_rect();
     let tile_count_x = 4;
@@ -88,7 +87,7 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn crop_tiles(app: &App, model: &mut Model, win: Rect) {
+fn crop_tiles(app: &App, model: &mut Model, win: geom::Rect) {
     model.tile_width = win.w() / model.tile_count_y as f32;
     model.tile_height = win.h() / model.tile_count_x as f32;
     model.tile_count = model.tile_count_x * model.tile_count_y;
@@ -97,26 +96,29 @@ fn crop_tiles(app: &App, model: &mut Model, win: Rect) {
         for _ in 0..model.tile_count_x {
             if model.random_mode {
                 model.crop_x = random_range(
-                    app.mouse.x - model.tile_width / 2.0,
-                    app.mouse.x + model.tile_width / 2.0,
+                    app.mouse().x - model.tile_width / 2.0,
+                    app.mouse().x + model.tile_width / 2.0,
                 );
                 model.crop_y = random_range(
-                    app.mouse.y - model.tile_height / 2.0,
-                    app.mouse.y + model.tile_height / 2.0,
+                    app.mouse().x - model.tile_height / 2.0,
+                    app.mouse().x + model.tile_height / 2.0,
                 );
             }
             model.crop_x = clamp(
                 model.crop_x,
-                win.left() + (model.tile_width as f32 / 2.0),
-                win.right() - (model.tile_width as f32 / 2.0),
+                win.left() + (model.tile_width / 2.0),
+                win.right() - (model.tile_width / 2.0),
             );
             model.crop_y = clamp(
                 model.crop_y,
-                win.top() - (model.tile_height as f32 / 2.0),
-                win.bottom() + (model.tile_height as f32 / 2.0),
+                win.top() - (model.tile_height / 2.0),
+                win.bottom() + (model.tile_height / 2.0),
             );
 
-            let [w, h] = model.texture.size();
+            let images = app.assets::<Image>();
+            let image = images.get(&model.texture).unwrap();
+            let image = image.clone().try_into_dynamic().unwrap();
+            let (w, h) = image.dimensions();
             let area = geom::Rect::from_x_y_w_h(
                 map_range(model.crop_x, win.left(), win.right(), 0.0, 1.0),
                 map_range(model.crop_y, win.top(), win.bottom(), 0.0, 1.0),
@@ -129,15 +131,15 @@ fn crop_tiles(app: &App, model: &mut Model, win: Rect) {
 }
 
 // Draw the state of your `Model` into the given `Frame` here.
-fn view(app: &App, model: &Model, frame: Frame) {
-    frame.clear(BLACK);
-
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
     let win = app.window_rect();
 
+    draw.background().color(BLACK);
+
     if model.select_mode {
         // in selection mode, a white selection rectangle is drawn over the image
-        draw.texture(&model.texture);
+        draw.rect().w_h(win.w(), win.h()).texture(&model.texture);
         draw.rect()
             .x_y(model.crop_x, model.crop_y)
             .w_h(model.tile_width, model.tile_height)
@@ -149,12 +151,10 @@ fn view(app: &App, model: &Model, frame: Frame) {
         let mut index = 0;
         for grid_y in 0..model.tile_count_y {
             for grid_x in 0..model.tile_count_x {
-                let x =
-                    win.left() + grid_x as f32 * model.tile_width + (model.tile_width as f32 / 2.0);
-                let y = win.top()
-                    - grid_y as f32 * model.tile_height
-                    - (model.tile_height as f32 / 2.0);
-                draw.texture(&model.texture)
+                let x = win.left() + grid_x as f32 * model.tile_width + (model.tile_width / 2.0);
+                let y = win.top() - grid_y as f32 * model.tile_height - (model.tile_height / 2.0);
+                draw.rect()
+                    .texture(&model.texture)
                     .x_y(x, y)
                     .w_h(model.tile_width, model.tile_height)
                     .area(model.img_tiles[index]);
@@ -162,8 +162,6 @@ fn view(app: &App, model: &Model, frame: Frame) {
             }
         }
     }
-
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn mouse_released(app: &App, model: &mut Model, _button: MouseButton) {
@@ -181,33 +179,33 @@ fn mouse_moved(app: &App, model: &mut Model, pos: Point2) {
 
     let htw = model.tile_width / 2.0;
     let hth = model.tile_height / 2.0;
-    model.crop_x = clamp(app.mouse.x, win.left() + htw, win.right() - htw);
-    model.crop_y = clamp(app.mouse.y, win.top() - hth, win.bottom() + hth);
+    model.crop_x = clamp(app.mouse().x, win.left() + htw, win.right() - htw);
+    model.crop_y = clamp(app.mouse().x, win.top() - hth, win.bottom() + hth);
 }
 
-fn key_released(app: &App, model: &mut Model, key: Key) {
+fn key_released(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::Key1 => {
+        KeyCode::Digit1 => {
             model.tile_count_x = 4;
             model.tile_count_y = 4;
             crop_tiles(app, model, app.window_rect());
         }
-        Key::Key2 => {
+        KeyCode::Digit2 => {
             model.tile_count_x = 10;
             model.tile_count_y = 10;
             crop_tiles(app, model, app.window_rect());
         }
-        Key::Key3 => {
+        KeyCode::Digit3 => {
             model.tile_count_x = 20;
             model.tile_count_y = 20;
             crop_tiles(app, model, app.window_rect());
         }
-        Key::R => {
+        KeyCode::KeyR => {
             model.random_mode = !model.random_mode;
         }
-        Key::S => {
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
         _other_key => {}
     }
diff --git a/generative_design/image/p_4_1_2_01.rs b/generative_design/image/p_4_1_2_01.rs
index 9c3763d79..036b05db1 100644
--- a/generative_design/image/p_4_1_2_01.rs
+++ b/generative_design/image/p_4_1_2_01.rs
@@ -32,7 +32,7 @@ fn main() {
 
 struct Model {
     // Store the window ID so we can refer to this specific window later if needed.
-    texture: wgpu::Texture,
+    texture: Handle<Image>,
 }
 
 fn model(app: &App) -> Model {
@@ -41,20 +41,25 @@ fn model(app: &App) -> Model {
         .size(1024, 780)
         .view(view)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
     // Load the image from disk and upload it to a GPU texture.
-    let assets = app.assets_path().unwrap();
+    let assets = app.assets_path();
     let img_path = assets
         .join("images")
         .join("generative_examples")
         .join("p_4_1_2_01.png");
-    let texture = wgpu::Texture::from_path(app, img_path).unwrap();
-    Model { texture }
+    let image = app.asset_server().load(img_path);
+    Model { texture: image }
 }
 
 // Draw the state of your `Model` into the given `Frame` here.
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
+    let images = app.assets::<Image>();
+    let Some(texture) = images.get(&model.texture) else {
+        return;
+    };
+
+    let draw = app.draw();
     let win = app.window_rect();
 
     let x1 = random_range(win.left(), win.right());
@@ -71,28 +76,22 @@ fn view(app: &App, model: &Model, frame: Frame) {
         map_range(h, 0.0, win.h(), 0.0, 1.0),
     );
 
-    // Don't interpolate between pixels.model
-    let sampler = wgpu::SamplerBuilder::new()
-        .min_filter(wgpu::FilterMode::Nearest)
-        .mag_filter(wgpu::FilterMode::Nearest)
-        .into_descriptor();
-    let draw = app.draw().sampler(sampler);
-
-    if frame.nth() == 0 || app.keys.down.contains(&Key::Delete) {
-        frame.clear(WHITE);
-        draw.texture(&model.texture);
+    let texture = model.texture.clone();
+    if app.elapsed_frames() == 0 || app.keys().just_pressed(KeyCode::Delete) {
+        draw.background().color(WHITE);
+        draw.rect().texture(&texture);
     } else {
-        draw.texture(&frame.resolve_target().unwrap_or(frame.texture_view()))
+        draw.rect()
             .x_y(x2, y2)
             .w_h(w, h)
+            .texture(&texture)
             .area(area);
     }
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_released(app: &App, _model: &mut Model, key: Key) {
-    if key == Key::S {
+fn key_released(app: &App, _model: &mut Model, key: KeyCode) {
+    if key == KeyCode::KeyS {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
 }
diff --git a/generative_design/image/p_4_1_2_02.rs b/generative_design/image/p_4_1_2_02.rs
index 25aef8b00..dc92cd833 100644
--- a/generative_design/image/p_4_1_2_02.rs
+++ b/generative_design/image/p_4_1_2_02.rs
@@ -32,7 +32,7 @@ fn main() {
 
 struct Model {
     // Store the window ID so we can refer to this specific window later if needed.
-    texture: wgpu::Texture,
+    texture: Handle<Image>,
 }
 
 fn model(app: &App) -> Model {
@@ -41,21 +41,26 @@ fn model(app: &App) -> Model {
         .size(1024, 580)
         .view(view)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
     // Load the image from disk and upload it to a GPU texture.
-    let assets = app.assets_path().unwrap();
+    let assets = app.assets_path();
     let img_path = assets
         .join("images")
         .join("generative_examples")
         .join("p_4_1_2_01.png");
-    let texture = wgpu::Texture::from_path(app, img_path).unwrap();
+    let texture = app.asset_server().load(img_path);
     Model { texture }
 }
 
 // Draw the state of your `Model` into the given `Frame` here.
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
+    let draw = app.draw();
+    let images = app.assets::<Image>();
+    let Some(texture) = images.get(&model.texture) else {
+        return;
+    };
+
     let win = app.window_rect();
 
     let w = 150.0;
@@ -73,27 +78,23 @@ fn view(app: &App, model: &Model, frame: Frame) {
     );
 
     // Don't interpolate between pixels.model
-    let sampler = wgpu::SamplerBuilder::new()
-        .min_filter(wgpu::FilterMode::Nearest)
-        .mag_filter(wgpu::FilterMode::Nearest)
-        .into_descriptor();
-    let draw = app.draw().sampler(sampler);
 
-    if frame.nth() == 0 || app.keys.down.contains(&Key::Delete) {
-        frame.clear(WHITE);
-        draw.texture(&model.texture);
+    let texture = model.texture.clone();
+    if app.elapsed_frames() == 0 || app.keys().just_pressed(KeyCode::Delete) {
+        draw.background().color(WHITE);
+        draw.rect().texture(&texture);
     } else {
-        draw.texture(&frame.resolve_target().unwrap_or(frame.texture_view()))
+        draw.rect()
+            .texture(&texture)
             .x_y(x2, y2)
             .w_h(w, h)
             .area(area);
     }
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_released(app: &App, _model: &mut Model, key: Key) {
-    if key == Key::S {
+fn key_released(app: &App, _model: &mut Model, key: KeyCode) {
+    if key == KeyCode::KeyS {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
 }
diff --git a/generative_design/image/p_4_3_1_01.rs b/generative_design/image/p_4_3_1_01.rs
index edbc56a1a..a433f02eb 100644
--- a/generative_design/image/p_4_3_1_01.rs
+++ b/generative_design/image/p_4_3_1_01.rs
@@ -1,3 +1,5 @@
+use nannou::image;
+use nannou::image::GenericImageView;
 // P_4_3_1_01
 //
 // Generative Gestaltung – Creative Coding im Web
@@ -28,9 +30,6 @@
  */
 use nannou::prelude::*;
 
-use nannou::image;
-use nannou::image::GenericImageView;
-
 fn main() {
     nannou::app(model).run();
 }
@@ -46,10 +45,9 @@ fn model(app: &App) -> Model {
         .size(603, 873)
         .view(view)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
-    let assets = app.assets_path().unwrap();
+    let assets = app.assets_path();
     let img_path = assets
         .join("images")
         .join("generative_examples")
@@ -63,14 +61,13 @@ fn model(app: &App) -> Model {
 }
 
 // Draw the state of your `Model` into the given `Frame` here.
-fn view(app: &App, model: &Model, frame: Frame) {
-    frame.clear(WHITE);
-
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
+    draw.background().color(WHITE);
     let win = app.window_rect();
 
-    let mouse_x_factor = map_range(app.mouse.x, win.left(), win.right(), 0.01, 1.0);
-    let mouse_y_factor = map_range(app.mouse.y, win.bottom(), win.top(), 0.01, 1.0);
+    let mouse_x_factor = map_range(app.mouse().x, win.left(), win.right(), 0.01, 1.0);
+    let mouse_y_factor = map_range(app.mouse().x, win.bottom(), win.top(), 0.01, 1.0);
 
     let (w, h) = model.image.dimensions();
     for grid_x in 0..w {
@@ -152,7 +149,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
                         .start(pt2(pos_x - d1, pos_y - d1))
                         .end(pt2(pos_x + tile_width - d2, pos_y - d2))
                         .weight(w5 * mouse_y_factor + 0.1)
-                        .rgb(red, green, blue);
+                        .srgb(red, green, blue);
                 }
                 6 => {
                     // pixel color to fill, greyscale to ellipse size
@@ -160,7 +157,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
                     draw.ellipse()
                         .x_y(pos_x, pos_y)
                         .w_h(w6 * mouse_x_factor, w6 * mouse_x_factor)
-                        .rgb(red, green, blue);
+                        .srgb(red, green, blue);
                 }
                 7 => {
                     let w7 = map_range(greyscale, 0.0, 1.0, 5.0, 0.1);
@@ -171,11 +168,11 @@ fn view(app: &App, model: &Model, frame: Frame) {
                         .x_y(0.0, 0.0)
                         .w_h(15.0, 15.0)
                         .stroke_weight(w7)
-                        .stroke(rgb(red, green, blue))
-                        .rgba(1.0, 1.0, 1.0, mouse_x_factor);
+                        .stroke(Color::srgb(red, green, blue))
+                        .srgba(1.0, 1.0, 1.0, mouse_x_factor);
                 }
                 8 => {
-                    let col = rgb(greyscale, greyscale * mouse_x_factor, mouse_y_factor);
+                    let col = Color::srgb(greyscale, greyscale * mouse_x_factor, mouse_y_factor);
                     draw.rect().x_y(pos_x, pos_y).w_h(3.5, 3.5).color(col);
                     draw.rect().x_y(pos_x + 4.0, pos_y).w_h(3.5, 3.5).color(col);
                     draw.rect().x_y(pos_x, pos_y - 4.0).w_h(3.5, 3.5).color(col);
@@ -190,55 +187,54 @@ fn view(app: &App, model: &Model, frame: Frame) {
                         .x_y(0.0, 0.0)
                         .w_h(15.0 * mouse_x_factor, 15.0 * mouse_y_factor)
                         .stroke_weight(1.0)
-                        .stroke(rgb(1.0, greyscale, 0.0))
+                        .stroke(Color::srgb(1.0, greyscale, 0.0))
                         .no_fill();
                     let w9 = map_range(greyscale, 0.0, 1.0, 15.0, 0.1);
                     draw.ellipse()
                         .x_y(0.0, 0.0)
                         .w_h(5.0, 2.5)
                         .stroke_weight(w9)
-                        .stroke(rgb(0.0, 0.0, 0.27))
+                        .stroke(Color::srgb(0.0, 0.0, 0.27))
                         .no_fill();
                 }
                 _ => (),
             }
         }
     }
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_released(app: &App, model: &mut Model, key: Key) {
+fn key_released(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::Key1 => {
+        KeyCode::Digit1 => {
             model.draw_mode = 1;
         }
-        Key::Key2 => {
+        KeyCode::Digit2 => {
             model.draw_mode = 2;
         }
-        Key::Key3 => {
+        KeyCode::Digit3 => {
             model.draw_mode = 3;
         }
-        Key::Key4 => {
+        KeyCode::Digit4 => {
             model.draw_mode = 4;
         }
-        Key::Key5 => {
+        KeyCode::Digit5 => {
             model.draw_mode = 5;
         }
-        Key::Key6 => {
+        KeyCode::Digit6 => {
             model.draw_mode = 6;
         }
-        Key::Key7 => {
+        KeyCode::Digit7 => {
             model.draw_mode = 7;
         }
-        Key::Key8 => {
+        KeyCode::Digit8 => {
             model.draw_mode = 8;
         }
-        Key::Key9 => {
+        KeyCode::Digit9 => {
             model.draw_mode = 9;
         }
-        Key::S => {
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
         _otherkey => (),
     }
diff --git a/generative_design/image/p_4_3_1_02.rs b/generative_design/image/p_4_3_1_02.rs
index 73247e5da..0f1c9579f 100644
--- a/generative_design/image/p_4_3_1_02.rs
+++ b/generative_design/image/p_4_3_1_02.rs
@@ -1,3 +1,6 @@
+use nannou::image::GenericImageView;
+use nannou::lyon::math::Point;
+use nannou::lyon::path::PathEvent;
 // P_4_3_1_02
 //
 // Generative Gestaltung – Creative Coding im Web
@@ -25,17 +28,12 @@
  */
 use nannou::prelude::*;
 
-use nannou::image;
-use nannou::image::GenericImageView;
-use nannou::lyon::math::Point;
-use nannou::lyon::path::PathEvent;
-
 fn main() {
     nannou::app(model).run();
 }
 
 struct Model {
-    image: image::DynamicImage,
+    image: Handle<Image>,
     shapes: Vec<SvgPath>,
 }
 
@@ -43,11 +41,11 @@ struct Model {
 struct SvgPath {
     events: Vec<PathEvent>,
     weight: f32,
-    color: Rgba,
+    color: Srgba,
 }
 
 impl SvgPath {
-    fn new(events: Vec<PathEvent>, weight: f32, color: Rgba) -> Self {
+    fn new(events: Vec<PathEvent>, weight: f32, color: Srgba) -> Self {
         SvgPath {
             events,
             weight,
@@ -62,14 +60,9 @@ fn model(app: &App) -> Model {
         .size(600, 900)
         .view(view)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
-    let svg_assets_path = app
-        .assets_path()
-        .unwrap()
-        .join("svg")
-        .join("generative_examples");
+    let svg_assets_path = app.assets_path().join("svg").join("generative_examples");
 
     let mut assets = Vec::new();
     assets.push(svg_assets_path.join("056.svg"));
@@ -90,19 +83,20 @@ fn model(app: &App) -> Model {
 
     for asset in assets {
         let opt = usvg::Options::default();
+        info!("Loading svg file: {:?}", asset);
         let rtree = usvg::Tree::from_file(&asset, &opt).unwrap();
 
         for node in rtree.root().descendants() {
             if let usvg::NodeKind::Path(ref p) = *node.borrow() {
                 if let Some(ref stroke) = p.stroke {
                     let color = match stroke.paint {
-                        usvg::Paint::Color(c) => rgba(
+                        usvg::Paint::Color(c) => Color::srgba(
                             c.red as f32 / 255.0,
                             c.green as f32 / 255.0,
                             c.blue as f32 / 255.0,
                             1.0,
                         ),
-                        _ => rgba(0.0, 0.0, 0.0, 1.0),
+                        _ => Color::srgba(0.0, 0.0, 0.0, 1.0),
                     };
 
                     let path_events = convert_path(p);
@@ -110,37 +104,36 @@ fn model(app: &App) -> Model {
                     for e in path_events {
                         v.push(e);
                     }
-                    let path = SvgPath::new(v, stroke.width.value() as f32, color);
+                    let path = SvgPath::new(v, stroke.width.value() as f32, color.into());
                     shapes.push(path);
                 }
             }
         }
     }
 
-    let img_path = app
-        .assets_path()
-        .unwrap()
-        .join("images")
-        .join("generative_examples")
-        .join("p_4_3_1_01.png");
-
-    let image = image::open(img_path).unwrap();
+    let image = app
+        .asset_server()
+        .load("images/generative_examples/p_4_3_1_01.png");
 
     Model { image, shapes }
 }
 
 // Draw the state of your `Model` into the given `Frame` here.
-fn view(app: &App, model: &Model, frame: Frame) {
-    frame.clear(WHITE);
+fn view(app: &App, model: &Model) {
+    let draw = app.draw();
+    draw.background().color(WHITE);
 
     let draw = app.draw();
     let win = app.window_rect();
 
-    let (w, h) = model.image.dimensions();
+    let images = app.assets::<Image>();
+    let image = images.get(&model.image).unwrap();
+    let image = image.clone().try_into_dynamic().unwrap();
+    let (w, h) = image.dimensions();
     for grid_x in 0..w {
         for grid_y in 0..h {
             // get current color
-            let c = model.image.get_pixel(grid_x, grid_y);
+            let c = image.get_pixel(grid_x, grid_y);
             // greyscale conversion
             let red = c[0] as f32 / 255.0;
             let green = c[1] as f32 / 255.0;
@@ -162,18 +155,17 @@ fn view(app: &App, model: &Model, frame: Frame) {
             draw.path()
                 .stroke()
                 .stroke_weight(weight)
-                .rgb(red, green, blue)
+                .srgb(red, green, blue)
                 .events(e)
                 .x_y(pos_x, pos_y);
         }
     }
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_released(app: &App, _model: &mut Model, key: Key) {
-    if key == Key::S {
+fn key_released(app: &App, _model: &mut Model, key: KeyCode) {
+    if key == KeyCode::KeyS {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
 }
 
@@ -272,7 +264,7 @@ impl<'l> Iterator for PathConvIter<'l> {
     }
 }
 
-pub fn convert_path<'a>(p: &'a usvg::Path) -> PathConvIter<'a> {
+pub fn convert_path(p: &usvg::Path) -> PathConvIter<'_> {
     PathConvIter {
         iter: p.segments.iter(),
         first: Point::new(0.0, 0.0),
diff --git a/generative_design/image/p_4_3_2_01.rs b/generative_design/image/p_4_3_2_01.rs
index a7e1a92c1..e9c25a365 100644
--- a/generative_design/image/p_4_3_2_01.rs
+++ b/generative_design/image/p_4_3_2_01.rs
@@ -17,6 +17,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use nannou::image::GenericImageView;
 /**
  * pixel mapping. each pixel is translated into a new element (letter)
  *
@@ -29,15 +30,12 @@
  */
 use nannou::prelude::*;
 
-use nannou::image;
-use nannou::image::GenericImageView;
-
 fn main() {
     nannou::app(model).run();
 }
 
 struct Model {
-    image: image::DynamicImage,
+    image: Handle<Image>,
     input_text: String,
     font_size_min: u32,
     font_size_max: u32,
@@ -48,17 +46,16 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    app.set_loop_mode(LoopMode::Wait);
+    app.set_update_mode(UpdateMode::wait());
 
     app.new_window()
         .size(533, 796)
         .view(view)
         .key_pressed(key_pressed)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
-    let assets = app.assets_path().unwrap();
+    let assets = app.assets_path();
     let img_path = assets
         .join("images")
         .join("generative_examples")
@@ -66,7 +63,7 @@ fn model(app: &App) -> Model {
 
     let input_text = "All the world's a stage, And all the men and women merely players; They have their exits and their entrances; And one man in his time plays many parts, His acts being seven ages. At first the infant, Mewling and puking in the nurse\'s arms; Then the whining school-boy, with his satchel And shining morning face, creeping like snail Unwillingly to school. And then the lover, Sighing like furnace, with a woeful ballad Made to his mistress\' eyebrow. Then a soldier, Full of strange oaths, and bearded like the pard, Jealous in honour, sudden and quick in quarrel, Seeking the bubble reputation Even in the cannon\'s mouth. And then the justice, In fair round belly with good capon lin\'d, With eyes severe and beard of formal cut, Full of wise saws and modern instances; And so he plays his part. The sixth age shifts Into the lean and slipper\'d pantaloon, With spectacles on nose and pouch on side, His youthful hose, well sav\'d, a world too wide For his shrunk shank; and his big manly voice, Turning again toward childish treble, pipes And whistles in his sound. Last scene of all, That ends this strange eventful history, Is second childishness and mere oblivion; Sans teeth, sans eyes, sans taste, sans every thing.".to_string();
 
-    let image = image::open(img_path).unwrap();
+    let image = app.asset_server().load(img_path);
     Model {
         image,
         input_text,
@@ -80,23 +77,26 @@ fn model(app: &App) -> Model {
 }
 
 // Draw the state of your `Model` into the given `Frame` here.
-fn view(app: &App, model: &Model, frame: Frame) {
-    frame.clear(WHITE);
-
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
+    draw.background().color(WHITE);
     let win = app.window_rect();
 
     let mut x = win.left();
     let mut y = win.top();
     let mut counter = 0;
 
+    let images = app.assets::<Image>();
+    let image = images.get(&model.image).unwrap();
+    let image = image.clone().try_into_dynamic().unwrap();
+    let (w, h) = image.dimensions();
+
     while y > win.bottom() {
         // translate position (display) to position (image)
-        let (w, h) = model.image.dimensions();
         let img_x = map_range(x, win.left(), win.right(), 0, w);
         let img_y = map_range(y, win.top(), win.bottom(), 0, h);
         // get current color
-        let c = model.image.get_pixel(img_x, img_y);
+        let c = image.get_pixel(img_x, img_y);
         // greyscale conversion
         let red = c[0] as f32 / 255.0;
         let green = c[1] as f32 / 255.0;
@@ -107,9 +107,9 @@ fn view(app: &App, model: &Model, frame: Frame) {
 
         let (font_size, col) = if model.font_size_static {
             let col = if model.black_and_white {
-                rgb(greyscale, greyscale, greyscale)
+                Color::srgb(greyscale, greyscale, greyscale)
             } else {
-                rgb(red, green, blue)
+                Color::srgb(red, green, blue)
             };
             (model.font_size_max, col)
         } else {
@@ -123,9 +123,9 @@ fn view(app: &App, model: &Model, frame: Frame) {
             )
             .max(1);
             let col = if model.black_and_white {
-                rgb(0.0, 0.0, 0.0)
+                Color::srgb(0.0, 0.0, 0.0)
             } else {
-                rgb(red, green, blue)
+                Color::srgb(red, green, blue)
             };
             (font_size, col)
         };
@@ -150,42 +150,40 @@ fn view(app: &App, model: &Model, frame: Frame) {
             counter = 0;
         }
     }
-
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_pressed(_app: &App, model: &mut Model, key: Key) {
+fn key_pressed(_app: &App, model: &mut Model, key: KeyCode) {
     match key {
         // change fontSizeMax with arrow keys up/down
-        Key::Up => {
+        KeyCode::ArrowUp => {
             model.font_size_max += 2;
         }
-        Key::Down => {
+        KeyCode::ArrowDown => {
             model.font_size_max -= 2;
         }
         // change fontSizeMin with arrow keys left/right
-        Key::Right => {
+        KeyCode::ArrowRight => {
             model.font_size_min += 2;
         }
-        Key::Left => {
+        KeyCode::ArrowLeft => {
             model.font_size_min -= 2;
         }
         _otherkey => (),
     }
 }
 
-fn key_released(app: &App, model: &mut Model, key: Key) {
+fn key_released(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::S => {
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
         // change render mode
-        Key::Key1 => {
+        KeyCode::Digit1 => {
             model.font_size_static = !model.font_size_static;
         }
         // change color style
-        Key::Key2 => {
+        KeyCode::Digit2 => {
             model.black_and_white = !model.black_and_white;
         }
         _otherkey => (),
diff --git a/generative_design/oscillation_figures/m_2_1_01.rs b/generative_design/oscillation_figures/m_2_1_01.rs
index 2dc22870c..112962f11 100644
--- a/generative_design/oscillation_figures/m_2_1_01.rs
+++ b/generative_design/oscillation_figures/m_2_1_01.rs
@@ -48,8 +48,7 @@ fn model(app: &App) -> Model {
         .size(800, 400)
         .view(view)
         .key_pressed(key_pressed)
-        .build()
-        .unwrap();
+        .build();
 
     Model {
         point_count: 20,
@@ -62,7 +61,7 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(app: &App, model: &mut Model, _update: Update) {
+fn update(app: &App, model: &mut Model) {
     if model.do_draw_animation {
         model.point_count = app.window_rect().w() as usize - 250;
         let t = fmod(app.elapsed_frames() as f32 / model.point_count as f32, 1.0);
@@ -70,13 +69,13 @@ fn update(app: &App, model: &mut Model, _update: Update) {
         model.x = (model.angle * model.freq + deg_to_rad(model.phi)).cos();
         model.x *= 100.0 - 125.0;
         model.y = (model.angle * model.freq + deg_to_rad(model.phi)).sin();
-        model.y = model.y * 100.0;
+        model.y *= 100.0;
     } else {
         model.point_count = app.window_rect().w() as usize;
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
     let win = app.window_rect();
 
@@ -95,9 +94,8 @@ fn view(app: &App, model: &Model, frame: Frame) {
             y *= 100.0;
             pt2(x_start + i as f32, y)
         })
-        .enumerate()
-        .map(|(_i, p)| {
-            let rgba = rgba(0.0, 0.0, 0.0, 1.0);
+        .map(|p| {
+            let rgba = Color::srgba(0.0, 0.0, 0.0, 1.0);
             (p, rgba)
         });
 
@@ -109,11 +107,11 @@ fn view(app: &App, model: &Model, frame: Frame) {
         draw.ellipse()
             .x_y(win.left() + 125.0, 0.0)
             .radius(100.0)
-            .stroke(gray(0.0))
+            .stroke(Color::gray(0.0))
             .no_fill();
 
         // Lines
-        let mut c = rgba(0.0, 0.0, 0.0, 0.5);
+        let mut c = Color::srgba(0.0, 0.0, 0.0, 0.5);
         draw.line()
             .start(pt2(x_start, -100.0))
             .end(pt2(x_start, 100.0))
@@ -137,7 +135,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
 
         let t = fmod(app.elapsed_frames() as f32 / model.point_count as f32, 1.0);
 
-        c = rgba(0.0, 0.5, 0.63, 1.0);
+        c = Color::srgba(0.0, 0.5, 0.63, 1.0);
         draw.line()
             .start(pt2(x_start + t * model.point_count as f32, model.y))
             .end(pt2(x_start + t * model.point_count as f32, 0.0))
@@ -153,7 +151,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
         let phi_y = deg_to_rad(model.phi).sin() * 100.0;
 
         // phi line
-        c = rgba(0.0, 0.0, 0.0, 0.5);
+        c = Color::srgba(0.0, 0.0, 0.0, 0.5);
         draw.line()
             .start(pt2(x_start - 125.0, 0.0))
             .end(pt2(x_start + phi_x, phi_y))
@@ -161,18 +159,18 @@ fn view(app: &App, model: &Model, frame: Frame) {
             .color(c);
 
         // phi dots
-        c = rgba(0.0, 0.0, 0.0, 1.0);
+        c = Color::srgba(0.0, 0.0, 0.0, 1.0);
         draw.ellipse()
             .x_y(x_start, phi_y)
             .radius(4.0)
             .color(c)
-            .stroke(gray(1.0))
+            .stroke(Color::gray(1.0))
             .stroke_weight(2.0);
         draw.ellipse()
             .x_y(x_start + phi_x, phi_y)
             .radius(4.0)
             .color(c)
-            .stroke(gray(1.0))
+            .stroke(Color::gray(1.0))
             .stroke_weight(2.0);
 
         // dot on curve
@@ -180,7 +178,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
             .x_y(x_start + t * model.point_count as f32, model.y)
             .radius(5.0)
             .color(c)
-            .stroke(gray(1.0))
+            .stroke(Color::gray(1.0))
             .stroke_weight(2.0);
 
         // dot on circle
@@ -188,34 +186,31 @@ fn view(app: &App, model: &Model, frame: Frame) {
             .x_y(x_start + model.x, model.y)
             .radius(5.0)
             .color(c)
-            .stroke(gray(1.0))
+            .stroke(Color::gray(1.0))
             .stroke_weight(2.0);
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_pressed(app: &App, model: &mut Model, key: Key) {
+fn key_pressed(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::Key1 => {
+        KeyCode::Digit1 => {
             model.freq -= 1.0;
         }
-        Key::Key2 => {
+        KeyCode::Digit2 => {
             model.freq += 1.0;
         }
-        Key::A => {
+        KeyCode::KeyA => {
             model.do_draw_animation = !model.do_draw_animation;
         }
-        Key::Left => {
+        KeyCode::ArrowLeft => {
             model.phi -= 15.0;
         }
-        Key::Right => {
+        KeyCode::ArrowRight => {
             model.phi += 15.0;
         }
-        Key::S => {
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
         _other_key => {}
     }
diff --git a/generative_design/oscillation_figures/m_2_2_01.rs b/generative_design/oscillation_figures/m_2_2_01.rs
index 831d5ad78..4ba3d5f24 100644
--- a/generative_design/oscillation_figures/m_2_2_01.rs
+++ b/generative_design/oscillation_figures/m_2_2_01.rs
@@ -51,8 +51,7 @@ fn model(app: &App) -> Model {
         .size(600, 600)
         .view(view)
         .key_pressed(key_pressed)
-        .build()
-        .unwrap();
+        .build();
 
     Model {
         point_count: 600,
@@ -67,7 +66,7 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(app: &App, model: &mut Model, _update: Update) {
+fn update(app: &App, model: &mut Model) {
     let t = fmod(app.elapsed_frames() as f32 / model.point_count as f32, 1.0);
     model.angle = map_range(t, 0.0, 1.0, 0.0, TAU);
     model.x = (model.angle * model.freq_x + deg_to_rad(model.phi)).sin();
@@ -76,7 +75,7 @@ fn update(app: &App, model: &mut Model, _update: Update) {
     model.y *= app.window_rect().h() / 4.0 - model.margin;
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
     let win = app.window_rect();
@@ -99,7 +98,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
         )
     };
 
-    let vertices = (0..=model.point_count)
+    let points_colored = (0..=model.point_count)
         .map(|i| {
             let angle = map_range(i, 0, model.point_count, 0.0, TAU);
             let mut x = (angle * model.freq_x + deg_to_rad(model.phi)).sin();
@@ -108,18 +107,17 @@ fn view(app: &App, model: &Model, frame: Frame) {
             y *= factor_y;
             pt2(xs + x, ys - y)
         })
-        .enumerate()
-        .map(|(_i, p)| {
-            let rgba = rgba(0.0, 0.0, 0.0, 1.0);
+        .map(|p| {
+            let rgba = Color::srgba(0.0, 0.0, 0.0, 1.0);
             (p, rgba)
         });
 
     // Draw the sine wave.
-    draw.polyline().weight(2.0).points_colored(vertices);
+    draw.polyline().weight(2.0).points_colored(points_colored);
 
     if model.do_draw_animation {
         // draw x oscillator
-        let vertices = (0..model.point_count)
+        let points_colored = (0..model.point_count)
             .map(|i| {
                 let angle = map_range(i, 0, model.point_count, 0.0, TAU);
                 let mut x = (angle * model.freq_x + deg_to_rad(model.phi)).sin();
@@ -128,16 +126,15 @@ fn view(app: &App, model: &Model, frame: Frame) {
                     + i as f32 / model.point_count as f32 * (win.h() / 2.0 - 2.0 * model.margin);
                 pt2(xs + x, ys - y)
             })
-            .enumerate()
-            .map(|(_i, p)| {
-                let rgba = rgba(0.0, 0.0, 0.0, 1.0);
+            .map(|p| {
+                let rgba = Color::srgba(0.0, 0.0, 0.0, 1.0);
                 (p, rgba)
             });
 
-        draw.polyline().weight(2.0).points_colored(vertices);
+        draw.polyline().weight(2.0).points_colored(points_colored);
 
         // draw y oscillator
-        let vertices = (0..model.point_count)
+        let points_colored = (0..model.point_count)
             .map(|i| {
                 let angle = map_range(i, 0, model.point_count, 0.0, TAU);
                 let mut y = (angle * model.freq_y).sin();
@@ -146,19 +143,18 @@ fn view(app: &App, model: &Model, frame: Frame) {
                     + i as f32 / model.point_count as f32 * (win.w() / 2.0 - 2.0 * model.margin);
                 pt2(xs + x, ys - y)
             })
-            .enumerate()
-            .map(|(_i, p)| {
-                let rgba = rgba(0.0, 0.0, 0.0, 1.0);
+            .map(|p| {
+                let rgba = Color::srgba(0.0, 0.0, 0.0, 1.0);
                 (p, rgba)
             });
-        draw.polyline().weight(2.0).points_colored(vertices);
+        draw.polyline().weight(2.0).points_colored(points_colored);
 
         let osc_yx = -win.w() * 2.0 / 3.0 - model.margin
             + fmod(model.angle / TAU, 1.0) * (win.w() / 2.0 - 2.0 * model.margin);
         let osc_xy = -win.h() * 2.0 / 3.0 - model.margin
             + fmod(model.angle / TAU, 1.0) * (win.h() / 2.0 - 2.0 * model.margin);
 
-        let c = rgba(0.0, 0.0, 0.0, 0.5);
+        let c = Color::srgba(0.0, 0.0, 0.0, 0.5);
         draw.line()
             .start(pt2(xs + model.x, ys - osc_xy))
             .end(pt2(xs + model.x, ys - model.y))
@@ -168,58 +164,55 @@ fn view(app: &App, model: &Model, frame: Frame) {
             .end(pt2(xs + model.x, ys - model.y))
             .color(c);
 
-        let c = rgba(0.0, 0.0, 0.0, 1.0);
+        let c = Color::srgba(0.0, 0.0, 0.0, 1.0);
         draw.ellipse()
             .x_y(xs + model.x, ys - osc_xy)
             .radius(4.0)
-            .stroke(gray(1.0))
+            .stroke(Color::gray(1.0))
             .stroke_weight(2.0)
             .color(c);
         draw.ellipse()
             .x_y(xs + osc_yx, ys - model.y)
             .radius(4.0)
-            .stroke(gray(1.0))
+            .stroke(Color::gray(1.0))
             .stroke_weight(2.0)
             .color(c);
 
         draw.ellipse()
             .x_y(xs + model.x, ys - model.y)
             .radius(5.0)
-            .stroke(gray(1.0))
+            .stroke(Color::gray(1.0))
             .stroke_weight(2.0)
             .color(c);
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_pressed(app: &App, model: &mut Model, key: Key) {
+fn key_pressed(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::Key1 => {
+        KeyCode::Digit1 => {
             model.freq_x -= 1.0;
         }
-        Key::Key2 => {
+        KeyCode::Digit2 => {
             model.freq_x += 1.0;
         }
-        Key::Key3 => {
+        KeyCode::Digit3 => {
             model.freq_y -= 1.0;
         }
-        Key::Key4 => {
+        KeyCode::Digit4 => {
             model.freq_y += 1.0;
         }
-        Key::A => {
+        KeyCode::KeyA => {
             model.do_draw_animation = !model.do_draw_animation;
         }
-        Key::Left => {
+        KeyCode::ArrowLeft => {
             model.phi -= 15.0;
         }
-        Key::Right => {
+        KeyCode::ArrowRight => {
             model.phi += 15.0;
         }
-        Key::S => {
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
         _other_key => {}
     }
diff --git a/generative_design/oscillation_figures/m_2_3_01.rs b/generative_design/oscillation_figures/m_2_3_01.rs
index d41537510..e31a13b00 100644
--- a/generative_design/oscillation_figures/m_2_3_01.rs
+++ b/generative_design/oscillation_figures/m_2_3_01.rs
@@ -49,8 +49,7 @@ fn model(app: &App) -> Model {
         .size(1000, 400)
         .view(view)
         .key_pressed(key_pressed)
-        .build()
-        .unwrap();
+        .build();
 
     Model {
         point_count: 1000,
@@ -62,11 +61,11 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(app: &App, model: &mut Model, _update: Update) {
+fn update(app: &App, model: &mut Model) {
     model.point_count = app.window_rect().w() as usize;
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
     let win = app.window_rect();
@@ -75,41 +74,39 @@ fn view(app: &App, model: &Model, frame: Frame) {
 
     // draw oscillator with freq and phi
     if model.draw_frequency {
-        let vertices = (0..=model.point_count)
+        let points_colored = (0..=model.point_count)
             .map(|i| {
                 let angle = map_range(i, 0, model.point_count, 0.0, TAU);
                 let mut y = (angle * model.freq + deg_to_rad(model.phi)).sin();
                 y *= win.h() / 4.0;
                 pt2(win.left() + i as f32, y)
             })
-            .enumerate()
-            .map(|(_i, p)| {
-                let rgba = rgba(0.0, 0.0, 0.0, 1.0);
+            .map(|p| {
+                let rgba = Color::srgba(0.0, 0.0, 0.0, 1.0);
                 (p, rgba)
             });
-        draw.polyline().weight(1.0).points_colored(vertices);
+        draw.polyline().weight(1.0).points_colored(points_colored);
     }
 
     // draw oscillator with mod_freq
     if model.draw_modulation {
-        let vertices = (0..=model.point_count)
+        let points_colored = (0..=model.point_count)
             .map(|i| {
                 let angle = map_range(i, 0, model.point_count, 0.0, TAU);
                 let mut y = (angle * model.mod_freq).cos();
                 y *= win.h() / 4.0;
                 pt2(win.left() + i as f32, y)
             })
-            .enumerate()
-            .map(|(_i, p)| {
-                let rgba = rgba(0.0, 0.5, 0.64, 0.5);
+            .map(|p| {
+                let rgba = Color::srgba(0.0, 0.5, 0.64, 0.5);
                 (p, rgba)
             });
-        draw.polyline().weight(1.0).points_colored(vertices);
+        draw.polyline().weight(1.0).points_colored(points_colored);
     }
 
     // draw both combined
     if model.draw_modulation {
-        let vertices = (0..=model.point_count)
+        let points_colored = (0..=model.point_count)
             .map(|i| {
                 let angle = map_range(i, 0, model.point_count, 0.0, TAU);
                 let info = (angle * model.freq + deg_to_rad(model.phi)).sin();
@@ -118,47 +115,43 @@ fn view(app: &App, model: &Model, frame: Frame) {
                 y *= win.h() / 4.0;
                 pt2(win.left() + i as f32, y)
             })
-            .enumerate()
-            .map(|(_i, p)| {
-                let rgba = rgba(0.30, 1.0, 0.64, 0.75);
+            .map(|p| {
+                let rgba = Color::srgba(0.30, 1.0, 0.64, 0.75);
                 (p, rgba)
             });
-        draw.polyline().weight(3.0).points_colored(vertices);
+        draw.polyline().weight(3.0).points_colored(points_colored);
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_pressed(app: &App, model: &mut Model, key: Key) {
+fn key_pressed(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::Key1 => {
+        KeyCode::Digit1 => {
             model.freq -= 1.0;
         }
-        Key::Key2 => {
+        KeyCode::Digit2 => {
             model.freq += 1.0;
         }
-        Key::Key7 => {
+        KeyCode::Digit7 => {
             model.mod_freq -= 1.0;
         }
-        Key::Key8 => {
+        KeyCode::Digit8 => {
             model.mod_freq += 1.0;
         }
-        Key::A => {
+        KeyCode::KeyA => {
             model.draw_frequency = !model.draw_frequency;
         }
-        Key::C => {
+        KeyCode::KeyC => {
             model.draw_modulation = !model.draw_modulation;
         }
-        Key::Left => {
+        KeyCode::ArrowLeft => {
             model.phi -= 15.0;
         }
-        Key::Right => {
+        KeyCode::ArrowRight => {
             model.phi += 15.0;
         }
-        Key::S => {
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
         _other_key => {}
     }
diff --git a/generative_design/oscillation_figures/m_2_3_02.rs b/generative_design/oscillation_figures/m_2_3_02.rs
index 43b074c5f..b6f87acf3 100644
--- a/generative_design/oscillation_figures/m_2_3_02.rs
+++ b/generative_design/oscillation_figures/m_2_3_02.rs
@@ -55,8 +55,7 @@ fn model(app: &App) -> Model {
         .size(600, 600)
         .view(view)
         .key_pressed(key_pressed)
-        .build()
-        .unwrap();
+        .build();
 
     let win = app.window_rect();
     let sq = |v: f32| -> f32 { v * v };
@@ -74,16 +73,16 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(app: &App, model: &mut Model, _update: Update) {
+fn update(app: &App, model: &mut Model) {
     let mx = clamp(
-        app.window_rect().right() + app.mouse.x,
+        app.window_rect().right() + app.mouse().x,
         0.0,
         app.window_rect().w(),
     );
     model.point_count = mx as usize * 2 + 200;
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
     let win = app.window_rect();
@@ -91,7 +90,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
     draw.background().color(WHITE);
 
     if model.draw_mode == 1 {
-        let vertices = (0..=model.point_count)
+        let points_colored = (0..=model.point_count)
             .map(|i| {
                 let angle = map_range(i, 0, model.point_count, 0.0, TAU);
                 let mut x = (angle * model.freq_x + deg_to_rad(model.phi)).sin()
@@ -101,12 +100,11 @@ fn view(app: &App, model: &Model, frame: Frame) {
                 y *= win.h() / 2.0 - 50.0;
                 pt2(x, y)
             })
-            .enumerate()
-            .map(|(_i, p)| {
-                let rgba = rgba(0.0, 0.0, 0.0, 1.0);
+            .map(|p| {
+                let rgba = Color::srgba(0.0, 0.0, 0.0, 1.0);
                 (p, rgba)
             });
-        draw.polyline().weight(1.0).points_colored(vertices);
+        draw.polyline().weight(1.0).points_colored(points_colored);
     } else if model.draw_mode == 2 {
         for i in 0..=model.point_count {
             let angle = map_range(i, 0, model.point_count, 0.0, TAU);
@@ -126,7 +124,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
                 old_x *= win.w() / 2.0 - 50.0;
                 old_y *= win.h() / 2.0 - 50.0;
                 let g = (i % 2 * 2) as f32;
-                let c = rgba(g, g, g, map_range(w, 0.0, model.max_dist, 1.0, 0.0));
+                let c = Color::srgba(g, g, g, map_range(w, 0.0, model.max_dist, 1.0, 0.0));
                 draw.line()
                     .start(pt2(old_x, old_y))
                     .end(pt2(x, y))
@@ -136,53 +134,50 @@ fn view(app: &App, model: &Model, frame: Frame) {
             }
         }
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_pressed(app: &App, model: &mut Model, key: Key) {
+fn key_pressed(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::D => {
+        KeyCode::KeyD => {
             if model.draw_mode == 1 {
                 model.draw_mode = 2;
             } else {
                 model.draw_mode = 1;
             }
         }
-        Key::Key1 => {
+        KeyCode::Digit1 => {
             model.freq_x -= 1.0;
         }
-        Key::Key2 => {
+        KeyCode::Digit2 => {
             model.freq_x += 1.0;
         }
-        Key::Key3 => {
+        KeyCode::Digit3 => {
             model.freq_y -= 1.0;
         }
-        Key::Key4 => {
+        KeyCode::Digit4 => {
             model.freq_y += 1.0;
         }
-        Key::Key7 => {
+        KeyCode::Digit7 => {
             model.mod_freq_x -= 1.0;
         }
-        Key::Key8 => {
+        KeyCode::Digit8 => {
             model.mod_freq_x += 1.0;
         }
-        Key::Key9 => {
+        KeyCode::Digit9 => {
             model.mod_freq_y -= 1.0;
         }
-        Key::Key0 => {
+        KeyCode::Digit0 => {
             model.mod_freq_y += 1.0;
         }
-        Key::Left => {
+        KeyCode::ArrowLeft => {
             model.phi -= 15.0;
         }
-        Key::Right => {
+        KeyCode::ArrowRight => {
             model.phi += 15.0;
         }
-        Key::S => {
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
         _other_key => {}
     }
diff --git a/generative_design/oscillation_figures/m_2_5_01.rs b/generative_design/oscillation_figures/m_2_5_01.rs
index 773e5b92a..5c26c0197 100644
--- a/generative_design/oscillation_figures/m_2_5_01.rs
+++ b/generative_design/oscillation_figures/m_2_5_01.rs
@@ -43,7 +43,7 @@ struct Model {
     mod_freq_x: f32,
     mod_freq_y: f32,
     line_weight: f32,
-    line_color: Rgba,
+    line_color: Srgba,
     line_alpha: f32,
     connection_radius: f32,
     should_draw: bool,
@@ -56,8 +56,7 @@ fn model(app: &App) -> Model {
         .size(800, 800)
         .view(view)
         .key_pressed(key_pressed)
-        .build()
-        .unwrap();
+        .build();
 
     let lissajous_points = Vec::new();
     let line_alpha = 0.2;
@@ -71,7 +70,7 @@ fn model(app: &App) -> Model {
         mod_freq_x: 3.0,
         mod_freq_y: 2.0,
         line_weight: 1.5,
-        line_color: rgba(0.0, 0.0, 0.0, line_alpha),
+        line_color: Srgba::new(0.0, 0.0, 0.0, line_alpha),
         line_alpha,
         connection_radius: 200.0,
         should_draw: true,
@@ -98,13 +97,13 @@ fn calculate_lissajous_points(app: &App, model: &mut Model) {
     }
 }
 
-fn update(app: &App, model: &mut Model, _update: Update) {
+fn update(app: &App, model: &mut Model) {
     if model.should_draw_frame != app.elapsed_frames() {
         model.should_draw = false;
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
 
     if model.should_draw {
@@ -128,45 +127,43 @@ fn view(app: &App, model: &Model, frame: Frame) {
             }
         }
     }
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_pressed(app: &App, model: &mut Model, key: Key) {
+fn key_pressed(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::Key1 => {
+        KeyCode::Digit1 => {
             model.freq_x -= 1.0;
         }
-        Key::Key2 => {
+        KeyCode::Digit2 => {
             model.freq_x += 1.0;
         }
-        Key::Key3 => {
+        KeyCode::Digit3 => {
             model.freq_y -= 1.0;
         }
-        Key::Key4 => {
+        KeyCode::Digit4 => {
             model.freq_y += 1.0;
         }
-        Key::Key7 => {
+        KeyCode::Digit7 => {
             model.mod_freq_x -= 1.0;
         }
-        Key::Key8 => {
+        KeyCode::Digit8 => {
             model.mod_freq_x += 1.0;
         }
-        Key::Key9 => {
+        KeyCode::Digit9 => {
             model.mod_freq_y -= 1.0;
         }
-        Key::Key0 => {
+        KeyCode::Digit0 => {
             model.mod_freq_y += 1.0;
         }
-        Key::Left => {
+        KeyCode::ArrowLeft => {
             model.phi -= 15.0;
         }
-        Key::Right => {
+        KeyCode::ArrowRight => {
             model.phi += 15.0;
         }
-        Key::S => {
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
         _other_key => {}
     }
diff --git a/generative_design/oscillation_figures/m_2_5_02.rs b/generative_design/oscillation_figures/m_2_5_02.rs
index c7dacec6e..fa762a60f 100644
--- a/generative_design/oscillation_figures/m_2_5_02.rs
+++ b/generative_design/oscillation_figures/m_2_5_02.rs
@@ -61,8 +61,7 @@ fn model(app: &App) -> Model {
         .size(800, 800)
         .key_pressed(key_pressed)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     let lissajous_points = Vec::new();
 
@@ -95,7 +94,7 @@ fn model(app: &App) -> Model {
     model
 }
 
-fn update(_app: &App, model: &mut Model, _update: Update) {
+fn update(_app: &App, model: &mut Model) {
     model.point_index += 1;
 
     if model.point_index >= model.point_count - 1 {
@@ -103,7 +102,7 @@ fn update(_app: &App, model: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
 
     if app.elapsed_frames() == 1 {
@@ -118,7 +117,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
             for i in 0..(model.point_count - 1) {
                 draw_line(
                     &draw,
-                    &model,
+                    model,
                     model.lissajous_points[i],
                     model.lissajous_points[i + 1],
                 );
@@ -127,15 +126,13 @@ fn view(app: &App, model: &Model, frame: Frame) {
             for i2 in 0..model.point_index {
                 draw_line(
                     &draw,
-                    &model,
+                    model,
                     model.lissajous_points[model.point_index],
                     model.lissajous_points[i2],
                 );
             }
         }
     }
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn draw_line(draw: &Draw, model: &Model, p1: Point2, p2: Point2) {
@@ -151,7 +148,7 @@ fn draw_line(draw: &Draw, model: &Model, p1: Point2, p2: Point2) {
         } else {
             model.brightness_value
         };
-        let c = hsva(
+        let c = Color::hsva(
             hue,
             model.saturation_value,
             b,
@@ -192,9 +189,9 @@ fn calculate_lissajous_points(app: &App, model: &mut Model) {
     }
 }
 
-fn key_pressed(app: &App, _model: &mut Model, key: Key) {
-    if key == Key::S {
+fn key_pressed(app: &App, _model: &mut Model, key: KeyCode) {
+    if key == KeyCode::KeyS {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
 }
diff --git a/generative_design/random_and_noise/m_1_1_01.rs b/generative_design/random_and_noise/m_1_1_01.rs
index 36a191ed0..1c319bf6c 100644
--- a/generative_design/random_and_noise/m_1_1_01.rs
+++ b/generative_design/random_and_noise/m_1_1_01.rs
@@ -45,15 +45,14 @@ fn model(app: &App) -> Model {
         .view(view)
         .key_pressed(key_pressed)
         .mouse_pressed(mouse_pressed)
-        .build()
-        .unwrap();
+        .build();
 
     Model {
         act_random_seed: 42,
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
     let win = app.window_rect();
 
@@ -63,34 +62,32 @@ fn view(app: &App, model: &Model, frame: Frame) {
 
     let range = win.w() as usize / 10;
     let vertices = (0..=range).map(|i| {
-        let y = rng.gen_range(win.bottom()..win.top() + 1.0) as f32;
-        pt2(win.left() + (i as f32 * 10.0), y as f32)
+        let y = rng.gen_range(win.bottom()..win.top() + 1.0);
+        pt2(win.left() + (i as f32 * 10.0), y)
     });
     draw.polyline()
         .weight(1.0)
         .points(vertices)
-        .rgb(0.0, 0.5, 0.64);
+        .srgb(0.0, 0.5, 0.64);
 
     let mut rng = StdRng::seed_from_u64(model.act_random_seed);
 
     for x in (0..win.w() as usize).step_by(10) {
-        let y = rng.gen_range(win.bottom()..win.top() + 1.0) as f32;
+        let y = rng.gen_range(win.bottom()..win.top() + 1.0);
         draw.ellipse()
-            .x_y(win.left() + x as f32, y as f32)
+            .x_y(win.left() + x as f32, y)
             .w_h(3.0, 3.0)
             .color(BLACK);
     }
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn mouse_pressed(_app: &App, model: &mut Model, _button: MouseButton) {
     model.act_random_seed = (random_f32() * 100000.0) as u64;
 }
 
-fn key_pressed(app: &App, _model: &mut Model, key: Key) {
-    if key == Key::S {
+fn key_pressed(app: &App, _model: &mut Model, key: KeyCode) {
+    if key == KeyCode::KeyS {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
 }
diff --git a/generative_design/random_and_noise/m_1_2_01.rs b/generative_design/random_and_noise/m_1_2_01.rs
index 8eb048a5b..7e87f37fc 100644
--- a/generative_design/random_and_noise/m_1_2_01.rs
+++ b/generative_design/random_and_noise/m_1_2_01.rs
@@ -47,8 +47,7 @@ fn model(app: &App) -> Model {
         .view(view)
         .mouse_pressed(mouse_pressed)
         .key_pressed(key_pressed)
-        .build()
-        .unwrap();
+        .build();
 
     Model {
         act_random_seed: 0,
@@ -56,12 +55,12 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
     let win = app.window_rect();
 
     draw.background().color(WHITE);
-    let fader_x = map_range(app.mouse.x, win.left(), win.right(), 0.0, 1.0);
+    let fader_x = map_range(app.mouse().x, win.left(), win.right(), 0.0, 1.0);
 
     let mut rng = StdRng::seed_from_u64(model.act_random_seed);
 
@@ -77,20 +76,20 @@ fn view(app: &App, model: &Model, frame: Frame) {
         let x = nannou::geom::Range::new(random_x, circle_x).lerp(fader_x);
         let y = nannou::geom::Range::new(random_y, circle_y).lerp(fader_x);
 
-        draw.ellipse().x_y(x, y).w_h(11.0, 11.0).rgb8(0, 130, 163);
+        draw.ellipse()
+            .x_y(x, y)
+            .w_h(11.0, 11.0)
+            .srgb_u8(0, 130, 163);
     }
-
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn mouse_pressed(_app: &App, model: &mut Model, _button: MouseButton) {
     model.act_random_seed = (random_f32() * 100000.0) as u64;
 }
 
-fn key_pressed(app: &App, _model: &mut Model, key: Key) {
-    if key == Key::S {
+fn key_pressed(app: &App, _model: &mut Model, key: KeyCode) {
+    if key == KeyCode::KeyS {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
 }
diff --git a/generative_design/random_and_noise/m_1_3_01.rs b/generative_design/random_and_noise/m_1_3_01.rs
index 52ba31e99..5fd22ad12 100644
--- a/generative_design/random_and_noise/m_1_3_01.rs
+++ b/generative_design/random_and_noise/m_1_3_01.rs
@@ -46,15 +46,14 @@ fn model(app: &App) -> Model {
         .view(view)
         .mouse_pressed(mouse_pressed)
         .key_pressed(key_pressed)
-        .build()
-        .unwrap();
+        .build();
 
     Model {
         act_random_seed: 42,
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
     let win = app.window_rect();
 
@@ -62,7 +61,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
 
     let noise = nannou::noise::Perlin::new().set_seed(model.act_random_seed);
 
-    let noise_x_range = map_range(app.mouse.x, win.left(), win.right(), 0.0, win.w()) / 10.0;
+    let noise_x_range = map_range(app.mouse().x, win.left(), win.right(), 0.0, win.w()) / 10.0;
 
     let range = win.w() as usize / 10;
     let vertices = (0..=range).map(|x| {
@@ -73,7 +72,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
     draw.polyline()
         .weight(1.0)
         .points(vertices)
-        .rgb(0.0, 0.5, 0.64);
+        .srgb(0.0, 0.5, 0.64);
 
     for x in (0..win.w() as usize).step_by(10) {
         let noise_x = map_range(x as f32 / 10.0, 0.0, win.w(), 0.0, noise_x_range) as f64;
@@ -83,17 +82,15 @@ fn view(app: &App, model: &Model, frame: Frame) {
             .w_h(3.0, 3.0)
             .color(BLACK);
     }
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn mouse_pressed(_app: &App, model: &mut Model, _button: MouseButton) {
     model.act_random_seed = (random_f32() * 100000.0) as u32;
 }
 
-fn key_pressed(app: &App, _model: &mut Model, key: Key) {
-    if key == Key::S {
+fn key_pressed(app: &App, _model: &mut Model, key: KeyCode) {
+    if key == KeyCode::KeyS {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
 }
diff --git a/generative_design/random_and_noise/m_1_3_02.rs b/generative_design/random_and_noise/m_1_3_02.rs
index 124651bd1..9083f1ab3 100644
--- a/generative_design/random_and_noise/m_1_3_02.rs
+++ b/generative_design/random_and_noise/m_1_3_02.rs
@@ -27,6 +27,7 @@
  * s                   : save png
  */
 use nannou::image;
+use nannou::image::DynamicImage;
 use nannou::prelude::*;
 use nannou::rand::rngs::SmallRng;
 use nannou::rand::{Rng, SeedableRng};
@@ -37,7 +38,6 @@ fn main() {
 
 struct Model {
     act_random_seed: u64,
-    texture: wgpu::Texture,
 }
 
 fn model(app: &App) -> Model {
@@ -47,54 +47,42 @@ fn model(app: &App) -> Model {
         .view(view)
         .mouse_pressed(mouse_pressed)
         .key_pressed(key_pressed)
-        .build()
-        .unwrap();
+        .build();
 
-    let window = app.main_window();
-    let win = window.rect();
-    let texture = wgpu::TextureBuilder::new()
-        .size([win.w() as u32, win.h() as u32])
-        .format(wgpu::TextureFormat::Rgba8Unorm)
-        .usage(wgpu::TextureUsages::COPY_DST | wgpu::TextureUsages::TEXTURE_BINDING)
-        .build(window.device());
     Model {
         act_random_seed: 42,
-        texture,
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
-    frame.clear(BLACK);
+fn view(app: &App, model: &Model) {
+    let draw = app.draw();
+    draw.background().color(BLACK);
 
     let win = app.window_rect();
     let mut rng = SmallRng::seed_from_u64(model.act_random_seed);
 
-    let image = image::ImageBuffer::from_fn(win.w() as u32, win.h() as u32, |_x, _y| {
-        let r: u8 = rng.gen_range(0..std::u8::MAX);
-        nannou::image::Rgba([r, r, r, std::u8::MAX])
-    });
+    let image: DynamicImage =
+        image::ImageBuffer::from_fn(win.w() as u32, win.h() as u32, |_x, _y| {
+            let r: u8 = rng.gen_range(0..std::u8::MAX);
+            nannou::image::Rgba([r, r, r, std::u8::MAX])
+        })
+        .into();
 
-    let flat_samples = image.as_flat_samples();
-    model.texture.upload_data(
-        app.main_window().device(),
-        &mut *frame.command_encoder(),
-        &flat_samples.as_slice(),
-    );
+    let image = Image::from_dynamic(image, true, default());
+    let mut images = app.assets_mut::<Image>();
+    let image = images.add(image);
 
     let draw = app.draw();
-    draw.texture(&model.texture);
-
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
+    draw.rect().w_h(win.w(), win.h()).texture(&image);
 }
 
 fn mouse_pressed(_app: &App, model: &mut Model, _button: MouseButton) {
     model.act_random_seed = (random_f32() * 100000.0) as u64;
 }
 
-fn key_pressed(app: &App, _model: &mut Model, key: Key) {
-    if key == Key::S {
+fn key_pressed(app: &App, _model: &mut Model, key: KeyCode) {
+    if key == KeyCode::KeyS {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
 }
diff --git a/generative_design/random_and_noise/m_1_3_03.rs b/generative_design/random_and_noise/m_1_3_03.rs
index 99daf1b24..839544456 100644
--- a/generative_design/random_and_noise/m_1_3_03.rs
+++ b/generative_design/random_and_noise/m_1_3_03.rs
@@ -44,7 +44,7 @@ struct Model {
     falloff: f32,
     noise_mode: u8,
     noise_random_seed: u32,
-    texture: wgpu::Texture,
+    texture: Handle<Image>,
 }
 
 fn model(app: &App) -> Model {
@@ -54,16 +54,23 @@ fn model(app: &App) -> Model {
         .view(view)
         .key_pressed(key_pressed)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
     let window = app.main_window();
     let win = window.rect();
-    let texture = wgpu::TextureBuilder::new()
-        .size([win.w() as u32, win.h() as u32])
-        .format(wgpu::TextureFormat::Rgba8Unorm)
-        .usage(wgpu::TextureUsages::COPY_DST | wgpu::TextureUsages::TEXTURE_BINDING)
-        .build(window.device());
+    let image = Image::new_fill(
+        Extent3d {
+            width: win.x().to_u32().unwrap(),
+            height: win.y().to_u32().unwrap(),
+            depth_or_array_layers: 1,
+        },
+        TextureDimension::D2,
+        &[0, 0, 0, 0],
+        TextureFormat::Rgba8Unorm,
+        // Need to keep this image CPU persistent in order to add additional glyphs later on
+        RenderAssetUsages::MAIN_WORLD | RenderAssetUsages::RENDER_WORLD,
+    );
+    let texture = app.asset_server().add(image);
     Model {
         octaves: 4,
         falloff: 0.5,
@@ -73,17 +80,15 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
-    frame.clear(BLACK);
-
+fn view(app: &App, model: &Model) {
     let win = app.window_rect();
     let noise = nannou::noise::Fbm::new()
         .set_seed(model.noise_random_seed)
         .set_octaves(model.octaves)
         .set_persistence(model.falloff as f64);
 
-    let noise_x_range = map_range(app.mouse.x, win.left(), win.right(), 0.0, win.w() / 10.0);
-    let noise_y_range = map_range(app.mouse.y, win.top(), win.bottom(), 0.0, win.h() / 10.0);
+    let noise_x_range = map_range(app.mouse().x, win.left(), win.right(), 0.0, win.w() / 10.0);
+    let noise_y_range = map_range(app.mouse().x, win.top(), win.bottom(), 0.0, win.h() / 10.0);
 
     let image = image::ImageBuffer::from_fn(win.w() as u32, win.h() as u32, |x, y| {
         let noise_x = map_range(x, 0, win.w() as u32, 0.0, noise_x_range) as f64;
@@ -112,62 +117,48 @@ fn view(app: &App, model: &Model, frame: Frame) {
         nannou::image::Rgba([n, n, n, std::u8::MAX])
     });
 
-    let flat_samples = image.as_flat_samples();
-    model.texture.upload_data(
-        app.main_window().device(),
-        &mut *frame.command_encoder(),
-        &flat_samples.as_slice(),
-    );
-
     let draw = app.draw();
-    draw.texture(&model.texture);
-
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
+    draw.rect().texture(&model.texture);
+    draw.background().color(BLACK);
 }
 
-fn key_released(app: &App, model: &mut Model, key: Key) {
+fn key_released(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::S => {
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
-        Key::Space => {
+        KeyCode::Space => {
             model.noise_random_seed = (random_f32() * 100000.0) as u32;
         }
-        Key::Key1 => {
+        KeyCode::Digit1 => {
             model.noise_mode = 1;
         }
-        Key::Key2 => {
+        KeyCode::Digit2 => {
             model.noise_mode = 2;
         }
         _otherkey => (),
     }
 }
 
-fn key_pressed(_app: &App, model: &mut Model, key: Key) {
+fn key_pressed(_app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::Up => {
+        KeyCode::ArrowUp => {
             model.falloff += 0.05;
         }
-        Key::Down => {
+        KeyCode::ArrowDown => {
             model.falloff -= 0.05;
         }
-        Key::Left => {
+        KeyCode::ArrowLeft => {
             model.octaves -= 1;
         }
-        Key::Right => {
+        KeyCode::ArrowRight => {
             model.octaves += 1;
         }
         _otherkey => (),
     }
 
-    if model.falloff > 1.0 {
-        model.falloff = 1.0;
-    }
-    if model.falloff <= 0.0 {
-        model.falloff = 0.0;
-    }
+    model.falloff = model.falloff.clamp(0.0, 1.0);
     if model.octaves <= 1 {
         model.octaves = 1;
     }
diff --git a/generative_design/random_and_noise/m_1_5_02.rs b/generative_design/random_and_noise/m_1_5_02.rs
index d49885e3c..5d2c9fc09 100644
--- a/generative_design/random_and_noise/m_1_5_02.rs
+++ b/generative_design/random_and_noise/m_1_5_02.rs
@@ -38,11 +38,11 @@ struct Agent {
     step_size: f32,
     angle: f32,
     is_outside: bool,
-    win_rect: Rect,
+    win_rect: geom::Rect,
 }
 
 impl Agent {
-    fn new(win_rect: Rect) -> Self {
+    fn new(win_rect: geom::Rect) -> Self {
         let vector = vec2(
             random_range(win_rect.left(), win_rect.right()),
             random_range(win_rect.top(), win_rect.bottom()),
@@ -97,7 +97,7 @@ impl Agent {
         draw.line()
             .start(self.vector_old)
             .end(self.vector)
-            .rgba(0.0, 0.0, 0.0, agent_alpha)
+            .srgba(0.0, 0.0, 0.0, agent_alpha)
             .stroke_weight(stroke_weight * self.step_size);
     }
 }
@@ -118,8 +118,7 @@ fn model(app: &App) -> Model {
         .size(720, 720)
         .view(view)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
     let agent_count = 4000;
     let agents = (0..agent_count)
@@ -138,7 +137,7 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(_app: &App, model: &mut Model, _update: Update) {
+fn update(_app: &App, model: &mut Model) {
     let noise = Perlin::new().set_seed(model.noise_seed);
 
     for agent in &mut model.agents {
@@ -151,36 +150,33 @@ fn update(_app: &App, model: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
 
-    if frame.nth() == 0 || app.keys.down.contains(&Key::Delete) {
+    if app.elapsed_frames() == 0 || app.keys().just_pressed(KeyCode::Delete) {
         draw.background().color(WHITE);
     } else {
         draw.rect()
             .wh(app.window_rect().wh())
-            .rgba(1.0, 1.0, 1.0, model.overlay_alpha);
+            .srgba(1.0, 1.0, 1.0, model.overlay_alpha);
     }
 
     model.agents.iter().for_each(|agent| {
         agent.display(&draw, model.stroke_width, model.agent_alpha);
     });
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_released(app: &App, model: &mut Model, key: Key) {
+fn key_released(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::Key1 => model.draw_mode = 1,
-        Key::Key2 => model.draw_mode = 2,
-        Key::Space => {
+        KeyCode::Digit1 => model.draw_mode = 1,
+        KeyCode::Digit2 => model.draw_mode = 2,
+        KeyCode::Space => {
             model.noise_seed = (random_f32() * 10000.0).floor() as u32;
         }
-        Key::S => {
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
         _other_key => {}
     }
diff --git a/generative_design/random_and_noise/m_1_5_03.rs b/generative_design/random_and_noise/m_1_5_03.rs
index 3a67a744a..ab1e5f306 100644
--- a/generative_design/random_and_noise/m_1_5_03.rs
+++ b/generative_design/random_and_noise/m_1_5_03.rs
@@ -38,11 +38,11 @@ struct Agent {
     step_size: f32,
     angle: f32,
     noise_z: f64,
-    win_rect: Rect,
+    win_rect: geom::Rect,
 }
 
 impl Agent {
-    fn new(win_rect: Rect, noise_z: f64) -> Self {
+    fn new(win_rect: geom::Rect, noise_z: f64) -> Self {
         let vector = vec2(
             random_range(win_rect.left(), win_rect.right()),
             random_range(win_rect.top(), win_rect.bottom()),
@@ -105,7 +105,7 @@ impl Agent {
         draw.line()
             .start(self.vector_old)
             .end(self.vector)
-            .rgba(0.0, 0.0, 0.0, agent_alpha)
+            .srgba(0.0, 0.0, 0.0, agent_alpha)
             .stroke_weight(stroke_weight * self.step_size);
     }
 }
@@ -127,8 +127,7 @@ fn model(app: &App) -> Model {
         .size(720, 720)
         .view(view)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
     let noise_z_range = 0.4;
     let agent_count = 4000;
@@ -149,7 +148,7 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(_app: &App, model: &mut Model, _update: Update) {
+fn update(_app: &App, model: &mut Model) {
     let noise = Perlin::new().set_seed(model.noise_seed);
 
     for agent in &mut model.agents {
@@ -162,36 +161,33 @@ fn update(_app: &App, model: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
 
-    if frame.nth() == 0 || app.keys.down.contains(&Key::Delete) {
+    if app.elapsed_frames() == 0 || app.keys().just_pressed(KeyCode::Delete) {
         draw.background().color(WHITE);
     } else {
         draw.rect()
             .wh(app.window_rect().wh())
-            .rgba(1.0, 1.0, 1.0, model.overlay_alpha);
+            .srgba(1.0, 1.0, 1.0, model.overlay_alpha);
     }
 
     model.agents.iter().for_each(|agent| {
         agent.display(&draw, model.stroke_width, model.agent_alpha);
     });
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_released(app: &App, model: &mut Model, key: Key) {
+fn key_released(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::Key1 => model.draw_mode = 1,
-        Key::Key2 => model.draw_mode = 2,
-        Key::Space => {
+        KeyCode::Digit1 => model.draw_mode = 1,
+        KeyCode::Digit2 => model.draw_mode = 2,
+        KeyCode::Space => {
             model.noise_seed = (random_f32() * 10000.0).floor() as u32;
         }
-        Key::S => {
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
         _other_key => {}
     }
diff --git a/generative_design/random_and_noise/m_1_5_04.rs b/generative_design/random_and_noise/m_1_5_04.rs
index c04baa858..d1995a025 100644
--- a/generative_design/random_and_noise/m_1_5_04.rs
+++ b/generative_design/random_and_noise/m_1_5_04.rs
@@ -47,12 +47,12 @@ struct Agent {
     agent_width_min: f32,
     agent_width_max: f32,
     noise_z_velocity: f64,
-    win_rect: Rect,
+    win_rect: geom::Rect,
 }
 
 impl Agent {
     fn new(
-        win_rect: Rect,
+        win_rect: geom::Rect,
         noise_sticking_range: f32,
         agent_alpha: f32,
         noise_scale: f64,
@@ -67,9 +67,9 @@ impl Agent {
         );
         let randomizer = random_f32();
         let color = if randomizer < 0.5 {
-            hsla(random_range(0.47, 0.52), 0.7, random_f32(), agent_alpha)
+            Color::hsla(random_range(0.47, 0.52), 0.7, random_f32(), agent_alpha)
         } else {
-            hsla(random_range(0.11, 0.16), 0.7, random_f32(), agent_alpha)
+            Color::hsla(random_range(0.11, 0.16), 0.7, random_f32(), agent_alpha)
         };
         Agent {
             vector,
@@ -78,7 +78,7 @@ impl Agent {
             step_size: 1.0 + randomizer * 4.0,
             z_noise: random_f32() * noise_sticking_range,
             angle: 0.0,
-            color,
+            color: color.into(),
             noise_scale,
             noise_strength,
             agent_width: agent_width_min,
@@ -170,8 +170,7 @@ fn model(app: &App) -> Model {
         .size(1280, 720)
         .view(view)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
     let agent_count = 2000;
     let noise_scale = 100.0;
@@ -205,7 +204,7 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(_app: &App, model: &mut Model, _update: Update) {
+fn update(_app: &App, model: &mut Model) {
     let noise = Perlin::new().set_seed(model.noise_seed);
 
     for agent in &mut model.agents {
@@ -213,11 +212,11 @@ fn update(_app: &App, model: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
 
-    if frame.nth() == 0 || app.keys.down.contains(&Key::Delete) {
+    if app.elapsed_frames() == 0 || app.keys().just_pressed(KeyCode::Delete) {
         draw.background().color(WHITE);
     } else {
         draw.rect()
@@ -228,21 +227,18 @@ fn view(app: &App, model: &Model, frame: Frame) {
     model.agents.iter().for_each(|agent| {
         agent.display(&draw, model.draw_mode, model.stroke_width);
     });
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_released(app: &App, model: &mut Model, key: Key) {
+fn key_released(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::Key1 => model.draw_mode = 1,
-        Key::Key2 => model.draw_mode = 2,
-        Key::Space => {
+        KeyCode::Digit1 => model.draw_mode = 1,
+        KeyCode::Digit2 => model.draw_mode = 2,
+        KeyCode::Space => {
             model.noise_seed = (random_f32() * 10000.0).floor() as u32;
         }
-        Key::S => {
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
         _other_key => {}
     }
diff --git a/generative_design/shape/p_2_0_01.rs b/generative_design/shape/p_2_0_01.rs
index cb9f0a39e..c81ca7033 100644
--- a/generative_design/shape/p_2_0_01.rs
+++ b/generative_design/shape/p_2_0_01.rs
@@ -35,12 +35,12 @@ fn main() {
     nannou::sketch(view).size(550, 550).run();
 }
 
-fn view(app: &App, frame: Frame) {
+fn view(app: &App) {
     // Prepare to draw.
     let draw = app.draw();
     let win = app.window_rect();
-    let circle_resolution = map_range(app.mouse.y, win.top(), win.bottom(), 2, 80);
-    let radius = app.mouse.x - win.left();
+    let circle_resolution = map_range(app.mouse().x, win.top(), win.bottom(), 2, 80);
+    let radius = app.mouse().x - win.left();
     let angle = TAU / circle_resolution as f32;
 
     draw.background().color(BLACK);
@@ -51,15 +51,13 @@ fn view(app: &App, frame: Frame) {
         draw.line()
             .start(pt2(0.0, 0.0))
             .end(pt2(x, y))
-            .stroke_weight(app.mouse.y / 20.0)
+            .stroke_weight(app.mouse().x / 20.0)
             .caps_round()
             .color(WHITE);
     }
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 
-    if app.keys.down.contains(&Key::S) {
+    if app.keys().just_pressed(KeyCode::KeyS) {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
 }
diff --git a/generative_design/shape/p_2_0_02.rs b/generative_design/shape/p_2_0_02.rs
index d881e77f4..560ce1664 100644
--- a/generative_design/shape/p_2_0_02.rs
+++ b/generative_design/shape/p_2_0_02.rs
@@ -49,20 +49,19 @@ fn model(app: &App) -> Model {
         .mouse_released(mouse_released)
         .key_pressed(key_pressed)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
     Model {
         clicked: false,
         clear_background: false,
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Prepare to draw.
     let draw = app.draw();
     let win = app.window_rect();
-    let circle_resolution = map_range(app.mouse.y, win.top(), win.bottom(), 3, 10);
-    let radius = app.mouse.x - win.left();
+    let circle_resolution = map_range(app.mouse().x, win.top(), win.bottom(), 3, 10);
+    let radius = app.mouse().x - win.left();
     let angle = TAU / circle_resolution as f32;
 
     if app.elapsed_frames() == 1 || model.clear_background {
@@ -78,13 +77,11 @@ fn view(app: &App, model: &Model, frame: Frame) {
 
     if model.clicked {
         draw.polygon()
-            .stroke(rgba(0.0, 0.0, 0.0, 0.1))
+            .stroke(Color::srgba(0.0, 0.0, 0.0, 0.1))
             .stroke_weight(2.0)
             .no_fill()
             .points(points);
     }
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn mouse_pressed(_app: &App, model: &mut Model, _button: MouseButton) {
@@ -93,20 +90,20 @@ fn mouse_pressed(_app: &App, model: &mut Model, _button: MouseButton) {
 fn mouse_released(_app: &App, model: &mut Model, _button: MouseButton) {
     model.clicked = false;
 }
-fn key_pressed(app: &App, model: &mut Model, key: Key) {
+fn key_pressed(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::Space => {
+        KeyCode::Space => {
             model.clear_background = true;
         }
-        Key::S => {
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
         _other_key => {}
     }
 }
-fn key_released(_app: &App, model: &mut Model, key: Key) {
-    if key == Key::Space {
+fn key_released(_app: &App, model: &mut Model, key: KeyCode) {
+    if key == KeyCode::Space {
         model.clear_background = false;
     }
 }
diff --git a/generative_design/shape/p_2_0_03.rs b/generative_design/shape/p_2_0_03.rs
index ff9078190..bb04c4a9a 100644
--- a/generative_design/shape/p_2_0_03.rs
+++ b/generative_design/shape/p_2_0_03.rs
@@ -51,21 +51,20 @@ fn model(app: &App) -> Model {
         .mouse_released(mouse_released)
         .key_pressed(key_pressed)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
     Model {
         clicked: false,
         clear_background: false,
-        stroke_color: hsva(0.0, 0.0, 0.0, 0.1),
+        stroke_color: Hsva::new(0.0, 0.0, 0.0, 0.1),
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Prepare to draw.
     let draw = app.draw();
     let win = app.window_rect();
-    let circle_resolution = map_range(app.mouse.y, win.top(), win.bottom(), 3, 10);
-    let radius = app.mouse.x - win.left();
+    let circle_resolution = map_range(app.mouse().x, win.top(), win.bottom(), 3, 10);
+    let radius = app.mouse().x - win.left();
     let angle = TAU / circle_resolution as f32;
 
     if app.elapsed_frames() == 1 || model.clear_background {
@@ -86,8 +85,6 @@ fn view(app: &App, model: &Model, frame: Frame) {
             .no_fill()
             .points(points);
     }
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn mouse_pressed(_app: &App, model: &mut Model, _button: MouseButton) {
@@ -96,29 +93,29 @@ fn mouse_pressed(_app: &App, model: &mut Model, _button: MouseButton) {
 fn mouse_released(_app: &App, model: &mut Model, _button: MouseButton) {
     model.clicked = false;
 }
-fn key_pressed(app: &App, model: &mut Model, key: Key) {
+fn key_pressed(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::Space => {
+        KeyCode::Space => {
             model.clear_background = true;
         }
-        Key::S => {
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
         _other_key => {}
     }
 }
-fn key_released(_app: &App, model: &mut Model, key: Key) {
-    if key == Key::Space {
+fn key_released(_app: &App, model: &mut Model, key: KeyCode) {
+    if key == KeyCode::Space {
         model.clear_background = false;
     }
-    if key == Key::Key1 {
-        model.stroke_color = hsva(0.0, 0.0, 0.0, 0.1);
+    if key == KeyCode::Digit1 {
+        model.stroke_color = Color::hsva(0.0, 0.0, 0.0, 0.1).into();
     }
-    if key == Key::Key2 {
-        model.stroke_color = hsva(0.53, 1.0, 0.64, 0.1);
+    if key == KeyCode::Digit2 {
+        model.stroke_color = Color::hsva(0.53, 1.0, 0.64, 0.1).into();
     }
-    if key == Key::Key3 {
-        model.stroke_color = hsva(0.147, 1.0, 0.71, 0.1);
+    if key == KeyCode::Digit3 {
+        model.stroke_color = Color::hsva(0.147, 1.0, 0.71, 0.1).into();
     }
 }
diff --git a/generative_design/shape/p_2_1_1_01.rs b/generative_design/shape/p_2_1_1_01.rs
index 972a8ebfa..ed370fb57 100644
--- a/generative_design/shape/p_2_1_1_01.rs
+++ b/generative_design/shape/p_2_1_1_01.rs
@@ -54,8 +54,7 @@ fn model(app: &App) -> Model {
         .mouse_pressed(mouse_pressed)
         .key_released(key_released)
         .key_pressed(key_pressed)
-        .build()
-        .unwrap();
+        .build();
 
     Model {
         tile_count: 20,
@@ -64,7 +63,7 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Prepare to draw.
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -78,12 +77,12 @@ fn view(app: &App, model: &Model, frame: Frame) {
             let tile_h = win.h() / model.tile_count as f32;
             let pos_x = win.left() + tile_w * grid_x as f32;
             let pos_y = (win.top() - tile_h) - tile_h * grid_y as f32;
-            let mx = clamp(win.right() + app.mouse.x, 0.0, win.w());
-            let my = clamp(win.top() - app.mouse.y, 0.0, win.h());
+            let mx = clamp(win.right() + app.mouse().x, 0.0, win.w());
+            let my = clamp(win.top() - app.mouse().x, 0.0, win.h());
 
             let toggle = rng.gen::<bool>();
 
-            if toggle == false {
+            if !toggle {
                 draw.line()
                     .weight(mx / 20.0)
                     .caps(model.act_stroke_cap)
@@ -95,7 +94,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
                         ),
                     );
             }
-            if toggle == true {
+            if toggle {
                 draw.line()
                     .weight(my / 20.0)
                     .caps(model.act_stroke_cap)
@@ -106,28 +105,25 @@ fn view(app: &App, model: &Model, frame: Frame) {
             }
         }
     }
-
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn mouse_pressed(_app: &App, model: &mut Model, _button: MouseButton) {
     model.act_random_seed = (random_f32() * 100000.0) as u64;
 }
-fn key_released(_app: &App, model: &mut Model, key: Key) {
-    if key == Key::Key1 {
+fn key_released(_app: &App, model: &mut Model, key: KeyCode) {
+    if key == KeyCode::Digit1 {
         model.act_stroke_cap = LineCap::Round;
     }
-    if key == Key::Key2 {
+    if key == KeyCode::Digit2 {
         model.act_stroke_cap = LineCap::Square;
     }
-    if key == Key::Key3 {
+    if key == KeyCode::Digit3 {
         model.act_stroke_cap = LineCap::Butt;
     }
 }
-fn key_pressed(app: &App, _model: &mut Model, key: Key) {
-    if key == Key::S {
+fn key_pressed(app: &App, _model: &mut Model, key: KeyCode) {
+    if key == KeyCode::KeyS {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
 }
diff --git a/generative_design/shape/p_2_1_1_02.rs b/generative_design/shape/p_2_1_1_02.rs
index 4e76e0eb2..b057132ac 100644
--- a/generative_design/shape/p_2_1_1_02.rs
+++ b/generative_design/shape/p_2_1_1_02.rs
@@ -49,8 +49,8 @@ struct Model {
     tile_count: u32,
     act_random_seed: u64,
     act_stroke_cap: LineCap,
-    color_left: Rgba,
-    color_right: Rgba,
+    color_left: Srgba,
+    color_right: Srgba,
     alpha_left: f32,
     alpha_right: f32,
 }
@@ -63,8 +63,7 @@ fn model(app: &App) -> Model {
         .mouse_pressed(mouse_pressed)
         .key_released(key_released)
         .key_pressed(key_pressed)
-        .build()
-        .unwrap();
+        .build();
 
     let alpha_left = 1.0;
     let alpha_right = 1.0;
@@ -73,14 +72,14 @@ fn model(app: &App) -> Model {
         tile_count: 20,
         act_random_seed: 0,
         act_stroke_cap: LineCap::Round,
-        color_left: rgba(0.77, 0.0, 0.48, alpha_left),
-        color_right: rgba(0.34, 0.137, 0.5, alpha_right),
+        color_left: Srgba::new(0.77, 0.0, 0.48, alpha_left),
+        color_right: Srgba::new(0.34, 0.137, 0.5, alpha_right),
         alpha_left,
         alpha_right,
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Prepare to draw.
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -94,12 +93,12 @@ fn view(app: &App, model: &Model, frame: Frame) {
             let tile_h = win.h() / model.tile_count as f32;
             let pos_x = win.left() + tile_w * grid_x as f32;
             let pos_y = (win.top() - tile_h) - tile_h * grid_y as f32;
-            let mx = clamp(win.right() + app.mouse.x, 0.0, win.w());
-            let my = clamp(win.top() - app.mouse.y, 0.0, win.h());
+            let mx = clamp(win.right() + app.mouse().x, 0.0, win.w());
+            let my = clamp(win.top() - app.mouse().x, 0.0, win.h());
 
             let toggle = rng.gen::<bool>();
 
-            if toggle == false {
+            if !toggle {
                 draw.line()
                     .color(model.color_left)
                     .weight(mx / 10.0)
@@ -112,7 +111,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
                         ),
                     );
             }
-            if toggle == true {
+            if toggle {
                 draw.line()
                     .color(model.color_right)
                     .weight(my / 10.0)
@@ -124,50 +123,47 @@ fn view(app: &App, model: &Model, frame: Frame) {
             }
         }
     }
-
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn mouse_pressed(_app: &App, model: &mut Model, _button: MouseButton) {
     model.act_random_seed = (random_f32() * 100000.0) as u64;
 }
 
-fn key_pressed(app: &App, _model: &mut Model, key: Key) {
-    if key == Key::S {
+fn key_pressed(app: &App, _model: &mut Model, key: KeyCode) {
+    if key == KeyCode::KeyS {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
 }
 
-fn key_released(_app: &App, model: &mut Model, key: Key) {
-    let black = rgba(0.0, 0.0, 0.0, 1.0);
+fn key_released(_app: &App, model: &mut Model, key: KeyCode) {
+    let black = Srgba::new(0.0, 0.0, 0.0, 1.0);
 
     match key {
-        Key::Key1 => {
+        KeyCode::Digit1 => {
             model.act_stroke_cap = LineCap::Round;
         }
-        Key::Key2 => {
+        KeyCode::Digit2 => {
             model.act_stroke_cap = LineCap::Square;
         }
-        Key::Key3 => {
+        KeyCode::Digit3 => {
             model.act_stroke_cap = LineCap::Butt;
         }
-        Key::Key4 => {
+        KeyCode::Digit4 => {
             if model.color_left.eq(&black) {
-                model.color_left = rgba(0.77, 0.0, 0.48, model.alpha_left);
+                model.color_left = Color::srgba(0.77, 0.0, 0.48, model.alpha_left).into();
             } else {
-                model.color_left = rgba(0.0, 0.0, 0.0, model.alpha_left);
+                model.color_left = Color::srgba(0.0, 0.0, 0.0, model.alpha_left).into();
             }
         }
-        Key::Key5 => {
+        KeyCode::Digit5 => {
             if model.color_right.eq(&black) {
-                model.color_right = rgba(0.34, 0.13, 0.5, model.alpha_right);
+                model.color_right = Color::srgba(0.34, 0.13, 0.5, model.alpha_right).into();
             } else {
-                model.color_right = rgba(0.0, 0.0, 0.0, model.alpha_right);
+                model.color_right = Color::srgba(0.0, 0.0, 0.0, model.alpha_right).into();
             }
         }
-        Key::Key6 => {
+        KeyCode::Digit6 => {
             if model.alpha_left == 1.0 {
                 model.alpha_left = 0.5;
             } else {
@@ -175,7 +171,7 @@ fn key_released(_app: &App, model: &mut Model, key: Key) {
             }
             model.color_left.alpha = model.alpha_left;
         }
-        Key::Key7 => {
+        KeyCode::Digit7 => {
             if model.alpha_right == 1.0 {
                 model.alpha_right = 0.5;
             } else {
@@ -183,12 +179,12 @@ fn key_released(_app: &App, model: &mut Model, key: Key) {
             }
             model.color_right.alpha = model.alpha_right;
         }
-        Key::Key0 => {
+        KeyCode::Digit0 => {
             model.act_stroke_cap = LineCap::Round;
             model.alpha_left = 1.0;
             model.alpha_right = 1.0;
-            model.color_left = rgba(0.0, 0.0, 0.0, model.alpha_left);
-            model.color_right = rgba(0.0, 0.0, 0.0, model.alpha_right);
+            model.color_left = Color::srgba(0.0, 0.0, 0.0, model.alpha_left).into();
+            model.color_right = Color::srgba(0.0, 0.0, 0.0, model.alpha_right).into();
         }
         _other_key => {}
     }
diff --git a/generative_design/shape/p_2_1_1_03.rs b/generative_design/shape/p_2_1_1_03.rs
index 45a5249bd..85434d8a7 100644
--- a/generative_design/shape/p_2_1_1_03.rs
+++ b/generative_design/shape/p_2_1_1_03.rs
@@ -44,8 +44,8 @@ fn main() {
 struct Model {
     tile_count: u32,
     act_random_seed: u64,
-    color_left: Hsv,
-    color_right: Hsv,
+    color_left: Hsva,
+    color_right: Hsva,
     transparent_left: bool,
     transparent_right: bool,
 }
@@ -58,24 +58,23 @@ fn model(app: &App) -> Model {
         .mouse_pressed(mouse_pressed)
         .key_released(key_released)
         .key_pressed(key_pressed)
-        .build()
-        .unwrap();
+        .build();
 
     Model {
         tile_count: 1,
         act_random_seed: 0,
-        color_left: hsv(0.88, 1.0, 0.77),
-        color_right: hsv(0.0, 0.0, 0.0),
+        color_left: Color::hsv(0.88, 1.0, 0.77).into(),
+        color_right: Color::hsv(0.0, 0.0, 0.0).into(),
         transparent_left: false,
         transparent_right: false,
     }
 }
 
-fn update(app: &App, model: &mut Model, _update: Update) {
-    model.tile_count = (app.mouse.y + app.window_rect().top()) as u32 / 15;
+fn update(app: &App, model: &mut Model) {
+    model.tile_count = (app.mouse().x + app.window_rect().top()) as u32 / 15;
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Prepare to draw.
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -89,16 +88,16 @@ fn view(app: &App, model: &Model, frame: Frame) {
             let tile_h = win.h() / model.tile_count as f32;
             let pos_x = win.left() + tile_w * grid_x as f32;
             let pos_y = (win.top() - tile_h) - tile_h * grid_y as f32;
-            let mx = clamp(win.right() + app.mouse.x, 0.0, win.w());
+            let mx = clamp(win.right() + app.mouse().x, 0.0, win.w());
 
             let toggle = rng.gen::<bool>();
 
-            if toggle == false {
-                let (h, s, v) = model.color_left.into_components();
+            if !toggle {
+                let [h, s, v] = model.color_left.to_f32_array_no_alpha();
                 let a = calculate_alpha_left(grid_y, model.transparent_left);
 
                 draw.line()
-                    .hsva(h.into(), s, v, a)
+                    .hsva(h, s, v, a)
                     .caps_round()
                     .weight(mx / 15.0)
                     .points(
@@ -109,7 +108,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
                         ),
                     );
                 draw.line()
-                    .hsva(h.into(), s, v, a)
+                    .hsva(h, s, v, a)
                     .caps_round()
                     .weight(mx / 15.0)
                     .points(
@@ -120,12 +119,12 @@ fn view(app: &App, model: &Model, frame: Frame) {
                         ),
                     );
             }
-            if toggle == true {
-                let (h, s, v) = model.color_right.into_components();
+            if toggle {
+                let [h, s, v] = model.color_right.to_f32_array_no_alpha();
                 let a = calculate_alpha_right(grid_y, model.transparent_right);
 
                 draw.line()
-                    .hsva(h.into(), s, v, a)
+                    .hsva(h, s, v, a)
                     .caps_round()
                     .weight(mx / 15.0)
                     .points(
@@ -133,7 +132,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
                         pt2(pos_x + (win.h() / model.tile_count as f32) / 2.0, pos_y),
                     );
                 draw.line()
-                    .hsva(h.into(), s, v, a)
+                    .hsva(h, s, v, a)
                     .caps_round()
                     .weight(mx / 15.0)
                     .points(
@@ -146,14 +145,12 @@ fn view(app: &App, model: &Model, frame: Frame) {
             }
         }
     }
-
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn calculate_alpha_left(grid_y: u32, transparent_left: bool) -> f32 {
     let max_alpha = 100.0;
-    let alpha_left = if transparent_left {
+
+    if transparent_left {
         let a = grid_y as f32 * 10.0;
         match a {
             _ if a > max_alpha => 1.0,
@@ -162,14 +159,13 @@ fn calculate_alpha_left(grid_y: u32, transparent_left: bool) -> f32 {
         }
     } else {
         1.0
-    };
-
-    alpha_left
+    }
 }
 
 fn calculate_alpha_right(grid_y: u32, transparent_right: bool) -> f32 {
     let max_alpha = 100.0;
-    let alpha_right = if transparent_right {
+
+    if transparent_right {
         let a = max_alpha - (grid_y as f32 * 10.0);
         match a {
             _ if a > max_alpha => 1.0,
@@ -178,49 +174,47 @@ fn calculate_alpha_right(grid_y: u32, transparent_right: bool) -> f32 {
         }
     } else {
         1.0
-    };
-
-    alpha_right
+    }
 }
 
 fn mouse_pressed(_app: &App, model: &mut Model, _button: MouseButton) {
     model.act_random_seed = (random_f32() * 100000.0) as u64;
 }
 
-fn key_pressed(app: &App, _model: &mut Model, key: Key) {
-    if key == Key::S {
+fn key_pressed(app: &App, _model: &mut Model, key: KeyCode) {
+    if key == KeyCode::KeyS {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
 }
 
-fn key_released(_app: &App, model: &mut Model, key: Key) {
+fn key_released(_app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::Key1 => {
-            if model.color_left.eq(&hsv(0.75, 0.73, 0.51)) {
-                model.color_left = hsv(0.89, 1.0, 0.77);
+        KeyCode::Digit1 => {
+            if model.color_left.eq(&Color::hsv(0.75, 0.73, 0.51).into()) {
+                model.color_left = Color::hsv(0.89, 1.0, 0.77).into();
             } else {
-                model.color_left = hsv(0.75, 0.73, 0.51);
+                model.color_left = Color::hsv(0.75, 0.73, 0.51).into();
             }
         }
-        Key::Key2 => {
-            if model.color_right.eq(&hsv(0.0, 0.0, 0.0)) {
-                model.color_right = hsv(0.53, 1.0, 0.64);
+        KeyCode::Digit2 => {
+            if model.color_right.eq(&Color::hsv(0.0, 0.0, 0.0).into()) {
+                model.color_right = Color::hsv(0.53, 1.0, 0.64).into()
             } else {
-                model.color_right = hsv(0.0, 0.0, 0.0);
+                model.color_right = Color::hsv(0.0, 0.0, 0.0).into();
             }
         }
-        Key::Key3 => {
+        KeyCode::Digit3 => {
             model.transparent_left = !model.transparent_left;
         }
-        Key::Key4 => {
+        KeyCode::Digit4 => {
             model.transparent_right = !model.transparent_right;
         }
-        Key::Key0 => {
+        KeyCode::Digit0 => {
             model.transparent_left = false;
             model.transparent_right = false;
-            model.color_left = hsv(0.89, 1.0, 0.77);
-            model.color_right = hsv(0.0, 0.0, 0.0);
+            model.color_left = Color::hsv(0.89, 1.0, 0.77).into();
+            model.color_right = Color::hsv(0.0, 0.0, 0.0).into();
         }
         _other_key => {}
     }
diff --git a/generative_design/shape/p_2_1_2_01.rs b/generative_design/shape/p_2_1_2_01.rs
index f3458d7fa..8eb9bb59d 100644
--- a/generative_design/shape/p_2_1_2_01.rs
+++ b/generative_design/shape/p_2_1_2_01.rs
@@ -39,7 +39,7 @@ fn main() {
 struct Model {
     tile_count: u32,
     act_random_seed: u64,
-    circle_color: Rgba,
+    circle_color: Srgba,
 }
 
 fn model(app: &App) -> Model {
@@ -49,19 +49,18 @@ fn model(app: &App) -> Model {
         .view(view)
         .mouse_pressed(mouse_pressed)
         .key_pressed(key_pressed)
-        .build()
-        .unwrap();
+        .build();
 
     let circle_alpha = 0.5;
 
     Model {
         tile_count: 20,
         act_random_seed: 0,
-        circle_color: rgba(0.0, 0.0, 0.0, circle_alpha),
+        circle_color: Color::srgba(0.0, 0.0, 0.0, circle_alpha).into(),
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
     let win = app.window_rect();
 
@@ -76,8 +75,8 @@ fn view(app: &App, model: &Model, frame: Frame) {
             let pos_x = (win.left() + (tile_w / 2.0)) + tile_w * grid_x as f32;
             let pos_y = (win.top() - (tile_h / 2.0)) - tile_h * grid_y as f32;
 
-            let mx = clamp(win.right() + app.mouse.x, 0.0, win.w());
-            let my = clamp(win.top() - app.mouse.y, 0.0, win.h());
+            let mx = clamp(win.right() + app.mouse().x, 0.0, win.w());
+            let my = clamp(win.top() - app.mouse().x, 0.0, win.h());
 
             let shift_x = rng.gen_range(-mx..mx + 1.0) / 20.0;
             let shift_y = rng.gen_range(-mx..mx + 1.0) / 20.0;
@@ -90,18 +89,15 @@ fn view(app: &App, model: &Model, frame: Frame) {
                 .stroke_weight(my / 50.0);
         }
     }
-
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn mouse_pressed(_app: &App, model: &mut Model, _button: MouseButton) {
     model.act_random_seed = (random_f32() * 100000.0) as u64;
 }
 
-fn key_pressed(app: &App, _model: &mut Model, key: Key) {
-    if key == Key::S {
+fn key_pressed(app: &App, _model: &mut Model, key: KeyCode) {
+    if key == KeyCode::KeyS {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
 }
diff --git a/generative_design/shape/p_2_1_2_02.rs b/generative_design/shape/p_2_1_2_02.rs
index ffe7ab302..370136d25 100644
--- a/generative_design/shape/p_2_1_2_02.rs
+++ b/generative_design/shape/p_2_1_2_02.rs
@@ -59,8 +59,7 @@ fn model(app: &App) -> Model {
         .mouse_pressed(mouse_pressed)
         .key_pressed(key_pressed)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
     let module_alpha_background = 1.0;
     let module_alpha_foreground = 1.0;
@@ -68,8 +67,8 @@ fn model(app: &App) -> Model {
     Model {
         tile_count: 20,
         act_random_seed: 0,
-        module_color_background: hsva(0.0, 0.0, 0.0, module_alpha_background),
-        module_color_foreground: hsva(0.0, 0.0, 1.0, module_alpha_foreground),
+        module_color_background: Hsva::new(0.0, 0.0, 0.0, module_alpha_background),
+        module_color_foreground: Hsva::new(0.0, 0.0, 1.0, module_alpha_foreground),
         module_alpha_background,
         module_alpha_foreground,
         module_radius_background: 15.0,
@@ -77,7 +76,7 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
     let win = app.window_rect();
 
@@ -85,8 +84,8 @@ fn view(app: &App, model: &Model, frame: Frame) {
 
     let mut rng = StdRng::seed_from_u64(model.act_random_seed);
 
-    let mx = clamp(win.right() + app.mouse.x, 0.0, win.w());
-    let my = clamp(win.top() - app.mouse.y, 0.0, win.h());
+    let mx = clamp(win.right() + app.mouse().x, 0.0, win.w());
+    let my = clamp(win.top() - app.mouse().x, 0.0, win.h());
 
     for grid_y in 0..model.tile_count {
         for grid_x in 0..model.tile_count {
@@ -118,47 +117,50 @@ fn view(app: &App, model: &Model, frame: Frame) {
                 .color(model.module_color_foreground);
         }
     }
-
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn mouse_pressed(_app: &App, model: &mut Model, _button: MouseButton) {
     model.act_random_seed = (random_f32() * 100000.0) as u64;
 }
 
-fn key_pressed(app: &App, _model: &mut Model, key: Key) {
-    if key == Key::S {
+fn key_pressed(app: &App, _model: &mut Model, key: KeyCode) {
+    if key == KeyCode::KeyS {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
 }
 
-fn key_released(_app: &App, model: &mut Model, key: Key) {
+fn key_released(_app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::Key1 => {
-            if model
-                .module_color_background
-                .eq(&hsva(0.0, 0.0, 0.0, model.module_alpha_background))
-            {
+        KeyCode::Digit1 => {
+            if model.module_color_background.eq(&Hsva::new(
+                0.0,
+                0.0,
+                0.0,
+                model.module_alpha_background,
+            )) {
                 model.module_color_background =
-                    hsva(0.758, 0.73, 0.51, model.module_alpha_background);
+                    Hsva::new(0.758, 0.73, 0.51, model.module_alpha_background);
             } else {
-                model.module_color_background = hsva(0.0, 0.0, 0.0, model.module_alpha_background);
+                model.module_color_background =
+                    Hsva::new(0.0, 0.0, 0.0, model.module_alpha_background);
             }
         }
-        Key::Key2 => {
-            if model
-                .module_color_foreground
-                .eq(&hsva(1.0, 1.0, 1.0, model.module_alpha_foreground))
-            {
+        KeyCode::Digit2 => {
+            if model.module_color_foreground.eq(&Hsva::new(
+                1.0,
+                1.0,
+                1.0,
+                model.module_alpha_foreground,
+            )) {
                 model.module_color_foreground =
-                    hsva(0.89, 1.0, 0.77, model.module_alpha_foreground);
+                    Hsva::new(0.89, 1.0, 0.77, model.module_alpha_foreground);
             } else {
-                model.module_color_foreground = hsva(1.0, 1.0, 1.0, model.module_alpha_foreground);
+                model.module_color_foreground =
+                    Hsva::new(1.0, 1.0, 1.0, model.module_alpha_foreground);
             }
         }
-        Key::Key3 => {
+        KeyCode::Digit3 => {
             if model.module_alpha_background == 1.0 {
                 model.module_alpha_background = 0.5;
                 model.module_alpha_foreground = 0.5;
@@ -169,24 +171,26 @@ fn key_released(_app: &App, model: &mut Model, key: Key) {
             model.module_color_background.alpha = model.module_alpha_background;
             model.module_color_foreground.alpha = model.module_alpha_foreground;
         }
-        Key::Key0 => {
+        KeyCode::Digit0 => {
             model.module_radius_background = 15.0;
             model.module_radius_foreground = 7.5;
             model.module_alpha_background = 1.0;
             model.module_alpha_foreground = 1.0;
-            model.module_color_background = hsva(0.0, 0.0, 0.0, model.module_alpha_background);
-            model.module_color_foreground = hsva(0.0, 0.0, 1.0, model.module_alpha_foreground);
+            model.module_color_background =
+                Color::hsva(0.0, 0.0, 0.0, model.module_alpha_background).into();
+            model.module_color_foreground =
+                Color::hsva(0.0, 0.0, 1.0, model.module_alpha_foreground).into();
         }
-        Key::Up => {
+        KeyCode::ArrowUp => {
             model.module_radius_background += 2.0;
         }
-        Key::Down => {
+        KeyCode::ArrowDown => {
             model.module_radius_background = 5.0.max(model.module_radius_background - 2.0);
         }
-        Key::Left => {
+        KeyCode::ArrowLeft => {
             model.module_radius_foreground = 2.5.max(model.module_radius_foreground - 2.0);
         }
-        Key::Right => {
+        KeyCode::ArrowRight => {
             model.module_radius_foreground += 2.0;
         }
         _other_key => {}
diff --git a/generative_design/shape/p_2_1_2_03.rs b/generative_design/shape/p_2_1_2_03.rs
index e99584b56..5bd6670be 100644
--- a/generative_design/shape/p_2_1_2_03.rs
+++ b/generative_design/shape/p_2_1_2_03.rs
@@ -34,7 +34,7 @@ fn main() {
 
 struct Model {
     tile_count: u32,
-    module_color: Rgba,
+    module_color: Srgba,
     max_distance: f32,
 }
 
@@ -44,19 +44,18 @@ fn model(app: &App) -> Model {
         .size(600, 600)
         .key_pressed(key_pressed)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     let module_alpha = 0.7;
 
     Model {
         tile_count: 20,
-        module_color: rgba(0.0, 0.0, 0.0, module_alpha),
+        module_color: Srgba::new(0.0, 0.0, 0.0, module_alpha),
         max_distance: 500.0,
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
     let win = app.window_rect();
 
@@ -69,7 +68,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
             let pos_x = (win.left() + (tile_w / 2.0)) + tile_w * grid_x as f32;
             let pos_y = (win.top() - (tile_h / 2.0)) - tile_h * grid_y as f32;
 
-            let mut diameter = pt2(app.mouse.x, app.mouse.y).distance(pt2(pos_x, pos_y));
+            let mut diameter = pt2(app.mouse().x, app.mouse().x).distance(pt2(pos_x, pos_y));
             diameter = diameter / model.max_distance * 40.0;
 
             draw.rect()
@@ -80,14 +79,11 @@ fn view(app: &App, model: &Model, frame: Frame) {
                 .stroke_weight(3.0);
         }
     }
-
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_pressed(app: &App, _model: &mut Model, key: Key) {
-    if key == Key::S {
+fn key_pressed(app: &App, _model: &mut Model, key: KeyCode) {
+    if key == KeyCode::KeyS {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
 }
diff --git a/generative_design/shape/p_2_1_2_04.rs b/generative_design/shape/p_2_1_2_04.rs
index 6319a53b5..92a0a4985 100644
--- a/generative_design/shape/p_2_1_2_04.rs
+++ b/generative_design/shape/p_2_1_2_04.rs
@@ -49,8 +49,7 @@ fn model(app: &App) -> Model {
         .view(view)
         .key_pressed(key_pressed)
         .mouse_pressed(mouse_pressed)
-        .build()
-        .unwrap();
+        .build();
 
     Model {
         tile_count: 20,
@@ -59,7 +58,7 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
     let win = app.window_rect();
 
@@ -74,8 +73,8 @@ fn view(app: &App, model: &Model, frame: Frame) {
             let pos_x = win.left() + tile_w * grid_x as f32;
             let pos_y = (win.top() - tile_h) - tile_h * grid_y as f32;
 
-            let mx = clamp(win.right() + app.mouse.x, 0.0, win.w());
-            let my = clamp(win.top() - app.mouse.y, 0.0, win.h());
+            let mx = clamp(win.right() + app.mouse().x, 0.0, win.w());
+            let my = clamp(win.top() - app.mouse().x, 0.0, win.h());
 
             let shift_x1 = mx / 20.0 * rng.gen_range(-1.0..1.0);
             let shift_y1 = my / 20.0 * rng.gen_range(-1.0..1.0);
@@ -97,18 +96,15 @@ fn view(app: &App, model: &Model, frame: Frame) {
             draw.polygon().hsva(0.53, 1.0, 0.64, 0.7).points(points);
         }
     }
-
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn mouse_pressed(_app: &App, model: &mut Model, _button: MouseButton) {
     model.act_random_seed = (random_f32() * 100000.0) as u64;
 }
 
-fn key_pressed(app: &App, _model: &mut Model, key: Key) {
-    if key == Key::S {
+fn key_pressed(app: &App, _model: &mut Model, key: KeyCode) {
+    if key == KeyCode::KeyS {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
 }
diff --git a/generative_design/shape/p_2_1_3_01.rs b/generative_design/shape/p_2_1_3_01.rs
index 08dc40950..508b0a55d 100644
--- a/generative_design/shape/p_2_1_3_01.rs
+++ b/generative_design/shape/p_2_1_3_01.rs
@@ -54,8 +54,7 @@ fn model(app: &App) -> Model {
         .key_released(key_released)
         .mouse_pressed(mouse_pressed)
         .mouse_moved(mouse_moved)
-        .build()
-        .unwrap();
+        .build();
 
     let tile_count_x = 10;
     let tile_count_y = 10;
@@ -72,7 +71,7 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let mut rng = StdRng::seed_from_u64(model.act_random_seed);
 
     let draw = app.draw();
@@ -111,13 +110,10 @@ fn view(app: &App, model: &Model, frame: Frame) {
                     //.color(BLACK);
                     .no_fill()
                     .stroke_weight(1.0 / scale)
-                    .stroke(rgba(0.0, 0.0, 0.0, 0.5));
+                    .stroke(Color::srgba(0.0, 0.0, 0.0, 0.5));
             }
         }
     }
-
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn mouse_pressed(_app: &App, model: &mut Model, _button: MouseButton) {
@@ -138,9 +134,9 @@ fn mouse_moved(app: &App, model: &mut Model, pos: Point2) {
     );
 }
 
-fn key_released(app: &App, _model: &mut Model, key: Key) {
-    if key == Key::S {
+fn key_released(app: &App, _model: &mut Model, key: KeyCode) {
+    if key == KeyCode::KeyS {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
 }
diff --git a/generative_design/shape/p_2_1_3_02.rs b/generative_design/shape/p_2_1_3_02.rs
index 9b3848351..b2ca15264 100644
--- a/generative_design/shape/p_2_1_3_02.rs
+++ b/generative_design/shape/p_2_1_3_02.rs
@@ -44,8 +44,7 @@ fn model(app: &App) -> Model {
         .size(600, 600)
         .view(view)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
     Model {
         background_color: 0.0,
@@ -53,7 +52,7 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(_app: &App, model: &mut Model, _update: Update) {
+fn update(_app: &App, model: &mut Model) {
     match model.draw_mode {
         1 => model.background_color = 1.0,
         2 => model.background_color = 1.0,
@@ -62,16 +61,16 @@ fn update(_app: &App, model: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
     let g = model.background_color;
-    draw.background().rgb(g, g, g);
+    draw.background().srgb(g, g, g);
 
     let win = app.window_rect();
     let count = 10;
 
-    let tile_count_x = map_range(app.mouse.x, win.left(), win.right(), 1, 30);
-    let tile_count_y = map_range(app.mouse.y, win.top(), win.bottom(), 1, 30);
+    let tile_count_x = map_range(app.mouse().x, win.left(), win.right(), 1, 30);
+    let tile_count_y = map_range(app.mouse().x, win.top(), win.bottom(), 1, 30);
     let tile_width = win.w() / tile_count_x as f32;
     let tile_height = win.h() / tile_count_y as f32;
 
@@ -132,7 +131,8 @@ fn view(app: &App, model: &Model, frame: Frame) {
                             stroke_color = 0.0;
                         }
                         3 => {
-                            line_weight = map_range(app.mouse.x, win.left(), win.right(), 1.0, 8.0);
+                            line_weight =
+                                map_range(app.mouse().x, win.left(), win.right(), 1.0, 8.0);
                         }
                         _ => unreachable!(),
                     }
@@ -148,25 +148,22 @@ fn view(app: &App, model: &Model, frame: Frame) {
             }
         }
     }
-
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_released(app: &App, model: &mut Model, key: Key) {
+fn key_released(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::Key1 => {
+        KeyCode::Digit1 => {
             model.draw_mode = 1;
         }
-        Key::Key2 => {
+        KeyCode::Digit2 => {
             model.draw_mode = 2;
         }
-        Key::Key3 => {
+        KeyCode::Digit3 => {
             model.draw_mode = 3;
         }
-        Key::S => {
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
         _other_key => {}
     }
diff --git a/generative_design/shape/p_2_1_3_03.rs b/generative_design/shape/p_2_1_3_03.rs
index a20c331fc..4c8a828fa 100644
--- a/generative_design/shape/p_2_1_3_03.rs
+++ b/generative_design/shape/p_2_1_3_03.rs
@@ -47,8 +47,7 @@ fn model(app: &App) -> Model {
         .size(900, 900)
         .view(view)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
     Model {
         draw_mode: 1,
@@ -57,13 +56,13 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
     draw.background().color(WHITE);
 
     let win = app.window_rect();
-    let count = map_range(app.mouse.x, win.left(), win.right(), 5, 35);
-    let para = map_range(app.mouse.y, win.top(), win.bottom(), -0.5, 0.5);
+    let count = map_range(app.mouse().x, win.left(), win.right(), 5, 35);
+    let para = map_range(app.mouse().x, win.top(), win.bottom(), -0.5, 0.5);
     let tile_width = win.w() / model.tile_count_x as f32;
     let tile_height = win.h() / model.tile_count_y as f32;
 
@@ -156,37 +155,34 @@ fn view(app: &App, model: &Model, frame: Frame) {
             }
         }
     }
-
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_released(app: &App, model: &mut Model, key: Key) {
+fn key_released(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::Key1 => {
+        KeyCode::Digit1 => {
             model.draw_mode = 1;
         }
-        Key::Key2 => {
+        KeyCode::Digit2 => {
             model.draw_mode = 2;
         }
-        Key::Key3 => {
+        KeyCode::Digit3 => {
             model.draw_mode = 3;
         }
-        Key::Down => {
+        KeyCode::ArrowDown => {
             model.tile_count_y = (model.tile_count_y - 1).max(1);
         }
-        Key::Up => {
+        KeyCode::ArrowUp => {
             model.tile_count_y += 1;
         }
-        Key::Left => {
+        KeyCode::ArrowLeft => {
             model.tile_count_x = (model.tile_count_x - 1).max(1);
         }
-        Key::Right => {
+        KeyCode::ArrowRight => {
             model.tile_count_x += 1;
         }
-        Key::S => {
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
         _other_key => {}
     }
diff --git a/generative_design/shape/p_2_1_3_04.rs b/generative_design/shape/p_2_1_3_04.rs
index 0b9fe2f5d..7ec1e8149 100644
--- a/generative_design/shape/p_2_1_3_04.rs
+++ b/generative_design/shape/p_2_1_3_04.rs
@@ -47,8 +47,7 @@ fn model(app: &App) -> Model {
         .size(900, 900)
         .view(view)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
     Model {
         draw_mode: 1,
@@ -57,13 +56,13 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
     draw.background().color(WHITE);
 
     let win = app.window_rect();
-    let count = map_range(app.mouse.x, win.left(), win.right(), 10, 60);
-    let para = map_range(app.mouse.y, win.top(), win.bottom(), 0.0, 1.0);
+    let count = map_range(app.mouse().x, win.left(), win.right(), 10, 60);
+    let para = map_range(app.mouse().x, win.top(), win.bottom(), 0.0, 1.0);
     let tile_width = win.w() / model.tile_count_x as f32;
     let tile_height = win.h() / model.tile_count_y as f32;
 
@@ -111,7 +110,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
                             .x_y(0.0, 0.0)
                             .w_h(tile_width / 4.0, tile_height / 4.0)
                             .resolution(12.0)
-                            .rgba(gradient.x, gradient.y, gradient.z, 0.66);
+                            .srgba(gradient.x, gradient.y, gradient.z, 0.66);
 
                         let draw3 = draw.x_y(-4.0 * i as f32, 0.0);
                         draw3
@@ -119,7 +118,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
                             .x_y(0.0, 0.0)
                             .w_h(tile_width / 4.0, tile_height / 4.0)
                             .resolution(12.0)
-                            .rgba(gradient.x, gradient.y, gradient.z, 0.66);
+                            .srgba(gradient.x, gradient.y, gradient.z, 0.66);
 
                         draw = draw.scale(1.0 - 1.5 / count as f32).rotate(para * 1.5);
                     }
@@ -128,37 +127,34 @@ fn view(app: &App, model: &Model, frame: Frame) {
             }
         }
     }
-
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_released(app: &App, model: &mut Model, key: Key) {
+fn key_released(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::Key1 => {
+        KeyCode::Digit1 => {
             model.draw_mode = 1;
         }
-        Key::Key2 => {
+        KeyCode::Digit2 => {
             model.draw_mode = 2;
         }
-        Key::Key3 => {
+        KeyCode::Digit3 => {
             model.draw_mode = 3;
         }
-        Key::Down => {
+        KeyCode::ArrowDown => {
             model.tile_count_y = (model.tile_count_y - 1).max(1);
         }
-        Key::Up => {
+        KeyCode::ArrowUp => {
             model.tile_count_y += 1;
         }
-        Key::Left => {
+        KeyCode::ArrowLeft => {
             model.tile_count_x = (model.tile_count_x - 1).max(1);
         }
-        Key::Right => {
+        KeyCode::ArrowRight => {
             model.tile_count_x += 1;
         }
-        Key::S => {
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
         _other_key => {}
     }
diff --git a/generative_design/shape/p_2_1_3_05.rs b/generative_design/shape/p_2_1_3_05.rs
index ee19981ec..c260aa97e 100644
--- a/generative_design/shape/p_2_1_3_05.rs
+++ b/generative_design/shape/p_2_1_3_05.rs
@@ -48,8 +48,7 @@ fn model(app: &App) -> Model {
         .size(600, 600)
         .view(view)
         .mouse_pressed(mouse_pressed)
-        .build()
-        .unwrap();
+        .build();
 
     Model {
         tile_count_x: 10,
@@ -58,7 +57,7 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
     let win = app.window_rect();
 
@@ -68,12 +67,12 @@ fn view(app: &App, model: &Model, frame: Frame) {
     let tile_width = win.w() / model.tile_count_x as f32;
     let tile_height = win.h() / model.tile_count_y as f32;
     let step_size = clamp(
-        map_range(app.mouse.x, win.left(), win.right(), 0.0, win.w()),
+        map_range(app.mouse().x, win.left(), win.right(), 0.0, win.w()),
         0.0,
         win.w(),
     ) / 10.0;
     let end_size = clamp(
-        map_range(app.mouse.y, win.top(), win.bottom(), 0.0, win.h()),
+        map_range(app.mouse().x, win.top(), win.bottom(), 0.0, win.h()),
         0.0,
         win.h(),
     ) / 10.0;
@@ -89,7 +88,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
 
             for i in 0..step_size as usize {
                 let radius = map_range(i, 0, step_size as usize, tile_width, end_size) / 2.0;
-                let col = gray((255.0 - (i * color_step) as f32) / 255.0);
+                let col = Color::gray((255.0 - (i * color_step) as f32) / 255.0);
                 let (x, y) = match heading {
                     0 => (pos_x + i as f32, pos_y),
                     1 => (pos_x, pos_y + i as f32),
@@ -105,9 +104,6 @@ fn view(app: &App, model: &Model, frame: Frame) {
             }
         }
     }
-
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn mouse_pressed(_app: &App, model: &mut Model, _button: MouseButton) {
diff --git a/generative_design/shape/p_2_1_5_01.rs b/generative_design/shape/p_2_1_5_01.rs
index 542feb685..b4ee4d674 100644
--- a/generative_design/shape/p_2_1_5_01.rs
+++ b/generative_design/shape/p_2_1_5_01.rs
@@ -49,25 +49,24 @@ fn model(app: &App) -> Model {
         .size(800, 800)
         .view(view)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
     Model { draw_mode: 1 }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Prepare to draw.
     let mut draw = app.draw();
     draw.background().color(WHITE);
 
     let win = app.window_rect();
     // first shape (fixed)
-    overlay(&draw, &model, win, 3.0);
+    overlay(&draw, model, win, 3.0);
 
     // second shape (dynamically translated/rotated and scaled)
-    let x = map_range(app.mouse.x, win.left(), win.right(), -50.0, 50.0);
-    let a = map_range(app.mouse.x, win.left(), win.right(), -0.5, 0.5);
-    let s = map_range(app.mouse.y, win.top(), win.bottom(), 0.7, 1.0);
+    let x = map_range(app.mouse().x, win.left(), win.right(), -50.0, 50.0);
+    let a = map_range(app.mouse().x, win.left(), win.right(), -0.5, 0.5);
+    let s = map_range(app.mouse().x, win.top(), win.bottom(), 0.7, 1.0);
 
     match model.draw_mode {
         1 => draw = draw.rotate(a),
@@ -76,13 +75,10 @@ fn view(app: &App, model: &Model, frame: Frame) {
     }
     draw = draw.scale(s);
 
-    overlay(&draw, &model, win, 2.0);
-
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
+    overlay(&draw, model, win, 2.0);
 }
 
-fn overlay(draw: &Draw, model: &Model, rect: Rect, stroke_weight: f32) {
+fn overlay(draw: &Draw, model: &Model, rect: geom::Rect, stroke_weight: f32) {
     let w = rect.w() - 100.0;
     let h = rect.h() - 100.0;
 
@@ -107,16 +103,16 @@ fn overlay(draw: &Draw, model: &Model, rect: Rect, stroke_weight: f32) {
     }
 }
 
-fn key_released(app: &App, model: &mut Model, key: Key) {
+fn key_released(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::S => {
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
-        Key::Key1 => {
+        KeyCode::Digit1 => {
             model.draw_mode = 1;
         }
-        Key::Key2 => {
+        KeyCode::Digit2 => {
             model.draw_mode = 2;
         }
         _other_key => (),
diff --git a/generative_design/shape/p_2_1_5_02.rs b/generative_design/shape/p_2_1_5_02.rs
index 6c1b38a2a..55c27d944 100644
--- a/generative_design/shape/p_2_1_5_02.rs
+++ b/generative_design/shape/p_2_1_5_02.rs
@@ -75,8 +75,7 @@ fn model(app: &App) -> Model {
         .view(view)
         .mouse_released(mouse_released)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
     let shapes = vec![Shape::new(0.0, 0.0, app.window_rect().w()); 1];
     Model {
@@ -87,30 +86,27 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Prepare to draw.
     let draw = app.draw();
     draw.background().color(WHITE);
 
     model.shapes.iter().for_each(|shape| {
-        shape.display(&draw, &model);
+        shape.display(&draw, model);
     });
-
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn mouse_released(app: &App, model: &mut Model, _button: MouseButton) {
     model.shapes.push(Shape::new(
-        app.mouse.x,
-        app.mouse.y,
+        app.mouse().x,
+        app.mouse().x,
         random_range(model.min_radius, model.max_radius),
     ));
 }
 
-fn key_released(app: &App, _model: &mut Model, key: Key) {
-    if key == Key::S {
+fn key_released(app: &App, _model: &mut Model, key: KeyCode) {
+    if key == KeyCode::KeyS {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
 }
diff --git a/generative_design/shape/p_2_1_5_03.rs b/generative_design/shape/p_2_1_5_03.rs
index ce88cd2a5..b30ac89f8 100644
--- a/generative_design/shape/p_2_1_5_03.rs
+++ b/generative_design/shape/p_2_1_5_03.rs
@@ -74,7 +74,7 @@ impl Shape {
             draw.line()
                 .start(pt2(0.0, i as f32))
                 .end(pt2(w, i as f32))
-                .rgb(self.c.x, self.c.y, self.c.z);
+                .srgb(self.c.x, self.c.y, self.c.z);
         }
     }
 }
@@ -96,8 +96,7 @@ fn model(app: &App) -> Model {
         .mouse_pressed(mouse_pressed)
         .mouse_released(mouse_released)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
     Model {
         shapes: Vec::new(),
@@ -109,44 +108,40 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(app: &App, model: &mut Model, _update: Update) {
+fn update(app: &App, model: &mut Model) {
     if let Some(ref mut s) = model.new_shape {
-        s.x2 = app.mouse.x;
-        s.y2 = app.mouse.y;
+        s.x2 = app.mouse().x;
+        s.y2 = app.mouse().x;
         s.h = model.shape_height;
         s.c = model.shape_color;
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Prepare to draw.
     let draw = app.draw();
     draw.background().color(WHITE);
 
     model.shapes.iter().for_each(|shape| {
-        shape.display(&draw, &model);
+        shape.display(&draw, model);
     });
 
     if let Some(ref s) = model.new_shape {
-        s.display(&draw, &model);
+        s.display(&draw, model);
     }
-
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn mouse_pressed(app: &App, model: &mut Model, _button: MouseButton) {
     model.p_mouse = app
-        .mouse
-        .buttons
-        .left()
-        .if_down()
-        .unwrap_or(app.mouse.position());
+        .mouse_buttons()
+        .just_pressed(MouseButton::Left)
+        .then_some(app.mouse())
+        .unwrap();
     model.new_shape = Some(Shape::new(
         model.p_mouse.x,
         model.p_mouse.y,
-        app.mouse.x,
-        app.mouse.y,
+        app.mouse().x,
+        app.mouse().x,
         model.shape_height,
         model.shape_color,
     ));
@@ -161,28 +156,28 @@ fn mouse_released(_app: &App, model: &mut Model, button: MouseButton) {
     }
 }
 
-fn key_released(app: &App, model: &mut Model, key: Key) {
+fn key_released(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::S => {
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
-        Key::Key1 => {
+        KeyCode::Digit1 => {
             model.shape_color = vec3(1.0, 0.0, 0.0);
         }
-        Key::Key2 => {
+        KeyCode::Digit2 => {
             model.shape_color = vec3(0.0, 1.0, 0.0);
         }
-        Key::Key3 => {
+        KeyCode::Digit3 => {
             model.shape_color = vec3(0.0, 0.0, 1.0);
         }
-        Key::Key4 => {
+        KeyCode::Digit4 => {
             model.shape_color = vec3(0.0, 0.0, 0.0);
         }
-        Key::Up => {
+        KeyCode::ArrowUp => {
             model.shape_height += model.density as f32;
         }
-        Key::Down => {
+        KeyCode::ArrowDown => {
             model.shape_height -= model.density as f32;
         }
         _other_key => (),
diff --git a/generative_design/shape/p_2_2_1_01.rs b/generative_design/shape/p_2_2_1_01.rs
index a3ae901f6..53522d1d8 100644
--- a/generative_design/shape/p_2_2_1_01.rs
+++ b/generative_design/shape/p_2_2_1_01.rs
@@ -58,8 +58,7 @@ fn model(app: &App) -> Model {
         .size(600, 600)
         .view(view)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
     Model {
         pos_x: 0.0,
@@ -70,9 +69,9 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(app: &App, model: &mut Model, _update: Update) {
+fn update(app: &App, model: &mut Model) {
     let win = app.window_rect();
-    let mx = map_range(app.mouse.x, win.left(), win.right(), 0.0, win.w()) as usize;
+    let mx = map_range(app.mouse().x, win.left(), win.right(), 0.0, win.w()) as usize;
     model.positions.resize(mx + 1, pt2(0.0, 0.0));
     for i in 0..=mx {
         let r = random_range(0, 8);
@@ -131,25 +130,23 @@ fn update(app: &App, model: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
 
-    if frame.nth() == 0 || app.keys.down.contains(&Key::R) {
+    if app.elapsed_frames() == 0 || app.keys().just_pressed(KeyCode::KeyR) {
         draw.background().color(WHITE);
     }
     model.positions.iter().for_each(|pos| {
         draw.ellipse()
             .x_y(pos.x + model.step_size / 2.0, pos.y + model.step_size / 2.0)
             .radius(1.0)
-            .rgba(0.0, 0.0, 0.0, 0.15);
+            .srgba(0.0, 0.0, 0.0, 0.15);
     });
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_released(app: &App, _model: &mut Model, key: Key) {
-    if key == Key::S {
+fn key_released(app: &App, _model: &mut Model, key: KeyCode) {
+    if key == KeyCode::KeyS {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
 }
diff --git a/generative_design/shape/p_2_2_1_02.rs b/generative_design/shape/p_2_2_1_02.rs
index 38afc5f4d..bdb77202c 100644
--- a/generative_design/shape/p_2_2_1_02.rs
+++ b/generative_design/shape/p_2_2_1_02.rs
@@ -64,8 +64,7 @@ fn model(app: &App) -> Model {
         .size(600, 600)
         .view(view)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
     Model {
         pos_x: 0.0,
@@ -80,10 +79,10 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(app: &App, model: &mut Model, _update: Update) {
+fn update(app: &App, model: &mut Model) {
     let win = app.window_rect();
     let mx = clamp(
-        map_range(app.mouse.x, win.left(), win.right(), 0.0, win.w()),
+        map_range(app.mouse().x, win.left(), win.right(), 0.0, win.w()),
         0.0,
         win.w(),
     ) as usize;
@@ -161,15 +160,15 @@ fn update(app: &App, model: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
 
-    if frame.nth() == 0 || app.keys.down.contains(&Key::R) {
+    if app.elapsed_frames() == 0 || app.keys().just_pressed(KeyCode::KeyR) {
         draw.background().color(WHITE);
     }
 
     model.positions.iter().enumerate().for_each(|(i, pos)| {
-        if model.draw_mode == 3 && model.counter_triggers[i] == true {
+        if model.draw_mode == 3 && model.counter_triggers[i] {
             draw.ellipse()
                 .x_y(pos.x + model.step_size / 2.0, pos.y + model.step_size / 2.0)
                 .radius(model.radius + 3.5)
@@ -178,29 +177,27 @@ fn view(app: &App, model: &Model, frame: Frame) {
         draw.ellipse()
             .x_y(pos.x + model.step_size / 2.0, pos.y + model.step_size / 2.0)
             .radius(model.radius)
-            .rgba(0.0, 0.0, 0.0, 0.15);
+            .srgba(0.0, 0.0, 0.0, 0.15);
     });
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_released(app: &App, model: &mut Model, key: Key) {
+fn key_released(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::S => {
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
-        Key::Key1 => {
+        KeyCode::Digit1 => {
             model.draw_mode = 1;
             model.step_size = 1.0;
             model.radius = 1.0;
         }
-        Key::Key2 => {
+        KeyCode::Digit2 => {
             model.draw_mode = 2;
             model.step_size = 1.0;
             model.radius = 1.0;
         }
-        Key::Key3 => {
+        KeyCode::Digit3 => {
             model.draw_mode = 3;
             model.step_size = 10.0;
             model.radius = 2.5;
diff --git a/generative_design/shape/p_2_2_3_01.rs b/generative_design/shape/p_2_2_3_01.rs
index e018c0875..438152815 100644
--- a/generative_design/shape/p_2_2_3_01.rs
+++ b/generative_design/shape/p_2_2_3_01.rs
@@ -55,8 +55,7 @@ fn model(app: &App) -> Model {
         .view(view)
         .key_released(key_released)
         .mouse_pressed(mouse_pressed)
-        .build()
-        .unwrap();
+        .build();
 
     let form_resolution = 150;
     let angle = (360.0 / form_resolution as f32).to_radians();
@@ -80,10 +79,10 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(app: &App, model: &mut Model, _update: Update) {
+fn update(app: &App, model: &mut Model) {
     // floating towards mouse position
-    model.center_x += (app.mouse.x - model.center_x) * 0.01;
-    model.center_y += (app.mouse.y - model.center_y) * 0.01;
+    model.center_x += (app.mouse().x - model.center_x) * 0.01;
+    model.center_y += (app.mouse().x - model.center_y) * 0.01;
 
     // calculate new points
     for i in 0..model.form_resolution {
@@ -92,9 +91,9 @@ fn update(app: &App, model: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
-    if frame.nth() == 0 || app.keys.down.contains(&Key::Delete) {
+    if app.elapsed_frames() == 0 || app.keys().just_pressed(KeyCode::Delete) {
         draw.background().color(WHITE);
     }
 
@@ -129,37 +128,34 @@ fn view(app: &App, model: &Model, frame: Frame) {
         let gray = random_f32();
         draw.path()
             .fill()
-            .rgba(gray, gray, gray, 0.4)
+            .srgba(gray, gray, gray, 0.4)
             .events(path.iter());
     } else {
         draw.path()
             .stroke()
-            .rgba(0.0, 0.0, 0.0, 0.4)
+            .srgba(0.0, 0.0, 0.0, 0.4)
             .events(path.iter());
     }
-
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_released(app: &App, model: &mut Model, key: Key) {
+fn key_released(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::S => {
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
-        Key::Key1 => {
+        KeyCode::Digit1 => {
             model.filled = false;
         }
-        Key::Key2 => {
+        KeyCode::Digit2 => {
             model.filled = true;
         }
-        Key::F => {
+        KeyCode::KeyF => {
             model.freeze = !model.freeze;
             if model.freeze {
-                app.set_loop_mode(LoopMode::loop_once());
+                app.set_update_mode(UpdateMode::freeze());
             } else {
-                app.set_loop_mode(LoopMode::RefreshSync);
+                app.set_update_mode(UpdateMode::Continuous);
             }
         }
         _ => (),
@@ -168,8 +164,8 @@ fn key_released(app: &App, model: &mut Model, key: Key) {
 
 fn mouse_pressed(app: &App, model: &mut Model, _button: MouseButton) {
     // init shape on mouse position
-    model.center_x = app.mouse.x;
-    model.center_y = app.mouse.y;
+    model.center_x = app.mouse().x;
+    model.center_y = app.mouse().x;
     let angle = (360.0 / model.form_resolution as f32).to_radians();
     let _radius = model.init_radius * random_range(0.5, 1.0);
     for i in 0..model.form_resolution {
diff --git a/generative_design/shape/p_2_2_4_01.rs b/generative_design/shape/p_2_2_4_01.rs
index 9a59a49bb..0537de7f0 100644
--- a/generative_design/shape/p_2_2_4_01.rs
+++ b/generative_design/shape/p_2_2_4_01.rs
@@ -42,8 +42,7 @@ fn model(app: &App) -> Model {
         .size(800, 800)
         .view(view)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
     let max_count = 5000; // max count of the circles
     Model {
@@ -55,7 +54,7 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(app: &App, model: &mut Model, _update: Update) {
+fn update(app: &App, model: &mut Model) {
     let win = app.window_rect();
 
     // create a random set of parameters
@@ -84,11 +83,11 @@ fn update(app: &App, model: &mut Model, _update: Update) {
     model.current_count += 1;
 
     if model.current_count >= model.max_count {
-        app.set_loop_mode(LoopMode::loop_once());
+        app.set_update_mode(UpdateMode::freeze());
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
     draw.background().color(WHITE);
 
@@ -98,13 +97,11 @@ fn view(app: &App, model: &Model, frame: Frame) {
             .radius(model.r[i])
             .gray(0.2);
     }
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_released(app: &App, _model: &mut Model, key: Key) {
-    if key == Key::S {
+fn key_released(app: &App, _model: &mut Model, key: KeyCode) {
+    if key == KeyCode::KeyS {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
 }
diff --git a/generative_design/shape/p_2_2_4_02.rs b/generative_design/shape/p_2_2_4_02.rs
index 44afcc1cc..060008932 100644
--- a/generative_design/shape/p_2_2_4_02.rs
+++ b/generative_design/shape/p_2_2_4_02.rs
@@ -46,8 +46,7 @@ fn model(app: &App) -> Model {
         .size(800, 800)
         .view(view)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
     let max_count = 5000; // max count of the circles
     Model {
@@ -62,7 +61,7 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(app: &App, model: &mut Model, _update: Update) {
+fn update(app: &App, model: &mut Model) {
     let win = app.window_rect();
 
     // create a random set of parameters
@@ -93,11 +92,11 @@ fn update(app: &App, model: &mut Model, _update: Update) {
     model.current_count += 1;
 
     if model.current_count >= model.max_count {
-        app.set_loop_mode(LoopMode::loop_once());
+        app.set_update_mode(UpdateMode::freeze());
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
     draw.background().color(WHITE);
 
@@ -130,17 +129,14 @@ fn view(app: &App, model: &Model, frame: Frame) {
                 .gray(0.2);
         }
     }
-
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_released(app: &App, model: &mut Model, key: Key) {
-    if key == Key::S {
+fn key_released(app: &App, model: &mut Model, key: KeyCode) {
+    if key == KeyCode::KeyS {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
-    if key == Key::Key1 {
+    if key == KeyCode::Digit1 {
         model.draw_ghosts = !model.draw_ghosts;
     }
 }
diff --git a/generative_design/shape/p_2_2_5_01.rs b/generative_design/shape/p_2_2_5_01.rs
index 7211ae49f..2180deb60 100644
--- a/generative_design/shape/p_2_2_5_01.rs
+++ b/generative_design/shape/p_2_2_5_01.rs
@@ -73,8 +73,7 @@ fn model(app: &App) -> Model {
         .size(1280, 720)
         .view(view)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
     Model {
         circles: Vec::new(),
@@ -87,7 +86,7 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(app: &App, model: &mut Model, _update: Update) {
+fn update(app: &App, model: &mut Model) {
     let win = app.window_rect();
 
     // Choose a random or the current mouse position
@@ -100,14 +99,14 @@ fn update(app: &App, model: &mut Model, _update: Update) {
         win.bottom() + model.max_radius as f32,
     );
 
-    if app.mouse.buttons.left().is_down() {
+    if app.mouse_buttons().just_pressed(MouseButton::Left) {
         new_x = random_range(
-            app.mouse.x - model.mouse_rect,
-            app.mouse.x + model.mouse_rect,
+            app.mouse().x - model.mouse_rect,
+            app.mouse().x + model.mouse_rect,
         );
         new_y = random_range(
-            app.mouse.y - model.mouse_rect,
-            app.mouse.y + model.mouse_rect,
+            app.mouse().x - model.mouse_rect,
+            app.mouse().x + model.mouse_rect,
         );
     }
 
@@ -128,7 +127,7 @@ fn update(app: &App, model: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
     draw.background().color(WHITE);
 
@@ -149,7 +148,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
                 draw.line()
                     .start(pt2(model.circles[i].x, model.circles[i].y))
                     .end(pt2(closest.x, closest.y))
-                    .rgb(0.4, 0.9, 0.4);
+                    .srgb(0.4, 0.9, 0.4);
             }
         }
 
@@ -159,43 +158,40 @@ fn view(app: &App, model: &Model, frame: Frame) {
         }
     }
 
-    if app.mouse.buttons.left().is_down() {
+    if app.mouse_buttons().just_pressed(MouseButton::Left) {
         draw.rect()
-            .x_y(app.mouse.x, app.mouse.y)
+            .x_y(app.mouse().x, app.mouse().x)
             .w_h(model.mouse_rect * 2.0, model.mouse_rect * 2.0)
             .no_fill()
             .stroke_weight(2.0)
-            .stroke(rgb(0.4, 0.9, 0.4));
+            .stroke(Color::srgb(0.4, 0.9, 0.4));
     }
-
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_released(app: &App, model: &mut Model, key: Key) {
+fn key_released(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::S => {
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
-        Key::Up => {
+        KeyCode::ArrowUp => {
             model.mouse_rect += 4.0;
         }
-        Key::Down => {
+        KeyCode::ArrowDown => {
             model.mouse_rect -= 4.0;
         }
-        Key::F => {
+        KeyCode::KeyF => {
             model.freeze = !model.freeze;
             if model.freeze {
-                app.set_loop_mode(LoopMode::loop_once());
+                app.set_update_mode(UpdateMode::freeze());
             } else {
-                app.set_loop_mode(LoopMode::RefreshSync);
+                app.set_update_mode(UpdateMode::Continuous);
             }
         }
-        Key::Key1 => {
+        KeyCode::Digit1 => {
             model.show_circle = !model.show_circle;
         }
-        Key::Key2 => {
+        KeyCode::Digit2 => {
             model.show_line = !model.show_line;
         }
         _other_key => {}
diff --git a/generative_design/shape/p_2_2_6_01.rs b/generative_design/shape/p_2_2_6_01.rs
index 5688fbe70..3d04a5409 100644
--- a/generative_design/shape/p_2_2_6_01.rs
+++ b/generative_design/shape/p_2_2_6_01.rs
@@ -61,8 +61,7 @@ fn model(app: &App) -> Model {
         .size(1280, 720)
         .view(view)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
     let joints = 5;
     Model {
@@ -91,7 +90,7 @@ fn start_drawing(model: &mut Model) {
     model.speed = 8.0 / 1.75.powf(model.joints as f32 - 1.0) / 2.0.powf(model.speed_relation - 1.0);
 }
 
-fn update(_app: &App, model: &mut Model, _update: Update) {
+fn update(_app: &App, model: &mut Model) {
     model.angle += model.speed;
 
     // each frame, create new positions for each joint
@@ -119,7 +118,7 @@ fn update(_app: &App, model: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
     draw.background().color(WHITE);
 
@@ -131,11 +130,11 @@ fn view(app: &App, model: &Model, frame: Frame) {
                 draw.ellipse()
                     .x_y(pos.x, pos.y)
                     .radius(3.0)
-                    .rgba(0.0, 0.0, 0.0, 0.5);
+                    .srgba(0.0, 0.0, 0.0, 0.5);
                 draw.line()
                     .start(pt2(pos.x, pos.y))
                     .end(pt2(next_pos.x, next_pos.y))
-                    .rgba(0.0, 0.0, 0.0, 0.5);
+                    .srgba(0.0, 0.0, 0.0, 0.5);
             }
         }
     }
@@ -144,9 +143,9 @@ fn view(app: &App, model: &Model, frame: Frame) {
         let weight = 2.5;
         for i in 0..model.pendulum_paths.len() {
             let hue = map_range(i, 0, model.joints, 0.0, 1.0);
-            let hsla = hsla(hue, 0.8, 0.6, 0.5);
+            let hsla = Color::hsla(hue, 0.8, 0.6, 0.5);
 
-            let vertices = model.pendulum_paths[i]
+            let points_colored = model.pendulum_paths[i]
                 .iter()
                 .map(|p| pt2(p.x, p.y))
                 // Colour each vertex uniquely based on its index.
@@ -156,56 +155,53 @@ fn view(app: &App, model: &Model, frame: Frame) {
             draw.polyline()
                 .weight(weight)
                 .join_round()
-                .points_colored(vertices);
+                .points_colored(points_colored);
         }
     }
-
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_released(app: &App, model: &mut Model, key: Key) {
+fn key_released(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::S => {
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
-        Key::Up => {
+        KeyCode::ArrowUp => {
             model.line_length += 2.0;
             start_drawing(model);
         }
-        Key::Down => {
+        KeyCode::ArrowDown => {
             model.line_length -= 2.0;
             start_drawing(model);
         }
-        Key::Left => {
+        KeyCode::ArrowLeft => {
             if model.joints > 1 {
                 model.joints -= 1;
                 start_drawing(model);
             }
         }
-        Key::Right => {
+        KeyCode::ArrowRight => {
             if model.joints < 10 {
                 model.joints += 1;
                 start_drawing(model);
             }
         }
-        Key::Equals => {
+        KeyCode::Equal => {
             if model.speed_relation < 5.0 {
                 model.speed_relation += 0.5;
                 start_drawing(model);
             }
         }
-        Key::Minus => {
+        KeyCode::Minus => {
             if model.speed_relation > 2.0 {
                 model.speed_relation -= 0.5;
                 start_drawing(model);
             }
         }
-        Key::Key1 => {
+        KeyCode::Digit1 => {
             model.show_pendulum = !model.show_pendulum;
         }
-        Key::Key2 => {
+        KeyCode::Digit2 => {
             model.show_pendulum_path = !model.show_pendulum_path;
         }
         _other_key => {}
diff --git a/generative_design/shape/p_2_3_1_01.rs b/generative_design/shape/p_2_3_1_01.rs
index 781e13be9..95ba75b3a 100644
--- a/generative_design/shape/p_2_3_1_01.rs
+++ b/generative_design/shape/p_2_3_1_01.rs
@@ -41,7 +41,7 @@ fn main() {
 }
 
 struct Model {
-    c: Rgba,
+    c: Srgba,
     line_length: f32,
     angle: f32,
     angle_speed: f32,
@@ -54,79 +54,75 @@ fn model(app: &App) -> Model {
         .mouse_pressed(mouse_pressed)
         .key_pressed(key_pressed)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
     Model {
-        c: rgba(0.7, 0.6, 0.0, 1.0),
+        c: Srgba::new(0.7, 0.6, 0.0, 1.0),
         line_length: 0.0,
         angle: 0.0,
         angle_speed: 1.0,
     }
 }
 
-fn update(app: &App, model: &mut Model, _update: Update) {
-    if app.mouse.buttons.left().is_down() {
+fn update(app: &App, model: &mut Model) {
+    if app.mouse_buttons().just_pressed(MouseButton::Left) {
         model.angle += model.angle_speed;
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let mut draw = app.draw();
-    if frame.nth() == 0 || app.keys.down.contains(&Key::Delete) {
-        frame.clear(WHITE);
+    if app.elapsed_frames() == 0 || app.keys().just_pressed(KeyCode::Delete) {
+        draw.background().color(WHITE);
     }
 
-    if app.mouse.buttons.left().is_down() {
+    if app.mouse_buttons().just_pressed(MouseButton::Left) {
         draw = draw
-            .x_y(app.mouse.x, app.mouse.y)
+            .x_y(app.mouse().x, app.mouse().x)
             .rotate(model.angle.to_radians());
         draw.line()
             .start(pt2(0.0, 0.0))
             .end(pt2(model.line_length, 0.0))
             .color(model.c);
     }
-
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn mouse_pressed(_app: &App, model: &mut Model, _button: MouseButton) {
     model.line_length = random_range(70.0, 200.0);
 }
 
-fn key_pressed(_app: &App, model: &mut Model, key: Key) {
+fn key_pressed(_app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::Up => {
+        KeyCode::ArrowUp => {
             model.line_length += 5.0;
         }
-        Key::Down => {
+        KeyCode::ArrowDown => {
             model.line_length -= 5.0;
         }
-        Key::Left => {
+        KeyCode::ArrowLeft => {
             model.angle_speed -= 0.5;
         }
-        Key::Right => {
+        KeyCode::ArrowRight => {
             model.angle_speed += 0.5;
         }
         _otherkey => (),
     }
 }
 
-fn key_released(app: &App, model: &mut Model, key: Key) {
+fn key_released(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::S => {
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
         // reverse direction and mirror angle
-        Key::D => {
+        KeyCode::KeyD => {
             model.angle += 180.0;
             model.angle_speed *= -1.0;
         }
         // change color
-        Key::Space => {
-            model.c = rgba(
+        KeyCode::Space => {
+            model.c = Srgba::new(
                 random_f32(),
                 random_f32(),
                 random_f32(),
@@ -134,17 +130,17 @@ fn key_released(app: &App, model: &mut Model, key: Key) {
             );
         }
         // default colors from 1 to 4
-        Key::Key1 => {
-            model.c = rgba(0.7, 0.61, 0.0, 1.0);
+        KeyCode::Digit1 => {
+            model.c = Srgba::new(0.7, 0.61, 0.0, 1.0);
         }
-        Key::Key2 => {
-            model.c = rgba(0.0, 0.5, 0.64, 1.0);
+        KeyCode::Digit2 => {
+            model.c = Srgba::new(0.0, 0.5, 0.64, 1.0);
         }
-        Key::Key3 => {
-            model.c = rgba(0.34, 0.13, 0.5, 1.0);
+        KeyCode::Digit3 => {
+            model.c = Srgba::new(0.34, 0.13, 0.5, 1.0);
         }
-        Key::Key4 => {
-            model.c = rgba(0.77, 0.0, 0.48, 1.0);
+        KeyCode::Digit4 => {
+            model.c = Srgba::new(0.77, 0.0, 0.48, 1.0);
         }
         _otherkey => (),
     }
diff --git a/generative_design/shape/p_2_3_2_01.rs b/generative_design/shape/p_2_3_2_01.rs
index 22f86436e..a0f4b06f4 100644
--- a/generative_design/shape/p_2_3_2_01.rs
+++ b/generative_design/shape/p_2_3_2_01.rs
@@ -39,7 +39,7 @@ fn main() {
 
 struct Model {
     draw_mode: u8,
-    col: Rgba,
+    col: Srgba,
     x: f32,
     y: f32,
     step_size: f32,
@@ -55,12 +55,11 @@ fn model(app: &App) -> Model {
         .mouse_pressed(mouse_pressed)
         .key_pressed(key_pressed)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
     Model {
         draw_mode: 1,
-        col: rgba(random_f32(), random_f32(), random_f32(), random_f32() * 0.4),
+        col: Color::srgba(random_f32(), random_f32(), random_f32(), random_f32() * 0.4).into(),
         x: 0.0,
         y: 0.0,
         step_size: 5.0,
@@ -70,33 +69,33 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(app: &App, model: &mut Model, _update: Update) {
-    if app.mouse.buttons.left().is_down() {
-        model.dist = pt2(model.x, model.y).distance(pt2(app.mouse.x, app.mouse.y));
+fn update(app: &App, model: &mut Model) {
+    if app.mouse_buttons().just_pressed(MouseButton::Left) {
+        model.dist = pt2(model.x, model.y).distance(pt2(app.mouse().x, app.mouse().x));
 
         if model.dist > model.step_size {
-            model.angle = (app.mouse.y - model.y).atan2(app.mouse.x - model.x);
+            model.angle = (app.mouse().x - model.y).atan2(app.mouse().x - model.x);
             if model.draw_mode == 1 {
-                model.x = model.x + model.angle.cos() * model.step_size;
-                model.y = model.y + model.angle.sin() * model.step_size;
+                model.x += model.angle.cos() * model.step_size;
+                model.y += model.angle.sin() * model.step_size;
             } else {
-                model.x = app.mouse.x;
-                model.y = app.mouse.y;
+                model.x = app.mouse().x;
+                model.y = app.mouse().x;
             }
         }
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let mut draw = app.draw();
-    if frame.nth() == 0 || app.keys.down.contains(&Key::Delete) {
-        frame.clear(WHITE);
+    if app.elapsed_frames() == 0 || app.keys().just_pressed(KeyCode::Delete) {
+        draw.background().color(WHITE);
     }
 
     if model.dist > model.step_size {
         draw = draw.x_y(model.x, model.y).rotate(model.angle);
         let c = if app.elapsed_frames() % 2 == 0 {
-            rgba(0.6, 0.6, 0.6, 1.0)
+            Color::srgba(0.6, 0.6, 0.6, 1.0).into()
         } else {
             model.col
         };
@@ -108,40 +107,37 @@ fn view(app: &App, model: &Model, frame: Frame) {
             ))
             .color(c);
     }
-
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn mouse_pressed(app: &App, model: &mut Model, _button: MouseButton) {
-    model.x = app.mouse.x;
-    model.y = app.mouse.y;
-    model.col = rgba(random_f32(), random_f32(), random_f32(), random_f32() * 0.4);
+    model.x = app.mouse().x;
+    model.y = app.mouse().x;
+    model.col = Color::srgba(random_f32(), random_f32(), random_f32(), random_f32() * 0.4).into();
 }
 
-fn key_pressed(_app: &App, model: &mut Model, key: Key) {
+fn key_pressed(_app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::Up => {
+        KeyCode::ArrowUp => {
             model.line_length += 5.0;
         }
-        Key::Down => {
+        KeyCode::ArrowDown => {
             model.line_length -= 5.0;
         }
         _otherkey => (),
     }
 }
 
-fn key_released(app: &App, model: &mut Model, key: Key) {
+fn key_released(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::S => {
+        KeyCode::KeyS => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
         // default colors from 1 to 4
-        Key::Key1 => {
+        KeyCode::Digit1 => {
             model.draw_mode = 1;
         }
-        Key::Key2 => {
+        KeyCode::Digit2 => {
             model.draw_mode = 2;
         }
         _otherkey => (),
diff --git a/generative_design/shape/p_2_3_3_01.rs b/generative_design/shape/p_2_3_3_01.rs
index 87373b4c2..a788f0261 100644
--- a/generative_design/shape/p_2_3_3_01.rs
+++ b/generative_design/shape/p_2_3_3_01.rs
@@ -55,8 +55,7 @@ fn model(app: &App) -> Model {
         .mouse_pressed(mouse_pressed)
         .key_pressed(key_pressed)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
     let letters = "All the world's a stage, and all the men and women merely players. They have their exits and their entrances.".to_string();
     Model {
@@ -73,9 +72,9 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(app: &App, model: &mut Model, _update: Update) {
-    if app.mouse.buttons.left().is_down() {
-        model.distance = pt2(model.x, model.y).distance(pt2(app.mouse.x, app.mouse.y));
+fn update(app: &App, model: &mut Model) {
+    if app.mouse_buttons().just_pressed(MouseButton::Left) {
+        model.distance = pt2(model.x, model.y).distance(pt2(app.mouse().x, app.mouse().x));
         model.font_size = model.font_size_min + model.distance as u32 / 2;
 
         let win_rect = app.main_window().rect();
@@ -92,25 +91,25 @@ fn update(app: &App, model: &mut Model, _update: Update) {
             .w();
 
         if model.distance > model.step_size {
-            model.angle = (app.mouse.y - model.y).atan2(app.mouse.x - model.x);
+            model.angle = (app.mouse().x - model.y).atan2(app.mouse().x - model.x);
             model.counter += 1;
             if model.counter >= model.letters.len() {
                 model.counter = 0;
             }
 
-            model.x = model.x + model.angle.cos() * model.step_size;
-            model.y = model.y + model.angle.sin() * model.step_size;
+            model.x += model.angle.cos() * model.step_size;
+            model.y += model.angle.sin() * model.step_size;
         }
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
-    if frame.nth() == 0 {
-        frame.clear(WHITE);
-    }
-
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
 
+    if app.elapsed_frames() == 0 {
+        draw.background().color(WHITE);
+    }
+
     if model.distance > model.step_size {
         let draw = app
             .draw()
@@ -128,28 +127,25 @@ fn view(app: &App, model: &Model, frame: Frame) {
             .x_y(0.0, 0.0)
             .color(BLACK);
     }
-
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn mouse_pressed(app: &App, model: &mut Model, _button: MouseButton) {
-    model.x = app.mouse.x;
-    model.y = app.mouse.y;
+    model.x = app.mouse().x;
+    model.y = app.mouse().x;
 }
 
-fn key_pressed(_app: &App, model: &mut Model, key: Key) {
-    if key == Key::Up {
+fn key_pressed(_app: &App, model: &mut Model, key: KeyCode) {
+    if key == KeyCode::ArrowUp {
         model.angle_distortion += 0.1;
     }
-    if key == Key::Down {
+    if key == KeyCode::ArrowDown {
         model.angle_distortion -= 0.1;
     }
 }
 
-fn key_released(app: &App, _model: &mut Model, key: Key) {
-    if key == Key::S {
+fn key_released(app: &App, _model: &mut Model, key: KeyCode) {
+    if key == KeyCode::KeyS {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
 }
diff --git a/generative_design/type/p_3_0_01.rs b/generative_design/type/p_3_0_01.rs
index 9248e83b3..ca153a79c 100644
--- a/generative_design/type/p_3_0_01.rs
+++ b/generative_design/type/p_3_0_01.rs
@@ -48,8 +48,7 @@ fn model(app: &App) -> Model {
         .mouse_pressed(mouse_pressed)
         .mouse_released(mouse_released)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
     Model {
         letter: '8',
@@ -57,21 +56,18 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
 
-    if model.mouse_drag == false {
+    if !model.mouse_drag {
         draw.background().color(WHITE);
     }
 
-    let size = app.mouse.x.max(4.0) as u32 * 5 + 1;
+    let size = app.mouse().x.max(4.0) as u32 * 5 + 1;
     draw.text(&model.letter.to_string())
         .color(BLACK)
         .font_size(size)
-        .x_y(0.0, app.mouse.y);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
+        .x_y(0.0, app.mouse().x);
 }
 
 fn mouse_pressed(_app: &App, model: &mut Model, _button: MouseButton) {
@@ -80,9 +76,9 @@ fn mouse_pressed(_app: &App, model: &mut Model, _button: MouseButton) {
 fn mouse_released(_app: &App, model: &mut Model, _button: MouseButton) {
     model.mouse_drag = false;
 }
-fn key_released(app: &App, _model: &mut Model, key: Key) {
-    if key == Key::LControl || key == Key::RControl {
+fn key_released(app: &App, _model: &mut Model, key: KeyCode) {
+    if key == KeyCode::ControlLeft || key == KeyCode::ControlRight {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
 }
diff --git a/generative_design/type/p_3_1_3_01.rs b/generative_design/type/p_3_1_3_01.rs
index dbf15e502..9952436b4 100644
--- a/generative_design/type/p_3_1_3_01.rs
+++ b/generative_design/type/p_3_1_3_01.rs
@@ -17,6 +17,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use nannou::prelude::text::text;
 /**
  * analysing and sorting the letters of a text
  * changing the letters alpha value in relation to frequency
@@ -47,14 +48,9 @@ fn model(app: &App) -> Model {
         .size(550, 650)
         .view(view)
         .key_released(key_released)
-        .build()
-        .unwrap();
-
-    let text_path = app
-        .assets_path()
-        .unwrap()
-        .join("text")
-        .join("faust_kurz.txt");
+        .build();
+
+    let text_path = app.assets_path().join("text").join("faust_kurz.txt");
     let joined_text = std::fs::read_to_string(text_path).unwrap().parse().unwrap();
     let alphabet = "ABCDEFGHIJKLMNORSTUVWYZÄÖÜß,.;!? ".to_string();
     let counters = vec![0; alphabet.len()];
@@ -70,7 +66,7 @@ fn model(app: &App) -> Model {
     model
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
     let win = app.window_rect();
     draw.background().color(WHITE);
@@ -88,19 +84,25 @@ fn view(app: &App, model: &Model, frame: Frame) {
         }
 
         let col = if model.draw_alpha {
-            rgba(
+            Color::srgba(
                 0.34,
                 0.14,
                 0.5,
                 (model.counters[index.unwrap()] * 3) as f32 / 255.0,
             )
         } else {
-            rgba(0.34, 0.14, 0.5, 1.0)
+            Color::srgba(0.34, 0.14, 0.5, 1.0)
         };
 
         let sort_y = win.top() - (index.unwrap() * 20 + 40) as f32;
         let m = clamp(
-            map_range(app.mouse.x, win.left() + 50.0, win.right() - 50.0, 0.0, 1.0),
+            map_range(
+                app.mouse().x,
+                win.left() + 50.0,
+                win.right() - 50.0,
+                0.0,
+                1.0,
+            ),
             0.0,
             1.0,
         );
@@ -120,9 +122,6 @@ fn view(app: &App, model: &Model, frame: Frame) {
             pos_x = win.left() + 20.0;
         }
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn count_characters(model: &mut Model) {
@@ -137,12 +136,12 @@ fn count_characters(model: &mut Model) {
     }
 }
 
-fn key_released(app: &App, model: &mut Model, key: Key) {
-    if key == Key::S {
+fn key_released(app: &App, model: &mut Model, key: KeyCode) {
+    if key == KeyCode::KeyS {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
-    if key == Key::A {
+    if key == KeyCode::KeyA {
         model.draw_alpha = !model.draw_alpha;
     }
 }
diff --git a/generative_design/type/p_3_1_3_02.rs b/generative_design/type/p_3_1_3_02.rs
index 29c9df4a6..66f948efc 100644
--- a/generative_design/type/p_3_1_3_02.rs
+++ b/generative_design/type/p_3_1_3_02.rs
@@ -53,14 +53,9 @@ fn model(app: &App) -> Model {
         .size(1200, 800)
         .view(view)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
-    let text_path = app
-        .assets_path()
-        .unwrap()
-        .join("text")
-        .join("faust_kurz.txt");
+    let text_path = app.assets_path().join("text").join("faust_kurz.txt");
     let joined_text = std::fs::read_to_string(text_path).unwrap().parse().unwrap();
     let alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZÄÖÜß,.;:!? ".to_string();
     let counters = vec![0; alphabet.len()];
@@ -79,7 +74,7 @@ fn model(app: &App) -> Model {
     model
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
     let win = app.window_rect();
     draw.background().color(WHITE);
@@ -100,7 +95,13 @@ fn view(app: &App, model: &Model, frame: Frame) {
 
         let sort_y = win.top() - (index.unwrap() * 20 + 40) as f32;
         let m = clamp(
-            map_range(app.mouse.x, win.left() + 50.0, win.right() - 50.0, 0.0, 1.0),
+            map_range(
+                app.mouse().x,
+                win.left() + 50.0,
+                win.right() - 50.0,
+                0.0,
+                1.0,
+            ),
             0.0,
             1.0,
         );
@@ -113,7 +114,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
                         .start(pt2(old_x, old_y))
                         .end(pt2(pos_x, inter_y))
                         .weight(1.5)
-                        .rgba(0.7, 0.6, 0.0, 0.6);
+                        .srgba(0.7, 0.6, 0.0, 0.6);
                 }
                 old_x = pos_x;
                 old_y = inter_y;
@@ -124,7 +125,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
                 draw.path()
                     .fill()
                     .x_y(pos_x, inter_y)
-                    .rgb(0.34, 0.13, 0.5)
+                    .srgb(0.34, 0.13, 0.5)
                     .events(text.path_events());
             }
         } else {
@@ -138,9 +139,6 @@ fn view(app: &App, model: &Model, frame: Frame) {
             pos_x = win.left() + 20.0;
         }
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn count_characters(model: &mut Model) {
@@ -155,24 +153,24 @@ fn count_characters(model: &mut Model) {
     }
 }
 
-fn key_released(app: &App, model: &mut Model, key: Key) {
+fn key_released(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::LControl | Key::RControl => {
+        KeyCode::ControlLeft | KeyCode::ControlRight => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
-        Key::Key1 => {
+        KeyCode::Digit1 => {
             model.draw_lines = !model.draw_lines;
         }
-        Key::Key2 => {
+        KeyCode::Digit2 => {
             model.draw_text = !model.draw_text;
         }
-        Key::Key3 => {
+        KeyCode::Digit3 => {
             for i in 0..model.alphabet.len() {
                 model.draw_letters[i] = false;
             }
         }
-        Key::Key4 => {
+        KeyCode::Digit4 => {
             for i in 0..model.alphabet.len() {
                 model.draw_letters[i] = true;
             }
diff --git a/generative_design/type/p_3_1_3_03.rs b/generative_design/type/p_3_1_3_03.rs
index 792c02c9d..814f0fede 100644
--- a/generative_design/type/p_3_1_3_03.rs
+++ b/generative_design/type/p_3_1_3_03.rs
@@ -58,14 +58,9 @@ fn model(app: &App) -> Model {
         .view(view)
         .mouse_pressed(mouse_pressed)
         .key_released(key_released)
-        .build()
-        .unwrap();
-
-    let text_path = app
-        .assets_path()
-        .unwrap()
-        .join("text")
-        .join("faust_kurz.txt");
+        .build();
+
+    let text_path = app.assets_path().join("text").join("faust_kurz.txt");
     let joined_text = std::fs::read_to_string(text_path).unwrap().parse().unwrap();
     let alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZÄÖÜß,.;:!? ".to_string();
     let counters = vec![0; alphabet.len()];
@@ -85,7 +80,7 @@ fn model(app: &App) -> Model {
     model
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
     let win = app.window_rect();
     draw.background().color(WHITE);
@@ -111,14 +106,26 @@ fn view(app: &App, model: &Model, frame: Frame) {
         }
 
         let my = clamp(
-            map_range(app.mouse.y, win.top() - 50.0, win.bottom() + 50.0, 0.0, 1.0),
+            map_range(
+                app.mouse().x,
+                win.top() - 50.0,
+                win.bottom() + 50.0,
+                0.0,
+                1.0,
+            ),
             0.0,
             1.0,
         );
         let char_size = model.counters[index.unwrap()] as f32 * my * 3.0;
 
         let mx = clamp(
-            map_range(app.mouse.x, win.left() + 50.0, win.right() - 50.0, 0.0, 1.0),
+            map_range(
+                app.mouse().x,
+                win.left() + 50.0,
+                win.right() - 50.0,
+                0.0,
+                1.0,
+            ),
             0.0,
             1.0,
         );
@@ -147,7 +154,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
             draw.path()
                 .fill()
                 .x_y(new_pos_x, new_pos_y)
-                .rgba(0.0, 0.0, 0.0, char_alpha)
+                .srgba(0.0, 0.0, 0.0, char_alpha)
                 .events(text.path_events());
         }
 
@@ -158,9 +165,6 @@ fn view(app: &App, model: &Model, frame: Frame) {
             pos_x = win.left() + 80.0;
         }
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn count_characters(model: &mut Model) {
@@ -179,22 +183,22 @@ fn mouse_pressed(_app: &App, model: &mut Model, _button: MouseButton) {
     model.act_random_seed = (random_f32() * 100000.0) as u64;
 }
 
-fn key_released(app: &App, model: &mut Model, key: Key) {
+fn key_released(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::LControl | Key::RControl => {
+        KeyCode::ControlLeft | KeyCode::ControlRight => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
-        Key::Key1 => {
+        KeyCode::Digit1 => {
             model.draw_alpha = !model.draw_alpha;
         }
-        Key::Key2 => {
+        KeyCode::Digit2 => {
             model.draw_lines = !model.draw_lines;
         }
-        Key::Key3 => {
+        KeyCode::Digit3 => {
             model.draw_ellipses = !model.draw_ellipses;
         }
-        Key::Key4 => {
+        KeyCode::Digit4 => {
             model.draw_text = !model.draw_text;
         }
         _other_key => {}
diff --git a/generative_design/type/p_3_1_3_04.rs b/generative_design/type/p_3_1_3_04.rs
index a1eaa9c36..3394c0194 100644
--- a/generative_design/type/p_3_1_3_04.rs
+++ b/generative_design/type/p_3_1_3_04.rs
@@ -55,14 +55,9 @@ fn model(app: &App) -> Model {
         .size(1300, 800)
         .view(view)
         .key_released(key_released)
-        .build()
-        .unwrap();
-
-    let text_path = app
-        .assets_path()
-        .unwrap()
-        .join("text")
-        .join("faust_kurz.txt");
+        .build();
+
+    let text_path = app.assets_path().join("text").join("faust_kurz.txt");
     let joined_text = std::fs::read_to_string(text_path).unwrap().parse().unwrap();
     let alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZÄÖÜß,.;:!? ".to_string();
     let counters = vec![0; alphabet.len()];
@@ -82,7 +77,7 @@ fn model(app: &App) -> Model {
     model
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let win = app.window_rect();
     let draw = app.draw().x_y(win.left() + 50.0, 0.0);
     draw.background().color(WHITE);
@@ -96,7 +91,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
     let mut old_positions_y = vec![0.0; model.joined_text.len()];
 
     // draw counters
-    if app.mouse.x >= win.right() - 50.0 {
+    if app.mouse().x >= win.right() - 50.0 {
         for (i, c) in model.alphabet.chars().enumerate() {
             let character = &c.to_string();
             let size = 10;
@@ -133,7 +128,13 @@ fn view(app: &App, model: &Model, frame: Frame) {
         }
 
         let m = clamp(
-            map_range(app.mouse.x, win.left() + 50.0, win.right() - 50.0, 0.0, 1.0),
+            map_range(
+                app.mouse().x,
+                win.left() + 50.0,
+                win.right() - 50.0,
+                0.0,
+                1.0,
+            ),
             0.0,
             1.0,
         );
@@ -194,9 +195,6 @@ fn view(app: &App, model: &Model, frame: Frame) {
             pos_x = 0.0;
         }
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn count_characters(model: &mut Model) {
@@ -211,27 +209,27 @@ fn count_characters(model: &mut Model) {
     }
 }
 
-fn key_released(app: &App, model: &mut Model, key: Key) {
+fn key_released(app: &App, model: &mut Model, key: KeyCode) {
     match key {
-        Key::LControl | Key::RControl => {
+        KeyCode::ControlLeft | KeyCode::ControlRight => {
             app.main_window()
-                .capture_frame(app.exe_name().unwrap() + ".png");
+                .save_screenshot(app.exe_name().unwrap() + ".png");
         }
-        Key::Key1 => {
+        KeyCode::Digit1 => {
             model.draw_grey_lines = !model.draw_grey_lines;
         }
-        Key::Key2 => {
+        KeyCode::Digit2 => {
             model.draw_colored_lines = !model.draw_colored_lines;
         }
-        Key::Key3 => {
+        KeyCode::Digit3 => {
             model.draw_text = !model.draw_text;
         }
-        Key::Key4 => {
+        KeyCode::Digit4 => {
             for i in 0..model.alphabet.len() {
                 model.draw_letters[i] = false;
             }
         }
-        Key::Key5 => {
+        KeyCode::Digit5 => {
             for i in 0..model.alphabet.len() {
                 model.draw_letters[i] = true;
             }
diff --git a/generative_design/type/p_3_2_1_01.rs b/generative_design/type/p_3_2_1_01.rs
index 99be67fa2..5aae2c5af 100644
--- a/generative_design/type/p_3_2_1_01.rs
+++ b/generative_design/type/p_3_2_1_01.rs
@@ -31,7 +31,7 @@
 use nannou::lyon;
 use nannou::lyon::algorithms::path::math::Point;
 use nannou::lyon::algorithms::path::PathSlice;
-use nannou::lyon::algorithms::walk::{walk_along_path, RepeatedPattern};
+use nannou::lyon::algorithms::walk::{walk_along_path, RepeatedPattern, WalkerEvent};
 use nannou::lyon::path::iterator::*;
 use nannou::prelude::*;
 
@@ -41,6 +41,7 @@ fn main() {
 
 struct Model {
     text_typed: String,
+    letter: Option<KeyCode>,
 }
 
 fn model(app: &App) -> Model {
@@ -50,15 +51,15 @@ fn model(app: &App) -> Model {
         .view(view)
         .key_pressed(key_pressed)
         .key_released(key_released)
-        .build()
-        .unwrap();
+        .build();
 
     Model {
         text_typed: "Nannou is Amazing!".to_string(),
+        letter: None,
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     let draw = app.draw();
     draw.background().color(BLACK);
     let win_rect = app.main_window().rect().pad_left(20.0);
@@ -87,14 +88,14 @@ fn view(app: &App, model: &Model, frame: Frame) {
         draw.line()
             .start(pt2(p.x + l, p.y - l))
             .end(pt2(p.x - l, p.y + l))
-            .rgb(0.7, 0.61, 0.0);
+            .srgb(0.7, 0.61, 0.0);
         // Dots
         let q = map_range(i, 0, path_points.len(), 0.0, 1.0);
         if i % 2 == 0 {
             draw.ellipse()
                 .x_y(p.x, p.y)
                 .radius(map_range(
-                    (i as f32 * 0.05 + app.time * 4.3).sin(),
+                    (i as f32 * 0.05 + app.time() * 4.3).sin(),
                     -1.0,
                     1.0,
                     3.0,
@@ -103,18 +104,15 @@ fn view(app: &App, model: &Model, frame: Frame) {
                 .hsv(q, 1.0, 0.5);
         }
     });
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
-fn key_pressed(_app: &App, _model: &mut Model, _key: Key) {
-    //model.letter = key.into();
+fn key_pressed(_app: &App, model: &mut Model, key: KeyCode) {
+    model.letter = key.into();
 }
-fn key_released(app: &App, _model: &mut Model, key: Key) {
-    if key == Key::LControl || key == Key::RControl {
+fn key_released(app: &App, _model: &mut Model, key: KeyCode) {
+    if key == KeyCode::ControlLeft || key == KeyCode::ControlRight {
         app.main_window()
-            .capture_frame(app.exe_name().unwrap() + ".png");
+            .save_screenshot(app.exe_name().unwrap() + ".png");
     }
 }
 
@@ -122,7 +120,8 @@ fn dots_along_path(path: PathSlice, dots: &mut Vec<Point>, interval: f32, offset
     use std::ops::Rem;
     let dot_spacing = map_range(interval, 0.0, 1.0, 0.025, 1.0);
     let mut pattern = RepeatedPattern {
-        callback: &mut |position, _tangent, _distance| {
+        callback: &mut |evt: WalkerEvent| {
+            let position = evt.position;
             dots.push(position);
             true // Return true to continue walking the path.
         },
@@ -133,5 +132,10 @@ fn dots_along_path(path: PathSlice, dots: &mut Vec<Point>, interval: f32, offset
 
     let tolerance = 0.01; // The path flattening tolerance.
     let start_offset = offset.rem(12.0 + dot_spacing); // Start walking at the beginning of the path.
-    walk_along_path(path.iter().flattened(tolerance), start_offset, &mut pattern);
+    walk_along_path(
+        path.iter().flattened(tolerance),
+        start_offset,
+        tolerance,
+        &mut pattern,
+    );
 }
diff --git a/guide/.dropboxignore b/guide/.dropboxignore
new file mode 100644
index 000000000..d8df5e971
--- /dev/null
+++ b/guide/.dropboxignore
@@ -0,0 +1,5 @@
+# ----
+# Automatically Generated .dropboxignore file at Tue Apr 23 13:35:37 PDT 2024
+# ----
+book
+# ----
diff --git a/guide/book_tests/.dropboxignore b/guide/book_tests/.dropboxignore
new file mode 100644
index 000000000..32026499e
--- /dev/null
+++ b/guide/book_tests/.dropboxignore
@@ -0,0 +1,7 @@
+# ----
+# Automatically Generated .dropboxignore file at Tue Apr 23 13:35:37 PDT 2024
+# ----
+target/
+Cargo.lock
+libtest.rmeta
+# ----
diff --git a/guide/book_tests/Cargo.toml b/guide/book_tests/Cargo.toml
index 32bcd83d1..b085b9ee8 100644
--- a/guide/book_tests/Cargo.toml
+++ b/guide/book_tests/Cargo.toml
@@ -6,15 +6,15 @@ edition = '2018'
 description = 'For testing the nannou-guide, while including the nannou dependencies.'
 
 [build-dependencies]
-# Temporarily use git dependency until budziq/rust-skeptic#121 is merged and published.
-# https://github.com/budziq/rust-skeptic/pull/121
-skeptic = { git = "https://github.com/mitchmindtree/rust-skeptic", branch = "1.45-extern" }
+# Temporarily use git dependency until budziq/rust-skeptic#142 is merged and published.
+# https://github.com/budziq/rust-skeptic/pull/142
+skeptic = { git = "https://github.com/Erk-/rust-skeptic", branch = "fix-rust-1-77" }
 #skeptic = "0.13"
 
 [dev-dependencies]
-# Temporarily use git dependency until budziq/rust-skeptic#121 is merged and published.
-# https://github.com/budziq/rust-skeptic/pull/121
-skeptic = { git = "https://github.com/mitchmindtree/rust-skeptic", branch = "1.45-extern" }
+# Temporarily use git dependency until budziq/rust-skeptic#142 is merged and published.
+# https://github.com/budziq/rust-skeptic/pull/142
+skeptic = { git = "https://github.com/Erk-/rust-skeptic", branch = "fix-rust-1-77" }
 #skeptic = "0.13"
 nannou = { version ="0.19.0", path = "../../nannou" }
 nannou_osc = { version ="0.19.0", path = "../../nannou_osc" }
diff --git a/guide/book_tests/build.rs b/guide/book_tests/build.rs
index 658759e98..2f0d481ae 100644
--- a/guide/book_tests/build.rs
+++ b/guide/book_tests/build.rs
@@ -1,7 +1,8 @@
-use skeptic::*;
 use std::path::{Path, PathBuf};
 use std::{env, fs, io};
 
+use skeptic::*;
+
 // Check the given path and parent directories for a path with the given name.
 fn check_parents(name: &str, path: &Path) -> io::Result<Option<PathBuf>> {
     match check_dir(name, path) {
diff --git a/guide/src/changelog.md b/guide/src/changelog.md
index 644e97277..9a1a8116a 100644
--- a/guide/src/changelog.md
+++ b/guide/src/changelog.md
@@ -294,7 +294,7 @@ changelog entry
 - Fixes the issue where `TextureCapturer` could spawn more user callbacks than
   there where worker threads to process them.
 - Fixes the issue where an application might exit before all
-  `window.capture_frames(path)` snapshots have completed.
+  `window.save_screenshots(path)` snapshots have completed.
 - Provides a `TextureCapturer::await_active_snapshots(device)` method that
   allows to properly await the completion of all snapshot read futures by
   polling the device as necessary.
@@ -303,10 +303,10 @@ changelog entry
 - `Snapshot::read_threaded` has been removed in favour of a single
   `Snapshot::read` method that is threaded by default. The old synchronous
   behaviour can be emulated by creating the `TextureCapturer` with a single
-  worker. Likewise, `window.capture_frame_threaded` has been removed in favour
-  of `window.capture_frame` for the same reason.
-- New `app::Builder` and `window::Builder` `max_capture_frame_jobs` and
-  `capture_frame_timeout` methods have been added to allow for specifying the
+  worker. Likewise, `window.save_screenshot_threaded` has been removed in favour
+  of `window.save_screenshot` for the same reason.
+- New `app::Builder` and `window::Builder` `max_save_screenshot_jobs` and
+  `save_screenshot_timeout` methods have been added to allow for specifying the
   number of worker threads and optional timeout duration for the windows' inner
   `TextureCapturer`s.
 
@@ -352,7 +352,7 @@ changelog entry
   crates.
 - Add a `random_ascii()` function.
 - Add many more "Generative Design" and "Nature of Code" examples.
-- Fix bug where `capture_frame_threaded` was not actually threaded.
+- Fix bug where `save_screenshot_threaded` was not actually threaded.
 
 **The Great Repository Refactor**
 
@@ -451,7 +451,7 @@ changelog entry
   ```
   the `view` function signature now must look like:
   ```rust,ignore
-  fn view(app: &App, model: &Model, frame: Frame) {}
+  fn view(app: &App, model: &Model) {}
   ```
   This was necessary to enable ergonomic texture capturing.
 - `frame.submit()` can now be used to submit the frame to the GPU before the end
@@ -461,7 +461,7 @@ changelog entry
   won't do anything!).
 - A `.size(w, h)` builder has been added to the `app::Builder` type that allows
   for specifying a default window size.
-- Add `window.capture_frame(path)` method for capturing the next frame to an
+- Add `window.save_screenshot(path)` method for capturing the next frame to an
   image file at the given file path.
 - Add a `simple_capture.rs` example.
 - Add a `capture_hi_res.rs` example.
@@ -651,7 +651,7 @@ changelog entry
 - Add `App::elapsed_frames` method.
 - Remove `app.window.id` field in favour of more reliable `app.window_id`
   method.
-- Change `ui::Builder` so that it no longer requires `window::Id`. Now defaults
+- Change `ui::Builder` so that it no longer requires `Entity`. Now defaults
   to focused window.
 - Fix several HiDPI related bugs introduced in the last winit update.
 - Add support for rotation and orientation to `draw` API.
diff --git a/guide/src/getting_started/create_a_project.md b/guide/src/getting_started/create_a_project.md
index 5a6fe24b4..55caf0e9d 100644
--- a/guide/src/getting_started/create_a_project.md
+++ b/guide/src/getting_started/create_a_project.md
@@ -58,11 +58,12 @@ create a new project with just a few small steps:
        Model {}
    }
 
-   fn update(_app: &App, _model: &mut Model, _update: Update) {
+   fn update(_app: &App, _model: &mut Model) {
    }
 
-   fn view(_app: &App, _model: &Model, frame: Frame) {
-       frame.clear(PURPLE);
+   fn view(app: &App, _model: &Model, _window: Entity) {
+       let draw = app.draw();
+       draw.background().color(PURPLE);
    }
    ```
 
diff --git a/guide/src/tutorials/basics/anatomy-of-a-nannou-app.md b/guide/src/tutorials/basics/anatomy-of-a-nannou-app.md
index 48bbdc806..826f32492 100644
--- a/guide/src/tutorials/basics/anatomy-of-a-nannou-app.md
+++ b/guide/src/tutorials/basics/anatomy-of-a-nannou-app.md
@@ -23,7 +23,6 @@ struct Model {}
 
 fn main() {
     nannou::app(model)
-        .event(event)
         .simple_window(view)
         .run();
 }
@@ -32,10 +31,7 @@ fn model(_app: &App) -> Model {
     Model {}
 }
 
-fn event(_app: &App, _model: &mut Model, _event: Event) {
-}
-
-fn view(_app: &App, _model: &Model, _frame: Frame) {
+fn view(_app: &App, _model: &Model, _window: Entity) {
 }
 ```
 
@@ -88,16 +84,13 @@ model can stay empty.
 # struct Model {}
 fn main() {
     nannou::app(model)
-        .event(event)
         .simple_window(view)
         .run();
 }
 # fn model(_app: &App) -> Model {
 #     Model {}
 # }
-# fn event(_app: &App, _model: &mut Model, _event: Event) {
-# }
-# fn view(_app: &App, _model: &Model, _frame: Frame) {
+# fn view(_app: &App, _model: &Model, _window: Entity) {
 # }
 ```
 
@@ -110,16 +103,13 @@ quite small. In short, we build a description of our app and then run it!
 # struct Model {}
 # fn main() {
     nannou::app(model)       // Start building the app and specify our `model`
-        .event(event)        // Specify that we want to handle app events with `event`
         .simple_window(view) // Request a simple window to which we'll draw with `view`
         .run();              // Run it!
 # }
 # fn model(_app: &App) -> Model {
 #     Model {}
 # }
-# fn event(_app: &App, _model: &mut Model, _event: Event) {
-# }
-# fn view(_app: &App, _model: &Model, _frame: Frame) {
+# fn view(_app: &App, _model: &Model, _window: Entity) {
 # }
 ```
 
@@ -195,8 +185,7 @@ will just return an instance of our empty **Model**.
 # #![allow(dead_code)]
 # use nannou::prelude::*;
 # struct Model {}
-fn event(_app: &App, _model: &mut Model, _event: Event) {
-}
+// TODO: Add an event function here!
 # fn main() {}
 ```
 
@@ -232,9 +221,9 @@ fn main() {
 # fn model(_app: &App) -> Model {
 #     Model {}
 # }
-# fn update(_app: &App, _model: &mut Model, _update: Update) {
+# fn update(_app: &App, _model: &mut Model) {
 # }
-# fn view(_app: &App, _model: &Model, _frame: Frame) {
+# fn view(_app: &App, _model: &Model, _window: Entity) {
 # }
 ```
 
@@ -244,7 +233,7 @@ And remove our `event` function in favour of an `update` function:
 # #![allow(dead_code)]
 # use nannou::prelude::*;
 # struct Model {}
-fn update(_app: &App, _model: &mut Model, _update: Update) {
+fn update(_app: &App, _model: &mut Model) {
 }
 # fn main() {}
 ```
@@ -264,7 +253,7 @@ occurs.
 # #![allow(dead_code)]
 # use nannou::prelude::*;
 # struct Model {}
-fn view(_app: &App, _model: &Model, _frame: Frame) {
+fn view(_app: &App, _model: &Model, _window: Entity) {
 }
 # fn main() {}
 ```
diff --git a/guide/src/tutorials/basics/draw-a-sketch.md b/guide/src/tutorials/basics/draw-a-sketch.md
index 6d7d10310..ca0eccc27 100644
--- a/guide/src/tutorials/basics/draw-a-sketch.md
+++ b/guide/src/tutorials/basics/draw-a-sketch.md
@@ -22,7 +22,7 @@ fn main() {
     nannou::sketch(view).run();
 }
 
-fn view(app: &App, frame: Frame) {
+fn view(app: &App) {
     // get canvas to draw on
     let draw = app.draw();
 
@@ -30,7 +30,7 @@ fn view(app: &App, frame: Frame) {
     draw.background().color(BLUE);
 
     // put everything on the frame
-    draw.to_frame(app, &frame).unwrap();
+    
 }
 ```
 
@@ -55,7 +55,7 @@ After this import the actual sketching code starts. The `main()` functions is wh
 # fn main() {
     nannou::sketch(view).run();
 # }
-# fn view(_app: &App, _frame: Frame) {}
+# fn view(_app: &App) {}
 ```
 
 calls a function to draw on the single window (`view()` in this case). This
@@ -71,12 +71,12 @@ Within the view() function, what we draw to the Frame will be presented in our w
 # fn main() {
 #    nannou::sketch(view).run();
 # }
-fn view(app: &App, frame: Frame) {
+fn view(app: &App) {
     let draw = app.draw();
 
     draw.background().color(BLUE);
 
-    draw.to_frame(app, &frame).unwrap();
+    
 }
 ```
 
@@ -88,7 +88,7 @@ This function follows the same scheme. First some setup is done. The line
 # fn main() {
 #    nannou::sketch(view).run();
 # }
-# fn view(app: &App, _frame: Frame) {
+# fn view(app: &App) {
 let draw = app.draw();
 # }
 ```
@@ -102,7 +102,7 @@ We can now paint on the this canvas by setting the background to blue.
 # fn main() {
 #    nannou::sketch(view).run();
 # }
-# fn view(app: &App, _frame: Frame) {
+# fn view(app: &App) {
 # let draw = app.draw();
 draw.background().color(BLUE);
 # }
@@ -117,9 +117,9 @@ create a computer graphics frame from it to display in the main window.
 # fn main() {
 #    nannou::sketch(view).run();
 # }
-# fn view(app: &App, frame: Frame) {
+# fn view(app: &App) {
 # let draw = app.draw();
-draw.to_frame(app, &frame).unwrap();
+
 # }
 ```
 
diff --git a/guide/src/tutorials/basics/sketch-vs-app.md b/guide/src/tutorials/basics/sketch-vs-app.md
index b50b7f5ec..bec0c0619 100644
--- a/guide/src/tutorials/basics/sketch-vs-app.md
+++ b/guide/src/tutorials/basics/sketch-vs-app.md
@@ -39,11 +39,11 @@ fn main() {
     nannou::sketch(view).run()
 }
 
-fn view(app: &App, frame: Frame) {
+fn view(app: &App) {
     let draw = app.draw();
     draw.background().color(PLUM);
-    draw.ellipse().color(STEELBLUE);
-    draw.to_frame(app, &frame).unwrap();
+    draw.ellipse().color(STEEL_BLUE);
+    
 }
 ```
 
@@ -68,21 +68,21 @@ fn main() {
 }
 
 struct Model {
-    _window: window::Id,
+    _window: Entity,
 }
 
 fn model(app: &App) -> Model {
-    let _window = app.new_window().view(view).build().unwrap();
+    let _window = app.new_window().view(view).build();
     Model { _window }
 }
 
-fn update(_app: &App, _model: &mut Model, _update: Update) {}
+fn update(_app: &App, _model: &mut Model) {}
 
-fn view(app: &App, _model: &Model, frame: Frame) {
+fn view(app: &App, _model: &Model) {
     let draw = app.draw();
     draw.background().color(PLUM);
-    draw.ellipse().color(STEELBLUE);
-    draw.to_frame(app, &frame).unwrap();
+    draw.ellipse().color(STEEL_BLUE);
+    
 }
 ```
 
@@ -119,7 +119,7 @@ flexibility, you can turn it into an app by following these steps:
    # fn main() {
    nannou::sketch(view).run()
    # }
-   # fn view(_: &App, _: Frame) {}
+   # fn view(_: &App) {}
    ```
 
    to
@@ -132,7 +132,7 @@ flexibility, you can turn it into an app by following these steps:
    # }
    # struct Model {}
    # fn model(_: &App) -> Model { Model {} }
-   # fn view(_: &App, _: &Model, _: Frame) {}
+   # fn view(_: &App, _: &Model, _: Entity) {}
    ```
 
 2. Add a `Model` for tracking state:
@@ -161,7 +161,7 @@ flexibility, you can turn it into an app by following these steps:
    # #![allow(dead_code, unused_variables)]
    # use nannou::prelude::*;
    # fn main() {}
-   fn view(app: &App, frame: Frame) {
+   fn view(app: &App) {
    # }
    ```
 
@@ -172,7 +172,7 @@ flexibility, you can turn it into an app by following these steps:
    # use nannou::prelude::*;
    # fn main() {}
    # struct Model {}
-   fn view(app: &App, _model: &Model, frame: Frame) {
+   fn view(app: &App, _model: &Model, _window: Entity) {
    # }
    ```
 
diff --git a/guide/src/tutorials/basics/window-coordinates.md b/guide/src/tutorials/basics/window-coordinates.md
index be001e37a..23ecc599a 100644
--- a/guide/src/tutorials/basics/window-coordinates.md
+++ b/guide/src/tutorials/basics/window-coordinates.md
@@ -177,7 +177,7 @@ square and call it `r`.
 # #![allow(unused_variables)]
 # use nannou::prelude::*;
 # fn main() {
-let r = Rect::from_w_h(100.0, 100.0);
+let r = geom::Rect::from_w_h(100.0, 100.0);
 # }
 ```
 
@@ -190,7 +190,7 @@ like so:
 # use nannou::prelude::*;
 # fn main() {
 #     let draw: Draw = unimplemented!();
-let r = Rect::from_w_h(100.0f32, 100.0f32);
+let r = geom::Rect::from_w_h(100.0f32, 100.0f32);
 draw.rect()
     .xy(r.xy())
     .wh(r.wh())
@@ -207,8 +207,8 @@ We can align our plum square to the `top_left_of` the window like so:
 # use nannou::prelude::*;
 # fn main() {
 #     let draw: Draw = unimplemented!();
-#     let win: Rect = unimplemented!();
-let r = Rect::from_w_h(100.0, 100.0).top_left_of(win);
+#     let win: geom::Rect = unimplemented!();
+let r = geom::Rect::from_w_h(100.0, 100.0).top_left_of(win);
 draw.rect()
     .xy(r.xy())
     .wh(r.wh())
@@ -239,12 +239,12 @@ semi-transparent blue color:
 # use nannou::prelude::*;
 # fn main() {
 #     let draw: Draw = unimplemented!();
-#     let win: Rect = unimplemented!();
+#     let win: geom::Rect = unimplemented!();
 let win_p = win.pad(25.0);
 draw.rect()
     .xy(win_p.xy())
     .wh(win_p.wh())
-    .color(rgba(0.3, 0.4, 0.7, 0.5));
+    .color(Color::srgba(0.3, 0.4, 0.7, 0.5));
 # }
 ```
 
@@ -258,9 +258,9 @@ square and achieve the desired look:
 # use nannou::prelude::*;
 # fn main() {
 #     let draw: Draw = unimplemented!();
-#     let win: Rect = unimplemented!();
+#     let win: geom::Rect = unimplemented!();
 let win_p = win.pad(25.0);
-let r = Rect::from_w_h(100.0, 100.0).top_left_of(win_p);
+let r = geom::Rect::from_w_h(100.0, 100.0).top_left_of(win_p);
 draw.rect()
     .xy(r.xy())
     .wh(r.wh())
@@ -286,9 +286,9 @@ circle:
 # use nannou::prelude::*;
 # fn main() {
 #     let draw: Draw = unimplemented!();
-#     let win: Rect = unimplemented!();
+#     let win: geom::Rect = unimplemented!();
 let win_p = win.pad(25.0);
-let square = Rect::from_w_h(100.0, 100.0).top_left_of(win_p);
+let square = geom::Rect::from_w_h(100.0, 100.0).top_left_of(win_p);
 draw.rect()
     .xy(square.xy())
     .wh(square.wh())
@@ -315,10 +315,10 @@ square:
 # use nannou::prelude::*;
 # fn main() {
 #     let draw: Draw = unimplemented!();
-#     let win: Rect = unimplemented!();
+#     let win: geom::Rect = unimplemented!();
 let pad = 25.0;
 let win_p = win.pad(pad);
-let square = Rect::from_w_h(100.0, 100.0).top_left_of(win_p);
+let square = geom::Rect::from_w_h(100.0, 100.0).top_left_of(win_p);
 draw.rect()
     .xy(square.xy())
     .wh(square.wh())
diff --git a/guide/src/tutorials/draw/animating-a-circle.md b/guide/src/tutorials/draw/animating-a-circle.md
index bcce32b94..5faff2811 100644
--- a/guide/src/tutorials/draw/animating-a-circle.md
+++ b/guide/src/tutorials/draw/animating-a-circle.md
@@ -29,16 +29,13 @@ Update the view function of your nannou-app to look like this:
 # struct Model{}
 # fn main() {
 #    nannou::app(model)
-#        .event(event)
 #        .simple_window(view)
 #        .run();
 # }
 # fn model(_app: &App) -> Model {
 #    Model {}
 # }
-# fn event(_app: &App, _model: &mut Model, _event: Event) {
-# }
-fn view(app: &App, _model: &Model, frame: Frame) {
+fn view(app: &App, _model: &Model, _window: Entity) {
 	// Prepare to draw.
     let draw = app.draw();
 
@@ -46,9 +43,9 @@ fn view(app: &App, _model: &Model, frame: Frame) {
     draw.background().color(PLUM);
 
 	// Draw a blue ellipse with a radius of 10 at the (x,y) coordinates of (0.0, 0.0)
-    draw.ellipse().color(STEELBLUE).x_y(0.0,0.0);
+    draw.ellipse().color(STEEL_BLUE).x_y(0.0,0.0);
 
-    draw.to_frame(app, &frame).unwrap();
+    
 }
 ```
 
@@ -65,7 +62,7 @@ These can be generated in nannou by taking the progressed time of the applicatio
 # use nannou::prelude::*;
 # fn main() {
 #     let app: App = unimplemented!();
-let sine = app.time.sin();
+let sine = app.time().sin();
 # }
 ```
 
@@ -76,7 +73,7 @@ Let's make another one but at half the speed by dividing the time value by two
 # use nannou::prelude::*;
 # fn main() {
 #     let app: App = unimplemented!();
-let slowersine = (app.time / 2.0).sin();
+let slowersine = (app.time() / 2.0).sin();
 # }
 ```
 
@@ -152,7 +149,7 @@ The `map_range` function takes 5 arguments: `val`, `in_min`, `in_max`, `out_min`
 # use nannou::prelude::*;
 # fn main() {
 #     let app: App = unimplemented!();
-#     let sine = app.time.sin();
+#     let sine = app.time().sin();
 #     let boundary = app.window_rect();
 let x = map_range(sine, -1.0, 1.0, boundary.left(), boundary.right());
 # }
@@ -165,8 +162,8 @@ And then the same for the y value but using the `slowersine` variable.
 # use nannou::prelude::*;
 # fn main() {
 #     let app: App = unimplemented!();
-#     let sine = app.time.sin();
-#     let slowersine = (app.time / 2.0).sin();
+#     let sine = app.time().sin();
+#     let slowersine = (app.time() / 2.0).sin();
 #     let boundary = app.window_rect();
 let y = map_range(slowersine, -1.0, 1.0, boundary.bottom(), boundary.top());
 # }
@@ -180,12 +177,12 @@ The only thing left to do now is to put this into the arguments of our circle-dr
 # fn main() {
 #     let app: App = unimplemented!();
 #     let draw = app.draw();
-#     let sine = app.time.sin();
-#     let slowersine = (app.time / 2.0).sin();
+#     let sine = app.time().sin();
+#     let slowersine = (app.time() / 2.0).sin();
 #     let boundary = app.window_rect();
 #     let x = map_range(sine, -1.0, 1.0, boundary.left(), boundary.right());
 #     let y = map_range(slowersine, -1.0, 1.0, boundary.bottom(), boundary.top());
-draw.ellipse().color(STEELBLUE).x_y(x, y);
+draw.ellipse().color(STEEL_BLUE).x_y(x, y);
 # }
 ```
 
@@ -196,13 +193,13 @@ Your updated `view` function should now look something like this:
 # use nannou::prelude::*;
 # struct Model{}
 # fn main() {}
-fn view(app: &App, _model: &Model, frame: Frame) {
+fn view(app: &App, _model: &Model, _window: Entity) {
     // Prepare to draw.
     let draw = app.draw();
 
     // Generate sine wave data based on the time of the app
-    let sine = app.time.sin();
-    let slowersine = (app.time / 2.0).sin();
+    let sine = app.time().sin();
+    let slowersine = (app.time() / 2.0).sin();
 
     // Get boundary of the window (to constrain the movements of our circle)
     let boundary = app.window_rect();
@@ -215,8 +212,8 @@ fn view(app: &App, _model: &Model, frame: Frame) {
     draw.background().color(PLUM);
 
     // Draw a blue ellipse at the x/y coordinates 0.0, 0.0
-    draw.ellipse().color(STEELBLUE).x_y(x, y);
+    draw.ellipse().color(STEEL_BLUE).x_y(x, y);
 
-    draw.to_frame(app, &frame).unwrap();
+    
 }
 ```
diff --git a/guide/src/tutorials/draw/drawing-2d-shapes.md b/guide/src/tutorials/draw/drawing-2d-shapes.md
index 7bfa679a7..8d481981e 100644
--- a/guide/src/tutorials/draw/drawing-2d-shapes.md
+++ b/guide/src/tutorials/draw/drawing-2d-shapes.md
@@ -24,7 +24,7 @@ fn main() {
     nannou::sketch(view).run();
 }
 
-fn view(app: &App, frame: Frame) {
+fn view(app: &App) {
     // Prepare to draw.
     let draw = app.draw();
 
@@ -32,10 +32,9 @@ fn view(app: &App, frame: Frame) {
     draw.background().color(PLUM);
 
     // Draw a blue ellipse with default size and position.
-    draw.ellipse().color(STEELBLUE);
+    draw.ellipse().color(STEEL_BLUE);
 
-    // Write to the window frame.
-    draw.to_frame(app, &frame).unwrap();
+    
 }
 ```
 
@@ -57,7 +56,7 @@ Already we are rendering a circle to our canvas.  As you may have guessed, the l
 # fn main() {
 #     let draw: Draw = unimplemented!();
 draw.ellipse()
-    .color(STEELBLUE);
+    .color(STEEL_BLUE);
 # }
 ```
 
@@ -69,7 +68,7 @@ There are many ways we can alter our circle here.  Let's start with changing the
 # fn main() {
 #     let draw: Draw = unimplemented!();
 draw.ellipse()
-    .color(STEELBLUE)
+    .color(STEEL_BLUE)
     .w(300.0)
     .h(200.0);
 # }
@@ -85,7 +84,7 @@ We can also change the position of our ellipse with the `x_y` method:
 # fn main() {
 #     let draw: Draw = unimplemented!();
 draw.ellipse()
-    .color(STEELBLUE)
+    .color(STEEL_BLUE)
     .w(300.0)
     .h(200.0)
     .x_y(200.0, -100.0);
@@ -107,7 +106,7 @@ Drawing a square or rectangle uses the same builder pattern that drawing an elli
 # fn main() {
 #     let draw: Draw = unimplemented!();
 draw.rect()
-    .color(STEELBLUE)
+    .color(STEEL_BLUE)
     .w(300.0)
     .h(200.0);
 # }
@@ -130,7 +129,7 @@ let point3 = pt2(15.0, 40.0);
 let point4 = pt2(-20.0, 35.0);
 
 draw.quad()
-    .color(STEELBLUE)
+    .color(STEEL_BLUE)
     .w(300.0)
     .h(200.0)
     .points(point1, point2, point3, point4);
@@ -167,7 +166,7 @@ draw.line()
     .start(start_point)
     .end(end_point)
     .weight(4.0)
-    .color(STEELBLUE);
+    .color(STEEL_BLUE);
 # }
 ```
 
@@ -187,7 +186,7 @@ To draw our sine wave, we will use the `polyline` function.  To use this functio
 let points = (0..50).map(|i| {
   let x = i as f32 - 25.0;          //subtract 25 to center the sine wave
   let point = pt2(x, x.sin()) * 20.0; //scale sine wave by 20.0
-  (point, STEELBLUE)
+  (point, STEEL_BLUE)
 });
 draw.polyline()
     .weight(3.0)
@@ -221,7 +220,7 @@ let points = (0..=360).map(|i| {
     // Do the same with cosine to find the y co-ordinate.
     let y = radian.cos() * radius;
     // Construct and return a point object with a color.
-    (pt2(x,y), STEELBLUE)
+    (pt2(x,y), STEEL_BLUE)
 });
 // Create a polyline builder. Hot-tip: polyline is short-hand for a path that is
 // drawn via "stroke" tessellation rather than "fill" tessellation.
@@ -280,7 +279,7 @@ let points = (0..=360).step_by(45).map(|i| {
     let radian = deg_to_rad(i as f32);
     let x = radian.sin() * radius;
     let y = radian.cos() * radius;
-    (pt2(x,y), STEELBLUE)
+    (pt2(x,y), STEEL_BLUE)
 });
 draw.polygon()
     .points_colored(points);
diff --git a/guide/src/tutorials/draw/drawing-images.md b/guide/src/tutorials/draw/drawing-images.md
index 9c3a97fbe..9c41c9ed7 100644
--- a/guide/src/tutorials/draw/drawing-images.md
+++ b/guide/src/tutorials/draw/drawing-images.md
@@ -48,11 +48,11 @@ fn main() {
 
 fn model(app: &App) -> Model {
   // Create a new window!
-  app.new_window().size(512, 512).view(view).build().unwrap();
+  app.new_window().size(512, 512).view(view).build();
   Model {}
 }
 
-fn view(_app: &App, _model: &Model, _frame: Frame) {
+fn view(_app: &App, _model: &Model) {
 }
 ```
 
@@ -66,18 +66,18 @@ Now, at the top of your `main.rs` file, add a [WGPU Texture](https://docs.rs/nan
 # #![allow(unreachable_code, unused_variables, dead_code)]
 # use nannou::prelude::*;
 struct Model {
-  texture: wgpu::Texture,
+  texture: Handle<Image>,
 }
 # fn main() {
 #   nannou::app(model).run();
 # }
 # fn model(app: &App) -> Model {
 #   // Create a new window!
-#   app.new_window().size(512, 512).view(view).build().unwrap();
-#   let texture: wgpu::Texture = unimplemented!();
+#   app.new_window().size(512, 512).view(view).build();
+#   let texture: Handle<Image> = unimplemented!();
 #   Model { texture }
 # }
-# fn view(_app: &App, _model: &Model, _frame: Frame) {
+# fn view(_app: &App, _model: &Model) {
 # }
 ```
 
@@ -87,21 +87,19 @@ Next, we'll need to create a GPU texture to initialize the struct with. We can a
 # #![allow(unreachable_code, unused_variables, dead_code)]
 # use nannou::prelude::*;
 # struct Model {
-#   texture: wgpu::Texture,
+#   texture: Handle<Image>,
 # }
 # fn main() {
 #   nannou::app(model).run();
 # }
 fn model(app: &App) -> Model {
   // Create a new window!
-  app.new_window().size(512, 512).view(view).build().unwrap();
-  // Load the image from disk and upload it to a GPU texture.
-  let assets = app.assets_path().unwrap();
-  let img_path = assets.join("images").join("nature").join("nature_1.jpg");
-  let texture = wgpu::Texture::from_path(app, img_path).unwrap();
+  app.new_window().size(512, 512).view(view).build();
+  // Load the image from disk and upload it to a GPU texture
+  let texture = app.asset_server().load("images/nature/nature_1.jpg");
   Model { texture }
 }
-# fn view(_app: &App, _model: &Model, _frame: Frame) {
+# fn view(_app: &App, _model: &Model) {
 # }
 ```
 
@@ -115,27 +113,26 @@ Finally, in our `view` function, we can draw the texture stored in our model wit
 # #![allow(unreachable_code, unused_variables, dead_code)]
 # use nannou::prelude::*;
 # struct Model {
-#   texture: wgpu::Texture,
+#   texture: Handle<Image>, 
 # }
 # fn main() {
 #   nannou::app(model).run();
 # }
 # fn model(app: &App) -> Model {
 #   // Create a new window!
-#   app.new_window().size(512, 512).view(view).build().unwrap();
+#   app.new_window().size(512, 512).view(view).build();
 #   // Load the image from disk and upload it to a GPU texture.
-#   let assets = app.assets_path().unwrap();
-#   let img_path = assets.join("images").join("nature").join("nature_1.jpg");
-#   let texture = wgpu::Texture::from_path(app, img_path).unwrap();
+#   let texture = app.asset_server().load("images/nature/nature_1.jpg");
 #   Model { texture }
 # }
-fn view(app: &App, model: &Model, frame: Frame) {
-  frame.clear(BLACK);
-
+fn view(app: &App, model: &Model) {
   let draw = app.draw();
-  draw.texture(&model.texture);
+  draw.background().color(BLACK);
 
-  draw.to_frame(app, &frame).unwrap();
+  let draw = app.draw();
+  draw
+    .rect()
+    .texture(&model.texture);
 }
 ```
 ![A texture](./images/drawing-images-0.png)
@@ -149,32 +146,31 @@ A texture can be drawn at any location and any size desired within the frame. Le
 # #![allow(unreachable_code, unused_variables, dead_code)]
 # use nannou::prelude::*;
 # struct Model {
-#   texture: wgpu::Texture,
+#   texture: Handle<Image>, 
 # }
 # fn main() {
 #   nannou::app(model).run();
 # }
 # fn model(app: &App) -> Model {
 #   // Create a new window!
-#   app.new_window().size(512, 512).view(view).build().unwrap();
+#   app.new_window().size(512, 512).view(view).build();
 #   // Load the image from disk and upload it to a GPU texture.
-#   let assets = app.assets_path().unwrap();
-#   let img_path = assets.join("images").join("nature").join("nature_1.jpg");
-#   let texture = wgpu::Texture::from_path(app, img_path).unwrap();
+#   let texture = app.asset_server().load("images/nature/nature_1.jpg");
 #   Model { texture }
 # }
-fn view(app: &App, model: &Model, frame: Frame) {
-  frame.clear(BLACK);
+fn view(app: &App, model: &Model) {
+  let draw = app.draw();
+  draw.background().color(BLACK);
 
   let win = app.window_rect();
-  let r = Rect::from_w_h(100.0, 100.0).top_left_of(win);
+  let r = geom::Rect::from_w_h(100.0, 100.0).top_left_of(win);
 
   let draw = app.draw();
-  draw.texture(&model.texture)
+  draw
+    .rect()
+    .texture(&model.texture)
     .xy(r.xy())
     .wh(r.wh());
-
-  draw.to_frame(app, &frame).unwrap();
 }
 ```
 ![A translated and scaled texture](./images/drawing-images-1.png)
diff --git a/guide/src/tutorials/osc/osc-sender.md b/guide/src/tutorials/osc/osc-sender.md
index 3daa868f5..4f7e22e07 100644
--- a/guide/src/tutorials/osc/osc-sender.md
+++ b/guide/src/tutorials/osc/osc-sender.md
@@ -178,10 +178,10 @@ fn model(_app: &App) -> Model {
     Model { sender }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model, _window: Entity) {
     // Use app time to progress through a sine wave
-    let sine = app.time.sin();
-    let slowersine = (app.time / 2.0).sin();
+    let sine = app.time().sin();
+    let slowersine = (app.time() / 2.0).sin();
 
     // Get boundary of the window (to constrain the movements of our circle)
     let boundary = app.window_rect();
@@ -204,9 +204,9 @@ fn view(app: &App, model: &Model, frame: Frame) {
     draw.background().color(PLUM);
 
     // Draw a blue ellipse at the x/y coordinates 0.0, 0.0
-    draw.ellipse().color(STEELBLUE).x_y(x, y);
+    draw.ellipse().color(STEEL_BLUE).x_y(x, y);
 
-    draw.to_frame(app, &frame).unwrap();
+    
 }
 ```
 
diff --git a/nannou/Cargo.toml b/nannou/Cargo.toml
index c7c5b63e5..3548e49f0 100644
--- a/nannou/Cargo.toml
+++ b/nannou/Cargo.toml
@@ -11,37 +11,42 @@ homepage = "https://github.com/nannou-org/nannou"
 edition = "2018"
 
 [dependencies]
+bevy = { workspace = true }
+bevy-inspector-egui = { workspace = true, optional = true }
+bevy_egui = { workspace = true, optional = true }
+bevy_common_assets = { workspace = true, optional = true }
+bevy_nannou = { version = "0.1.0", path = "../bevy_nannou" }
 futures = "0.3"
 find_folder = "0.3"
 getrandom = "0.2.3"
-image = "0.23"
 instant = "0.1.9"
-lyon = "0.17"
-nannou_core = { version ="0.19.0", path = "../nannou_core", features = ["std", "serde"] }
-nannou_mesh = { version ="0.19.0", path = "../nannou_mesh", features = ["serde1"] }
-nannou_wgpu = { version ="0.19.0", path = "../nannou_wgpu", features = ["capturer"] }
+lyon = "1.0"
+nannou_core = { version ="0.19.0", path = "../nannou_core", features = ["std"] }
 noise = "0.7"
 notosans = { version = "0.1", optional = true }
 num_cpus = "1"
 pennereq = "0.3"
 rusttype = { version = "0.8", features = ["gpu_cache"] }
-serde = "1"
-serde_derive = "1"
-serde_json = "1"
-toml = "0.5"
+serde = { workspace = true, features = ["derive"], optional = true}
+serde_json = { workspace = true, optional = true }
+toml = { workspace = true, optional = true }
 walkdir = "2"
 web-sys = { version = "0.3.64", optional = true }
-wgpu_upstream = { version = "0.17.1", package = "wgpu" }
-winit = "0.28"
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 tokio = { version = "1", features = ["full"]}
+image = { version = "0.25", features = ["default"] }
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 tokio = { version = "1", features = ["rt"]}
+image = { version = "0.25", features = [], default-features = false }
 
 [features]
 default = ["notosans"]
-# Enables SPIR-V support in the `wgpu` module.
-spirv = ["nannou_wgpu/spirv"]
-# Enables experimental WASM compilation for CI-use only
-wasm-experimental = ["getrandom/js", "web-sys", "wgpu_upstream/webgl", "wgpu_upstream/fragile-send-sync-non-atomic-wasm"]
+egui = ["bevy_egui", "bevy-inspector-egui"]
+nightly = ["bevy_nannou/nightly"]
+hot_reload = ["bevy/file_watcher"]
+isf = ["bevy_nannou/isf"]
+video = ["bevy_nannou/video"]
+serde = ["dep:serde", "toml", "serde_json", "nannou_core/serde"]
+config_json = ["bevy_common_assets/json"]
+config_toml = ["bevy_common_assets/toml"]
\ No newline at end of file
diff --git a/nannou/src/app.rs b/nannou/src/app.rs
index 17a136f45..2b2de18ea 100644
--- a/nannou/src/app.rs
+++ b/nannou/src/app.rs
@@ -7,44 +7,67 @@
 //! - [**Proxy**](./struct.Proxy.html) - a handle to an **App** that may be used from a non-main
 //!   thread.
 //! - [**LoopMode**](./enum.LoopMode.html) - describes the behaviour of the application event loop.
-
-use crate::draw;
-use crate::event::{self, Event, Key, LoopEvent, Update};
-use crate::frame::{Frame, RawFrame};
-use crate::geom;
-use crate::state;
-use crate::time::DurationF64;
-use crate::wgpu;
-use crate::window::{self, Window};
-use find_folder;
-use instant::Instant;
+use std::any::Any;
 use std::cell::{RefCell, RefMut};
-use std::collections::HashMap;
-use std::future::Future;
+use std::hash::Hash;
 use std::path::PathBuf;
-use std::pin::Pin;
-use std::sync::atomic::{self, AtomicBool};
-use std::sync::Arc;
+use std::rc::Rc;
+use std::sync::atomic::{AtomicUsize, Ordering};
 use std::time::Duration;
-use std::{self, future};
-use wgpu_upstream::InstanceDescriptor;
-use winit;
-use winit::event_loop::ControlFlow;
+use std::{self};
+
+use bevy::app::AppExit;
+#[cfg(not(target_arch = "wasm32"))]
+use bevy::asset::io::file::FileAssetReader;
+use bevy::core::FrameCount;
+use bevy::diagnostic::{DiagnosticsStore, FrameTimeDiagnosticsPlugin};
+use bevy::ecs::system::SystemParam;
+use bevy::ecs::world::unsafe_world_cell::UnsafeWorldCell;
+use bevy::input::keyboard::KeyboardInput;
+use bevy::input::mouse::{MouseButtonInput, MouseWheel};
+use bevy::input::ButtonState;
+use bevy::prelude::*;
+use bevy::reflect::{
+    ApplyError, DynamicTypePath, GetTypeRegistration, ReflectMut, ReflectOwned, ReflectRef,
+    TypeInfo,
+};
+use bevy::window::{ExitCondition, PrimaryWindow, WindowClosed, WindowFocused, WindowResized};
+use bevy::winit::{UpdateMode, WinitEvent, WinitSettings};
+#[cfg(feature = "egui")]
+use bevy_egui::EguiContext;
+#[cfg(feature = "egui")]
+use bevy_inspector_egui::quick::ResourceInspectorPlugin;
+#[cfg(feature = "egui")]
+use bevy_inspector_egui::quick::WorldInspectorPlugin;
+#[cfg(feature = "egui")]
+use bevy_inspector_egui::DefaultInspectorConfigPlugin;
+use find_folder;
+
+use bevy_nannou::prelude::render::ExtendedNannouMaterial;
+use bevy_nannou::prelude::{draw, DrawHolder};
+use bevy_nannou::NannouPlugin;
+
+use crate::prelude::bevy_asset::io::AssetSource;
+use crate::prelude::bevy_ecs::system::SystemState;
+use crate::prelude::render::NannouMesh;
+use crate::prelude::NannouMaterialPlugin;
+use crate::window::WindowUserFunctions;
+use crate::{camera, geom, light, window};
 
 /// The user function type for initialising their model.
 pub type ModelFn<Model> = fn(&App) -> Model;
 
 /// The user function type for updating their model in accordance with some event.
-pub type EventFn<Model, Event> = fn(&App, &mut Model, Event);
+pub type EventFn<Model, Event> = fn(&App, &mut Model, &Event);
 
 /// The user function type for updating the user model within the application loop.
-pub type UpdateFn<Model> = fn(&App, &mut Model, Update);
+pub type UpdateFn<Model> = fn(&App, &mut Model);
 
 /// The user function type for drawing their model to the surface of a single window.
-pub type ViewFn<Model> = fn(&App, &Model, Frame);
+pub type ViewFn<Model> = fn(&App, &Model, view: Entity);
 
 /// A shorthand version of `ViewFn` for sketches where the user does not need a model.
-pub type SketchViewFn = fn(&App, Frame);
+pub type SketchViewFn = fn(&App);
 
 /// The user function type allowing them to consume the `model` when the application exits.
 pub type ExitFn<Model> = fn(&App, Model);
@@ -57,37 +80,41 @@ enum View<Model = ()> {
     Sketch(SketchViewFn),
 }
 
+impl<M> Clone for View<M> {
+    fn clone(&self) -> Self {
+        match self {
+            View::WithModel(view) => View::WithModel(*view),
+            View::Sketch(view) => View::Sketch(*view),
+        }
+    }
+}
+
 /// A nannou `App` builder.
-pub struct Builder<M = (), E = Event> {
-    model: Box<dyn FnOnce(&App) -> Box<dyn Future<Output = M> + '_>>,
+pub struct Builder<M = (), E = WinitEvent> {
+    app: bevy::app::App,
+    model: ModelFn<M>,
     config: Config,
     event: Option<EventFn<M, E>>,
     update: Option<UpdateFn<M>>,
     default_view: Option<View<M>>,
     exit: Option<ExitFn<M>>,
-    create_default_window: bool,
-    default_window_size: Option<DefaultWindowSize>,
-    capture_frame_timeout: Option<Option<Duration>>,
-    max_capture_frame_jobs: Option<u32>,
-    backends: wgpu::Backends,
 }
 
 /// A nannou `Sketch` builder.
-pub struct SketchBuilder<E = Event> {
+pub struct SketchBuilder<E = WinitEvent> {
     builder: Builder<(), E>,
 }
 
+#[derive(Debug, Clone)]
 enum DefaultWindowSize {
     /// Default window size in logical coordinates.
-    Logical(winit::dpi::LogicalSize<u32>),
+    Logical([u32; 2]),
     /// Fullscreen on whatever the primary monitor is at the time of window creation.
     Fullscreen,
 }
 
 /// The default `model` function used when none is specified by the user.
-fn default_model(_: &App) -> () {
-    ()
-}
+fn default_model(_: &App) {}
 
 /// Each nannou application has a single **App** instance. This **App** represents the entire
 /// context of the application.
@@ -103,144 +130,65 @@ fn default_model(_: &App) -> () {
 /// - The sharing of wgpu devices between windows.
 /// - A default **Draw** instance for ease of use.
 /// - A map of channels for submitting user input updates to active **Ui**s.
-pub struct App {
-    config: RefCell<Config>,
-    default_window_size: Option<DefaultWindowSize>,
-    max_capture_frame_jobs: u32,
-    capture_frame_timeout: Option<Duration>,
-    pub(crate) event_loop_window_target: Option<EventLoopWindowTarget>,
-    pub(crate) event_loop_proxy: Proxy,
-    pub(crate) windows: RefCell<HashMap<window::Id, Window>>,
-    /// The wgpu backends to choose between.
-    backends: wgpu::Backends,
-    /// The main wgpu instance.
-    instance: wgpu::Instance,
-    /// A map of active wgpu physical device adapters.
-    adapters: wgpu::AdapterMap,
-    draw_state: DrawState,
-    /// The window that is currently in focus.
-    pub(crate) focused_window: RefCell<Option<window::Id>>,
-    /// The current state of the `Mouse`.
-    pub mouse: state::Mouse,
-    /// State of the keyboard keys.
-    ///
-    /// `mods` provides state of each of the modifier keys: `shift`, `ctrl`, `alt`, `logo`.
-    ///
-    /// `down` is the set of keys that are currently pressed.
-    ///
-    /// NOTE: `down` this is tracked by the nannou `App` so issues might occur if e.g. a key is
-    /// pressed while the app is in focus and then released when out of focus. Eventually we should
-    /// change this to query the OS somehow, but I don't think `winit` provides a way to do this
-    /// yet.
-    pub keys: state::Keys,
-    /// Key time measurements tracked by the App.
-    ///
-    /// `duration.since_start` specifies the duration since the app started running.
-    ///
-    /// `duration.since_prev_update` specifies the duration since the previous update event.
-    pub duration: state::Time,
-    /// The time in seconds since the `App` started running.
-    ///
-    /// Primarily, this field is a convenience that removes the need to call
-    /// `app.duration.since_start.secs()`. Normally we would try to avoid using such an ambiguous
-    /// field name, however due to the sheer amount of use that this value has we feel it is
-    /// beneficial to provide easier access.
-    ///
-    /// This value is of the same type as the scalar value used for describing space in animations.
-    /// This makes it very easy to animate graphics and create changes over time without having to
-    /// cast values or repeatedly calculate it from a `Duration` type. A small example might be
-    /// `app.time.sin()` for simple oscillation behaviour.
-    ///
-    /// **Note:** This is suitable for use in short sketches, however should be avoided in long
-    /// running installations. This is because the "resolution" of floating point values reduces as
-    /// the number becomes higher. Instead, we recommend using `app.duration.since_start` or
-    /// `app.duration.since_prev_update` to access a more precise form of app time.
-    pub time: f32,
+pub struct App<'w> {
+    current_view: Option<Entity>,
+    resourece_world: Rc<RefCell<UnsafeWorldCell<'w>>>,
+    component_world: Rc<RefCell<UnsafeWorldCell<'w>>>,
+    window_count: AtomicUsize,
 }
 
+#[derive(Resource, Deref, DerefMut)]
+struct ModelFnRes<M>(ModelFn<M>);
+
+#[derive(Resource, Deref, DerefMut)]
+struct EventFnRes<M, E>(Option<EventFn<M, E>>);
+
+#[derive(Resource, Deref, DerefMut)]
+struct UpdateFnRes<M>(Option<UpdateFn<M>>);
+
+#[derive(Resource, Deref, DerefMut)]
+struct ViewFnRes<M>(Option<View<M>>);
+
+#[derive(Resource, Deref, DerefMut)]
+struct ExitFnRes<M>(Option<ExitFn<M>>);
+
 /// Miscellaneous app configuration parameters.
-#[derive(Debug)]
+#[derive(Resource, Debug, Clone)]
 struct Config {
-    loop_mode: LoopMode,
     exit_on_escape: bool,
     fullscreen_on_shortcut: bool,
+    default_window_size: Option<DefaultWindowSize>,
 }
 
-// Draw state managed by the **App**.
-#[derive(Debug)]
-struct DrawState {
-    draw: RefCell<draw::Draw>,
-    renderers: RefCell<HashMap<window::Id, RefCell<draw::Renderer>>>,
-}
-
-/// A handle to the **App** that can be shared across threads. This may be used to "wake up" the
-/// **App**'s inner event loop.
-#[derive(Clone)]
-pub struct Proxy {
-    event_loop_proxy: winit::event_loop::EventLoopProxy<()>,
-    // Whether or not a wakeup is already queued.
-    //
-    // Used to avoid spuriously calling `EventLoopProxy::send_event` as this can be expensive on
-    // some platforms.
-    wakeup_queued: Arc<AtomicBool>,
-}
-
-// State related specifically to the application loop, shared between loop modes.
-struct LoopState {
-    updates_since_event: u64,
-    loop_start: Instant,
-    last_update: Instant,
-    total_updates: u64,
+#[derive(Resource, Deref, DerefMut)]
+pub struct ModelHolder<M>(pub M);
+
+#[derive(Resource)]
+struct CreateDefaultWindow;
+
+/// Controls the behaviour of the application loop.
+#[derive(Resource, Default)]
+pub enum RunMode {
+    /// Run until the user exits the application.
+    #[default]
+    UntilExit,
+    /// Run for a fixed number of frames.
+    Ticks(u64),
+    /// Run for a fixed duration (best effort).
+    Duration(Duration),
 }
 
-/// The mode in which the **App** is currently running the event loop and emitting `Update` events.
-#[derive(Clone, Debug, PartialEq)]
-pub enum LoopMode {
-    /// Synchronises `Update` events with requests for a new frame for the surface.
-    ///
-    /// The result of using this loop mode is similar to using vsync in traditional applications.
-    /// E.g. if you have one window running on a monitor with a 60hz refresh rate, your update will
-    /// get called at a fairly consistent interval that is close to 60 times per second.
-    RefreshSync,
-
-    /// Specifies that the application is continuously looping at a consistent rate.
-    ///
-    /// **NOTE:** This currently behaves the same as `RefreshSync`. Need to upate this to handled a
-    /// fix step properly in the future. See #456.
-    Rate {
-        /// The minimum interval between emitted updates.
-        update_interval: Duration,
-    },
-
-    /// Waits for user input, window, device and wake-up events to occur before producing `Update`
-    /// events.
-    ///
-    /// This is particularly useful for low-energy GUIs that only need to update when some sort of
-    /// input has occurred. The benefit of using this mode is that you don't waste CPU cycles
-    /// looping or updating when you know nothing is changing in your model or view.
-    Wait,
-
-    /// Loops for the given number of updates and then finishes.
-    ///
-    /// This is similar to the **Wait** loop mode, except that windowing, application and input
-    /// events will not cause the loop to update or view again after the initial
-    /// `number_of_updates` have already been applied.
-    ///
-    /// This is useful for sketches where you only want to draw one frame, or if you know exactly
-    /// how many updates you require for an animation, etc.
-    NTimes {
-        /// The number of updates that must be emited regardless of non-update events
-        number_of_updates: usize,
-    },
+impl RunMode {
+    /// Run the main update loop once.
+    pub fn once() -> Self {
+        RunMode::Ticks(1)
+    }
 }
 
-impl<M> Builder<M, Event>
+impl<M> Builder<M>
 where
     M: 'static,
 {
-    /// The default set of backends requested.
-    pub const DEFAULT_BACKENDS: wgpu::Backends = wgpu::DEFAULT_BACKENDS;
-
     /// Begin building the `App`.
     ///
     /// The `model` argument is the function that the App will call to initialise your Model.
@@ -253,78 +201,37 @@ where
     /// The Model that is returned by the function is the same model that will be passed to the
     /// given event and view functions.
     pub fn new(model: ModelFn<M>) -> Self {
-        Self::new_async(move |app| Box::new(future::ready(model(app))))
-    }
+        let mut app = bevy::app::App::new();
+        app.add_plugins((
+            DefaultPlugins.set(WindowPlugin {
+                // Don't spawn a  window by default, we'll handle this ourselves
+                primary_window: None,
+                exit_condition: ExitCondition::DontExit,
+                ..default()
+            }),
+            #[cfg(feature = "egui")]
+            bevy_egui::EguiPlugin,
+            NannouPlugin,
+        ))
+        .init_resource::<RunMode>();
 
-    pub fn new_async(
-        model: impl FnOnce(&App) -> Box<dyn Future<Output = M> + '_> + 'static,
-    ) -> Self {
         Builder {
-            model: Box::new(model),
+            app,
+            model,
             config: Config::default(),
             event: None,
             update: None,
             default_view: None,
             exit: None,
-            create_default_window: false,
-            default_window_size: None,
-            max_capture_frame_jobs: None,
-            capture_frame_timeout: None,
-            backends: Self::DEFAULT_BACKENDS,
-        }
-    }
-
-    /// The function that the app will call to allow you to update your Model on events.
-    ///
-    /// The `event` function allows you to expect any event type that implements `LoopEvent`,
-    /// however nannou also provides a default `Event` type that should cover most use cases. This
-    /// event type is an `enum` that describes all the different kinds of I/O events that might
-    /// occur during the life of the program. These include things like `Update`s and
-    /// `WindowEvent`s such as `KeyPressed`, `MouseMoved`, and so on.
-    #[cfg_attr(rustfmt, rustfmt_skip)]
-    pub fn event<E>(self, event: EventFn<M, E>) -> Builder<M, E>
-    where
-        E: LoopEvent,
-    {
-        let Builder {
-            model,
-            config,
-            update,
-            default_view,
-            exit,
-            create_default_window,
-            default_window_size,
-            max_capture_frame_jobs,
-            capture_frame_timeout,
-            backends,
-            ..
-        } = self;
-        Builder {
-            model,
-            config,
-            event: Some(event),
-            update,
-            default_view,
-            exit,
-            create_default_window,
-            default_window_size,
-            max_capture_frame_jobs,
-            capture_frame_timeout,
-            backends
         }
     }
 }
 
 impl<M, E> Builder<M, E>
 where
-    M: 'static,
-    E: LoopEvent,
+    M: 'static + Send + Sync,
+    E: Event,
 {
-    /// By default, we timeout if waiting for a frame capture job takes longer than 5 seconds. This
-    /// is to avoid hanging forever in the case the frame writing process encounters an
-    /// unrecoverable error.
-    pub const DEFAULT_CAPTURE_FRAME_TIMEOUT: Duration = Duration::from_secs(10);
-
     /// The default `view` function that the app will call to allow you to present your Model to
     /// the surface of a window on your display.
     ///
@@ -366,7 +273,7 @@ where
     /// small single-window applications and examples.
     pub fn simple_window(mut self, view: ViewFn<M>) -> Self {
         self.default_view = Some(View::WithModel(view));
-        self.create_default_window = true;
+        self.app.insert_resource(CreateDefaultWindow);
         self
     }
 
@@ -379,68 +286,62 @@ where
         self
     }
 
-    /// Specify the default window size in points.
-    ///
-    /// If a window is created and its size is not specified, this size will be used.
-    pub fn size(mut self, width: u32, height: u32) -> Self {
-        let size = winit::dpi::LogicalSize { width, height };
-        self.default_window_size = Some(DefaultWindowSize::Logical(size));
+    /// Specify the behaviour of the application loop.
+    pub fn set_run_mode(mut self, run_mode: RunMode) -> Self {
+        self.app.insert_resource(run_mode);
         self
     }
 
-    /// Specify that windows should be created on the primary monitor by default.
-    pub fn fullscreen(mut self) -> Self {
-        self.default_window_size = Some(DefaultWindowSize::Fullscreen);
+    pub fn init_custom_material<T>(mut self) -> Self
+    where
+        T: Material + Default,
+        T::Data: PartialEq + Eq + Hash + Clone,
+    {
+        self.app.add_plugins(NannouMaterialPlugin::<T>::default());
         self
     }
 
-    /// Specify the default initial loop mode for this app.
-    pub fn loop_mode(mut self, mode: LoopMode) -> Self {
-        self.config.loop_mode = mode;
+    /// Load a fragment shader asset from the given path for use with the nannou `Draw` API.
+    #[cfg(feature = "nightly")]
+    pub fn init_fragment_shader<const SHADER: &'static str>(mut self) -> Self {
+        self.app
+            .add_plugins(NannouMaterialPlugin::<ExtendedNannouMaterial<"", SHADER>>::default());
         self
     }
 
-    /// The maximum number of simultaneous capture frame jobs that can be run per window before we
-    /// block and wait for the existing jobs to complete.
-    ///
-    /// A "capture frame job" refers to the combind process of waiting to read a frame from the GPU
-    /// and then writing that frame to an image file on the disk. Each call to
-    /// `window.capture_frame(path)` spawns a new "capture frame job" on an internal thread pool.
-    ///
-    /// By default, this value is equal to the number of physical cpu threads available on the
-    /// system. However, keep in mind that this means there must be room in both RAM and VRAM for
-    /// this number of textures to exist per window at any moment in time. If you run into an "out
-    /// of memory" error, try reducing the number of max jobs to a lower value, though never lower
-    /// than `1`.
-    ///
-    /// **Panics** if the specified value is less than `1`.
-    pub fn max_capture_frame_jobs(mut self, max_jobs: u32) -> Self {
-        assert!(
-            max_jobs >= 1,
-            "must allow for at least one capture frame job at a time"
-        );
-        self.max_capture_frame_jobs = Some(max_jobs);
+    #[cfg(any(feature = "config_json", feature = "config_toml"))]
+    pub fn init_config<T>(mut self) -> Self
+    where
+        for<'de> T: serde::Deserialize<'de> + Asset,
+    {
+        self.app.add_plugins((
+            #[cfg(feature = "config_json")]
+            bevy_common_assets::json::JsonAssetPlugin::<T>::new(&[".json"]),
+            #[cfg(feature = "config_toml")]
+            bevy_common_assets::toml::TomlAssetPlugin::<T>::new(&[".toml"]),
+        ));
         self
     }
 
-    /// In the case that `max_capture_frame_jobs` is reached and the main thread must block, this
-    /// specifies how long to wait for a running capture job to complete. See the
-    /// `max_capture_frame_jobs` docs for more details.
-    ///
-    /// By default, the timeout used is equal to `app::Builder::DEFAULT_CAPTURE_FRAME_TIMEOUT`.
-    ///
-    /// If `None` is specified, the capture process will never time out. This may be necessary on
-    /// extremely low-powered machines that take a long time to write each frame to disk.
-    pub fn capture_frame_timeout(mut self, timeout: Option<std::time::Duration>) -> Self {
-        self.capture_frame_timeout = Some(timeout);
+    pub fn add_plugin<P>(mut self, plugin: P) -> Self
+    where
+        P: Plugin,
+    {
+        self.app.add_plugins(plugin);
         self
     }
 
-    /// Specify the set of preferred WGPU backends.
+    /// Specify the default window size in points.
     ///
-    /// By default, this is `wgpu::Backends::PRIMARY | wgpu::Backends::GL`.
-    pub fn backends(mut self, backends: wgpu::Backends) -> Self {
-        self.backends = backends;
+    /// If a window is created and its size is not specified, this size will be used.
+    pub fn size(mut self, width: u32, height: u32) -> Self {
+        self.config.default_window_size = Some(DefaultWindowSize::Logical([width, height]));
+        self
+    }
+
+    /// Specify that windows should be created on the primary monitor by default.
+    pub fn fullscreen(mut self) -> Self {
+        self.config.default_window_size = Some(DefaultWindowSize::Fullscreen);
         self
     }
 
@@ -451,100 +352,61 @@ where
     /// If you wish to remain cross-platform friendly, we recommend that you call this on the main
     /// thread as some platforms require that their application event loop and windows are
     /// initialised on the main thread.
-    pub fn run(self) {
-        let rt = Self::build_runtime();
-        rt.block_on(self.run_async())
-    }
-
-    #[cfg(not(target_arch = "wasm32"))]
-    fn build_runtime() -> tokio::runtime::Runtime {
-        tokio::runtime::Builder::new_multi_thread()
-            .enable_all()
-            .build()
-            .expect("failed to create tokio runtime")
-    }
-
-    #[cfg(target_arch = "wasm32")]
-    fn build_runtime() -> tokio::runtime::Runtime {
-        tokio::runtime::Builder::new_current_thread()
-            .enable_all()
-            .build()
-            .expect("failed to create tokio runtime")
-    }
-
-    pub async fn run_async(self) {
-        // Start the winit window event loop.
-        let event_loop = winit::event_loop::EventLoop::new();
-
-        // Create the proxy used to awaken the event loop.
-        let event_loop_proxy = event_loop.create_proxy();
-        let wakeup_queued = Arc::new(AtomicBool::new(false));
-        let event_loop_proxy = Proxy {
-            event_loop_proxy,
-            wakeup_queued,
-        };
-
-        // Initialise the app.
-        let max_capture_frame_jobs = self
-            .max_capture_frame_jobs
-            .unwrap_or(num_cpus::get() as u32);
-        let capture_frame_timeout = self
-            .capture_frame_timeout
-            .unwrap_or(Some(Self::DEFAULT_CAPTURE_FRAME_TIMEOUT));
-        let event_loop_window_target = Some(EventLoopWindowTarget::Owned(event_loop));
-        let app = App::new(
-            self.config,
-            event_loop_proxy,
-            event_loop_window_target,
-            self.default_window_size,
-            max_capture_frame_jobs,
-            capture_frame_timeout,
-            self.backends,
-        );
-
-        // Create the default window if necessary
-        if self.create_default_window {
-            let window_id = app
-                .new_window()
-                .build_async()
-                .await
-                .expect("could not build default app window");
-            *app.focused_window.borrow_mut() = Some(window_id);
-        }
-
-        // Call the user's model function.
-        let model = Pin::from((self.model)(&app)).await;
-
-        // If there is not yet some default window in "focus" check to see if one has been created.
-        if app.focused_window.borrow().is_none() {
-            if let Some(id) = app.windows.borrow().keys().next() {
-                *app.focused_window.borrow_mut() = Some(id.clone());
-            }
-        }
-
-        run_loop(
-            app,
-            model,
-            self.event,
-            self.update,
-            self.default_view,
-            self.exit,
-        );
+    pub fn run(mut self) {
+        self.app
+            // This ensures that color materials are rendered correctly.
+            .insert_resource(AmbientLight {
+                color: Color::WHITE,
+                // This isn't randomly chosen
+                // See:  https://discord.com/channels/691052431525675048/866787577687310356/1229248273735487560
+                brightness: 998.096,
+            })
+            .insert_resource(self.config.clone())
+            .insert_resource(ModelFnRes(self.model))
+            .insert_resource(EventFnRes(self.event))
+            .insert_resource(UpdateFnRes(self.update))
+            .insert_resource(ViewFnRes(self.default_view))
+            .insert_resource(ExitFnRes(self.exit))
+            .add_systems(Startup, startup::<M>)
+            .add_systems(First, first::<M>)
+            .add_systems(
+                Update,
+                (
+                    update::<M>,
+                    events::<M, E>,
+                    key_events::<M>,
+                    received_char_events::<M>,
+                    cursor_moved_events::<M>,
+                    mouse_button_events::<M>,
+                    cursor_entered_events::<M>,
+                    cursor_left_events::<M>,
+                    mouse_wheel_events::<M>,
+                    window_moved_events::<M>,
+                    window_resized_events::<M>,
+                    touch_events::<M>,
+                    file_drop_events::<M>,
+                    window_focus_events::<M>,
+                    window_closed_events::<M>,
+                ),
+            )
+            .add_systems(Last, last::<M>)
+            .run();
     }
 }
 
-impl<E> SketchBuilder<E>
+impl<M> Builder<M>
 where
-    E: LoopEvent,
+    M: Reflect + GetTypeRegistration + 'static,
 {
-    /// Specify the default initial loop mode for this sketch.
-    ///
-    /// This method delegates to `Builder::loop_mode`.
-    pub fn loop_mode(mut self, mode: LoopMode) -> Self {
-        self.builder = self.builder.loop_mode(mode);
+    #[cfg(feature = "egui")]
+    pub fn model_ui(mut self) -> Self {
+        self.app
+            .add_plugins((ResourceInspectorPlugin::<ModelHolder<M>>::default(),));
         self
     }
+}
 
+impl SketchBuilder {
     /// The size of the sketch window.
     pub fn size(mut self, width: u32, height: u32) -> Self {
         self.builder = self.builder.size(width, height);
@@ -559,237 +421,358 @@ where
     }
 }
 
-impl Builder<(), Event> {
+impl Builder<()> {
     /// Shorthand for building a simple app that has no model, handles no events and simply draws
     /// to a single window.
     ///
     /// This is useful for late night hack sessions where you just don't care about all that other
     /// stuff, you just want to play around with some ideas or make something pretty.
-    pub fn sketch(view: SketchViewFn) -> SketchBuilder<Event> {
+    pub fn sketch(view: SketchViewFn) -> SketchBuilder {
         let mut builder = Builder::new(default_model);
         builder.default_view = Some(View::Sketch(view));
-        builder.create_default_window = true;
+        builder.app.insert_resource(CreateDefaultWindow);
         SketchBuilder { builder }
     }
 }
 
-/// Given some "frames per second", return the interval between frames as a `Duration`.
-fn update_interval(fps: f64) -> Duration {
-    assert!(fps > 0.0);
-    const NANOSEC_PER_SEC: f64 = 1_000_000_000.0;
-    let interval_nanosecs = NANOSEC_PER_SEC / fps;
-    let secs = (interval_nanosecs / NANOSEC_PER_SEC) as u64;
-    let nanosecs = (interval_nanosecs % NANOSEC_PER_SEC) as u32;
-    Duration::new(secs, nanosecs)
+impl Default for Config {
+    fn default() -> Self {
+        let exit_on_escape = App::DEFAULT_EXIT_ON_ESCAPE;
+        let fullscreen_on_shortcut = App::DEFAULT_FULLSCREEN_ON_SHORTCUT;
+        Config {
+            exit_on_escape,
+            fullscreen_on_shortcut,
+            default_window_size: None,
+        }
+    }
 }
 
-impl LoopMode {
-    pub const DEFAULT_RATE_FPS: f64 = 60.0;
-    /// The minimum number of updates that will be emitted after an event is triggered in Wait
-    /// mode.
-    pub const UPDATES_PER_WAIT_EVENT: u32 = 3;
+impl<M> GetTypeRegistration for ModelHolder<M>
+where
+    M: GetTypeRegistration,
+{
+    fn get_type_registration() -> bevy::reflect::TypeRegistration {
+        M::get_type_registration()
+    }
+}
 
-    /// A simplified constructor for the default `RefreshSync` loop mode.
-    ///
-    /// Assumes a display refresh rate of ~60hz and in turn specifies a `minimum_update_latency` of
-    /// ~8.33ms. The `windows` field is set to `None`.
-    pub fn refresh_sync() -> Self {
-        LoopMode::RefreshSync
+impl<M> DynamicTypePath for ModelHolder<M>
+where
+    M: DynamicTypePath,
+{
+    fn reflect_type_path(&self) -> &str {
+        self.0.reflect_type_path()
     }
 
-    /// Specify the **Rate** mode with the given frames-per-second.
-    pub fn rate_fps(fps: f64) -> Self {
-        let update_interval = update_interval(fps);
-        LoopMode::Rate { update_interval }
+    fn reflect_short_type_path(&self) -> &str {
+        self.0.reflect_short_type_path()
     }
 
-    /// Specify the **Wait** mode.
-    pub fn wait() -> Self {
-        LoopMode::Wait
+    fn reflect_type_ident(&self) -> Option<&str> {
+        self.0.reflect_type_ident()
     }
 
-    /// Specify the **Ntimes** mode with one update
-    ///
-    /// Waits long enough to ensure loop iteration never occurs faster than the given `max_fps`.
-    pub fn loop_ntimes(number_of_updates: usize) -> Self {
-        LoopMode::NTimes { number_of_updates }
+    fn reflect_crate_name(&self) -> Option<&str> {
+        self.0.reflect_crate_name()
     }
 
-    /// Specify the **Ntimes** mode with one update
-    pub fn loop_once() -> Self {
-        Self::loop_ntimes(1)
+    fn reflect_module_path(&self) -> Option<&str> {
+        self.0.reflect_module_path()
     }
 }
 
-impl Default for LoopMode {
-    fn default() -> Self {
-        LoopMode::refresh_sync()
+impl<M> Reflect for ModelHolder<M>
+where
+    M: Reflect + DynamicTypePath + Any + GetTypeRegistration + 'static,
+{
+    fn get_represented_type_info(&self) -> Option<&'static TypeInfo> {
+        self.0.get_represented_type_info()
     }
-}
 
-impl Default for Config {
-    fn default() -> Self {
-        let loop_mode = Default::default();
-        let exit_on_escape = App::DEFAULT_EXIT_ON_ESCAPE;
-        let fullscreen_on_shortcut = App::DEFAULT_FULLSCREEN_ON_SHORTCUT;
-        Config {
-            loop_mode,
-            exit_on_escape,
-            fullscreen_on_shortcut,
-        }
+    fn into_any(self: Box<Self>) -> Box<dyn Any> {
+        Box::new(self.0).into_any()
+    }
+
+    fn as_any(&self) -> &dyn Any {
+        self.0.as_any()
+    }
+
+    fn as_any_mut(&mut self) -> &mut dyn Any {
+        self.0.as_any_mut()
+    }
+
+    fn into_reflect(self: Box<Self>) -> Box<dyn Reflect> {
+        Box::new(self.0).into_reflect()
+    }
+
+    fn as_reflect(&self) -> &dyn Reflect {
+        self.0.as_reflect()
+    }
+
+    fn as_reflect_mut(&mut self) -> &mut dyn Reflect {
+        self.0.as_reflect_mut()
+    }
+
+    fn apply(&mut self, value: &dyn Reflect) {
+        self.0.apply(value)
+    }
+
+    fn try_apply(&mut self, value: &dyn Reflect) -> Result<(), ApplyError> {
+        self.0.try_apply(value)
+    }
+
+    fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>> {
+        self.0.set(value)
+    }
+
+    fn reflect_ref(&self) -> ReflectRef {
+        self.0.reflect_ref()
+    }
+
+    fn reflect_mut(&mut self) -> ReflectMut {
+        self.0.reflect_mut()
+    }
+
+    fn reflect_owned(self: Box<Self>) -> ReflectOwned {
+        Box::new(self.0).reflect_owned()
+    }
+
+    fn clone_value(&self) -> Box<dyn Reflect> {
+        self.0.clone_value()
     }
 }
 
-impl App {
-    pub const ASSETS_DIRECTORY_NAME: &'static str = "assets";
+impl<'w> App<'w> {
     pub const DEFAULT_EXIT_ON_ESCAPE: bool = true;
     pub const DEFAULT_FULLSCREEN_ON_SHORTCUT: bool = true;
 
+    /// Retrieve a mutable reference to the [`AssetServer`] resource.
+    pub fn asset_server(&self) -> RefMut<AssetServer> {
+        let world = self.resource_world_mut();
+        RefMut::map(world, |world| {
+            world.resource_mut::<AssetServer>().into_inner()
+        })
+    }
+
+    pub fn assets_mut<T: Asset>(&self) -> RefMut<'_, Assets<T>> {
+        let world = self.resource_world_mut();
+        RefMut::map(world, |world| {
+            world.resource_mut::<Assets<T>>().into_inner()
+        })
+    }
+
+    pub fn assets<T: Asset>(&self) -> std::cell::Ref<'_, Assets<T>> {
+        let world = self.resource_world();
+        std::cell::Ref::map(world, |world| world.resource::<Assets<T>>())
+    }
+
+    pub fn resource<T: Resource>(&self) -> std::cell::Ref<'_, T> {
+        let world = self.resource_world();
+        std::cell::Ref::map(world, |world| world.resource::<T>())
+    }
+
+    pub fn resource_mut<T: Resource>(&self) -> std::cell::RefMut<'_, T> {
+        let world = self.resource_world_mut();
+        std::cell::RefMut::map(world, |world| world.resource_mut::<T>().into_inner())
+    }
+
+    /// Retrieve the path to the assets directory.
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn assets_path(&self) -> PathBuf {
+        FileAssetReader::get_base_path().join("assets")
+    }
+
+    #[cfg(feature = "egui")]
+    /// Get the egui context for the provided window.
+    pub fn egui_for_window(&self, window: Entity) -> RefMut<EguiContext> {
+        let world = self.component_world_mut();
+        RefMut::map(world, |world| {
+            world
+                .get_mut::<EguiContext>(window)
+                .expect("No egui context")
+                .into_inner()
+        })
+    }
+
+    #[cfg(feature = "egui")]
+    /// Get the egui context for the currently focused window.
+    pub fn egui(&self) -> RefMut<EguiContext> {
+        self.egui_for_window(self.window_id())
+    }
+
+    /// Get the current mouse position in points.
+    pub fn mouse(&self) -> Vec2 {
+        let window = self.window_id();
+        let world = self.component_world();
+
+        let window = world
+            .entity(window)
+            .get::<Window>()
+            .expect("Entity is not a window");
+        let screen_position = window.cursor_position().unwrap_or(Vec2::ZERO);
+        Vec2::new(
+            screen_position.x - window.width() / 2.0,
+            -(screen_position.y - window.height() / 2.0),
+        )
+    }
+
+    /// Get the current input state for the mouse.
+    pub fn mouse_buttons(&self) -> ButtonInput<MouseButton> {
+        let mouse_input = self.resource::<ButtonInput<MouseButton>>();
+        mouse_input.clone()
+    }
+
+    /// Get the current input state for the keyboard.
+    pub fn keys(&self) -> ButtonInput<KeyCode> {
+        let keyboard_input = self.resource::<ButtonInput<KeyCode>>();
+        keyboard_input.clone()
+    }
+
+    /// Get the elapsed seconds since startup.
+    pub fn time(&self) -> f32 {
+        let time = self.resource::<Time>();
+        time.elapsed_seconds()
+    }
+
+    /// Get the elapsed seconds since the last frame.
+    pub fn time_delta(&self) -> f32 {
+        let time = self.resource::<Time>();
+        time.delta_seconds()
+    }
+
     // Create a new `App`.
-    fn new(
-        config: Config,
-        event_loop_proxy: Proxy,
-        event_loop_window_target: Option<EventLoopWindowTarget>,
-        default_window_size: Option<DefaultWindowSize>,
-        max_capture_frame_jobs: u32,
-        capture_frame_timeout: Option<Duration>,
-        backends: wgpu::Backends,
-    ) -> Self {
-        let instance = wgpu::Instance::new(InstanceDescriptor {
-            backends,
-            ..Default::default()
-        });
-        let adapters = Default::default();
-        let windows = RefCell::new(HashMap::new());
-        let draw = RefCell::new(draw::Draw::default());
-        let config = RefCell::new(config);
-        let renderers = RefCell::new(Default::default());
-        let draw_state = DrawState { draw, renderers };
-        let focused_window = RefCell::new(None);
-        let mouse = state::Mouse::new();
-        let keys = state::Keys::default();
-        let duration = state::Time::default();
-        let time = duration.since_start.secs() as _;
-        let app = App {
-            event_loop_proxy,
-            event_loop_window_target,
-            default_window_size,
-            max_capture_frame_jobs,
-            capture_frame_timeout,
-            focused_window,
-            backends,
-            instance,
-            adapters,
-            windows,
-            config,
-            draw_state,
-            mouse,
-            keys,
-            duration,
-            time,
-        };
-        app
+    fn new(world: &'w mut World) -> Self {
+        let world = world.as_unsafe_world_cell();
+        let window_count = unsafe { world.world_mut() }
+            .query::<&Window>()
+            .iter(unsafe { world.world_mut() })
+            .count();
+
+        App {
+            current_view: None,
+            resourece_world: Rc::new(RefCell::new(world)),
+            component_world: Rc::new(RefCell::new(world)),
+            window_count: window_count.into(),
+        }
+    }
+
+    pub(crate) fn resource_world(&self) -> std::cell::Ref<'_, World> {
+        let world = self.resourece_world.borrow();
+        std::cell::Ref::map(world, |world| unsafe { world.world() })
+    }
+
+    pub(crate) fn resource_world_mut(&self) -> RefMut<'_, World> {
+        let world = unsafe { self.resourece_world.borrow_mut() };
+        RefMut::map(world, |world| unsafe { world.world_mut() })
+    }
+
+    pub(crate) fn component_world(&self) -> std::cell::Ref<'_, World> {
+        let world = self.component_world.borrow();
+        std::cell::Ref::map(world, |world| unsafe { world.world() })
+    }
+
+    pub(crate) fn component_world_mut(&self) -> RefMut<'_, World> {
+        let world = unsafe { self.component_world.borrow_mut() };
+        RefMut::map(world, |world| unsafe { world.world_mut() })
+    }
+
+    /// Retreive a mutable reference to the `App`'s world.
+    ///
+    /// WARNING: This should be used with extreme caution as it can lead to undefined behavior.
+    /// This is only safe to use if you are certain that the world is not being accessed by any
+    /// other part of the application.
+    ///
+    /// Applications that wish to make greater use of the ECS should consider using the Bevy ECS
+    /// API directly.
+    pub unsafe fn unsafe_world_mut(&self) -> &'w mut World {
+        self.resourece_world.borrow_mut().world_mut()
     }
 
     /// Returns the list of all the monitors available on the system.
-    pub fn available_monitors(&self) -> Vec<winit::monitor::MonitorHandle> {
-        match self.event_loop_window_target {
-            Some(EventLoopWindowTarget::Owned(ref event_loop)) => {
-                event_loop.available_monitors().collect()
-            }
-            _ => {
-                let windows = self.windows.borrow();
-                match windows.values().next() {
-                    None => vec![],
-                    Some(window) => window.window.available_monitors().collect(),
-                }
-            }
-        }
+    pub fn available_monitors(&self) -> Vec<()> {
+        // Bevy doesn't expose this right now but could be nice
+        todo!()
     }
 
     /// Returns the primary monitor of the system.
     /// May return None if none can be detected. For example, this can happen when running on Linux
     /// with Wayland.
-    pub fn primary_monitor(&self) -> Option<winit::monitor::MonitorHandle> {
-        match self.event_loop_window_target {
-            Some(EventLoopWindowTarget::Owned(ref event_loop)) => event_loop.primary_monitor(),
-            _ => {
-                let windows = self.windows.borrow();
-                match windows.values().next() {
-                    None => unimplemented!(
-                        "yet to implement a way to get `primary_monitor` if neither \
-                         event loop or window can be safely accessed"
-                    ),
-                    Some(window) => window.window.primary_monitor(),
-                }
-            }
-        }
+    pub fn primary_monitor(&self) -> Option<()> {
+        // Bevy doesn't expose this right now but could be nice
+        todo!()
     }
 
-    /// Find and return the absolute path to the project's `assets` directory.
-    ///
-    /// This method looks for the assets directory in the following order:
-    ///
-    /// 1. Checks the same directory as the executable.
-    /// 2. Recursively checks exe's parent directories (to a max depth of 5).
-    /// 3. Recursively checks exe's children directories (to a max depth of 3).
-    pub fn assets_path(&self) -> Result<PathBuf, find_folder::Error> {
-        find_assets_path()
+    pub fn new_light<'a>(&'a self) -> light::Builder<'a, 'w> {
+        light::Builder::new(self)
     }
 
-    /// The path to the current project directory.
-    ///
-    /// The current project directory is considered to be the directory containing the cargo
-    /// manifest (aka the `Cargo.toml` file).
-    ///
-    /// **Note:** Be careful not to rely on this directory for apps or sketches that you wish to
-    /// distribute! This directory is mostly useful for local sketches, experiments and testing.
-    pub fn project_path(&self) -> Result<PathBuf, find_folder::Error> {
-        find_project_path()
+    /// Begin building a new camera.
+    pub fn new_camera<'a>(&'a self) -> camera::Builder<'a, 'w> {
+        camera::Builder::new(self)
     }
 
     /// Begin building a new window.
-    pub fn new_window(&self) -> window::Builder {
+    pub fn new_window<'a, M>(&'a self) -> window::Builder<'a, 'w, M>
+    where
+        M: 'static,
+    {
+        self.window_count.fetch_add(1usize, Ordering::SeqCst);
         let builder = window::Builder::new(self);
-        let builder = match self.default_window_size {
+        let world = self.resource_world();
+        let config = world.resource::<Config>();
+        let builder = match config.default_window_size {
             Some(DefaultWindowSize::Fullscreen) => builder.fullscreen(),
-            Some(DefaultWindowSize::Logical(size)) => builder.size(size.width, size.height),
+            Some(DefaultWindowSize::Logical([w, h])) => builder.size(w, h),
             None => builder,
         };
         builder
-            .max_capture_frame_jobs(self.max_capture_frame_jobs)
-            .capture_frame_timeout(self.capture_frame_timeout)
     }
 
     /// The number of windows currently in the application.
     pub fn window_count(&self) -> usize {
-        self.windows.borrow().len()
+        self.window_count.load(Ordering::SeqCst)
     }
 
     /// A reference to the window with the given `Id`.
-    pub fn window(&self, id: window::Id) -> Option<std::cell::Ref<Window>> {
-        let windows = self.windows.borrow();
-        if !windows.contains_key(&id) {
-            None
-        } else {
-            Some(std::cell::Ref::map(windows, |ws| &ws[&id]))
-        }
+    pub fn window<'a>(&'a self, id: Entity) -> window::Window<'a, 'w> {
+        window::Window::new(self, id)
+    }
+
+    pub fn camera<'a>(&'a self, id: Entity) -> camera::Camera<'a, 'w> {
+        camera::Camera::new(self, id)
     }
 
-    /// Return the **Id** of the currently focused window.
+    pub fn light<'a>(&'a self, id: Entity) -> light::Light<'a, 'w> {
+        light::Light::new(self, id)
+    }
+
+    /// Return the [Entity] of the currently focused window.
     ///
     /// **Panics** if there are no windows or if no window is in focus.
-    pub fn window_id(&self) -> window::Id {
-        self.focused_window
-            .borrow()
-            .expect("called `App::window_id` but there is no window currently in focus")
+    pub fn window_id(&self) -> Entity {
+        let mut window_q = self.component_world_mut().query::<(Entity, &Window)>();
+        for (entity, window) in window_q.iter(&self.component_world()) {
+            if window.focused {
+                return entity;
+            }
+        }
+
+        let mut primary_window = self
+            .component_world_mut()
+            .query_filtered::<Entity, With<PrimaryWindow>>();
+        primary_window
+            .get_single(&self.component_world())
+            .expect("No windows are open in the App")
     }
 
-    /// Return a `Vec` containing a unique `window::Id` for each currently open window managed by
-    /// the `App`.
-    pub fn window_ids(&self) -> Vec<window::Id> {
-        let windows = self.windows.borrow();
-        windows.keys().cloned().collect()
+    /// Return a [Vec] containing a unique [Entity] for each currently open window managed by
+    /// the [App].
+    pub fn window_ids(&self) -> Vec<Entity> {
+        let mut window_q = self.component_world_mut().query::<(Entity, &Window)>();
+        window_q
+            .iter(&self.component_world())
+            .map(|(entity, _)| entity)
+            .collect()
     }
 
     /// Return the **Rect** for the currently focused window.
@@ -798,61 +781,43 @@ impl App {
     ///
     /// **Panics** if there are no windows or if no window is in focus.
     pub fn window_rect(&self) -> geom::Rect<f32> {
-        self.main_window().rect()
+        let window = self.window_id();
+        let world = self.component_world();
+
+        let window = world
+            .entity(window)
+            .get::<Window>()
+            .expect("Entity is not a window");
+        geom::Rect::from_w_h(window.width(), window.height())
     }
 
     /// A reference to the window currently in focus.
     ///
     /// **Panics** if their are no windows open in the **App**.
-    ///
-    /// Uses the **App::window** method internally.
-    ///
-    /// TODO: Currently this produces a reference to the *focused* window, but this behaviour
-    /// should be changed to track the "main" window (the first window created?).
-    pub fn main_window(&self) -> std::cell::Ref<Window> {
-        self.window(self.window_id())
-            .expect("no window for focused id")
-    }
-
-    /// Return the wgpu `Backends` in use.
-    pub fn backends(&self) -> wgpu::Backends {
-        self.backends
-    }
-
-    /// Return the main wgpu `Instance` in use.
-    ///
-    /// This must be passed into the various methods on `AdapterMap`.
-    pub fn instance(&self) -> &wgpu::Instance {
-        &self.instance
-    }
-
-    /// Access to the **App**'s inner map of wgpu adapters representing access to physical GPU
-    /// devices.
-    ///
-    /// By maintaining a map of active adapters and their established devices, nannou allows for
-    /// devices to be shared based on the desired `RequestAdapterOptions` and `DeviceDescriptor`s.
-    ///
-    /// For example, when creating new windows with the same set of `RequestAdapterOptions` and
-    /// `DeviceDescriptor`s, nannou will automatically share devices between windows where
-    /// possible. This allows for sharing GPU resources like **Texture**s and **Buffer**s between
-    /// windows.
-    ///
-    /// All methods on `AdapterMap` that take a `wgpu::Instance` must be passed the main instance
-    /// in use by the app, accessed via `App::instance()`.
-    pub fn wgpu_adapters(&self) -> &wgpu::AdapterMap {
-        &self.adapters
+    pub fn main_window<'a>(&'a self) -> crate::window::Window<'a, 'w> {
+        let mut window_q = self
+            .component_world_mut()
+            .query_filtered::<Entity, With<PrimaryWindow>>();
+        let main_window = window_q
+            .get_single(&self.component_world())
+            .expect("No windows are open in the App");
+        window::Window::new(self, main_window)
     }
 
     /// Return whether or not the `App` is currently set to exit when the `Escape` key is pressed.
     pub fn exit_on_escape(&self) -> bool {
-        self.config.borrow().exit_on_escape
+        let world = self.resource_world();
+        let config = world.resource::<Config>();
+        config.exit_on_escape
     }
 
     /// Specify whether or not the app should close when the `Escape` key is pressed.
     ///
     /// By default this is `true`.
-    pub fn set_exit_on_escape(&self, b: bool) {
-        self.config.borrow_mut().exit_on_escape = b;
+    pub fn set_exit_on_escape(&mut self, b: bool) {
+        let mut world = self.resource_world_mut();
+        let mut config = world.resource_mut::<Config>();
+        config.exit_on_escape = b;
     }
 
     /// Returns whether or not the `App` is currently allows the focused window to enter or exit
@@ -861,8 +826,10 @@ impl App {
     /// - Linux uses F11.
     /// - macOS uses apple key + f.
     /// - Windows uses windows key + f.
-    pub fn fullscreen_on_shortcut(&self) -> bool {
-        self.config.borrow().fullscreen_on_shortcut
+    pub fn fullscreen_on_shortcut(&mut self) -> bool {
+        let world = self.resource_world();
+        let config = world.resource::<Config>();
+        config.fullscreen_on_shortcut
     }
 
     /// Set whether or not the `App` should allow the focused window to enter or exit fullscreen
@@ -871,53 +838,43 @@ impl App {
     /// - Linux uses F11.
     /// - macOS uses apple key + f.
     /// - Windows uses windows key + f.
-    pub fn set_fullscreen_on_shortcut(&self, b: bool) {
-        self.config.borrow_mut().fullscreen_on_shortcut = b;
-    }
-
-    /// Returns the **App**'s current **LoopMode**.
-    ///
-    /// The default loop mode is `LoopMode::RefreshSync`.
-    pub fn loop_mode(&self) -> LoopMode {
-        self.config.borrow().loop_mode.clone()
-    }
-
-    /// Sets the loop mode of the **App**.
-    ///
-    /// Note: Setting the loop mode will not affect anything until the end of the current loop
-    /// iteration. The behaviour of a single loop iteration is described under each of the
-    /// **LoopMode** variants.
-    pub fn set_loop_mode(&self, mode: LoopMode) {
-        self.config.borrow_mut().loop_mode = mode;
+    pub fn set_fullscreen_on_shortcut(&mut self, b: bool) {
+        let mut world = self.resource_world_mut();
+        let mut config = world.resource_mut::<Config>();
+        config.fullscreen_on_shortcut = b;
     }
 
-    /// A handle to the **App** that can be shared across threads.
-    ///
-    /// This can be used to "wake up" the **App**'s inner event loop.
-    pub fn create_proxy(&self) -> Proxy {
-        self.event_loop_proxy.clone()
+    /// Produce the [App]'s [DrawHolder] API for drawing geometry and text with colors and textures.
+    pub fn draw(&self) -> draw::Draw {
+        let window_id = self.window_id();
+        let world = self.component_world();
+        let draw = world.entity(window_id).get::<DrawHolder>();
+        draw.unwrap().0.clone()
     }
 
-    /// Produce the **App**'s **Draw** API for drawing geometry and text with colors and textures.
-    ///
-    /// **Note:** You can also create your own **Draw** instances via `Draw::new()`! This method
-    /// makes it a tiny bit easier as the **App** stores the **Draw** instance for you and
-    /// automatically resets the state on each call to `app.draw()`.
-    pub fn draw(&self) -> draw::Draw {
-        let draw = self.draw_state.draw.borrow_mut();
-        draw.reset();
-        draw.clone()
+    pub fn draw_for_window(&self, window: Entity) -> draw::Draw {
+        let world = self.component_world();
+        let draw = world.entity(window).get::<DrawHolder>();
+        draw.unwrap().0.clone()
     }
 
     /// The number of times the focused window's **view** function has been called since the start
     /// of the program.
     pub fn elapsed_frames(&self) -> u64 {
-        self.main_window().frame_count
+        let world = self.component_world();
+        let frame_count = world.resource::<FrameCount>();
+        frame_count.0 as u64
     }
 
     /// The number of frames that can currently be displayed a second
-    pub fn fps(&self) -> f32 {
-        self.duration.updates_per_second()
+    pub fn fps(&self) -> f64 {
+        let world = self.resource_world();
+        let diagnostics = world.resource::<DiagnosticsStore>();
+        diagnostics
+            .get(&FrameTimeDiagnosticsPlugin::FPS)
+            .expect("FrameTime diagnostics not found")
+            .smoothed()
+            .expect("Could not get smoothed fps")
     }
 
     /// The name of the nannou executable that is currently running.
@@ -930,821 +887,607 @@ impl App {
         Ok(string)
     }
 
-    /// Quits the currently running application.
-    pub fn quit(&self) {
-        self.windows.borrow_mut().clear();
-    }
-}
-
-impl Proxy {
-    /// Wake up the application!
+    /// The path to the current project directory.
     ///
-    /// This wakes up the **App**'s inner event loop and causes a user event to be emitted by the
-    /// event loop.
+    /// The current project directory is considered to be the directory containing the cargo
+    /// manifest (aka the `Cargo.toml` file).
     ///
-    /// The `app::Proxy` stores a flag in order to track whether or not the `EventLoop` is
-    /// currently blocking and waiting for events. This method will only call the underlying
-    /// `winit::event_loop::EventLoopProxy::send_event` method if this flag is set to true and will
-    /// immediately set the flag to false afterwards. This makes it safe to call the `wakeup`
-    /// method as frequently as necessary across methods without causing any underlying OS methods
-    /// to be called more than necessary.
-    pub fn wakeup(&self) -> Result<(), winit::event_loop::EventLoopClosed<()>> {
-        if !self.wakeup_queued.load(atomic::Ordering::SeqCst) {
-            self.event_loop_proxy.send_event(())?;
-            self.wakeup_queued.store(true, atomic::Ordering::SeqCst);
-        }
-        Ok(())
+    /// **Note:** Be careful not to rely on this directory for apps or sketches that you wish to
+    /// distribute! This directory is mostly useful for local sketches, experiments and testing.
+    pub fn project_path(&self) -> Result<PathBuf, find_folder::Error> {
+        find_project_path()
     }
-}
 
-impl draw::Draw {
-    /// Render the **Draw**'s inner list of commands to the texture associated with the **Frame**.
-    ///
-    /// The **App** stores a unique render.
-    pub fn to_frame(&self, app: &App, frame: &Frame) -> Result<(), draw::renderer::DrawError> {
-        let window_id = frame.window_id();
-        let window = app
-            .window(window_id)
-            .expect("no window to draw to for `Draw`'s window_id");
-
-        // Retrieve a renderer for this window.
-        let renderers = app.draw_state.renderers.borrow_mut();
-        let renderer = RefMut::map(renderers, |renderers| {
-            renderers.entry(window_id).or_insert_with(|| {
-                let device = window.device();
-                let frame_dims: [u32; 2] = window.tracked_state.physical_size.into();
-                let scale_factor = window.tracked_state.scale_factor as f32;
-                let msaa_samples = window.msaa_samples();
-                let target_format = crate::frame::Frame::TEXTURE_FORMAT;
-                let renderer = draw::RendererBuilder::new().build(
-                    device,
-                    frame_dims,
-                    scale_factor,
-                    msaa_samples,
-                    target_format,
-                );
-                RefCell::new(renderer)
-            })
-        });
-
-        let scale_factor = window.tracked_state.scale_factor as _;
-        let mut renderer = renderer.borrow_mut();
-        renderer.render_to_frame(window.device(), self, scale_factor, frame);
-        Ok(())
+    /// Quits the currently running application.
+    pub fn quit(&mut self) {
+        self.resource_world_mut().send_event(AppExit::Success);
     }
-}
 
-impl<'a> wgpu::WithDeviceQueuePair for &'a crate::app::App {
-    fn with_device_queue_pair<F, O>(self, f: F) -> O
-    where
-        F: FnOnce(&wgpu::Device, &wgpu::Queue) -> O,
-    {
-        self.main_window().with_device_queue_pair(f)
+    pub fn set_update_mode(&self, mode: UpdateMode) {
+        let mut world = self.resource_world_mut();
+        let mut winit_settings = world.resource_mut::<WinitSettings>();
+        winit_settings.unfocused_mode = mode;
+        winit_settings.focused_mode = mode;
     }
-}
 
-/// Attempt to find the assets directory path relative to the executable location.
-pub fn find_assets_path() -> Result<PathBuf, find_folder::Error> {
-    let exe_path = std::env::current_exe()?;
-    find_folder::Search::ParentsThenKids(5, 3)
-        .of(exe_path
-            .parent()
-            .expect("executable has no parent directory to search")
-            .into())
-        .for_folder(App::ASSETS_DIRECTORY_NAME)
-}
+    pub fn set_unfocused_update_mode(&self, mode: UpdateMode) {
+        let mut world = self.resource_world_mut();
+        let mut winit_settings = world.resource_mut::<WinitSettings>();
+        winit_settings.unfocused_mode = mode;
+    }
 
-/// Attempt to find the assets directory path relative to the executable location.
-pub fn find_project_path() -> Result<PathBuf, find_folder::Error> {
-    let exe_path = std::env::current_exe()?;
-    let mut path = exe_path.parent().expect("exe has no parent directory");
-    while let Some(parent) = path.parent() {
-        path = parent;
-        if path.join("Cargo").with_extension("toml").exists() {
-            return Ok(path.to_path_buf());
-        }
+    pub fn set_focused_update_mode(&self, mode: UpdateMode) {
+        let mut world = self.resource_world_mut();
+        let mut winit_settings = world.resource_mut::<WinitSettings>();
+        winit_settings.focused_mode = mode;
     }
-    Err(find_folder::Error::NotFound)
 }
 
-// This type allows the `App` to provide an API for creating new windows.
-//
-// During the `setup` before the
-pub(crate) enum EventLoopWindowTarget {
-    // Ownership over the event loop.
-    //
-    // This is the state before the `EventLoop::run` begins.
-    Owned(winit::event_loop::EventLoop<()>),
-    // A pointer to the target for building windows.
-    //
-    // This is the state during `EventLoop::run`. This pointer becomes invalid following
-    // `EventLoop::run`, so it is essential to take care that we are in the correct state when
-    // using this pointer.
-    Pointer(*const winit::event_loop::EventLoopWindowTarget<()>),
+fn get_app_and_state<'w, 's, S: SystemParam + 'static>(
+    world: &'w mut World,
+    state: &'s mut SystemState<S>,
+) -> (App<'w>, <S as SystemParam>::Item<'w, 's>) {
+    state.update_archetypes(world);
+    let app = App::new(world);
+    let param = unsafe { state.get_unchecked_manual(*app.resourece_world.borrow_mut()) };
+    (app, param)
 }
 
-impl EventLoopWindowTarget {
-    // Take a reference to the inner event loop window target.
-    //
-    // This method is solely used during `window::Builder::build` to allow for
-    pub(crate) fn as_ref(&self) -> &winit::event_loop::EventLoopWindowTarget<()> {
-        match *self {
-            EventLoopWindowTarget::Owned(ref event_loop) => &**event_loop,
-            EventLoopWindowTarget::Pointer(ptr) => {
-                // This cast is safe, assuming that the `App`'s `EventLoopWindowTarget` will only
-                // ever be in the `Pointer` state while the pointer is valid - that is, during the
-                // call to `EventLoop::run`. Great care is taken to ensure that the
-                // `EventLoopWindowTarget` is dropped immediately after `EventLoop::run` completes.
-                // This allows us to take care of abiding by the `EventLoopWindowTarget` lifetime
-                // manually while avoiding having the lifetime propagate up through the `App` type.
-                unsafe { &*ptr as &winit::event_loop::EventLoopWindowTarget<()> }
+fn startup<M>(world: &mut World)
+where
+    M: 'static + Send + Sync,
+{
+    let default_window_size = world.resource::<Config>().default_window_size.clone();
+    let model_fn = world.resource::<ModelFnRes<M>>().0;
+
+    let mut app = App::new(world);
+
+    // Create our default window if necessary
+    if app
+        .resource_world()
+        .get_resource::<CreateDefaultWindow>()
+        .is_some()
+    {
+        let mut window: window::Builder<'_, '_, M> = app.new_window();
+        match default_window_size {
+            None => {}
+            Some(default_window) => {
+                match default_window {
+                    DefaultWindowSize::Logical([w, h]) => {
+                        window = window.size(w, h);
+                    }
+                    DefaultWindowSize::Fullscreen => {
+                        window = window.fullscreen();
+                    }
+                };
             }
+        };
+        #[cfg(not(target_os = "unknown"))]
+        {
+            let _ = window.primary().build();
         }
     }
+
+    // Initialise the model.
+    let model = model_fn(&mut app);
+    world.insert_resource(ModelHolder(model));
 }
 
-// Application Loop.
-//
-// Beyond this point lies the master function for running the main application loop!
-//
-// This is undoubtedly the hairiest part of nannou's code base. This is largely due to the fact
-// that it is the part of nannou where we marry application and user input events, loop timing,
-// updating the model, platform-specific quirks and warts, the various possible `LoopMode`s and
-// wgpu interop.
-//
-// If you would like to contribute but are unsure about any of the following, feel free to open an
-// issue and ask!
-fn run_loop<M, E>(
-    mut app: App,
-    model: M,
-    event_fn: Option<EventFn<M, E>>,
-    update_fn: Option<UpdateFn<M>>,
-    default_view: Option<View<M>>,
-    exit_fn: Option<ExitFn<M>>,
+fn first<M>(
+    mut commands: Commands,
+    bg_color_q: Query<Entity, With<BackgroundColor>>,
+    meshes_q: Query<Entity, With<NannouMesh>>,
 ) where
-    M: 'static,
-    E: LoopEvent,
+    M: 'static + Send + Sync,
 {
-    // Track the moment the loop starts.
-    let loop_start = Instant::now();
+    for entity in meshes_q.iter() {
+        commands.entity(entity).despawn_recursive();
+    }
+    for entity in bg_color_q.iter() {
+        commands.entity(entity).despawn_recursive();
+    }
+}
 
-    // Wrap the `model` in an `Option`, allowing us to take full ownership within the `event_loop`
-    // on `exit`.
-    let mut model = Some(model);
+#[allow(clippy::type_complexity)]
+fn update<M>(
+    world: &mut World,
+    state: &mut SystemState<(
+        Res<UpdateFnRes<M>>,
+        Res<ViewFnRes<M>>,
+        ResMut<ModelHolder<M>>,
+        Res<RunMode>,
+        Res<Time>,
+        Local<u64>,
+        Query<(Entity, &WindowUserFunctions<M>)>,
+    )>,
+) where
+    M: 'static + Send + Sync,
+{
+    let (mut app, (update_fn, view_fn, mut model, run_mode, time, mut ticks, windows)) =
+        get_app_and_state(world, state);
 
-    // Take ownership of the `EventLoop` from the `App`.
-    let event_loop = match app.event_loop_window_target.take() {
-        Some(EventLoopWindowTarget::Owned(event_loop)) => event_loop,
-        _ => unreachable!("the app should always own the event loop at this point"),
+    match *run_mode {
+        RunMode::UntilExit => {
+            // Do nothing, we'll quit when the user closes the window.
+        }
+        RunMode::Ticks(run_ticks) => {
+            if *ticks >= run_ticks {
+                app.quit();
+                return;
+            }
+        }
+        RunMode::Duration(duration) => {
+            if time.elapsed() >= duration {
+                app.quit();
+                return;
+            }
+        }
     };
 
-    // Keep track of state related to the loop mode itself.
-    let mut loop_state = LoopState {
-        updates_since_event: 0,
-        loop_start,
-        last_update: loop_start,
-        total_updates: 0,
-    };
+    // Run the model update function.
+    if let Some(update_fn) = update_fn.0 {
+        update_fn(&app, &mut model);
+    }
 
-    // Run the event loop.
-    event_loop.run(move |mut event, event_loop_window_target, control_flow| {
-        // Set the event loop window target pointer to allow for building windows.
-        app.event_loop_window_target = Some(EventLoopWindowTarget::Pointer(
-            event_loop_window_target as *const _,
-        ));
+    // Run the view function for each window's draw.
+    for (entity, user_fns) in windows.iter() {
+        // Makes sure we return the correct draw component
+        app.current_view = Some(entity);
 
-        let mut exit = false;
-
-        match event {
-            // Check to see if we need to emit an update and request a redraw.
-            winit::event::Event::MainEventsCleared => {
-                if let Some(model) = model.as_mut() {
-                    let loop_mode = app.loop_mode();
-                    let now = Instant::now();
-                    let mut do_update = |loop_state: &mut LoopState| {
-                        apply_update(&mut app, model, event_fn, update_fn, loop_state, now);
-                    };
-                    match loop_mode {
-                        LoopMode::NTimes { number_of_updates }
-                            if loop_state.total_updates >= number_of_updates as u64 => {}
-                        // Sometimes winit interrupts ControlFlow::Wait for no good reason, so we
-                        // make sure that there were some events in order to do an update when
-                        // LoopMode::Wait is used.
-                        LoopMode::Wait if loop_state.updates_since_event > 0 => {}
-                        // TODO: Consider allowing for a custom number of updates like so:
-                        // LoopMode::Wait { updates_before_waiting } =>
-                        //     if loop_state.updates_since_event > updates_before_waiting as u64 => {}
-                        _ => {
-                            do_update(&mut loop_state);
-                        },
-                    }
+        // Run user fns
+        if let Some(view) = &user_fns.view {
+            match view {
+                window::View::WithModel(view_fn) => {
+                    view_fn(&app, &model);
                 }
-            }
-
-            // Request a frame from the user for the specified window.
-            //
-            // TODO: Only request a frame from the user if this redraw was requested following an
-            // update. Otherwise, just use the existing intermediary frame.
-            winit::event::Event::RedrawRequested(window_id) => {
-                if let Some(model) = model.as_mut() {
-                    // Retrieve the surface frame and the number of this frame.
-                    // NOTE: We avoid mutably borrowing `windows` map any longer than necessary to
-                    // avoid restricting users from accessing `windows` during `view`.
-                    let (mut surface_tex_result, nth_frame) = {
-                        let mut windows = app.windows.borrow_mut();
-                        let window = windows
-                            .get_mut(&window_id)
-                            .expect("no window for `RedrawRequest`");
-                        let texture = window.surface.get_current_texture();
-                        let nth_frame = window.frame_count;
-                        (texture, nth_frame)
-                    };
-
-                    if let Err(e) = &surface_tex_result {
-                        match e {
-                            // Sometimes redraws get delivered before resizes on x11 for unclear reasons.
-                            // It goes all the way down to the API: if you ask x11 about the window size
-                            // at this time, it'll tell you that it hasn't changed. So... we skip
-                            // this frame. The resize will show up in a bit and then we can get on
-                            // with our lives.
-                            // If you turn on debug logging this does occasionally cause some vulkan
-                            // validation errors... that's not great.
-                            // TODO find a better long-term fix than ignoring.
-                            wgpu::SurfaceError::Lost => {
-                                // Attempt to reconfigure the surface.
-                                let mut windows = app.windows.borrow_mut();
-                                let window = windows
-                                    .get_mut(&window_id)
-                                    .expect("no window for `RedrawRequest`");
-                                window
-                                    .reconfigure_surface(window.tracked_state.physical_size.into());
-                                surface_tex_result = window.surface.get_current_texture();
-                            }
-                            wgpu::SurfaceError::Outdated => {} // skip frame
-                            wgpu::SurfaceError::Timeout => {}  // skip frame
-                            wgpu::SurfaceError::OutOfMemory => {
-                                panic!("out of memory acquiring the surface frame: {}", e);
-                            }
-                        }
-                    }
-
-                    if let Ok(surface_tex) = surface_tex_result {
-                        let surface_texture = &surface_tex
-                            .texture
-                            .create_view(&wgpu::TextureViewDescriptor::default());
-
-                        // Borrow the window now that we don't need it mutably until setting the render
-                        // data back.
-                        let windows = app.windows.borrow();
-                        let window = windows
-                            .get(&window_id)
-                            .expect("failed to find window for redraw request");
-                        let frame_data = &window.frame_data;
-
-                        // Construct and emit a frame via `view` for receiving the user's graphics commands.
-                        let sf = window.tracked_state.scale_factor;
-                        let (w, h) = window
-                            .tracked_state
-                            .physical_size
-                            .to_logical::<f32>(sf)
-                            .into();
-                        let window_rect = geom::Rect::from_w_h(w, h);
-                        let raw_frame = RawFrame::new_empty(
-                            window.device_queue_pair().clone(),
-                            window_id,
-                            nth_frame,
-                            surface_texture,
-                            window.surface_conf.format,
-                            window_rect,
-                        );
-
-                        // Clear the raw frame immediately once the window is invalidated
-                        if window.is_invalidated {
-                            if let Some(data) = frame_data {
-                                raw_frame.clear(&data.render.texture_view(), window.clear_color);
-                            }
-                        }
-
-                        // If the user specified a view function specifically for this window, use it.
-                        // Otherwise, use the fallback, default view passed to the app if there was one.
-                        let window_view = window.user_functions.view.clone();
-
-                        match window_view {
-                            Some(window::View::Sketch(view)) => {
-                                let data = frame_data.as_ref().expect("missing `frame_data`");
-                                let frame =
-                                    Frame::new_empty(raw_frame, &data.render, &data.capture);
-                                view(&app, frame);
-                            }
-                            Some(window::View::WithModel(view)) => {
-                                let data = frame_data.as_ref().expect("missing `frame_data`");
-                                let frame =
-                                    Frame::new_empty(raw_frame, &data.render, &data.capture);
-                                let view = view.to_fn_ptr::<M>().expect(
-                                    "unexpected model argument given to window view function",
-                                );
-                                (*view)(&app, model, frame);
-                            }
-                            Some(window::View::WithModelRaw(raw_view)) => {
-                                let raw_view = raw_view.to_fn_ptr::<M>().expect(
-                                    "unexpected model argument given to window raw_view function",
-                                );
-                                (*raw_view)(&app, &model, raw_frame);
-                            }
-                            None => match default_view {
-                                Some(View::Sketch(view)) => {
-                                    let data = frame_data.as_ref().expect("missing `frame_data`");
-                                    let frame =
-                                        Frame::new_empty(raw_frame, &data.render, &data.capture);
-                                    view(&app, frame);
-                                }
-                                Some(View::WithModel(view)) => {
-                                    let data = frame_data.as_ref().expect("missing `frame_data`");
-                                    let frame =
-                                        Frame::new_empty(raw_frame, &data.render, &data.capture);
-                                    view(&app, &model, frame);
-                                }
-                                None => raw_frame.submit(),
-                            },
-                        }
-
-                        // Queue has been submitted by now, time to present.
-                        surface_tex.present();
-
-                        // Release immutable lock
-                        drop(windows);
-
-                        // Increment the window's frame count.
-                        let mut windows = app.windows.borrow_mut();
-                        let window = windows
-                            .get_mut(&window_id)
-                            .expect("no window for redraw request ID");
-
-                        // Assume invalidated window was cleared above before `view()`
-                        window.is_invalidated = false;
-                        window.frame_count += 1;
-                    }
+                window::View::Sketch(view_fn) => {
+                    view_fn(&app);
                 }
             }
-
-            // Clear any inactive adapters and devices and poll those remaining.
-            winit::event::Event::RedrawEventsCleared => {
-                app.wgpu_adapters().clear_inactive_adapters_and_devices();
-                // TODO: This seems to cause some glitching and slows down macOS drastically.
-                // While not necessary, this would be nice to have to automatically process async
-                // read/write callbacks submitted by users who aren't aware that they need to poll
-                // their devices in order to make them do work. Perhaps as a workaround we could
-                // only poll devices that aren't already associated with a window?
-                //app.wgpu_adapters().poll_all_devices(false);
-            }
-
-            // For all window, device and user (app proxy) events reset the `updates_since_event`
-            // count which is used to improve behaviour for the `Wait` loop mode.
-            // TODO: Document this set of events under `LoopMode::Wait`.
-            winit::event::Event::WindowEvent { .. }
-            | winit::event::Event::DeviceEvent { .. }
-            | winit::event::Event::UserEvent(_)
-            | winit::event::Event::Suspended
-            | winit::event::Event::Resumed => {
-                loop_state.updates_since_event = 0;
-
-                // `UserEvent` is emitted on `wakeup`.
-                if let winit::event::Event::UserEvent(_) = event {
-                    app.event_loop_proxy.wakeup_queued.store(false, atomic::Ordering::SeqCst);
+        } else if let Some(view) = view_fn.0.as_ref() {
+            match view {
+                View::WithModel(view_fn) => {
+                    view_fn(&app, &mut model, entity);
+                }
+                View::Sketch(view_fn) => {
+                    view_fn(&app);
                 }
             }
+        }
+    }
 
-            // Ignore `NewEvents`.
-            winit::event::Event::NewEvents(_)
-            // `LoopDestroyed` is handled later in `process_and_emit_winit_event` so ignore it here.
-            | winit::event::Event::LoopDestroyed => {}
+    // Increment the frame count.
+    *ticks += 1;
+}
+
+fn events<M, E>(
+    world: &mut World,
+    state: &mut SystemState<(
+        EventReader<E>,
+        Res<EventFnRes<M, E>>,
+        Query<&WindowUserFunctions<M>>,
+        ResMut<ModelHolder<M>>,
+    )>,
+) where
+    M: Send + Sync + 'static,
+    E: Event,
+{
+    let (app, (mut events, event_fn, user_fns, mut model)) = get_app_and_state(world, state);
+    for evt in events.read() {
+        if let Some(f) = event_fn.0.as_ref() {
+            f(&app, &mut model, evt);
         }
+    }
+}
 
-        // We must reconfigure the wgpu surface if the window was resized.
-        if let winit::event::Event::WindowEvent {
-            ref mut event,
-            window_id,
-        } = event
-        {
-            match event {
-                winit::event::WindowEvent::Resized(new_inner_size) => {
-                    let mut windows = app.windows.borrow_mut();
-                    if let Some(window) = windows.get_mut(&window_id) {
-                        window.reconfigure_surface(new_inner_size.clone().into());
+#[allow(clippy::type_complexity)]
+fn key_events<M>(
+    world: &mut World,
+    state: &mut SystemState<(
+        EventReader<KeyboardInput>,
+        Query<&WindowUserFunctions<M>>,
+        ResMut<ModelHolder<M>>,
+    )>,
+) where
+    M: 'static + Send + Sync,
+{
+    let (mut app, (mut key_events, user_fns, mut model)) = get_app_and_state(world, state);
+
+    for evt in key_events.read() {
+        if let Ok(user_fns) = user_fns.get(evt.window) {
+            match evt.state {
+                ButtonState::Pressed => {
+                    if let Some(f) = user_fns.key_pressed {
+                        app.current_view = Some(evt.window);
+                        f(&app, &mut model, evt.key_code);
                     }
                 }
-
-                winit::event::WindowEvent::ScaleFactorChanged {
-                    scale_factor,
-                    new_inner_size,
-                } => {
-                    let mut windows = app.windows.borrow_mut();
-                    if let Some(window) = windows.get_mut(&window_id) {
-                        window.tracked_state.scale_factor = *scale_factor;
-                        window.reconfigure_surface(new_inner_size.clone().into());
+                ButtonState::Released => {
+                    if let Some(f) = user_fns.key_released {
+                        app.current_view = Some(evt.window);
+                        f(&app, &mut model, evt.key_code);
                     }
                 }
-
-                _ => (),
             }
         }
+    }
+}
 
-        // Process the event with the user's functions and see if we need to exit.
-        if let Some(model) = model.as_mut() {
-            exit |= process_and_emit_winit_event::<M, E>(&mut app, model, event_fn, &event);
+#[allow(clippy::type_complexity)]
+fn received_char_events<M>(
+    world: &mut World,
+    state: &mut SystemState<(
+        EventReader<ReceivedCharacter>,
+        Query<&WindowUserFunctions<M>>,
+        ResMut<ModelHolder<M>>,
+    )>,
+) where
+    M: 'static + Send + Sync,
+{
+    let (mut app, (mut received_char_events, user_fns, mut model)) =
+        get_app_and_state(world, state);
+
+    for evt in received_char_events.read() {
+        if let Ok(user_fns) = user_fns.get(evt.window) {
+            if let Some(f) = user_fns.received_character {
+                app.current_view = Some(evt.window);
+                let char = evt.char.chars().next().unwrap();
+                f(&app, &mut model, char);
+            }
         }
+    }
+}
+
+#[allow(clippy::type_complexity)]
+fn cursor_moved_events<M>(
+    world: &mut World,
+    state: &mut SystemState<(
+        EventReader<CursorMoved>,
+        Query<&WindowUserFunctions<M>>,
+        ResMut<ModelHolder<M>>,
+    )>,
+) where
+    M: 'static + Send + Sync,
+{
+    let (mut app, (mut cursor_moved_events, user_fns, mut model)) = get_app_and_state(world, state);
 
-        // Set the control flow based on the loop mode.
-        let loop_mode = app.loop_mode();
-        *control_flow = match loop_mode {
-            LoopMode::Wait => ControlFlow::Wait,
-            LoopMode::NTimes { number_of_updates }
-                if loop_state.total_updates >= number_of_updates as u64 =>
-            {
-                ControlFlow::Wait
+    for evt in cursor_moved_events.read() {
+        if let Ok(user_fns) = user_fns.get(evt.window) {
+            if let Some(f) = user_fns.mouse_moved {
+                app.current_view = Some(evt.window);
+                f(&app, &mut model, evt.position);
             }
-            _ => ControlFlow::Poll,
-        };
+        }
+    }
+}
 
-        // If we need to exit, call the user's function and update control flow.
-        if exit {
-            if let Some(model) = model.take() {
-                if let Some(exit_fn) = exit_fn {
-                    exit_fn(&app, model);
+#[allow(clippy::type_complexity)]
+fn mouse_button_events<M>(
+    world: &mut World,
+    state: &mut SystemState<(
+        EventReader<MouseButtonInput>,
+        Query<&WindowUserFunctions<M>>,
+        ResMut<ModelHolder<M>>,
+    )>,
+) where
+    M: 'static + Send + Sync,
+{
+    let (mut app, (mut mouse_button_events, user_fns, mut model)) = get_app_and_state(world, state);
+
+    for evt in mouse_button_events.read() {
+        if let Ok(user_fns) = user_fns.get(evt.window) {
+            match evt.state {
+                ButtonState::Pressed => {
+                    if let Some(f) = user_fns.mouse_pressed {
+                        app.current_view = Some(evt.window);
+                        f(&app, &mut model, evt.button);
+                    }
+                }
+                ButtonState::Released => {
+                    if let Some(f) = user_fns.mouse_released {
+                        app.current_view = Some(evt.window);
+                        f(&app, &mut model, evt.button);
+                    }
                 }
             }
-
-            *control_flow = ControlFlow::Exit;
-            return;
         }
-    });
-
-    // Ensure the app no longer points to the window target now that `run` has completed.
-    // TODO: Right now `event_loop.run` can't return. This is just a reminder in case one day the
-    // API is changed so that it does return.
-    #[allow(unreachable_code)]
-    {
-        app.event_loop_window_target.take();
     }
 }
 
-// Apply an update to the model via the user's function and update the app and loop state
-// accordingly.
-fn apply_update<M, E>(
-    app: &mut App,
-    model: &mut M,
-    event_fn: Option<EventFn<M, E>>,
-    update_fn: Option<UpdateFn<M>>,
-    loop_state: &mut LoopState,
-    now: Instant,
+#[allow(clippy::type_complexity)]
+fn cursor_entered_events<M>(
+    world: &mut World,
+    state: &mut SystemState<(
+        EventReader<CursorEntered>,
+        Query<&WindowUserFunctions<M>>,
+        ResMut<ModelHolder<M>>,
+    )>,
 ) where
-    M: 'static,
-    E: LoopEvent,
+    M: 'static + Send + Sync,
 {
-    // Update the app's durations.
-    let since_last = now.duration_since(loop_state.last_update);
-    let since_start = now.duration_since(loop_state.loop_start);
-    app.duration.since_prev_update = since_last;
-    app.duration.since_start = since_start;
-    app.time = since_start.secs() as _;
-    let update = crate::event::Update {
-        since_start,
-        since_last,
-    };
-    // User event function.
-    if let Some(event_fn) = event_fn {
-        let event = E::from(update.clone());
-        event_fn(app, model, event);
-    }
-    // User update function.
-    if let Some(update_fn) = update_fn {
-        update_fn(app, model, update);
-    }
-    loop_state.last_update = now;
-    loop_state.total_updates += 1;
-    loop_state.updates_since_event += 1;
-    // Request redraw from windows.
-    let windows = app.windows.borrow();
-    for window in windows.values() {
-        window.window.request_redraw();
+    let (mut app, (mut cursor_entered_events, user_fns, mut model)) =
+        get_app_and_state(world, state);
+
+    for evt in cursor_entered_events.read() {
+        if let Ok(user_fns) = user_fns.get(evt.window) {
+            if let Some(f) = user_fns.mouse_entered {
+                app.current_view = Some(evt.window);
+                f(&app, &mut model);
+            }
+        }
     }
 }
 
-// Whether or not the given event should toggle fullscreen.
-fn should_toggle_fullscreen(
-    winit_event: &winit::event::WindowEvent,
-    mods: &winit::event::ModifiersState,
-) -> bool {
-    let input = match *winit_event {
-        winit::event::WindowEvent::KeyboardInput { ref input, .. } => match input.state {
-            event::ElementState::Pressed => input,
-            _ => return false,
-        },
-        _ => return false,
-    };
-
-    let key = match input.virtual_keycode {
-        None => return false,
-        Some(k) => k,
-    };
+#[allow(clippy::type_complexity)]
+fn cursor_left_events<M>(
+    world: &mut World,
+    state: &mut SystemState<(
+        EventReader<CursorLeft>,
+        Query<&WindowUserFunctions<M>>,
+        ResMut<ModelHolder<M>>,
+    )>,
+) where
+    M: 'static + Send + Sync,
+{
+    let (mut app, (mut cursor_left_events, user_fns, mut model)) = get_app_and_state(world, state);
 
-    // On linux, check for the F11 key (with no modifiers down).
-    //
-    // TODO: Somehow add special case for KDE?
-    if cfg!(target_os = "linux") {
-        if *mods == winit::event::ModifiersState::empty() {
-            if let Key::F11 = key {
-                return true;
+    for evt in cursor_left_events.read() {
+        if let Ok(user_fns) = user_fns.get(evt.window) {
+            if let Some(f) = user_fns.mouse_exited {
+                app.current_view = Some(evt.window);
+                f(&app, &mut model);
             }
         }
+    }
+}
 
-    // On macos and windows check for the logo key plus `f` with no other modifiers.
-    } else if cfg!(target_os = "macos") || cfg!(target_os = "windows") {
-        if mods.logo() {
-            if let Key::F = key {
-                return true;
+#[allow(clippy::type_complexity)]
+fn mouse_wheel_events<M>(
+    world: &mut World,
+    state: &mut SystemState<(
+        EventReader<MouseWheel>,
+        Query<&WindowUserFunctions<M>>,
+        ResMut<ModelHolder<M>>,
+    )>,
+) where
+    M: 'static + Send + Sync,
+{
+    let (mut app, (mut mouse_wheel_events, user_fns, mut model)) = get_app_and_state(world, state);
+
+    for evt in mouse_wheel_events.read() {
+        if let Ok(user_fns) = user_fns.get(evt.window) {
+            if let Some(f) = user_fns.mouse_wheel {
+                app.current_view = Some(evt.window);
+                f(&app, &mut model, *evt);
             }
         }
     }
-
-    false
 }
 
-// Event handling boilerplate shared between the loop modes.
-//
-// 1. Checks for exit on escape.
-// 2. Removes closed windows from app.
-// 3. Emits event via `event_fn`.
-// 4. Returns whether or not we should break from the loop.
-fn process_and_emit_winit_event<'a, M, E>(
-    app: &mut App,
-    model: &mut M,
-    event_fn: Option<EventFn<M, E>>,
-    winit_event: &winit::event::Event<'a, ()>,
-) -> bool
-where
-    M: 'static,
-    E: LoopEvent,
+#[allow(clippy::type_complexity)]
+fn window_moved_events<M>(
+    world: &mut World,
+    state: &mut SystemState<(
+        EventReader<WindowMoved>,
+        Query<&WindowUserFunctions<M>>,
+        ResMut<ModelHolder<M>>,
+    )>,
+) where
+    M: 'static + Send + Sync,
 {
-    // Inspect the event to see if it would require closing the App.
-    let mut exit_on_escape = false;
-    let mut removed_window = None;
-    if let winit::event::Event::WindowEvent {
-        window_id,
-        ref event,
-    } = *winit_event
-    {
-        // If we should exit the app on escape, check for the escape key.
-        if app.exit_on_escape() {
-            if let winit::event::WindowEvent::KeyboardInput { input, .. } = *event {
-                if let Some(Key::Escape) = input.virtual_keycode {
-                    exit_on_escape = true;
-                }
+    let (mut app, (mut window_moved_events, user_fns, mut model)) = get_app_and_state(world, state);
+
+    for evt in window_moved_events.read() {
+        if let Ok(user_fns) = user_fns.get(evt.window) {
+            if let Some(f) = user_fns.moved {
+                app.current_view = Some(evt.window);
+                f(&app, &mut model, evt.position);
             }
         }
+    }
+}
 
-        // When a window has been closed, this function is called to remove any state associated
-        // with that window so that the state doesn't leak.
-        //
-        // Returns the `Window` that was removed.
-        fn remove_related_window_state(app: &App, window_id: &window::Id) -> Option<Window> {
-            app.draw_state.renderers.borrow_mut().remove(window_id);
-            app.windows.borrow_mut().remove(window_id)
+#[allow(clippy::type_complexity)]
+fn window_resized_events<M>(
+    world: &mut World,
+    state: &mut SystemState<(
+        EventReader<WindowResized>,
+        Query<&WindowUserFunctions<M>>,
+        ResMut<ModelHolder<M>>,
+    )>,
+) where
+    M: 'static + Send + Sync,
+{
+    let (mut app, (mut window_resized_events, user_fns, mut model)) =
+        get_app_and_state(world, state);
+
+    for evt in window_resized_events.read() {
+        if let Ok(user_fns) = user_fns.get(evt.window) {
+            if let Some(f) = user_fns.resized {
+                app.current_view = Some(evt.window);
+                f(&app, &mut model, Vec2::new(evt.width, evt.height));
+            }
         }
+    }
+}
 
-        if let winit::event::WindowEvent::Destroyed = *event {
-            removed_window = remove_related_window_state(app, &window_id);
-        // TODO: We should allow the user to handle this case. E.g. allow for doing things like
-        // "would you like to save". We currently do this with the app exit function, but maybe a
-        // window `close` function would be useful?
-        } else if let winit::event::WindowEvent::CloseRequested = *event {
-            removed_window = remove_related_window_state(app, &window_id);
-        } else {
-            // Get the size of the window for translating coords and dimensions.
-            let (win_w, win_h, scale_factor) = match app.window(window_id) {
-                Some(win) => {
-                    // If we should toggle fullscreen for this window, do so.
-                    if app.fullscreen_on_shortcut() {
-                        if should_toggle_fullscreen(event, &app.keys.mods) {
-                            if win.is_fullscreen() {
-                                win.set_fullscreen(false);
-                            } else {
-                                win.set_fullscreen(true);
-                            }
-                        }
-                    }
-
-                    let sf = win.tracked_state.scale_factor;
-                    let (w, h) = win.tracked_state.physical_size.to_logical::<f32>(sf).into();
-                    (w, h, sf)
-                }
-                None => (0.0, 0.0, 1.0),
-            };
-
-            // Translate the coordinates from top-left-origin-with-y-down to centre-origin-with-y-up.
-            let tx = |x: geom::scalar::Default| x - win_w as geom::scalar::Default / 2.0;
-            let ty = |y: geom::scalar::Default| -(y - win_h as geom::scalar::Default / 2.0);
+#[allow(clippy::type_complexity)]
+fn touch_events<M>(
+    world: &mut World,
+    state: &mut SystemState<(
+        EventReader<TouchInput>,
+        Query<&WindowUserFunctions<M>>,
+        ResMut<ModelHolder<M>>,
+    )>,
+) where
+    M: 'static + Send + Sync,
+{
+    let (mut app, (mut touch_events, user_fns, mut model)) = get_app_and_state(world, state);
 
-            // If the window ID has changed, ensure the dimensions are up to date.
-            if *app.focused_window.borrow() != Some(window_id) {
-                if app.window(window_id).is_some() {
-                    *app.focused_window.borrow_mut() = Some(window_id);
-                }
+    for evt in touch_events.read() {
+        if let Ok(user_fns) = user_fns.get(evt.window) {
+            if let Some(f) = user_fns.touch {
+                app.current_view = Some(evt.window);
+                f(&app, &mut model, *evt);
             }
+        }
+    }
+}
 
-            // Check for events that would update either mouse, keyboard or window state.
-            match *event {
-                winit::event::WindowEvent::CursorMoved { position, .. } => {
-                    let (x, y) = position.to_logical::<f32>(scale_factor).into();
-                    let x = tx(x);
-                    let y = ty(y);
-                    app.mouse.x = x;
-                    app.mouse.y = y;
-                    app.mouse.window = Some(window_id);
+#[allow(clippy::type_complexity)]
+fn file_drop_events<M>(
+    world: &mut World,
+    state: &mut SystemState<(
+        EventReader<FileDragAndDrop>,
+        Query<&WindowUserFunctions<M>>,
+        ResMut<ModelHolder<M>>,
+    )>,
+) where
+    M: 'static + Send + Sync,
+{
+    let (mut app, (mut file_drop_events, user_fns, mut model)) = get_app_and_state(world, state);
+
+    for evt in file_drop_events.read() {
+        match evt {
+            FileDragAndDrop::DroppedFile { window, path_buf } => {
+                if let Ok(user_fns) = user_fns.get(*window) {
+                    if let Some(f) = user_fns.dropped_file {
+                        app.current_view = Some(*window);
+                        f(&app, &mut model, path_buf.clone());
+                    }
                 }
-
-                winit::event::WindowEvent::MouseInput { state, button, .. } => {
-                    match state {
-                        event::ElementState::Pressed => {
-                            let p = app.mouse.position();
-                            app.mouse.buttons.press(button, p);
-                        }
-                        event::ElementState::Released => {
-                            app.mouse.buttons.release(button);
-                        }
+            }
+            FileDragAndDrop::HoveredFile { window, path_buf } => {
+                if let Ok(user_fns) = user_fns.get(*window) {
+                    if let Some(f) = user_fns.hovered_file {
+                        app.current_view = Some(*window);
+                        f(&app, &mut model, path_buf.clone());
                     }
-                    app.mouse.window = Some(window_id);
                 }
-
-                winit::event::WindowEvent::KeyboardInput { input, .. } => {
-                    if let Some(key) = input.virtual_keycode {
-                        match input.state {
-                            event::ElementState::Pressed => {
-                                app.keys.down.keys.insert(key);
-                            }
-                            event::ElementState::Released => {
-                                app.keys.down.keys.remove(&key);
-                            }
-                        }
+            }
+            FileDragAndDrop::HoveredFileCanceled { window } => {
+                if let Ok(user_fns) = user_fns.get(*window) {
+                    if let Some(f) = user_fns.hovered_file_cancelled {
+                        app.current_view = Some(*window);
+                        f(&app, &mut model);
                     }
                 }
-
-                _ => (),
             }
         }
     }
+}
 
-    // Update the modifier keys within the app if necessary.
-    if let winit::event::Event::WindowEvent { event, .. } = winit_event {
-        if let winit::event::WindowEvent::ModifiersChanged(new_mods) = event {
-            app.keys.mods = new_mods.clone();
+#[allow(clippy::type_complexity)]
+fn window_focus_events<M>(
+    world: &mut World,
+    state: &mut SystemState<(
+        EventReader<WindowFocused>,
+        Query<&WindowUserFunctions<M>>,
+        ResMut<ModelHolder<M>>,
+    )>,
+) where
+    M: 'static + Send + Sync,
+{
+    let (mut app, (mut window_focus_events, user_fns, mut model)) = get_app_and_state(world, state);
+
+    for evt in window_focus_events.read() {
+        if let Ok(user_fns) = user_fns.get(evt.window) {
+            if evt.focused {
+                if let Some(f) = user_fns.focused {
+                    app.current_view = Some(evt.window);
+                    f(&app, &mut model);
+                }
+            } else if let Some(f) = user_fns.unfocused {
+                app.current_view = Some(evt.window);
+                f(&app, &mut model);
+            }
         }
     }
+}
 
-    // If the user provided an event function and winit::event::Event could be interpreted as some event
-    // `E`, use it to update the model.
-    if let Some(event_fn) = event_fn {
-        if let Some(event) = E::from_winit_event(winit_event, app) {
-            event_fn(&app, model, event);
+#[allow(clippy::type_complexity)]
+fn window_closed_events<M>(
+    world: &mut World,
+    state: &mut SystemState<(
+        EventReader<WindowClosed>,
+        Query<&WindowUserFunctions<M>>,
+        ResMut<ModelHolder<M>>,
+    )>,
+) where
+    M: 'static + Send + Sync,
+{
+    let (mut app, (mut window_closed_events, user_fns, mut model)) =
+        get_app_and_state(world, state);
+
+    for evt in window_closed_events.read() {
+        if let Ok(user_fns) = user_fns.get(evt.window) {
+            if let Some(f) = user_fns.closed {
+                app.current_view = Some(evt.window);
+                f(&app, &mut model);
+            }
         }
     }
+}
 
-    // If the event was a window event, and the user specified an event function for this window,
-    // call it.
-    if let winit::event::Event::WindowEvent {
-        window_id,
-        ref event,
-    } = *winit_event
-    {
-        // Raw window events.
-        if let Some(raw_window_event_fn) = {
-            let windows = app.windows.borrow();
-            windows
-                .get(&window_id)
-                .and_then(|w| w.user_functions.raw_event.clone())
-                .or_else(|| {
-                    removed_window
-                        .as_ref()
-                        .and_then(|w| w.user_functions.raw_event.clone())
-                })
-        } {
-            let raw_window_event_fn = raw_window_event_fn
-                .to_fn_ptr::<M>()
-                .expect("unexpected model argument given to window event function");
-            (*raw_window_event_fn)(&app, model, event);
-        }
+#[allow(clippy::type_complexity)]
+fn last<M>(world: &mut World, state: &mut SystemState<(EventReader<AppExit>, Res<ExitFnRes<M>>)>)
+where
+    M: 'static + Send + Sync,
+{
+    let (app, (exit_events, exit_fn)) = get_app_and_state(world, state);
 
-        let (win_w, win_h, scale_factor) = {
-            let windows = app.windows.borrow();
-            windows
-                .get(&window_id)
-                .map(|w| {
-                    let sf = w.tracked_state.scale_factor;
-                    let (w, h) = w.tracked_state.physical_size.to_logical::<f64>(sf).into();
-                    (w, h, sf)
-                })
-                .unwrap_or((0.0, 0.0, 1.0))
-        };
+    let should_exit = !exit_events.is_empty();
+    if !should_exit {
+        return;
+    }
 
-        // If the event can be represented by a simplified nannou event, check for relevant user
-        // functions to be called.
-        if let Some(simple) =
-            event::WindowEvent::from_winit_window_event(event, win_w, win_h, scale_factor)
-        {
-            // Nannou window events.
-            if let Some(window_event_fn) = {
-                let windows = app.windows.borrow();
-                windows
-                    .get(&window_id)
-                    .and_then(|w| w.user_functions.event.clone())
-                    .or_else(|| {
-                        removed_window
-                            .as_ref()
-                            .and_then(|w| w.user_functions.event.clone())
-                    })
-            } {
-                let window_event_fn = window_event_fn
-                    .to_fn_ptr::<M>()
-                    .expect("unexpected model argument given to window event function");
-                (*window_event_fn)(&app, model, simple.clone());
-            }
+    let model = app
+        .resource_world_mut()
+        .remove_resource::<ModelHolder<M>>()
+        .expect("ModelHolder resource not found")
+        .0;
 
-            // A macro to simplify calling event-specific user functions.
-            macro_rules! call_user_function {
-                ($fn_name:ident $(,$arg:expr)*) => {{
-                    if let Some(event_fn) = {
-                        let windows = app.windows.borrow();
-                        windows
-                            .get(&window_id)
-                            .and_then(|w| w.user_functions.$fn_name.clone())
-                            .or_else(|| {
-                                removed_window
-                                    .as_ref()
-                                    .and_then(|w| w.user_functions.$fn_name.clone())
-                            })
-                    } {
-                        let event_fn = event_fn
-                            .to_fn_ptr::<M>()
-                            .unwrap_or_else(|| {
-                                panic!(
-                                    "unexpected model argument given to {} function",
-                                    stringify!($fn_name),
-                                );
-                            });
-                        (*event_fn)(&app, model, $($arg),*);
-                    }
-                }};
-            }
+    if let Some(exit_fn) = exit_fn.0 {
+        exit_fn(&app, model);
+    }
+}
 
-            // Check for more specific event functions.
-            match simple {
-                event::WindowEvent::KeyPressed(key) => call_user_function!(key_pressed, key),
-                event::WindowEvent::KeyReleased(key) => call_user_function!(key_released, key),
-                event::WindowEvent::ReceivedCharacter(char) => {
-                    call_user_function!(received_character, char)
-                }
-                event::WindowEvent::MouseMoved(pos) => call_user_function!(mouse_moved, pos),
-                event::WindowEvent::MousePressed(button) => {
-                    call_user_function!(mouse_pressed, button)
-                }
-                event::WindowEvent::MouseReleased(button) => {
-                    call_user_function!(mouse_released, button)
-                }
-                event::WindowEvent::MouseEntered => call_user_function!(mouse_entered),
-                event::WindowEvent::MouseExited => call_user_function!(mouse_exited),
-                event::WindowEvent::MouseWheel(amount, phase) => {
-                    call_user_function!(mouse_wheel, amount, phase)
-                }
-                event::WindowEvent::Moved(pos) => call_user_function!(moved, pos),
-                event::WindowEvent::Resized(size) => call_user_function!(resized, size),
-                event::WindowEvent::Touch(touch) => call_user_function!(touch, touch),
-                event::WindowEvent::TouchPressure(pressure) => {
-                    call_user_function!(touchpad_pressure, pressure)
-                }
-                event::WindowEvent::HoveredFile(path) => call_user_function!(hovered_file, path),
-                event::WindowEvent::HoveredFileCancelled => {
-                    call_user_function!(hovered_file_cancelled)
-                }
-                event::WindowEvent::DroppedFile(path) => call_user_function!(dropped_file, path),
-                event::WindowEvent::Focused => call_user_function!(focused),
-                event::WindowEvent::Unfocused => call_user_function!(unfocused),
-                event::WindowEvent::Closed => call_user_function!(closed),
-            }
+pub trait UpdateModeExt {
+    /// Wait indefinitely for the next update.
+    fn wait() -> UpdateMode;
+    /// Freeze the application, sending no further updates.
+    fn freeze() -> UpdateMode;
+}
+
+impl UpdateModeExt for UpdateMode {
+    fn wait() -> UpdateMode {
+        UpdateMode::Reactive {
+            wait: Duration::MAX,
+            react_to_device_events: true,
+            react_to_user_events: true,
+            react_to_window_events: true,
         }
     }
 
-    // If the loop was destroyed, we'll need to exit.
-    let loop_destroyed = match winit_event {
-        winit::event::Event::LoopDestroyed => true,
-        _ => false,
-    };
-
-    // If any exist conditions were triggered, indicate so.
-    let exit = if loop_destroyed || exit_on_escape || app.windows.borrow().is_empty() {
-        true
-    } else {
-        false
-    };
+    fn freeze() -> UpdateMode {
+        UpdateMode::Reactive {
+            wait: Duration::MAX,
+            react_to_device_events: false,
+            react_to_user_events: false,
+            react_to_window_events: false,
+        }
+    }
+}
 
-    exit
+/// Attempt to find the assets directory path relative to the executable location.
+pub fn find_project_path() -> Result<PathBuf, find_folder::Error> {
+    let exe_path = std::env::current_exe()?;
+    let mut path = exe_path.parent().expect("exe has no parent directory");
+    while let Some(parent) = path.parent() {
+        path = parent;
+        if path.join("Cargo").with_extension("toml").exists() {
+            return Ok(path.to_path_buf());
+        }
+    }
+    Err(find_folder::Error::NotFound)
 }
diff --git a/nannou/src/camera.rs b/nannou/src/camera.rs
new file mode 100644
index 000000000..3b6e758e5
--- /dev/null
+++ b/nannou/src/camera.rs
@@ -0,0 +1,319 @@
+use crate::prelude::bevy_render::camera::RenderTarget;
+use crate::prelude::Camera3dBundle;
+use crate::App;
+use bevy::core_pipeline::bloom::BloomSettings;
+use bevy::core_pipeline::tonemapping::Tonemapping;
+use bevy::math::UVec2;
+use bevy::prelude::{Camera3d, PerspectiveProjection, Projection, Transform, Vec2};
+use bevy::render::camera;
+use bevy::render::view::RenderLayers;
+use bevy::window::WindowRef;
+use bevy_nannou::prelude::render::NannouCamera;
+use bevy_nannou::prelude::{default, ClearColorConfig, Entity, OrthographicProjection, Vec3};
+
+pub struct Camera<'a, 'w> {
+    entity: Entity,
+    app: &'a App<'w>,
+}
+
+pub struct Builder<'a, 'w> {
+    app: &'a App<'w>,
+    camera: Camera3dBundle,
+    bloom_settings: Option<BloomSettings>,
+    layer: Option<RenderLayers>,
+}
+
+pub trait SetCamera: Sized {
+    fn layer(mut self, layer: RenderLayers) -> Self {
+        self.map_layer(|_| layer)
+    }
+
+    fn order(mut self, order: isize) -> Self {
+        self.map_camera(|mut camera| {
+            camera.camera.order = order;
+            camera
+        })
+    }
+
+    fn x_y(mut self, x: f32, y: f32) -> Self {
+        self.map_camera(|mut camera| {
+            camera.transform.translation =
+                bevy::math::Vec3::new(x, y, camera.transform.translation.z);
+            camera
+        })
+    }
+
+    fn xy(mut self, p: Vec2) -> Self {
+        self.map_camera(|mut camera| {
+            camera.transform.translation = p.extend(camera.transform.translation.z);
+            camera
+        })
+    }
+
+    fn x_y_z(mut self, x: f32, y: f32, z: f32) -> Self {
+        self.map_camera(|mut camera| {
+            camera.transform.translation = bevy::math::Vec3::new(x, y, z);
+            camera
+        })
+    }
+
+    fn xyz(mut self, p: Vec3) -> Self {
+        self.map_camera(|mut camera| {
+            camera.transform.translation = p;
+            camera
+        })
+    }
+
+    fn hdr(mut self, hdr: bool) -> Self {
+        self.map_camera(|mut camera| {
+            camera.camera.hdr = hdr;
+            camera
+        })
+    }
+
+    fn viewport(mut self, position: UVec2, size: UVec2) -> Self {
+        self.map_camera(|mut camera| {
+            camera.camera.viewport = Some(camera::Viewport {
+                physical_position: position,
+                physical_size: size,
+                depth: Default::default(),
+            });
+            camera
+        })
+    }
+
+    fn window(mut self, window: Entity) -> Self {
+        self.map_camera(|mut camera| {
+            camera.camera.target = RenderTarget::Window(WindowRef::Entity(window));
+            camera
+        })
+    }
+
+    fn tonemapping(mut self, tonemapping: Tonemapping) -> Self {
+        self.map_camera(|mut camera| {
+            camera.tonemapping = tonemapping;
+            camera
+        })
+    }
+
+    fn clear_color(mut self, color: ClearColorConfig) -> Self {
+        self.map_camera(|mut camera| {
+            camera.camera.clear_color = color;
+            camera
+        })
+    }
+
+    fn bloom_settings(mut self, settings: BloomSettings) -> Self {
+        self.map_bloom_settings(|_| settings)
+    }
+
+    fn bloom_intensity(mut self, intensity: f32) -> Self {
+        self.map_bloom_settings(|mut settings| {
+            settings.intensity = intensity;
+            settings
+        })
+    }
+
+    fn bloom_low_frequency_boost(mut self, low_frequency_boost: f32) -> Self {
+        self.map_bloom_settings(|mut settings| {
+            settings.low_frequency_boost = low_frequency_boost;
+            settings
+        })
+    }
+
+    fn bloom_low_frequency_boost_curvature(mut self, low_frequency_boost_curvature: f32) -> Self {
+        self.map_bloom_settings(|mut settings| {
+            settings.low_frequency_boost_curvature = low_frequency_boost_curvature;
+            settings
+        })
+    }
+
+    fn bloom_high_pass_frequency(mut self, high_pass_frequency: f32) -> Self {
+        self.map_bloom_settings(|mut settings| {
+            settings.high_pass_frequency = high_pass_frequency;
+            settings
+        })
+    }
+
+    fn bloom_prefilter_settings(mut self, threshold: f32, threshold_softness: f32) -> Self {
+        self.map_bloom_settings(|mut settings| {
+            settings.prefilter_settings = bevy::core_pipeline::bloom::BloomPrefilterSettings {
+                threshold,
+                threshold_softness,
+            };
+            settings
+        })
+    }
+
+    fn bloom_composite_mode(
+        mut self,
+        composite_mode: bevy::core_pipeline::bloom::BloomCompositeMode,
+    ) -> Self {
+        self.map_bloom_settings(|mut settings| {
+            settings.composite_mode = composite_mode;
+            settings
+        })
+    }
+
+    fn projection(self, projection: impl Into<Projection>) -> Self {
+        self.map_camera(|mut camera| {
+            camera.projection = projection.into();
+            camera
+        })
+    }
+
+    fn map_layer<F>(self, f: F) -> Self
+    where
+        F: FnOnce(RenderLayers) -> RenderLayers;
+
+    fn map_bloom_settings<F>(self, f: F) -> Self
+    where
+        F: FnOnce(BloomSettings) -> BloomSettings;
+
+    fn map_camera<F>(self, f: F) -> Self
+    where
+        F: FnOnce(Camera3dBundle) -> Camera3dBundle;
+}
+
+impl<'a, 'w> Builder<'a, 'w> {
+    pub fn new(app: &'a App<'w>) -> Self {
+        Self {
+            app,
+            camera: Camera3dBundle {
+                transform: Transform::from_xyz(0.0, 0.0, 10.0).looking_at(Vec3::ZERO, Vec3::Y),
+                projection: OrthographicProjection::default().into(),
+                ..default()
+            },
+            bloom_settings: None,
+            layer: None,
+        }
+    }
+
+    pub fn build(self) -> Entity {
+        let entity = self
+            .app
+            .component_world_mut()
+            .spawn((self.camera, NannouCamera))
+            .id();
+        if let Some(layer) = self.layer {
+            self.app
+                .component_world_mut()
+                .entity_mut(entity)
+                .insert(layer);
+        } else {
+            self.app
+                .component_world_mut()
+                .entity_mut(entity)
+                .insert(RenderLayers::default());
+        }
+        if let Some(bloom_settings) = self.bloom_settings {
+            self.app
+                .component_world_mut()
+                .entity_mut(entity)
+                .insert(bloom_settings);
+        }
+        entity
+    }
+}
+
+impl<'a, 'w> SetCamera for Builder<'a, 'w> {
+    fn map_layer<F>(self, f: F) -> Self
+    where
+        F: FnOnce(RenderLayers) -> RenderLayers,
+    {
+        Self {
+            layer: Some(f(self.layer.unwrap_or(RenderLayers::default()))),
+            ..self
+        }
+    }
+
+    fn map_bloom_settings<F>(self, f: F) -> Self
+    where
+        F: FnOnce(BloomSettings) -> BloomSettings,
+    {
+        Self {
+            bloom_settings: Some(f(self.bloom_settings.unwrap_or(BloomSettings::default()))),
+            ..self
+        }
+    }
+
+    fn map_camera<F>(self, f: F) -> Self
+    where
+        F: FnOnce(Camera3dBundle) -> Camera3dBundle,
+    {
+        Self {
+            camera: f(self.camera),
+            ..self
+        }
+    }
+}
+
+impl<'a, 'w> Camera<'a, 'w> {
+    pub fn new(app: &'a App<'w>, entity: Entity) -> Self {
+        Self { entity, app }
+    }
+}
+
+impl<'a, 'w> SetCamera for Camera<'a, 'w> {
+    fn map_layer<F>(self, f: F) -> Self
+    where
+        F: FnOnce(RenderLayers) -> RenderLayers,
+    {
+        let mut world = self.app.component_world_mut();
+        let mut layer_q = world.query::<Option<&mut RenderLayers>>();
+        if let Ok(mut layer) = layer_q.get_mut(&mut world, self.entity) {
+            if let Some(mut layer) = layer {
+                *layer = f(layer.clone());
+            } else {
+                world
+                    .entity_mut(self.entity)
+                    .insert(f(RenderLayers::default()));
+            }
+        }
+        self
+    }
+
+    fn map_bloom_settings<F>(self, f: F) -> Self
+    where
+        F: FnOnce(BloomSettings) -> BloomSettings,
+    {
+        let mut world = self.app.component_world_mut();
+        let mut bloom_q = world.query::<Option<&mut BloomSettings>>();
+        if let Ok(mut bloom) = bloom_q.get_mut(&mut world, self.entity) {
+            if let Some(mut bloom) = bloom {
+                *bloom = f(bloom.clone());
+            } else {
+                world
+                    .entity_mut(self.entity)
+                    .insert(f(BloomSettings::default()));
+            }
+        }
+        self
+    }
+
+    fn map_camera<F>(self, f: F) -> Self
+    where
+        F: FnOnce(Camera3dBundle) -> Camera3dBundle,
+    {
+        let mut world = self.app.component_world_mut();
+        let mut camera_q = world.query::<(
+            &mut Transform,
+            &mut camera::Camera,
+            &mut Camera3d,
+            &mut Projection,
+        )>();
+        let (transform, camera, camera_3d, projection) =
+            camera_q.get_mut(&mut world, self.entity).unwrap();
+        let bundle = Camera3dBundle {
+            transform: transform.clone(),
+            camera: camera.clone(),
+            camera_3d: camera_3d.clone(),
+            projection: projection.clone(),
+            ..default()
+        };
+
+        let bundle = f(bundle);
+        world.entity_mut(self.entity).insert(bundle);
+        self
+    }
+}
diff --git a/nannou/src/draw/background.rs b/nannou/src/draw/background.rs
deleted file mode 100644
index c09d69f7c..000000000
--- a/nannou/src/draw/background.rs
+++ /dev/null
@@ -1,96 +0,0 @@
-use crate::color::{self, IntoLinSrgba, Srgb, Srgba};
-use crate::draw::properties::ColorScalar;
-use crate::draw::Draw;
-
-/// A type used to update the background colour.
-pub struct Background<'a> {
-    draw: &'a Draw,
-}
-
-/// Begin coloring the background.
-pub fn new<'a>(draw: &'a Draw) -> Background<'a> {
-    Background { draw }
-}
-
-impl<'a> Background<'a> {
-    /// Clear the background with the given color.
-    ///
-    /// This method supports any color type that can be converted into RGBA.
-    ///
-    /// Colors that have no alpha channel will be given an opaque alpha channel value `1.0`.
-    pub fn color<C>(self, color: C) -> Self
-    where
-        C: IntoLinSrgba<ColorScalar>,
-    {
-        if let Ok(mut state) = self.draw.state.try_borrow_mut() {
-            state.background_color = Some(color.into_lin_srgba());
-        }
-        self
-    }
-
-    /// Specify the color via red, green and blue channels.
-    pub fn rgb(self, r: ColorScalar, g: ColorScalar, b: ColorScalar) -> Self {
-        self.color(Srgb::new(r, g, b))
-    }
-
-    /// Specify the color via red, green, blue and alpha channels.
-    pub fn rgba(self, r: ColorScalar, g: ColorScalar, b: ColorScalar, a: ColorScalar) -> Self {
-        self.color(Srgba::new(r, g, b, a))
-    }
-
-    /// Specify the color via hue, saturation and luminance.
-    ///
-    /// If you're looking for HSV or HSB, use the `hsv` method instead.
-    ///
-    /// The given hue expects a value between `0.0` and `1.0` where `0.0` is 0 degress and `1.0` is
-    /// 360 degrees (or 2 PI radians).
-    ///
-    /// See the [wikipedia entry](https://en.wikipedia.org/wiki/HSL_and_HSV) for more details on
-    /// this color space.
-    pub fn hsl(self, h: ColorScalar, s: ColorScalar, l: ColorScalar) -> Self {
-        let hue = h * 360.0;
-        self.color(color::Hsl::new(hue, s, l))
-    }
-
-    /// Specify the color via hue, saturation, luminance and an alpha channel.
-    ///
-    /// If you're looking for HSVA or HSBA, use the `hsva` method instead.
-    ///
-    /// The given hue expects a value between `0.0` and `1.0` where `0.0` is 0 degress and `1.0` is
-    /// 360 degrees (or 2 PI radians).
-    ///
-    /// See the [wikipedia entry](https://en.wikipedia.org/wiki/HSL_and_HSV) for more details on
-    /// this color space.
-    pub fn hsla(self, h: ColorScalar, s: ColorScalar, l: ColorScalar, a: ColorScalar) -> Self {
-        let hue = h * 360.0;
-        self.color(color::Hsla::new(hue, s, l, a))
-    }
-
-    /// Specify the color via hue, saturation and *value* (brightness).
-    ///
-    /// This is sometimes also known as "hsb".
-    ///
-    /// The given hue expects a value between `0.0` and `1.0` where `0.0` is 0 degress and `1.0` is
-    /// 360 degrees (or 2 PI radians).
-    ///
-    /// See the [wikipedia entry](https://en.wikipedia.org/wiki/HSL_and_HSV) for more details on
-    /// this color space.
-    pub fn hsv(self, h: ColorScalar, s: ColorScalar, v: ColorScalar) -> Self {
-        let hue = h * 360.0;
-        self.color(color::Hsv::new(hue, s, v))
-    }
-
-    /// Specify the color via hue, saturation, *value* (brightness) and an alpha channel.
-    ///
-    /// This is sometimes also known as "hsba".
-    ///
-    /// The given hue expects a value between `0.0` and `1.0` where `0.0` is 0 degress and `1.0` is
-    /// 360 degrees (or 2 PI radians).
-    ///
-    /// See the [wikipedia entry](https://en.wikipedia.org/wiki/HSL_and_HSV) for more details on
-    /// this color space.
-    pub fn hsva(self, h: ColorScalar, s: ColorScalar, v: ColorScalar, a: ColorScalar) -> Self {
-        let hue = h * 360.0;
-        self.color(color::Hsva::new(hue, s, v, a))
-    }
-}
diff --git a/nannou/src/draw/drawing.rs b/nannou/src/draw/drawing.rs
deleted file mode 100644
index 9b902039a..000000000
--- a/nannou/src/draw/drawing.rs
+++ /dev/null
@@ -1,708 +0,0 @@
-use crate::color::IntoLinSrgba;
-use crate::draw::mesh::vertex::{Color, TexCoords};
-use crate::draw::primitive::Primitive;
-use crate::draw::properties::{
-    ColorScalar, SetColor, SetDimensions, SetFill, SetOrientation, SetPosition, SetStroke,
-};
-use crate::draw::{self, Draw};
-use crate::geom::{Point2, Point3};
-use crate::glam::{Quat, Vec2, Vec3};
-use lyon::path::PathEvent;
-use lyon::tessellation::{FillOptions, LineCap, LineJoin, StrokeOptions};
-use std::marker::PhantomData;
-
-/// A **Drawing** in progress.
-///
-/// **Drawing** provides a way of chaining together method calls describing properties of the thing
-/// that we are drawing. **Drawing** ends when the instance is **Drop**ped, at which point the
-/// properties of the drawing are inserted into the **Draw** type.
-///
-/// When a **Drawing** begins, a node is immediately created for the drawing within the **Draw**'s
-/// inner **geom::Graph**. This ensures the correct instantiation order is maintained within the
-/// graph. As a result, each **Drawing** is associated with a single, unique node. Thus a
-/// **Drawing** can be thought of as a way of specifying properties for a node.
-#[derive(Debug)]
-pub struct Drawing<'a, T> {
-    // The `Draw` instance used to create this drawing.
-    draw: &'a Draw,
-    // The draw command index of the primitive being drawn.
-    index: usize,
-    // Whether or not the **Drawing** should attempt to finish the drawing on drop.
-    finish_on_drop: bool,
-    // The node type currently being drawn.
-    _ty: PhantomData<T>,
-}
-
-/// Some context that may be optionally provided to primitives in the drawing implementation.
-///
-/// This is particularly useful for paths and meshes.
-pub struct DrawingContext<'a> {
-    /// The intermediary mesh for buffering yet-to-be-drawn paths and meshes.
-    pub mesh: &'a mut draw::Mesh,
-    /// A re-usable buffer for collecting path events.
-    pub path_event_buffer: &'a mut Vec<PathEvent>,
-    /// A re-usable buffer for collecting colored polyline points.
-    pub path_points_colored_buffer: &'a mut Vec<(Point2, Color)>,
-    /// A re-usable buffer for collecting textured polyline points.
-    pub path_points_textured_buffer: &'a mut Vec<(Point2, TexCoords)>,
-    /// A re-usable buffer for collecting text.
-    pub text_buffer: &'a mut String,
-}
-
-/// Construct a new **Drawing** instance.
-pub fn new<'a, T>(draw: &'a Draw, index: usize) -> Drawing<'a, T> {
-    let _ty = PhantomData;
-    let finish_on_drop = true;
-    Drawing {
-        draw,
-        index,
-        finish_on_drop,
-        _ty,
-    }
-}
-
-impl<'a, T> Drop for Drawing<'a, T> {
-    fn drop(&mut self) {
-        if self.finish_on_drop {
-            self.finish_inner();
-        }
-    }
-}
-
-impl<'a> DrawingContext<'a> {
-    // Initialise the DrawingContext from the draw's IntermediaryState.
-    pub(crate) fn from_intermediary_state(state: &'a mut super::IntermediaryState) -> Self {
-        let super::IntermediaryState {
-            ref mut intermediary_mesh,
-            ref mut path_event_buffer,
-            ref mut path_points_colored_buffer,
-            ref mut path_points_textured_buffer,
-            ref mut text_buffer,
-        } = *state;
-        DrawingContext {
-            mesh: intermediary_mesh,
-            path_event_buffer: path_event_buffer,
-            path_points_colored_buffer: path_points_colored_buffer,
-            path_points_textured_buffer: path_points_textured_buffer,
-            text_buffer: text_buffer,
-        }
-    }
-}
-
-impl<'a, T> Drawing<'a, T> {
-    // Shared between the **finish** method and the **Drawing**'s **Drop** implementation.
-    //
-    // 1. Create vertices based on node-specific position, points, etc.
-    // 2. Insert edges into geom graph based on
-    fn finish_inner(&mut self) {
-        match self.draw.state.try_borrow_mut() {
-            Err(err) => eprintln!("drawing failed to borrow state and finish: {}", err),
-            Ok(mut state) => state.finish_drawing(self.index),
-        }
-    }
-
-    /// Complete the drawing and insert it into the parent **Draw** instance.
-    ///
-    /// This will be called when the **Drawing** is **Drop**ped if it has not yet been called.
-    pub fn finish(mut self) {
-        self.finish_inner()
-    }
-
-    // Map the given function onto the primitive stored within **Draw** at `index`.
-    //
-    // The functionn is only applied if the node has not yet been **Drawn**.
-    fn map_primitive<F, T2>(mut self, map: F) -> Drawing<'a, T2>
-    where
-        F: FnOnce(Primitive) -> Primitive,
-        T2: Into<Primitive>,
-    {
-        if let Ok(mut state) = self.draw.state.try_borrow_mut() {
-            if let Some(mut primitive) = state.drawing.remove(&self.index) {
-                primitive = map(primitive);
-                state.drawing.insert(self.index, primitive);
-            }
-        }
-        self.finish_on_drop = false;
-        let Drawing { draw, index, .. } = self;
-        Drawing {
-            draw,
-            index,
-            finish_on_drop: true,
-            _ty: PhantomData,
-        }
-    }
-
-    // The same as `map_primitive` but also passes a mutable reference to the vertex data to the
-    // map function. This is useful for types that may have an unknown number of arbitrary
-    // vertices.
-    fn map_primitive_with_context<F, T2>(mut self, map: F) -> Drawing<'a, T2>
-    where
-        F: FnOnce(Primitive, DrawingContext) -> Primitive,
-        T2: Into<Primitive>,
-    {
-        if let Ok(mut state) = self.draw.state.try_borrow_mut() {
-            if let Some(mut primitive) = state.drawing.remove(&self.index) {
-                {
-                    let mut intermediary_state = state.intermediary_state.borrow_mut();
-                    let ctxt = DrawingContext::from_intermediary_state(&mut *intermediary_state);
-                    primitive = map(primitive, ctxt);
-                }
-                state.drawing.insert(self.index, primitive);
-            }
-        }
-        self.finish_on_drop = false;
-        let Drawing { draw, index, .. } = self;
-        Drawing {
-            draw,
-            index,
-            finish_on_drop: true,
-            _ty: PhantomData,
-        }
-    }
-
-    /// Apply the given function to the type stored within **Draw**.
-    ///
-    /// The function is only applied if the node has not yet been **Drawn**.
-    ///
-    /// **Panics** if the primitive does not contain type **T**.
-    pub fn map_ty<F, T2>(self, map: F) -> Drawing<'a, T2>
-    where
-        F: FnOnce(T) -> T2,
-        T2: Into<Primitive>,
-        Primitive: Into<Option<T>>,
-    {
-        self.map_primitive(|prim| {
-            let maybe_ty: Option<T> = prim.into();
-            let ty = maybe_ty.expect("expected `T` but primitive contained different type");
-            let ty2 = map(ty);
-            ty2.into()
-        })
-    }
-
-    /// Apply the given function to the type stored within **Draw**.
-    ///
-    /// The function is only applied if the node has not yet been **Drawn**.
-    ///
-    /// **Panics** if the primitive does not contain type **T**.
-    pub(crate) fn map_ty_with_context<F, T2>(self, map: F) -> Drawing<'a, T2>
-    where
-        F: FnOnce(T, DrawingContext) -> T2,
-        T2: Into<Primitive>,
-        Primitive: Into<Option<T>>,
-    {
-        self.map_primitive_with_context(|prim, ctxt| {
-            let maybe_ty: Option<T> = prim.into();
-            let ty = maybe_ty.expect("expected `T` but primitive contained different type");
-            let ty2 = map(ty, ctxt);
-            ty2.into()
-        })
-    }
-}
-
-// SetColor implementations.
-
-impl<'a, T> Drawing<'a, T>
-where
-    T: SetColor<ColorScalar> + Into<Primitive>,
-    Primitive: Into<Option<T>>,
-{
-    /// Specify a color.
-    ///
-    /// This method supports any color type that can be converted into RGBA.
-    ///
-    /// Colors that have no alpha channel will be given an opaque alpha channel value `1.0`.
-    pub fn color<C>(self, color: C) -> Self
-    where
-        C: IntoLinSrgba<ColorScalar>,
-    {
-        self.map_ty(|ty| SetColor::color(ty, color))
-    }
-
-    /// Specify the color via red, green and blue channels.
-    pub fn rgb(self, r: ColorScalar, g: ColorScalar, b: ColorScalar) -> Self {
-        self.map_ty(|ty| SetColor::rgb(ty, r, g, b))
-    }
-
-    /// Specify the color via red, green and blue channels as bytes
-    pub fn rgb8(self, r: u8, g: u8, b: u8) -> Self {
-        self.map_ty(|ty| SetColor::rgb8(ty, r, g, b))
-    }
-
-    /// Specify the color via red, green, blue and alpha channels.
-    pub fn rgba(self, r: ColorScalar, g: ColorScalar, b: ColorScalar, a: ColorScalar) -> Self {
-        self.map_ty(|ty| SetColor::rgba(ty, r, g, b, a))
-    }
-
-    /// Specify the color via red, green, blue and alpha channels as bytes.
-    pub fn rgba8(self, r: u8, g: u8, b: u8, a: u8) -> Self {
-        self.map_ty(|ty| SetColor::rgba8(ty, r, g, b, a))
-    }
-
-    /// Specify the color via hue, saturation and luminance.
-    ///
-    /// If you're looking for HSVA or HSBA, use the `hsva` method instead.
-    ///
-    /// The given hue expects a value between `0.0` and `1.0` where `0.0` is 0 degress and `1.0` is
-    /// 360 degrees (or 2 PI radians).
-    ///
-    /// See the [wikipedia entry](https://en.wikipedia.org/wiki/HSL_and_HSV) for more details on
-    /// this color space.
-    pub fn hsl(self, h: ColorScalar, s: ColorScalar, l: ColorScalar) -> Self {
-        self.map_ty(|ty| SetColor::hsl(ty, h, s, l))
-    }
-
-    /// Specify the color via hue, saturation, luminance and an alpha channel.
-    ///
-    /// If you're looking for HSVA or HSBA, use the `hsva` method instead.
-    ///
-    /// The given hue expects a value between `0.0` and `1.0` where `0.0` is 0 degress and `1.0` is
-    /// 360 degrees (or 2 PI radians).
-    ///
-    /// See the [wikipedia entry](https://en.wikipedia.org/wiki/HSL_and_HSV) for more details on
-    /// this color space.
-    pub fn hsla(self, h: ColorScalar, s: ColorScalar, l: ColorScalar, a: ColorScalar) -> Self {
-        self.map_ty(|ty| SetColor::hsla(ty, h, s, l, a))
-    }
-
-    /// Specify the color via hue, saturation and *value* (brightness).
-    ///
-    /// This is sometimes also known as "hsb".
-    ///
-    /// The given hue expects a value between `0.0` and `1.0` where `0.0` is 0 degress and `1.0` is
-    /// 360 degrees (or 2 PI radians).
-    ///
-    /// See the [wikipedia entry](https://en.wikipedia.org/wiki/HSL_and_HSV) for more details on
-    /// this color space.
-    pub fn hsv(self, h: ColorScalar, s: ColorScalar, v: ColorScalar) -> Self {
-        self.map_ty(|ty| SetColor::hsv(ty, h, s, v))
-    }
-
-    /// Specify the color via hue, saturation, *value* (brightness) and an alpha channel.
-    ///
-    /// This is sometimes also known as "hsba".
-    ///
-    /// The given hue expects a value between `0.0` and `1.0` where `0.0` is 0 degress and `1.0` is
-    /// 360 degrees (or 2 PI radians).
-    ///
-    /// See the [wikipedia entry](https://en.wikipedia.org/wiki/HSL_and_HSV) for more details on
-    /// this color space.
-    pub fn hsva(self, h: ColorScalar, s: ColorScalar, v: ColorScalar, a: ColorScalar) -> Self {
-        self.map_ty(|ty| SetColor::hsva(ty, h, s, v, a))
-    }
-
-    /// Specify the color as gray scale
-    ///
-    /// The given g expects a value between `0.0` and `1.0` where `0.0` is black and `1.0` is white
-    pub fn gray(self, g: ColorScalar) -> Self {
-        self.map_ty(|ty| SetColor::gray(ty, g))
-    }
-}
-
-// SetDimensions implementations.
-
-impl<'a, T> Drawing<'a, T>
-where
-    T: SetDimensions + Into<Primitive>,
-    Primitive: Into<Option<T>>,
-{
-    /// Set the absolute width for the node.
-    pub fn width(self, w: f32) -> Self {
-        self.map_ty(|ty| SetDimensions::width(ty, w))
-    }
-
-    /// Set the absolute height for the node.
-    pub fn height(self, h: f32) -> Self {
-        self.map_ty(|ty| SetDimensions::height(ty, h))
-    }
-
-    /// Set the absolute depth for the node.
-    pub fn depth(self, d: f32) -> Self {
-        self.map_ty(|ty| SetDimensions::depth(ty, d))
-    }
-
-    /// Short-hand for the **width** method.
-    pub fn w(self, w: f32) -> Self {
-        self.map_ty(|ty| SetDimensions::w(ty, w))
-    }
-
-    /// Short-hand for the **height** method.
-    pub fn h(self, h: f32) -> Self {
-        self.map_ty(|ty| SetDimensions::h(ty, h))
-    }
-
-    /// Short-hand for the **depth** method.
-    pub fn d(self, d: f32) -> Self {
-        self.map_ty(|ty| SetDimensions::d(ty, d))
-    }
-
-    /// Set the **x** and **y** dimensions for the node.
-    pub fn wh(self, v: Vec2) -> Self {
-        self.map_ty(|ty| SetDimensions::wh(ty, v))
-    }
-
-    /// Set the **x**, **y** and **z** dimensions for the node.
-    pub fn whd(self, v: Vec3) -> Self {
-        self.map_ty(|ty| SetDimensions::whd(ty, v))
-    }
-
-    /// Set the width and height for the node.
-    pub fn w_h(self, x: f32, y: f32) -> Self {
-        self.map_ty(|ty| SetDimensions::w_h(ty, x, y))
-    }
-
-    /// Set the width and height for the node.
-    pub fn w_h_d(self, x: f32, y: f32, z: f32) -> Self {
-        self.map_ty(|ty| SetDimensions::w_h_d(ty, x, y, z))
-    }
-}
-
-// SetPosition methods.
-
-impl<'a, T> Drawing<'a, T>
-where
-    T: SetPosition + Into<Primitive>,
-    Primitive: Into<Option<T>>,
-{
-    /// Build with the given **Absolute** **Position** along the *x* axis.
-    pub fn x(self, x: f32) -> Self {
-        self.map_ty(|ty| SetPosition::x(ty, x))
-    }
-
-    /// Build with the given **Absolute** **Position** along the *y* axis.
-    pub fn y(self, y: f32) -> Self {
-        self.map_ty(|ty| SetPosition::y(ty, y))
-    }
-
-    /// Build with the given **Absolute** **Position** along the *z* axis.
-    pub fn z(self, z: f32) -> Self {
-        self.map_ty(|ty| SetPosition::z(ty, z))
-    }
-
-    /// Set the **Position** with some two-dimensional point.
-    pub fn xy(self, p: Point2) -> Self {
-        self.map_ty(|ty| SetPosition::xy(ty, p))
-    }
-
-    /// Set the **Position** with some three-dimensional point.
-    pub fn xyz(self, p: Point3) -> Self {
-        self.map_ty(|ty| SetPosition::xyz(ty, p))
-    }
-
-    /// Set the **Position** with *x* *y* coordinates.
-    pub fn x_y(self, x: f32, y: f32) -> Self {
-        self.map_ty(|ty| SetPosition::x_y(ty, x, y))
-    }
-
-    /// Set the **Position** with *x* *y* *z* coordinates.
-    pub fn x_y_z(self, x: f32, y: f32, z: f32) -> Self {
-        self.map_ty(|ty| SetPosition::x_y_z(ty, x, y, z))
-    }
-}
-
-// SetOrientation methods.
-
-impl<'a, T> Drawing<'a, T>
-where
-    T: SetOrientation + Into<Primitive>,
-    Primitive: Into<Option<T>>,
-{
-    /// Describe orientation via the vector that points to the given target.
-    pub fn look_at(self, target: Point3) -> Self {
-        self.map_ty(|ty| SetOrientation::look_at(ty, target))
-    }
-
-    /// Specify the orientation around the *x* axis as an absolute value in radians.
-    pub fn x_radians(self, x: f32) -> Self {
-        self.map_ty(|ty| SetOrientation::x_radians(ty, x))
-    }
-
-    /// Specify the orientation around the *y* axis as an absolute value in radians.
-    pub fn y_radians(self, y: f32) -> Self {
-        self.map_ty(|ty| SetOrientation::y_radians(ty, y))
-    }
-
-    /// Specify the orientation around the *z* axis as an absolute value in radians.
-    pub fn z_radians(self, z: f32) -> Self {
-        self.map_ty(|ty| SetOrientation::z_radians(ty, z))
-    }
-
-    /// Specify the orientation around the *x* axis as an absolute value in degrees.
-    pub fn x_degrees(self, x: f32) -> Self {
-        self.map_ty(|ty| SetOrientation::x_degrees(ty, x))
-    }
-
-    /// Specify the orientation around the *y* axis as an absolute value in degrees.
-    pub fn y_degrees(self, y: f32) -> Self {
-        self.map_ty(|ty| SetOrientation::y_degrees(ty, y))
-    }
-
-    /// Specify the orientation around the *z* axis as an absolute value in degrees.
-    pub fn z_degrees(self, z: f32) -> Self {
-        self.map_ty(|ty| SetOrientation::z_degrees(ty, z))
-    }
-
-    /// Specify the orientation around the *x* axis as a number of turns around the axis.
-    pub fn x_turns(self, x: f32) -> Self {
-        self.map_ty(|ty| SetOrientation::x_turns(ty, x))
-    }
-
-    /// Specify the orientation around the *y* axis as a number of turns around the axis.
-    pub fn y_turns(self, y: f32) -> Self {
-        self.map_ty(|ty| SetOrientation::y_turns(ty, y))
-    }
-
-    /// Specify the orientation around the *z* axis as a number of turns around the axis.
-    pub fn z_turns(self, z: f32) -> Self {
-        self.map_ty(|ty| SetOrientation::z_turns(ty, z))
-    }
-
-    /// Specify the orientation along each axis with the given **Vector** of radians.
-    ///
-    /// This has the same affect as calling `self.x_radians(v.x).y_radians(v.y).z_radians(v.z)`.
-    pub fn radians(self, v: Vec3) -> Self {
-        self.map_ty(|ty| SetOrientation::radians(ty, v))
-    }
-
-    /// Specify the orientation along each axis with the given **Vector** of degrees.
-    ///
-    /// This has the same affect as calling `self.x_degrees(v.x).y_degrees(v.y).z_degrees(v.z)`.
-    pub fn degrees(self, v: Vec3) -> Self {
-        self.map_ty(|ty| SetOrientation::degrees(ty, v))
-    }
-
-    /// Specify the orientation along each axis with the given **Vector** of "turns".
-    ///
-    /// This has the same affect as calling `self.x_turns(v.x).y_turns(v.y).z_turns(v.z)`.
-    pub fn turns(self, v: Vec3) -> Self {
-        self.map_ty(|ty| SetOrientation::turns(ty, v))
-    }
-
-    /// Specify the orientation with the given **Euler**.
-    ///
-    /// The euler must be specified in radians.
-    pub fn euler(self, e: Vec3) -> Self {
-        self.map_ty(|ty| SetOrientation::euler(ty, e))
-    }
-
-    /// Specify the orientation with the given **Quaternion**.
-    pub fn quaternion(self, q: Quat) -> Self {
-        self.map_ty(|ty| SetOrientation::quaternion(ty, q))
-    }
-
-    // Higher level methods.
-
-    /// Specify the "pitch" of the orientation in radians.
-    ///
-    /// This has the same effect as calling `x_radians`.
-    pub fn pitch(self, pitch: f32) -> Self {
-        self.map_ty(|ty| SetOrientation::pitch(ty, pitch))
-    }
-
-    /// Specify the "yaw" of the orientation in radians.
-    ///
-    /// This has the same effect as calling `y_radians`.
-    pub fn yaw(self, yaw: f32) -> Self {
-        self.map_ty(|ty| SetOrientation::yaw(ty, yaw))
-    }
-
-    /// Specify the "roll" of the orientation in radians.
-    ///
-    /// This has the same effect as calling `z_radians`.
-    pub fn roll(self, roll: f32) -> Self {
-        self.map_ty(|ty| SetOrientation::roll(ty, roll))
-    }
-
-    /// Assuming we're looking at a 2D plane, positive values cause a clockwise rotation where the
-    /// given value is specified in radians.
-    ///
-    /// This is equivalent to calling the `z_radians` or `roll` methods.
-    pub fn rotate(self, radians: f32) -> Self {
-        self.map_ty(|ty| SetOrientation::rotate(ty, radians))
-    }
-}
-
-// SetFill methods
-
-impl<'a, T> Drawing<'a, T>
-where
-    T: SetFill + Into<Primitive>,
-    Primitive: Into<Option<T>>,
-{
-    /// Specify the whole set of fill tessellation options.
-    pub fn fill_opts(self, opts: FillOptions) -> Self {
-        self.map_ty(|ty| ty.fill_opts(opts))
-    }
-
-    /// Maximum allowed distance to the path when building an approximation.
-    pub fn fill_tolerance(self, tolerance: f32) -> Self {
-        self.map_ty(|ty| ty.fill_tolerance(tolerance))
-    }
-
-    /// Specify the rule used to determine what is inside and what is outside of the shape.
-    ///
-    /// Currently, only the `EvenOdd` rule is implemented.
-    pub fn fill_rule(self, rule: lyon::tessellation::FillRule) -> Self {
-        self.map_ty(|ty| ty.fill_rule(rule))
-    }
-
-    /// Whether to perform a vertical or horizontal traversal of the geometry.
-    ///
-    /// Default value: `Vertical`.
-    pub fn fill_sweep_orientation(self, orientation: lyon::tessellation::Orientation) -> Self {
-        self.map_ty(|ty| ty.fill_sweep_orientation(orientation))
-    }
-
-    /// A fast path to avoid some expensive operations if the path is known to not have any
-    /// self-intersections.
-    ///
-    /// Do not set this to `false` if the path may have intersecting edges else the tessellator may
-    /// panic or produce incorrect results. In doubt, do not change the default value.
-    ///
-    /// Default value: `true`.
-    pub fn handle_intersections(self, b: bool) -> Self {
-        self.map_ty(|ty| ty.handle_intersections(b))
-    }
-}
-
-// SetStroke methods
-
-impl<'a, T> Drawing<'a, T>
-where
-    T: SetStroke + Into<Primitive>,
-    Primitive: Into<Option<T>>,
-{
-    /// The start line cap as specified by the SVG spec.
-    pub fn start_cap(self, cap: LineCap) -> Self {
-        self.map_ty(|ty| ty.start_cap(cap))
-    }
-
-    /// The end line cap as specified by the SVG spec.
-    pub fn end_cap(self, cap: LineCap) -> Self {
-        self.map_ty(|ty| ty.end_cap(cap))
-    }
-
-    /// The start and end line cap as specified by the SVG spec.
-    pub fn caps(self, cap: LineCap) -> Self {
-        self.map_ty(|ty| ty.caps(cap))
-    }
-
-    /// The stroke for each sub-path does not extend beyond its two endpoints. A zero length
-    /// sub-path will therefore not have any stroke.
-    pub fn start_cap_butt(self) -> Self {
-        self.map_ty(|ty| ty.start_cap_butt())
-    }
-
-    /// At the end of each sub-path, the shape representing the stroke will be extended by a
-    /// rectangle with the same width as the stroke width and whose length is half of the stroke
-    /// width. If a sub-path has zero length, then the resulting effect is that the stroke for that
-    /// sub-path consists solely of a square with side length equal to the stroke width, centered
-    /// at the sub-path's point.
-    pub fn start_cap_square(self) -> Self {
-        self.map_ty(|ty| ty.start_cap_square())
-    }
-
-    /// At each end of each sub-path, the shape representing the stroke will be extended by a half
-    /// circle with a radius equal to the stroke width. If a sub-path has zero length, then the
-    /// resulting effect is that the stroke for that sub-path consists solely of a full circle
-    /// centered at the sub-path's point.
-    pub fn start_cap_round(self) -> Self {
-        self.map_ty(|ty| ty.start_cap_round())
-    }
-
-    /// The stroke for each sub-path does not extend beyond its two endpoints. A zero length
-    /// sub-path will therefore not have any stroke.
-    pub fn end_cap_butt(self) -> Self {
-        self.map_ty(|ty| ty.end_cap_butt())
-    }
-
-    /// At the end of each sub-path, the shape representing the stroke will be extended by a
-    /// rectangle with the same width as the stroke width and whose length is half of the stroke
-    /// width. If a sub-path has zero length, then the resulting effect is that the stroke for that
-    /// sub-path consists solely of a square with side length equal to the stroke width, centered
-    /// at the sub-path's point.
-    pub fn end_cap_square(self) -> Self {
-        self.map_ty(|ty| ty.end_cap_square())
-    }
-
-    /// At each end of each sub-path, the shape representing the stroke will be extended by a half
-    /// circle with a radius equal to the stroke width. If a sub-path has zero length, then the
-    /// resulting effect is that the stroke for that sub-path consists solely of a full circle
-    /// centered at the sub-path's point.
-    pub fn end_cap_round(self) -> Self {
-        self.map_ty(|ty| ty.end_cap_round())
-    }
-
-    /// The stroke for each sub-path does not extend beyond its two endpoints. A zero length
-    /// sub-path will therefore not have any stroke.
-    pub fn caps_butt(self) -> Self {
-        self.map_ty(|ty| ty.caps_butt())
-    }
-
-    /// At the end of each sub-path, the shape representing the stroke will be extended by a
-    /// rectangle with the same width as the stroke width and whose length is half of the stroke
-    /// width. If a sub-path has zero length, then the resulting effect is that the stroke for that
-    /// sub-path consists solely of a square with side length equal to the stroke width, centered
-    /// at the sub-path's point.
-    pub fn caps_square(self) -> Self {
-        self.map_ty(|ty| ty.caps_square())
-    }
-
-    /// At each end of each sub-path, the shape representing the stroke will be extended by a half
-    /// circle with a radius equal to the stroke width. If a sub-path has zero length, then the
-    /// resulting effect is that the stroke for that sub-path consists solely of a full circle
-    /// centered at the sub-path's point.
-    pub fn caps_round(self) -> Self {
-        self.map_ty(|ty| ty.caps_round())
-    }
-
-    /// The way in which lines are joined at the vertices, matching the SVG spec.
-    ///
-    /// Default value is `MiterClip`.
-    pub fn join(self, join: LineJoin) -> Self {
-        self.map_ty(|ty| ty.join(join))
-    }
-
-    /// A sharp corner is to be used to join path segments.
-    pub fn join_miter(self) -> Self {
-        self.map_ty(|ty| ty.join_miter())
-    }
-
-    /// Same as a `join_miter`, but if the miter limit is exceeded, the miter is clipped at a miter
-    /// length equal to the miter limit value multiplied by the stroke width.
-    pub fn join_miter_clip(self) -> Self {
-        self.map_ty(|ty| ty.join_miter_clip())
-    }
-
-    /// A round corner is to be used to join path segments.
-    pub fn join_round(self) -> Self {
-        self.map_ty(|ty| ty.join_round())
-    }
-
-    /// A bevelled corner is to be used to join path segments. The bevel shape is a triangle that
-    /// fills the area between the two stroked segments.
-    pub fn join_bevel(self) -> Self {
-        self.map_ty(|ty| ty.join_bevel())
-    }
-
-    /// The total stroke_weight (aka width) of the line.
-    pub fn stroke_weight(self, stroke_weight: f32) -> Self {
-        self.map_ty(|ty| ty.stroke_weight(stroke_weight))
-    }
-
-    /// Describes the limit before miter lines will clip, as described in the SVG spec.
-    ///
-    /// Must be greater than or equal to `1.0`.
-    pub fn miter_limit(self, limit: f32) -> Self {
-        self.map_ty(|ty| ty.miter_limit(limit))
-    }
-
-    /// Maximum allowed distance to the path when building an approximation.
-    pub fn stroke_tolerance(self, tolerance: f32) -> Self {
-        self.map_ty(|ty| ty.stroke_tolerance(tolerance))
-    }
-
-    /// Specify the full set of stroke options for the path tessellation.
-    pub fn stroke_opts(self, opts: StrokeOptions) -> Self {
-        self.map_ty(|ty| ty.stroke_opts(opts))
-    }
-}
diff --git a/nannou/src/draw/mesh/builder.rs b/nannou/src/draw/mesh/builder.rs
deleted file mode 100644
index 26d41937f..000000000
--- a/nannou/src/draw/mesh/builder.rs
+++ /dev/null
@@ -1,232 +0,0 @@
-//! Implementations of the lyon geometry builder traits for the `Mesh`.
-//!
-//! The aim is to allow for a tessellator to efficiently extend a mesh without using an
-//! intermediary buffer.
-//!
-//! Lyon tessellators assume `f32` data, so we do the same in the following implementations.
-
-use crate::draw;
-use crate::geom::Point2;
-use crate::glam::Mat4;
-use lyon::tessellation::geometry_builder::{
-    self, FillGeometryBuilder, GeometryBuilder, StrokeGeometryBuilder,
-};
-use lyon::tessellation::{FillVertex, GeometryBuilderError, StrokeVertex, VertexId};
-
-pub struct MeshBuilder<'a, A> {
-    /// The mesh that is to be extended.
-    mesh: &'a mut draw::Mesh,
-    /// The number of vertices in the mesh when begin was called.
-    begin_vertex_count: u32,
-    /// The number of indices in the mesh when begin was called.
-    begin_index_count: u32,
-    /// Transform matrix that also integrates position and orientation here.
-    transform: Mat4,
-    /// The way in which vertex attributes should be sourced.
-    attributes: A,
-}
-
-pub struct SingleColor(draw::mesh::vertex::Color);
-pub struct ColorPerPoint;
-pub struct TexCoordsPerPoint;
-
-impl<'a, A> MeshBuilder<'a, A> {
-    /// Begin extending the mesh.
-    fn new(mesh: &'a mut draw::Mesh, transform: Mat4, attributes: A) -> Self {
-        MeshBuilder {
-            mesh,
-            begin_vertex_count: 0,
-            begin_index_count: 0,
-            transform,
-            attributes,
-        }
-    }
-}
-
-impl<'a> MeshBuilder<'a, SingleColor> {
-    /// Begin extending a mesh rendered with a single colour.
-    pub fn single_color(
-        mesh: &'a mut draw::Mesh,
-        transform: Mat4,
-        color: draw::mesh::vertex::Color,
-    ) -> Self {
-        Self::new(mesh, transform, SingleColor(color))
-    }
-}
-
-impl<'a> MeshBuilder<'a, ColorPerPoint> {
-    /// Begin extending a mesh where the path interpolates a unique color per point.
-    pub fn color_per_point(mesh: &'a mut draw::Mesh, transform: Mat4) -> Self {
-        Self::new(mesh, transform, ColorPerPoint)
-    }
-}
-
-impl<'a> MeshBuilder<'a, TexCoordsPerPoint> {
-    /// Begin extending a mesh where the path interpolates a unique texture coordinates per point.
-    pub fn tex_coords_per_point(mesh: &'a mut draw::Mesh, transform: Mat4) -> Self {
-        Self::new(mesh, transform, TexCoordsPerPoint)
-    }
-}
-
-impl<'a, A> GeometryBuilder for MeshBuilder<'a, A> {
-    fn begin_geometry(&mut self) {
-        self.begin_vertex_count = self.mesh.points().len() as u32;
-        self.begin_index_count = self.mesh.indices().len() as u32;
-    }
-
-    fn end_geometry(&mut self) -> geometry_builder::Count {
-        geometry_builder::Count {
-            vertices: self.mesh.points().len() as u32 - self.begin_vertex_count,
-            indices: self.mesh.indices().len() as u32 - self.begin_index_count,
-        }
-    }
-
-    fn add_triangle(&mut self, a: VertexId, b: VertexId, c: VertexId) {
-        self.mesh.push_index(a.to_usize() as u32);
-        self.mesh.push_index(b.to_usize() as u32);
-        self.mesh.push_index(c.to_usize() as u32);
-    }
-
-    fn abort_geometry(&mut self) {
-        unimplemented!();
-    }
-}
-
-impl<'a> FillGeometryBuilder for MeshBuilder<'a, SingleColor> {
-    fn add_fill_vertex(&mut self, vertex: FillVertex) -> Result<VertexId, GeometryBuilderError> {
-        // Retrieve the index.
-        let id = VertexId::from_usize(self.mesh.points().len());
-
-        let position = vertex.position();
-
-        // Construct and insert the point
-        let p = Point2::new(position.x, position.y).extend(0.0);
-        let point = self.transform.transform_point3(p);
-        let SingleColor(color) = self.attributes;
-        let tex_coords = draw::mesh::vertex::default_tex_coords();
-        let vertex = draw::mesh::vertex::new(point, color, tex_coords);
-        self.mesh.push_vertex(vertex);
-
-        // Return the index.
-        Ok(id)
-    }
-}
-
-impl<'a> StrokeGeometryBuilder for MeshBuilder<'a, SingleColor> {
-    fn add_stroke_vertex(
-        &mut self,
-        vertex: StrokeVertex,
-    ) -> Result<VertexId, GeometryBuilderError> {
-        // Retrieve the index.
-        let id = VertexId::from_usize(self.mesh.points().len());
-
-        let position = vertex.position();
-
-        // Construct and insert the point
-        let p = Point2::new(position.x, position.y).extend(0.0);
-        let point = self.transform.transform_point3(p);
-        let SingleColor(color) = self.attributes;
-        let tex_coords = draw::mesh::vertex::default_tex_coords();
-        let vertex = draw::mesh::vertex::new(point, color, tex_coords);
-        self.mesh.push_vertex(vertex);
-
-        // Return the index.
-        Ok(id)
-    }
-}
-
-impl<'a> FillGeometryBuilder for MeshBuilder<'a, ColorPerPoint> {
-    fn add_fill_vertex(
-        &mut self,
-        mut vertex: FillVertex,
-    ) -> Result<VertexId, GeometryBuilderError> {
-        // Retrieve the index.
-        let id = VertexId::from_usize(self.mesh.points().len());
-
-        let position = vertex.position();
-
-        // Construct and insert the point
-        let p = Point2::new(position.x, position.y).extend(0.0);
-        let point = self.transform.transform_point3(p);
-        let col = vertex.interpolated_attributes();
-        let color: draw::mesh::vertex::Color = (col[0], col[1], col[2], col[3]).into();
-        let tex_coords = draw::mesh::vertex::default_tex_coords();
-        let vertex = draw::mesh::vertex::new(point, color, tex_coords);
-        self.mesh.push_vertex(vertex);
-
-        // Return the index.
-        Ok(id)
-    }
-}
-
-impl<'a> StrokeGeometryBuilder for MeshBuilder<'a, ColorPerPoint> {
-    fn add_stroke_vertex(
-        &mut self,
-        mut vertex: StrokeVertex,
-    ) -> Result<VertexId, GeometryBuilderError> {
-        // Retrieve the index.
-        let id = VertexId::from_usize(self.mesh.points().len());
-
-        let position = vertex.position();
-
-        // Construct and insert the point
-        let p = Point2::new(position.x, position.y).extend(0.0);
-        let point = self.transform.transform_point3(p);
-        let col = vertex.interpolated_attributes();
-        let color: draw::mesh::vertex::Color = (col[0], col[1], col[2], col[3]).into();
-        let tex_coords = draw::mesh::vertex::default_tex_coords();
-        let vertex = draw::mesh::vertex::new(point, color, tex_coords);
-        self.mesh.push_vertex(vertex);
-
-        // Return the index.
-        Ok(id)
-    }
-}
-
-impl<'a> FillGeometryBuilder for MeshBuilder<'a, TexCoordsPerPoint> {
-    fn add_fill_vertex(
-        &mut self,
-        mut vertex: FillVertex,
-    ) -> Result<VertexId, GeometryBuilderError> {
-        // Retrieve the index.
-        let id = VertexId::from_usize(self.mesh.points().len());
-
-        let position = vertex.position();
-
-        // Construct and insert the point
-        let p = Point2::new(position.x, position.y).extend(0.0);
-        let point = self.transform.transform_point3(p);
-        let tc = vertex.interpolated_attributes();
-        let tex_coords: draw::mesh::vertex::TexCoords = (tc[0], tc[1]).into();
-        let color = draw::mesh::vertex::DEFAULT_VERTEX_COLOR;
-        let vertex = draw::mesh::vertex::new(point, color, tex_coords);
-        self.mesh.push_vertex(vertex);
-
-        // Return the index.
-        Ok(id)
-    }
-}
-
-impl<'a> StrokeGeometryBuilder for MeshBuilder<'a, TexCoordsPerPoint> {
-    fn add_stroke_vertex(
-        &mut self,
-        mut vertex: StrokeVertex,
-    ) -> Result<VertexId, GeometryBuilderError> {
-        // Retrieve the index.
-        let id = VertexId::from_usize(self.mesh.points().len());
-
-        let position = vertex.position();
-
-        // Construct and insert the point
-        let p = Point2::new(position.x, position.y).extend(0.0);
-        let point = self.transform.transform_point3(p);
-        let tc = vertex.interpolated_attributes();
-        let tex_coords: draw::mesh::vertex::TexCoords = (tc[0], tc[1]).into();
-        let color = draw::mesh::vertex::DEFAULT_VERTEX_COLOR;
-        let vertex = draw::mesh::vertex::new(point, color, tex_coords);
-        self.mesh.push_vertex(vertex);
-
-        // Return the index.
-        Ok(id)
-    }
-}
diff --git a/nannou/src/draw/mesh/mod.rs b/nannou/src/draw/mesh/mod.rs
deleted file mode 100644
index 3bc07f73e..000000000
--- a/nannou/src/draw/mesh/mod.rs
+++ /dev/null
@@ -1,279 +0,0 @@
-//! Items related to the custom mesh type used by the `Draw` API.
-
-use crate::geom;
-use crate::mesh::{self, MeshPoints, WithColors, WithIndices, WithTexCoords};
-use std::ops::{Deref, DerefMut};
-
-pub mod builder;
-pub mod vertex;
-
-pub use self::builder::MeshBuilder;
-pub use self::vertex::Vertex;
-
-pub type Points = Vec<vertex::Point>;
-pub type Indices = Vec<u32>;
-pub type Colors = Vec<vertex::Color>;
-pub type TexCoords = Vec<vertex::TexCoords>;
-
-/// The inner mesh type used by the **draw::Mesh**.
-pub type MeshType =
-    WithTexCoords<WithColors<WithIndices<MeshPoints<Points>, Indices>, Colors>, TexCoords>;
-
-/// The custom mesh type used internally by the **Draw** API.
-#[derive(Clone, Debug)]
-pub struct Mesh {
-    mesh: MeshType,
-}
-
-impl Mesh {
-    /// The number of raw vertices contained within the mesh.
-    pub fn raw_vertex_count(&self) -> usize {
-        mesh::raw_vertex_count(self)
-    }
-
-    /// The number of vertices that would be yielded by a **Vertices** iterator for the given mesh.
-    pub fn vertex_count(&self) -> usize {
-        mesh::vertex_count(self)
-    }
-
-    /// The number of triangles that would be yielded by a **Triangles** iterator for the given mesh.
-    pub fn triangle_count(&self) -> usize {
-        mesh::triangle_count(self)
-    }
-
-    /// The **Mesh**'s vertex position channel.
-    pub fn points(&self) -> &[vertex::Point] {
-        mesh::Points::points(self)
-    }
-
-    /// The **Mesh**'s vertex indices channel.
-    pub fn indices(&self) -> &[u32] {
-        mesh::Indices::indices(self)
-    }
-
-    /// The **Mesh**'s vertex colors channel.
-    pub fn colors(&self) -> &[vertex::Color] {
-        mesh::Colors::colors(self)
-    }
-
-    /// The **Mesh**'s vertex texture coordinates channel.
-    pub fn tex_coords(&self) -> &[vertex::TexCoords] {
-        mesh::TexCoords::tex_coords(self)
-    }
-
-    /// Push the given vertex onto the inner channels.
-    pub fn push_vertex(&mut self, v: Vertex) {
-        mesh::push_vertex(self, v);
-    }
-
-    /// Push the given index onto the inner **Indices** channel.
-    pub fn push_index(&mut self, i: u32) {
-        mesh::push_index(self, i);
-    }
-
-    /// Extend the mesh channels with the given vertices.
-    pub fn extend_vertices<I>(&mut self, vs: I)
-    where
-        I: IntoIterator<Item = Vertex>,
-    {
-        mesh::extend_vertices(self, vs);
-    }
-
-    /// Extend the **Mesh** indices channel with the given indices.
-    pub fn extend_indices<I>(&mut self, is: I)
-    where
-        I: IntoIterator<Item = u32>,
-    {
-        mesh::extend_indices(self, is);
-    }
-
-    /// Extend the **Mesh** with the given vertices and indices.
-    pub fn extend<V, I>(&mut self, vs: V, is: I)
-    where
-        V: IntoIterator<Item = Vertex>,
-        I: IntoIterator<Item = u32>,
-    {
-        self.extend_vertices(vs);
-        self.extend_indices(is);
-    }
-
-    /// Clear all vertices from the mesh.
-    pub fn clear_vertices(&mut self) {
-        mesh::clear_vertices(self);
-    }
-
-    /// Clear all indices from the mesh.
-    pub fn clear_indices(&mut self) {
-        mesh::clear_indices(self);
-    }
-
-    /// Clear all vertices and indices from the mesh.
-    pub fn clear(&mut self) {
-        mesh::clear(self);
-    }
-
-    /// Produce an iterator yielding all raw (non-index-order) vertices.
-    pub fn raw_vertices(&self) -> mesh::RawVertices<&Self> {
-        mesh::raw_vertices(self)
-    }
-
-    /// Consume self and produce an iterator yielding all raw (non-index_order) vertices.
-    pub fn into_raw_vertices(self) -> mesh::RawVertices<Self> {
-        mesh::raw_vertices(self)
-    }
-
-    /// Extend the mesh from the given slices.
-    ///
-    /// This is faster than `extend` which uses iteration internally.
-    ///
-    /// **Panic!**s if the length of the given points, colors and tex_coords slices do not match.
-    pub fn extend_from_slices(
-        &mut self,
-        points: &[vertex::Point],
-        indices: &[u32],
-        colors: &[vertex::Color],
-        tex_coords: &[vertex::TexCoords],
-    ) {
-        assert_eq!(points.len(), colors.len());
-        assert_eq!(points.len(), tex_coords.len());
-        let slices = (tex_coords, (colors, (indices, points)));
-        mesh::ExtendFromSlice::extend_from_slice(&mut self.mesh, slices);
-    }
-
-    /// Extend the mesh with the given slices of vertices.
-    pub fn extend_vertices_from_slices(
-        &mut self,
-        points: &[vertex::Point],
-        colors: &[vertex::Color],
-        tex_coords: &[vertex::TexCoords],
-    ) {
-        self.extend_from_slices(points, &[], colors, tex_coords);
-    }
-
-    /// Extend the mesh with the given slices of vertices.
-    pub fn extend_indices_from_slice(&mut self, indices: &[u32]) {
-        self.extend_from_slices(&[], indices, &[], &[]);
-    }
-
-    /// Produce an iterator yielding all vertices in the order specified via the vertex indices.
-    pub fn vertices(&self) -> mesh::Vertices<&Self> {
-        mesh::vertices(self)
-    }
-
-    /// Produce an iterator yielding all triangles.
-    pub fn triangles(&self) -> mesh::Triangles<&Self> {
-        mesh::triangles(self)
-    }
-
-    /// Consume self and produce an iterator yielding all vertices in index-order.
-    pub fn into_vertices(self) -> mesh::Vertices<Self> {
-        mesh::vertices(self)
-    }
-
-    /// Consume self and produce an iterator yielding all triangles.
-    pub fn into_triangles(self) -> mesh::Triangles<Self> {
-        mesh::triangles(self)
-    }
-}
-
-impl Default for Mesh {
-    fn default() -> Self {
-        let mesh = Default::default();
-        Mesh { mesh }
-    }
-}
-
-impl Deref for Mesh {
-    type Target = MeshType;
-    fn deref(&self) -> &Self::Target {
-        &self.mesh
-    }
-}
-
-impl DerefMut for Mesh {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.mesh
-    }
-}
-
-impl mesh::GetVertex<u32> for Mesh {
-    type Vertex = Vertex;
-    fn get_vertex(&self, index: u32) -> Option<Self::Vertex> {
-        mesh::WithTexCoords::get_vertex(&self.mesh, index)
-    }
-}
-
-impl mesh::Points for Mesh {
-    type Point = vertex::Point;
-    type Points = Points;
-    fn points(&self) -> &Self::Points {
-        self.mesh.points()
-    }
-}
-
-impl mesh::Indices for Mesh {
-    type Index = u32;
-    type Indices = Indices;
-    fn indices(&self) -> &Self::Indices {
-        self.mesh.indices()
-    }
-}
-
-impl mesh::Colors for Mesh {
-    type Color = vertex::Color;
-    type Colors = Colors;
-    fn colors(&self) -> &Self::Colors {
-        self.mesh.colors()
-    }
-}
-
-impl mesh::TexCoords for Mesh {
-    type TexCoord = geom::Point2;
-    type TexCoords = TexCoords;
-    fn tex_coords(&self) -> &Self::TexCoords {
-        self.mesh.tex_coords()
-    }
-}
-
-impl mesh::PushVertex<Vertex> for Mesh {
-    fn push_vertex(&mut self, v: Vertex) {
-        self.mesh.push_vertex(v);
-    }
-}
-
-impl mesh::PushIndex for Mesh {
-    type Index = u32;
-
-    fn push_index(&mut self, index: Self::Index) {
-        self.mesh.push_index(index);
-    }
-
-    fn extend_indices<I>(&mut self, indices: I)
-    where
-        I: IntoIterator<Item = Self::Index>,
-    {
-        self.mesh.extend_indices(indices);
-    }
-}
-
-impl mesh::ClearIndices for Mesh {
-    fn clear_indices(&mut self) {
-        self.mesh.clear_indices();
-    }
-}
-
-impl mesh::ClearVertices for Mesh {
-    fn clear_vertices(&mut self) {
-        self.mesh.clear_vertices();
-    }
-}
-
-#[test]
-fn test_method_access() {
-    let mesh: Mesh = Default::default();
-    assert_eq!(None, mesh::GetVertex::get_vertex(&mesh, 0));
-    mesh::Points::points(&mesh);
-    mesh::Indices::indices(&mesh);
-    mesh::Colors::colors(&mesh);
-    mesh::TexCoords::tex_coords(&mesh);
-}
diff --git a/nannou/src/draw/mesh/vertex.rs b/nannou/src/draw/mesh/vertex.rs
deleted file mode 100644
index e72274b4e..000000000
--- a/nannou/src/draw/mesh/vertex.rs
+++ /dev/null
@@ -1,177 +0,0 @@
-use crate::color;
-use crate::geom::{Point2, Point3, Vec3};
-use crate::mesh::vertex::{WithColor, WithTexCoords};
-
-pub type Point = Point3;
-pub type Color = color::LinSrgba;
-pub type TexCoords = Point2;
-pub type Normal = Vec3;
-pub type ColoredPoint = WithColor<Point, Color>;
-pub type ColoredPoint2 = WithColor<Point2, Color>;
-
-/// The vertex type produced by the **draw::Mesh**'s inner **MeshType**.
-pub type Vertex = WithTexCoords<WithColor<Point, Color>, TexCoords>;
-
-/// The number of channels in the color type.
-pub const COLOR_CHANNEL_COUNT: usize = 4;
-
-pub const DEFAULT_VERTEX_COLOR: Color = color::Alpha {
-    color: color::rgb::Rgb {
-        red: 1.0,
-        green: 1.0,
-        blue: 1.0,
-        standard: std::marker::PhantomData,
-    },
-    alpha: 1.0,
-};
-
-/// Simplified constructor for a **draw::mesh::Vertex**.
-pub fn new(point: Point, color: Color, tex_coords: TexCoords) -> Vertex {
-    WithTexCoords {
-        tex_coords,
-        vertex: WithColor {
-            color,
-            vertex: point,
-        },
-    }
-}
-
-/// Default texture coordinates, for the case where a type is not textured.
-pub fn default_tex_coords() -> TexCoords {
-    [0.0; 2].into()
-}
-
-/// A type that converts an iterator yielding colored points to an iterator yielding **Vertex**s.
-///
-/// Default values are used for tex_coords.
-#[derive(Clone, Debug)]
-pub struct IterFromColoredPoints<I> {
-    colored_points: I,
-}
-
-impl<I> IterFromColoredPoints<I> {
-    /// Produce an iterator that converts an iterator yielding colored points to an iterator
-    /// yielding **Vertex**s.
-    ///
-    /// The default value of `(0.0, 0.0)` is used for tex_coords.
-    pub fn new<P>(colored_points: P) -> Self
-    where
-        P: IntoIterator<IntoIter = I, Item = WithColor<Point, Color>>,
-        I: Iterator<Item = WithColor<Point, Color>>,
-    {
-        let colored_points = colored_points.into_iter();
-        IterFromColoredPoints { colored_points }
-    }
-}
-
-impl<I> Iterator for IterFromColoredPoints<I>
-where
-    I: Iterator<Item = WithColor<Point, Color>>,
-{
-    type Item = Vertex;
-    fn next(&mut self) -> Option<Self::Item> {
-        self.colored_points.next().map(|vertex| {
-            let tex_coords = default_tex_coords();
-            let vertex = WithTexCoords { tex_coords, vertex };
-            vertex
-        })
-    }
-}
-
-/// A type that converts an iterator yielding points to an iterator yielding **Vertex**s.
-///
-/// The given `default_color` is used to color every vertex.
-///
-/// The default value of `(0.0, 0.0)` is used for tex_coords.
-#[derive(Clone, Debug)]
-pub struct IterFromPoints<I> {
-    points: I,
-    default_color: Color,
-}
-
-/// A type that converts an iterator yielding 2D points to an iterator yielding **Vertex**s.
-///
-/// The `z` position for each vertex will be `0.0`.
-///
-/// The given `default_color` is used to color every vertex.
-///
-/// The default value of `(0.0, 0.0)` is used for tex_coords.
-#[derive(Clone, Debug)]
-pub struct IterFromPoint2s<I> {
-    points: I,
-    default_color: Color,
-}
-
-impl<I> IterFromPoints<I> {
-    /// Produce an iterator that converts an iterator yielding points to an iterator yielding
-    /// **Vertex**s.
-    ///
-    /// The given `default_color` is used to color every vertex.
-    ///
-    /// The default value of `(0.0, 0.0)` is used for tex_coords.
-    pub fn new<P>(points: P, default_color: Color) -> Self
-    where
-        P: IntoIterator<IntoIter = I, Item = Point>,
-        I: Iterator<Item = Point3>,
-    {
-        let points = points.into_iter();
-        IterFromPoints {
-            points,
-            default_color,
-        }
-    }
-}
-
-impl<I> IterFromPoint2s<I> {
-    /// A type that converts an iterator yielding 2D points to an iterator yielding **Vertex**s.
-    ///
-    /// The `z` position for each vertex will be `0.0`.
-    ///
-    /// The given `default_color` is used to color every vertex.
-    ///
-    /// The default value of `(0.0, 0.0)` is used for tex_coords.
-    pub fn new<P>(points: P, default_color: Color) -> Self
-    where
-        P: IntoIterator<IntoIter = I, Item = Point2>,
-        I: Iterator<Item = Point2>,
-    {
-        let points = points.into_iter();
-        IterFromPoint2s {
-            points,
-            default_color,
-        }
-    }
-}
-
-impl<I> Iterator for IterFromPoints<I>
-where
-    I: Iterator<Item = Point>,
-{
-    type Item = Vertex;
-    fn next(&mut self) -> Option<Self::Item> {
-        self.points.next().map(|vertex| {
-            let color = self.default_color;
-            let vertex = WithColor { vertex, color };
-            let tex_coords = default_tex_coords();
-            let vertex = WithTexCoords { vertex, tex_coords };
-            vertex
-        })
-    }
-}
-
-impl<I> Iterator for IterFromPoint2s<I>
-where
-    I: Iterator<Item = Point2>,
-{
-    type Item = Vertex;
-    fn next(&mut self) -> Option<Self::Item> {
-        self.points.next().map(|p| {
-            let vertex = p.extend(0.0);
-            let color = self.default_color;
-            let vertex = WithColor { vertex, color };
-            let tex_coords = default_tex_coords();
-            let vertex = WithTexCoords { vertex, tex_coords };
-            vertex
-        })
-    }
-}
diff --git a/nannou/src/draw/mod.rs b/nannou/src/draw/mod.rs
deleted file mode 100644
index aee06422c..000000000
--- a/nannou/src/draw/mod.rs
+++ /dev/null
@@ -1,654 +0,0 @@
-//! A simple API for drawing 2D and 3D graphics.
-//!
-//! See the [**Draw** type](./struct.Draw.html) for more details.
-
-use crate::geom::{self, Point2};
-use crate::glam::{vec3, EulerRot, Mat4, Quat, Vec2, Vec3};
-use crate::math::{deg_to_rad, turns_to_rad};
-use crate::wgpu;
-use lyon::path::PathEvent;
-use std::cell::RefCell;
-use std::collections::HashMap;
-use std::mem;
-use std::rc::Rc;
-
-pub use self::background::Background;
-pub use self::drawing::{Drawing, DrawingContext};
-use self::mesh::vertex::{Color, TexCoords};
-pub use self::mesh::Mesh;
-use self::primitive::Primitive;
-pub use self::renderer::{Builder as RendererBuilder, Renderer};
-pub use self::theme::Theme;
-
-pub mod background;
-mod drawing;
-pub mod mesh;
-pub mod primitive;
-pub mod properties;
-pub mod renderer;
-pub mod theme;
-
-/// A simple API for drawing 2D and 3D graphics.
-///
-/// **Draw** provides a simple way to compose together geometry and text with custom colours and
-/// textures and draw them to the screen. A suite of methods have been provided for drawing
-/// polygons, paths, meshes, text and textures in an accessible-yet-efficient manner.
-///
-/// **Draw** can also be used to create new **Draw** instances that refer to the same inner draw
-/// state but are slightly different from one another. E.g. `draw.rotate(radians)` produces a new
-/// **Draw** instance where all drawings will be rotated by the given amount. `draw.x(x)` produces
-/// a new **Draw** instance where all drawings are translated along the *x* axis by the given
-/// amount.
-///
-/// See the [draw](https://github.com/nannou-org/nannou/blob/master/examples) examples for a
-/// variety of demonstrations of how the **Draw** type can be used!
-#[derive(Clone, Debug)]
-pub struct Draw {
-    /// The state of the **Draw**.
-    ///
-    /// State is shared between this **Draw** instance and all other **Draw** instances that were
-    /// produced by cloning or changing transform, scissor or blend mode.
-    ///
-    /// We use a `RefCell` in order to avoid requiring a `mut` handle to a `draw`. The primary
-    /// purpose of a **Draw** is to be an easy-as-possible, high-level API for drawing stuff. In
-    /// order to be friendlier to new users, we want to avoid them having to think about mutability
-    /// and focus on creativity. Rust-lang nuances can come later.
-    state: Rc<RefCell<State>>,
-    /// The current context of this **Draw** instance.
-    context: Context,
-}
-
-/// The current **Transform**, alpha **BlendState** and **Scissor** of a **Draw** instance.
-#[derive(Clone, Debug, PartialEq)]
-pub struct Context {
-    pub transform: Mat4,
-    pub blend: wgpu::BlendState,
-    pub scissor: Scissor,
-    // TODO: Consider changing `PolygonMode` (added as of wgpu 0.7) rather than `PrimitiveTopology`
-    // here.
-    pub topology: wgpu::PrimitiveTopology,
-    pub sampler: wgpu::SamplerDescriptor<'static>,
-}
-
-/// Commands generated by drawings.
-///
-/// During rendering, the list of **DrawCommand**s are converted into a list of **RenderCommands**
-/// that are directly associated with encodable render pass commands.
-#[derive(Clone, Debug)]
-pub enum DrawCommand {
-    /// Draw a primitive.
-    Primitive(Primitive),
-    /// A change in the rendering context occurred.
-    Context(Context),
-}
-
-/// The scissor for a **Draw**'s render context.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum Scissor {
-    /// The extent of the scissor matches the bounds of the target texture.
-    Full,
-    /// Crop the view to the given rect.
-    Rect(geom::Rect),
-    /// The scissor has no overlap with the previous window, resulting in nothing to draw.
-    NoOverlap,
-}
-
-/// The inner state of the **Draw** type.
-///
-/// The **Draw** type stores its **State** behind a **RefCell** - a type used for moving mutability
-/// checks from compile time to runtime. We do this in order to avoid requiring a `mut` handle to a
-/// `draw`. The primary purpose of a **Draw** is to be an easy-as-possible, high-level API for
-/// drawing stuff. In order to be friendlier to new users, we want to avoid requiring them to think
-/// about mutability and instead focus on creativity. Rust-lang nuances can come later.
-#[derive(Clone, Debug)]
-pub struct State {
-    /// The last context used to draw an image, used to detect changes and emit commands for them.
-    last_draw_context: Option<Context>,
-    /// If `Some`, the **Draw** should first clear the frame's texture with the given color.
-    background_color: Option<properties::LinSrgba>,
-    /// Primitives that are in the process of being drawn.
-    ///
-    /// Keys are indices into the `draw_commands` Vec.
-    drawing: HashMap<usize, Primitive>,
-    /// The list of recorded draw commands.
-    ///
-    /// An element may be `None` if it is a primitive in the process of being drawn.
-    draw_commands: Vec<Option<DrawCommand>>,
-    /// State made accessible via the `DrawingContext`.
-    intermediary_state: RefCell<IntermediaryState>,
-    /// The theme containing default values.
-    theme: Theme,
-}
-
-/// State made accessible via the `DrawingContext`.
-#[derive(Clone, Debug)]
-pub struct IntermediaryState {
-    /// Buffers of vertex data that may be re-used for paths, meshes, etc between view calls.
-    intermediary_mesh: Mesh,
-    /// A re-usable buffer for collecting path events.
-    path_event_buffer: Vec<PathEvent>,
-    /// A re-usable buffer for collecting colored polyline points.
-    path_points_colored_buffer: Vec<(Point2, Color)>,
-    /// A re-usable buffer for collecting textured polyline points.
-    path_points_textured_buffer: Vec<(Point2, TexCoords)>,
-    /// A buffer containing all text.
-    text_buffer: String,
-}
-
-impl IntermediaryState {
-    pub fn reset(&mut self) {
-        self.intermediary_mesh.clear();
-        self.path_event_buffer.clear();
-        self.path_points_colored_buffer.clear();
-        self.path_points_textured_buffer.clear();
-        self.text_buffer.clear();
-    }
-}
-
-impl State {
-    // Resets all state within the `Draw` instance.
-    fn reset(&mut self) {
-        self.background_color = None;
-        self.last_draw_context = None;
-        self.drawing.clear();
-        self.draw_commands.clear();
-        self.intermediary_state.borrow_mut().reset();
-    }
-
-    // Drain any remaining `drawing`s and insert them as draw commands.
-    fn finish_remaining_drawings(&mut self) {
-        let mut drawing = mem::replace(&mut self.drawing, Default::default());
-        for (index, primitive) in drawing.drain() {
-            self.insert_draw_command(index, primitive);
-        }
-        mem::swap(&mut self.drawing, &mut drawing);
-    }
-
-    // Finish the drawing at the given node index if it is not yet complete.
-    pub(crate) fn finish_drawing(&mut self, index: usize) {
-        if let Some(primitive) = self.drawing.remove(&index) {
-            self.insert_draw_command(index, primitive);
-        }
-    }
-
-    // Insert the draw primitive command at the given index.
-    fn insert_draw_command(&mut self, index: usize, prim: Primitive) {
-        if let Some(elem) = self.draw_commands.get_mut(index) {
-            *elem = Some(DrawCommand::Primitive(prim));
-        }
-    }
-}
-
-impl Draw {
-    /// Create a new **Draw** instance.
-    ///
-    /// This is the same as calling **Draw::default**.
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Resets all state within the `Draw` instance.
-    pub fn reset(&self) {
-        self.state.borrow_mut().reset();
-    }
-
-    // Context changes.
-
-    /// Produce a new **Draw** instance transformed by the given transform matrix.
-    ///
-    /// The resulting **Draw** instance will be have a transform equal to the new transform applied
-    /// to the existing transform.
-    pub fn transform(&self, transform_matrix: Mat4) -> Self {
-        let mut context = self.context.clone();
-        context.transform = context.transform * transform_matrix;
-        self.context(context)
-    }
-
-    /// Translate the position of the origin by the given translation vector.
-    pub fn translate(&self, v: Vec3) -> Self {
-        self.transform(Mat4::from_translation(v))
-    }
-
-    /// Translate the position of the origin by the given translation vector.
-    ///
-    /// This method is short for `translate`.
-    pub fn xyz(&self, v: Vec3) -> Self {
-        self.translate(v)
-    }
-
-    /// Translate the position of the origin by the given translation vector.
-    pub fn xy(&self, v: Vec2) -> Self {
-        self.xyz(v.extend(0.0))
-    }
-
-    /// Translate the position of the origin by the given amount across each axis.
-    pub fn x_y_z(&self, x: f32, y: f32, z: f32) -> Self {
-        self.xyz([x, y, z].into())
-    }
-
-    /// Translate the position of the origin by the given amount across each axis.
-    pub fn x_y(&self, x: f32, y: f32) -> Self {
-        self.xy([x, y].into())
-    }
-
-    /// Translate the position of the origin along the x axis.
-    pub fn x(&self, x: f32) -> Self {
-        self.x_y(x, 0.0)
-    }
-
-    /// Translate the position of the origin along the y axis.
-    pub fn y(&self, y: f32) -> Self {
-        self.x_y(0.0, y)
-    }
-
-    /// Translate the position of the origin along the z axis.
-    pub fn z(&self, z: f32) -> Self {
-        self.x_y_z(0.0, 0.0, z)
-    }
-
-    /// Produce a new **Draw** instance where the contents are scaled uniformly by the given value.
-    pub fn scale(&self, s: f32) -> Self {
-        self.scale_axes(vec3(s, s, s))
-    }
-
-    /// Produce a new **Draw** instance where the contents are scaled by the given amount across
-    /// each axis.
-    pub fn scale_axes(&self, v: Vec3) -> Self {
-        self.transform(Mat4::from_scale(v))
-    }
-
-    /// Produce a new **Draw** instance where the contents are scaled by the given amount along the
-    /// x axis
-    pub fn scale_x(&self, s: f32) -> Self {
-        self.scale_axes(vec3(s, 1.0, 1.0))
-    }
-
-    /// Produce a new **Draw** instance where the contents are scaled by the given amount along the
-    /// y axis
-    pub fn scale_y(&self, s: f32) -> Self {
-        self.scale_axes(vec3(1.0, s, 1.0))
-    }
-
-    /// Produce a new **Draw** instance where the contents are scaled by the given amount along the
-    /// z axis
-    pub fn scale_z(&self, s: f32) -> Self {
-        self.scale_axes(vec3(1.0, 1.0, s))
-    }
-
-    /// The given vector is interpreted as a Euler angle in radians and a transform is applied
-    /// accordingly.
-    pub fn euler(&self, euler: Vec3) -> Self {
-        self.transform(Mat4::from_euler(EulerRot::XYZ, euler.x, euler.y, euler.z))
-    }
-
-    /// Specify the orientation with the given **Quaternion**.
-    pub fn quaternion(&self, q: Quat) -> Self {
-        self.transform(Mat4::from_quat(q))
-    }
-
-    /// Specify the orientation along each axis with the given **Vector** of radians.
-    ///
-    /// This currently has the same affect as calling `euler`.
-    pub fn radians(&self, v: Vec3) -> Self {
-        self.euler(v)
-    }
-
-    /// Specify the orientation around the *x* axis in radians.
-    pub fn x_radians(&self, x: f32) -> Self {
-        self.radians(vec3(x, 0.0, 0.0))
-    }
-
-    /// Specify the orientation around the *y* axis in radians.
-    pub fn y_radians(&self, y: f32) -> Self {
-        self.radians(vec3(0.0, y, 0.0))
-    }
-
-    /// Specify the orientation around the *z* axis in radians.
-    pub fn z_radians(&self, z: f32) -> Self {
-        self.radians(vec3(0.0, 0.0, z))
-    }
-
-    /// Specify the orientation along each axis with the given **Vector** of degrees.
-    pub fn degrees(&self, v: Vec3) -> Self {
-        self.radians(vec3(deg_to_rad(v.x), deg_to_rad(v.y), deg_to_rad(v.z)))
-    }
-
-    /// Specify the orientation around the *x* axis in degrees.
-    pub fn x_degrees(&self, x: f32) -> Self {
-        self.x_radians(deg_to_rad(x))
-    }
-
-    /// Specify the orientation around the *y* axis in degrees.
-    pub fn y_degrees(&self, y: f32) -> Self {
-        self.y_radians(deg_to_rad(y))
-    }
-
-    /// Specify the orientation around the *z* axis in degrees.
-    pub fn z_degrees(&self, z: f32) -> Self {
-        self.z_radians(deg_to_rad(z))
-    }
-
-    /// Specify the orientation along each axis with the given **Vector** of degrees.
-    pub fn turns(&self, v: Vec3) -> Self {
-        self.radians(vec3(
-            turns_to_rad(v.x),
-            turns_to_rad(v.y),
-            turns_to_rad(v.z),
-        ))
-    }
-
-    /// Specify the orientation around the *x* axis as a number of turns around the axis.
-    pub fn x_turns(&self, x: f32) -> Self {
-        self.x_radians(turns_to_rad(x))
-    }
-
-    /// Specify the orientation around the *y* axis as a number of turns around the axis.
-    pub fn y_turns(&self, y: f32) -> Self {
-        self.y_radians(turns_to_rad(y))
-    }
-
-    /// Specify the orientation around the *z* axis as a number of turns around the axis.
-    pub fn z_turns(&self, z: f32) -> Self {
-        self.z_radians(turns_to_rad(z))
-    }
-
-    /// Specify the "pitch" of the orientation in radians.
-    ///
-    /// This has the same effect as calling `x_radians`.
-    pub fn pitch(&self, pitch: f32) -> Self {
-        self.x_radians(pitch)
-    }
-
-    /// Specify the "yaw" of the orientation in radians.
-    ///
-    /// This has the same effect as calling `y_radians`.
-    pub fn yaw(&self, yaw: f32) -> Self {
-        self.y_radians(yaw)
-    }
-
-    /// Specify the "roll" of the orientation in radians.
-    ///
-    /// This has the same effect as calling `z_radians`.
-    pub fn roll(&self, roll: f32) -> Self {
-        self.z_radians(roll)
-    }
-
-    /// Assuming we're looking at a 2D plane, positive values cause a clockwise rotation where the
-    /// given value is specified in radians.
-    ///
-    /// This is equivalent to calling the `z_radians` or `roll` methods.
-    pub fn rotate(&self, radians: f32) -> Self {
-        self.z_radians(radians)
-    }
-
-    /// Produce a new **Draw** instance that will draw with the given alpha blend descriptor.
-    pub fn alpha_blend(&self, blend_descriptor: wgpu::BlendComponent) -> Self {
-        let mut context = self.context.clone();
-        context.blend.alpha = blend_descriptor;
-        self.context(context)
-    }
-
-    /// Produce a new **Draw** instance that will draw with the given color blend descriptor.
-    pub fn color_blend(&self, blend_descriptor: wgpu::BlendComponent) -> Self {
-        let mut context = self.context.clone();
-        context.blend.color = blend_descriptor;
-        self.context(context)
-    }
-
-    /// Short-hand for `color_blend`, the common use-case.
-    pub fn blend(&self, blend_descriptor: wgpu::BlendComponent) -> Self {
-        self.color_blend(blend_descriptor)
-    }
-
-    /// Produce a new **Draw** instance that will be cropped to the given rectangle.
-    ///
-    /// If the current **Draw** instance already contains a scissor, the result will be the overlap
-    /// between the original scissor and the new one.
-    pub fn scissor(&self, scissor: geom::Rect<f32>) -> Self {
-        let mut context = self.context.clone();
-        context.scissor = match context.scissor {
-            Scissor::Full => Scissor::Rect(scissor),
-            Scissor::Rect(rect) => rect
-                .overlap(scissor)
-                .map(Scissor::Rect)
-                .unwrap_or(Scissor::NoOverlap),
-            Scissor::NoOverlap => Scissor::NoOverlap,
-        };
-        self.context(context)
-    }
-
-    /// Produce a new **Draw** instance.
-    ///
-    /// All drawing that occurs on the new instance will be rendered as a "wireframe" between all
-    /// vertices.
-    ///
-    /// This will cause the **draw::Renderer** to switch render pipelines in order to use the
-    /// **LineList** primitive topology. The switch will only occur if this topology was not
-    /// already enabled.
-    pub fn line_mode(&self) -> Self {
-        self.primitive_topology(wgpu::PrimitiveTopology::LineList)
-    }
-
-    /// Produce a new **Draw** instance.
-    ///
-    /// All drawing that occurs on the new instance will be rendered as points on the vertices.
-    ///
-    /// This will cause the **draw::Renderer** to switch render pipelines in order to use the
-    /// **PointList** primitive topology. The switch will only occur if this topology was not
-    /// already enabled.
-    pub fn point_mode(&self) -> Self {
-        self.primitive_topology(wgpu::PrimitiveTopology::PointList)
-    }
-
-    /// Produce a new **Draw** instance.
-    ///
-    /// All drawing that occurs on the new instance will be rendered as triangles on the vertices.
-    ///
-    /// This will cause the **draw::Renderer** to switch render pipelines in order to use the
-    /// **TriangleList** primitive topology. The switch will only occur if this topology was not
-    /// already enabled.
-    ///
-    /// This is the default primitive topology mode.
-    pub fn triangle_mode(&self) -> Self {
-        self.primitive_topology(wgpu::PrimitiveTopology::TriangleList)
-    }
-
-    /// Produce a new **Draw** instance where all textures and textured vertices drawn will be
-    /// sampled via a sampler of the given descriptor.
-    pub fn sampler(&self, desc: wgpu::SamplerDescriptor<'static>) -> Self {
-        let mut context = self.context.clone();
-        context.sampler = desc;
-        self.context(context)
-    }
-
-    /// Specify the primitive topology to use within the render pipeline.
-    ///
-    /// This method is shared between the `line_mode`, `point_mode` and `triangle_mode` methods.
-    fn primitive_topology(&self, topology: wgpu::PrimitiveTopology) -> Self {
-        let mut context = self.context.clone();
-        context.topology = topology;
-        self.context(context)
-    }
-
-    /// Produce a new **Draw** instance with the given context.
-    fn context(&self, context: Context) -> Self {
-        let state = self.state.clone();
-        Draw { state, context }
-    }
-
-    // Primitives.
-
-    /// Specify a color with which the background should be cleared.
-    pub fn background(&self) -> Background {
-        background::new(self)
-    }
-
-    /// Add the given type to be drawn.
-    pub fn a<T>(&self, primitive: T) -> Drawing<T>
-    where
-        T: Into<Primitive>,
-        Primitive: Into<Option<T>>,
-    {
-        let index = {
-            let mut state = self.state.borrow_mut();
-            // If drawing with a different context, insert the necessary command to update it.
-            if state.last_draw_context.as_ref() != Some(&self.context) {
-                state
-                    .draw_commands
-                    .push(Some(DrawCommand::Context(self.context.clone())));
-                state.last_draw_context = Some(self.context.clone());
-            }
-            // The primitive will be inserted in the next element.
-            let index = state.draw_commands.len();
-            let primitive: Primitive = primitive.into();
-            state.draw_commands.push(None);
-            state.drawing.insert(index, primitive);
-            index
-        };
-        drawing::new(self, index)
-    }
-
-    /// Begin drawing a **Path**.
-    pub fn path(&self) -> Drawing<primitive::PathInit> {
-        self.a(Default::default())
-    }
-
-    /// Begin drawing an **Ellipse**.
-    pub fn ellipse(&self) -> Drawing<primitive::Ellipse> {
-        self.a(Default::default())
-    }
-
-    /// Begin drawing a **Line**.
-    pub fn line(&self) -> Drawing<primitive::Line> {
-        self.a(Default::default())
-    }
-
-    /// Begin drawing an **Arrow**.
-    pub fn arrow(&self) -> Drawing<primitive::Arrow> {
-        self.a(Default::default())
-    }
-
-    /// Begin drawing a **Quad**.
-    pub fn quad(&self) -> Drawing<primitive::Quad> {
-        self.a(Default::default())
-    }
-
-    /// Begin drawing a **Rect**.
-    pub fn rect(&self) -> Drawing<primitive::Rect> {
-        self.a(Default::default())
-    }
-
-    /// Begin drawing a **Triangle**.
-    pub fn tri(&self) -> Drawing<primitive::Tri> {
-        self.a(Default::default())
-    }
-
-    /// Begin drawing a **Polygon**.
-    pub fn polygon(&self) -> Drawing<primitive::PolygonInit> {
-        self.a(Default::default())
-    }
-
-    /// Begin drawing a **Mesh**.
-    pub fn mesh(&self) -> Drawing<primitive::mesh::Vertexless> {
-        self.a(Default::default())
-    }
-
-    /// Begin drawing a **Polyline**.
-    ///
-    /// Note that this is simply short-hand for `draw.path().stroke()`
-    pub fn polyline(&self) -> Drawing<primitive::PathStroke> {
-        self.path().stroke()
-    }
-
-    /// Begin drawing a **Text**.
-    pub fn text(&self, s: &str) -> Drawing<primitive::Text> {
-        let text = {
-            let state = self.state.borrow();
-            let mut intermediary_state = state.intermediary_state.borrow_mut();
-            let ctxt = DrawingContext::from_intermediary_state(&mut *intermediary_state);
-            primitive::text::Text::new(ctxt, s)
-        };
-        self.a(text)
-    }
-
-    /// Begin drawing a **Texture**.
-    pub fn texture(&self, view: &dyn wgpu::ToTextureView) -> Drawing<primitive::Texture> {
-        self.a(primitive::Texture::new(view))
-    }
-
-    /// Finish any drawings-in-progress and produce an iterator draining the inner draw commands
-    /// and yielding them by value.
-    pub fn drain_commands(&self) -> impl Iterator<Item = DrawCommand> {
-        self.finish_remaining_drawings();
-        let cmds = {
-            let mut state = self.state.borrow_mut();
-            let empty = Vec::with_capacity(state.draw_commands.len());
-            std::mem::replace(&mut state.draw_commands, empty)
-        };
-        cmds.into_iter().filter_map(|opt| opt)
-    }
-
-    /// Drain any remaining `drawing`s and convert them to draw commands.
-    pub fn finish_remaining_drawings(&self) {
-        self.state.borrow_mut().finish_remaining_drawings()
-    }
-}
-
-impl Default for IntermediaryState {
-    fn default() -> Self {
-        let intermediary_mesh = Default::default();
-        let path_event_buffer = Default::default();
-        let path_points_colored_buffer = Default::default();
-        let path_points_textured_buffer = Default::default();
-        let text_buffer = Default::default();
-        IntermediaryState {
-            intermediary_mesh,
-            path_event_buffer,
-            path_points_colored_buffer,
-            path_points_textured_buffer,
-            text_buffer,
-        }
-    }
-}
-
-impl Default for State {
-    fn default() -> Self {
-        let last_draw_context = None;
-        let background_color = Default::default();
-        let draw_commands = Default::default();
-        let drawing = Default::default();
-        let intermediary_state = RefCell::new(Default::default());
-        let theme = Default::default();
-        State {
-            last_draw_context,
-            draw_commands,
-            drawing,
-            intermediary_state,
-            theme,
-            background_color,
-        }
-    }
-}
-
-impl Default for Draw {
-    fn default() -> Self {
-        let state: Rc<RefCell<State>> = Rc::new(RefCell::new(Default::default()));
-        let context = Default::default();
-        Draw { state, context }
-    }
-}
-
-impl Default for Context {
-    fn default() -> Self {
-        Self {
-            transform: Mat4::IDENTITY,
-            blend: wgpu::BlendState {
-                color: wgpu::RenderPipelineBuilder::DEFAULT_COLOR_BLEND,
-                alpha: wgpu::RenderPipelineBuilder::DEFAULT_ALPHA_BLEND,
-            },
-            scissor: Scissor::Full,
-            topology: wgpu::RenderPipelineBuilder::DEFAULT_PRIMITIVE_TOPOLOGY,
-            sampler: wgpu::SamplerBuilder::new().into_descriptor(),
-        }
-    }
-}
diff --git a/nannou/src/draw/primitive/arrow.rs b/nannou/src/draw/primitive/arrow.rs
deleted file mode 100644
index 1296c6409..000000000
--- a/nannou/src/draw/primitive/arrow.rs
+++ /dev/null
@@ -1,263 +0,0 @@
-use crate::color::LinSrgba;
-use crate::draw::primitive::path;
-use crate::draw::primitive::Line;
-use crate::draw::primitive::Primitive;
-use crate::draw::properties::spatial::{orientation, position};
-use crate::draw::properties::{ColorScalar, SetColor, SetOrientation, SetPosition, SetStroke};
-use crate::draw::{self, Drawing};
-use crate::geom::{pt2, Point2};
-use crate::glam::vec2;
-use lyon::tessellation::StrokeOptions;
-
-/// A path containing only two points - a start and end.
-///
-/// A triangle is drawn on the end to indicate direction.
-#[derive(Clone, Debug)]
-pub struct Arrow {
-    line: Line,
-    head_length: Option<f32>,
-    head_width: Option<f32>,
-}
-
-/// The drawing context for a line.
-pub type DrawingArrow<'a> = Drawing<'a, Arrow>;
-
-impl Arrow {
-    /// Short-hand for the `stroke_weight` method.
-    pub fn weight(self, weight: f32) -> Self {
-        self.map_line(|l| l.weight(weight))
-    }
-
-    /// Short-hand for the `stroke_tolerance` method.
-    pub fn tolerance(self, tolerance: f32) -> Self {
-        self.map_line(|l| l.tolerance(tolerance))
-    }
-
-    /// Specify the start point of the arrow.
-    pub fn start(self, start: Point2) -> Self {
-        self.map_line(|l| l.start(start))
-    }
-
-    /// Specify the end point of the arrow.
-    pub fn end(self, end: Point2) -> Self {
-        self.map_line(|l| l.end(end))
-    }
-
-    /// Specify the start and end points of the arrow.
-    pub fn points(self, start: Point2, end: Point2) -> Self {
-        self.map_line(|l| l.points(start, end))
-    }
-
-    /// The length of the arrow head.
-    ///
-    /// By default, this is equal to `weight * 4.0`.
-    ///
-    /// This value will be clamped to the length of the line itself.
-    pub fn head_length(mut self, length: f32) -> Self {
-        self.head_length = Some(length);
-        self
-    }
-
-    /// The width of the arrow head.
-    ///
-    /// By default, this is equal to `weight * 2.0`.
-    pub fn head_width(mut self, width: f32) -> Self {
-        self.head_width = Some(width);
-        self
-    }
-
-    // Map the inner `PathStroke<S>` using the given function.
-    fn map_line<F>(self, map: F) -> Self
-    where
-        F: FnOnce(Line) -> Line,
-    {
-        let Arrow {
-            line,
-            head_length,
-            head_width,
-        } = self;
-        let line = map(line);
-        Arrow {
-            line,
-            head_length,
-            head_width,
-        }
-    }
-}
-
-impl<'a> DrawingArrow<'a> {
-    /// Short-hand for the `stroke_weight` method.
-    pub fn weight(self, weight: f32) -> Self {
-        self.map_ty(|ty| ty.weight(weight))
-    }
-
-    /// Short-hand for the `stroke_tolerance` method.
-    pub fn tolerance(self, tolerance: f32) -> Self {
-        self.map_ty(|ty| ty.tolerance(tolerance))
-    }
-
-    /// Specify the start point of the arrow.
-    pub fn start(self, start: Point2) -> Self {
-        self.map_ty(|ty| ty.start(start))
-    }
-
-    /// Specify the end point of the arrow.
-    pub fn end(self, end: Point2) -> Self {
-        self.map_ty(|ty| ty.end(end))
-    }
-
-    /// Specify the start and end points of the arrow.
-    pub fn points(self, start: Point2, end: Point2) -> Self {
-        self.map_ty(|ty| ty.points(start, end))
-    }
-
-    /// The length of the arrow head.
-    ///
-    /// By default, this is equal to `weight * 4.0`.
-    ///
-    /// This value will be clamped to the length of the line itself.
-    pub fn head_length(self, length: f32) -> Self {
-        self.map_ty(|ty| ty.head_length(length))
-    }
-
-    /// The width of the arrow head.
-    ///
-    /// By default, this is equal to `weight * 2.0`.
-    pub fn head_width(self, width: f32) -> Self {
-        self.map_ty(|ty| ty.head_width(width))
-    }
-}
-
-impl SetStroke for Arrow {
-    fn stroke_options_mut(&mut self) -> &mut StrokeOptions {
-        SetStroke::stroke_options_mut(&mut self.line)
-    }
-}
-
-impl SetOrientation for Arrow {
-    fn properties(&mut self) -> &mut orientation::Properties {
-        SetOrientation::properties(&mut self.line)
-    }
-}
-
-impl SetPosition for Arrow {
-    fn properties(&mut self) -> &mut position::Properties {
-        SetPosition::properties(&mut self.line)
-    }
-}
-
-impl SetColor<ColorScalar> for Arrow {
-    fn rgba_mut(&mut self) -> &mut Option<LinSrgba> {
-        SetColor::rgba_mut(&mut self.line)
-    }
-}
-
-impl From<Arrow> for Primitive {
-    fn from(prim: Arrow) -> Self {
-        Primitive::Arrow(prim)
-    }
-}
-
-impl Into<Option<Arrow>> for Primitive {
-    fn into(self) -> Option<Arrow> {
-        match self {
-            Primitive::Arrow(prim) => Some(prim),
-            _ => None,
-        }
-    }
-}
-
-impl draw::renderer::RenderPrimitive for Arrow {
-    fn render_primitive(
-        self,
-        mut ctxt: draw::renderer::RenderContext,
-        mesh: &mut draw::Mesh,
-    ) -> draw::renderer::PrimitiveRender {
-        let Arrow {
-            line,
-            head_length,
-            head_width,
-        } = self;
-        let start = line.start.unwrap_or(pt2(0.0, 0.0));
-        let end = line.end.unwrap_or(pt2(0.0, 0.0));
-        if start == end {
-            return draw::renderer::PrimitiveRender::default();
-        }
-
-        // Calculate the arrow head points.
-        let line_w_2 = line.path.opts.line_width * 2.0;
-        let line_w_4 = line_w_2 * 2.0;
-        let head_width = head_width.unwrap_or(line_w_2);
-        let head_length = head_length.unwrap_or(line_w_4);
-        let line_dir = end - start;
-        let line_dir_len = line_dir.length();
-        let tri_len = head_length.min(line_dir_len);
-        let tri_dir_norm = line_dir.normalize() * tri_len;
-        let tri_start = end - tri_dir_norm;
-        let tri_end = end;
-        let line_start = start;
-        let line_end = tri_start;
-        let tri_a = tri_end;
-        let tri_w_dir = vec2(-tri_dir_norm.y, tri_dir_norm.x).normalize() * head_width;
-        let tri_b = tri_start + tri_w_dir;
-        let tri_c = tri_start - tri_w_dir;
-        // The line should only be drawn if there is space after drawing the triangle.
-        let draw_line = line_dir_len > tri_len;
-
-        // Determine the transform to apply to all points.
-        let global_transform = *ctxt.transform;
-        let local_transform = line.path.position.transform() * line.path.orientation.transform();
-        let transform = global_transform * local_transform;
-
-        // Draw the tri.
-        let tri_points = [tri_a, tri_b, tri_c];
-        let tri_points = tri_points.iter().cloned().map(|p| p.to_array().into());
-        let close_tri = true;
-        let tri_events = lyon::path::iterator::FromPolyline::new(close_tri, tri_points);
-        path::render_path_events(
-            tri_events,
-            line.path.color,
-            transform,
-            path::Options::Fill(Default::default()),
-            &ctxt.theme,
-            &draw::theme::Primitive::Arrow,
-            &mut ctxt.fill_tessellator,
-            &mut ctxt.stroke_tessellator,
-            mesh,
-        );
-
-        // Draw the line.
-        if draw_line {
-            let line_points = [line_start, line_end];
-            let line_points = line_points.iter().cloned().map(|p| p.to_array().into());
-            let close_line = false;
-            let line_events = lyon::path::iterator::FromPolyline::new(close_line, line_points);
-            path::render_path_events(
-                line_events,
-                line.path.color,
-                transform,
-                path::Options::Stroke(line.path.opts),
-                &ctxt.theme,
-                &draw::theme::Primitive::Arrow,
-                &mut ctxt.fill_tessellator,
-                &mut ctxt.stroke_tessellator,
-                mesh,
-            );
-        }
-
-        draw::renderer::PrimitiveRender::default()
-    }
-}
-
-impl Default for Arrow {
-    fn default() -> Self {
-        let line = Default::default();
-        let head_length = Default::default();
-        let head_width = Default::default();
-        Arrow {
-            line,
-            head_length,
-            head_width,
-        }
-    }
-}
diff --git a/nannou/src/draw/primitive/ellipse.rs b/nannou/src/draw/primitive/ellipse.rs
deleted file mode 100644
index 28e61fe61..000000000
--- a/nannou/src/draw/primitive/ellipse.rs
+++ /dev/null
@@ -1,188 +0,0 @@
-use crate::color::conv::IntoLinSrgba;
-use crate::draw;
-use crate::draw::primitive::polygon::{self, PolygonInit, PolygonOptions, SetPolygon};
-use crate::draw::primitive::Primitive;
-use crate::draw::properties::spatial::{dimension, orientation, position};
-use crate::draw::properties::{
-    spatial, ColorScalar, LinSrgba, SetColor, SetDimensions, SetOrientation, SetPosition, SetStroke,
-};
-use crate::draw::Drawing;
-use crate::geom;
-use crate::glam::Vec2;
-use lyon::tessellation::StrokeOptions;
-
-/// Properties related to drawing an **Ellipse**.
-#[derive(Clone, Debug, Default)]
-pub struct Ellipse {
-    dimensions: spatial::dimension::Properties,
-    resolution: Option<f32>,
-    polygon: PolygonInit,
-}
-
-/// The drawing context for an ellipse.
-pub type DrawingEllipse<'a> = Drawing<'a, Ellipse>;
-
-// Ellipse-specific methods.
-
-impl Ellipse {
-    /// Stroke the outline with the given color.
-    pub fn stroke<C>(self, color: C) -> Self
-    where
-        C: IntoLinSrgba<ColorScalar>,
-    {
-        self.stroke_color(color)
-    }
-
-    /// Specify the width and height of the **Ellipse** via a given **radius**.
-    pub fn radius(self, radius: f32) -> Self {
-        let side = radius * 2.0;
-        self.w_h(side, side)
-    }
-
-    /// The number of sides used to draw the ellipse.
-    ///
-    /// By default, ellipse does not use a resolution, but rather uses a stroke tolerance to
-    /// determine how many vertices to use during tessellation.
-    pub fn resolution(mut self, resolution: f32) -> Self {
-        self.resolution = Some(resolution);
-        self
-    }
-}
-
-// Trait implementations.
-
-impl draw::renderer::RenderPrimitive for Ellipse {
-    fn render_primitive(
-        self,
-        ctxt: draw::renderer::RenderContext,
-        mesh: &mut draw::Mesh,
-    ) -> draw::renderer::PrimitiveRender {
-        let Ellipse {
-            dimensions,
-            polygon,
-            resolution,
-        } = self;
-
-        // First get the dimensions of the ellipse.
-        let (maybe_x, maybe_y, maybe_z) = (dimensions.x, dimensions.y, dimensions.z);
-        assert!(
-            maybe_z.is_none(),
-            "z dimension support for ellipse is unimplemented"
-        );
-
-        let w = maybe_x.map(f32::abs).unwrap_or(100.0);
-        let h = maybe_y.map(f32::abs).unwrap_or(100.0);
-        match resolution {
-            None => {
-                // Determine the transform to apply to all points.
-                let radii = lyon::math::vector(w * 0.5, h * 0.5);
-                if radii.square_length() > 0.0 {
-                    let centre = lyon::math::point(0.0, 0.0);
-                    let mut builder = lyon::path::Path::svg_builder();
-                    let sweep_angle = lyon::math::Angle::radians(std::f32::consts::PI * 2.0);
-                    let x_rotation = lyon::math::Angle::radians(0.0);
-                    let start = lyon::math::point(w * 0.5, 0.0);
-                    builder.move_to(start);
-                    builder.arc(centre, radii, sweep_angle, x_rotation);
-                    let path = builder.build();
-                    polygon::render_events_themed(
-                        polygon.opts,
-                        || (&path).into_iter(),
-                        ctxt,
-                        &draw::theme::Primitive::Ellipse,
-                        mesh,
-                    );
-                }
-            }
-            Some(resolution) => {
-                let rect = geom::Rect::from_w_h(w, h);
-                let ellipse = geom::Ellipse::new(rect, resolution);
-                let points = ellipse.circumference().map(Vec2::from);
-                polygon::render_points_themed(
-                    polygon.opts,
-                    points,
-                    ctxt,
-                    &draw::theme::Primitive::Ellipse,
-                    mesh,
-                );
-            }
-        }
-
-        draw::renderer::PrimitiveRender::default()
-    }
-}
-
-impl SetOrientation for Ellipse {
-    fn properties(&mut self) -> &mut orientation::Properties {
-        SetOrientation::properties(&mut self.polygon)
-    }
-}
-
-impl SetPosition for Ellipse {
-    fn properties(&mut self) -> &mut position::Properties {
-        SetPosition::properties(&mut self.polygon)
-    }
-}
-
-impl SetDimensions for Ellipse {
-    fn properties(&mut self) -> &mut dimension::Properties {
-        SetDimensions::properties(&mut self.dimensions)
-    }
-}
-
-impl SetColor<ColorScalar> for Ellipse {
-    fn rgba_mut(&mut self) -> &mut Option<LinSrgba> {
-        SetColor::rgba_mut(&mut self.polygon)
-    }
-}
-
-impl SetStroke for Ellipse {
-    fn stroke_options_mut(&mut self) -> &mut StrokeOptions {
-        SetStroke::stroke_options_mut(&mut self.polygon)
-    }
-}
-
-impl SetPolygon for Ellipse {
-    fn polygon_options_mut(&mut self) -> &mut PolygonOptions {
-        SetPolygon::polygon_options_mut(&mut self.polygon)
-    }
-}
-
-// Primitive conversion.
-
-impl From<Ellipse> for Primitive {
-    fn from(prim: Ellipse) -> Self {
-        Primitive::Ellipse(prim)
-    }
-}
-
-impl Into<Option<Ellipse>> for Primitive {
-    fn into(self) -> Option<Ellipse> {
-        match self {
-            Primitive::Ellipse(prim) => Some(prim),
-            _ => None,
-        }
-    }
-}
-
-// Drawing methods.
-
-impl<'a> DrawingEllipse<'a> {
-    /// Stroke the outline with the given color.
-    pub fn stroke<C>(self, color: C) -> Self
-    where
-        C: IntoLinSrgba<ColorScalar>,
-    {
-        self.map_ty(|ty| ty.stroke(color))
-    }
-
-    /// Specify the width and height of the **Ellipse** via a given **radius**.
-    pub fn radius(self, radius: f32) -> Self {
-        self.map_ty(|ty| ty.radius(radius))
-    }
-
-    /// The number of sides used to draw the ellipse.
-    pub fn resolution(self, resolution: f32) -> Self {
-        self.map_ty(|ty| ty.resolution(resolution))
-    }
-}
diff --git a/nannou/src/draw/primitive/line.rs b/nannou/src/draw/primitive/line.rs
deleted file mode 100644
index b263c29e8..000000000
--- a/nannou/src/draw/primitive/line.rs
+++ /dev/null
@@ -1,165 +0,0 @@
-use crate::color::LinSrgba;
-use crate::draw::primitive::path;
-use crate::draw::primitive::{PathStroke, Primitive};
-use crate::draw::properties::spatial::{orientation, position};
-use crate::draw::properties::{ColorScalar, SetColor, SetOrientation, SetPosition, SetStroke};
-use crate::draw::{self, Drawing};
-use crate::geom::{pt2, Point2};
-use lyon::tessellation::StrokeOptions;
-
-/// A path containing only two points - a start and end.
-///
-/// The usage of this type is almost identical to `PathStroke` but provides `start`, `end` and
-/// `points(a, b)` methods.
-#[derive(Clone, Debug, Default)]
-pub struct Line {
-    pub path: PathStroke,
-    pub start: Option<Point2>,
-    pub end: Option<Point2>,
-}
-
-/// The drawing context for a line.
-pub type DrawingLine<'a> = Drawing<'a, Line>;
-
-impl Line {
-    /// Short-hand for the `stroke_weight` method.
-    pub fn weight(self, weight: f32) -> Self {
-        self.map_path(|p| p.stroke_weight(weight))
-    }
-
-    /// Short-hand for the `stroke_tolerance` method.
-    pub fn tolerance(self, tolerance: f32) -> Self {
-        self.map_path(|p| p.stroke_tolerance(tolerance))
-    }
-
-    /// Specify the start point of the line.
-    pub fn start(mut self, start: Point2) -> Self {
-        self.start = Some(start);
-        self
-    }
-
-    /// Specify the end point of the line.
-    pub fn end(mut self, end: Point2) -> Self {
-        self.end = Some(end);
-        self
-    }
-
-    /// Specify the start and end points of the line.
-    pub fn points(self, start: Point2, end: Point2) -> Self {
-        self.start(start).end(end)
-    }
-
-    // Map the inner `PathStroke<S>` using the given function.
-    fn map_path<F>(self, map: F) -> Self
-    where
-        F: FnOnce(PathStroke) -> PathStroke,
-    {
-        let Line { path, start, end } = self;
-        let path = map(path);
-        Line { path, start, end }
-    }
-}
-
-impl<'a> DrawingLine<'a> {
-    /// Short-hand for the `stroke_weight` method.
-    pub fn weight(self, weight: f32) -> Self {
-        self.map_ty(|ty| ty.weight(weight))
-    }
-
-    /// Short-hand for the `stroke_tolerance` method.
-    pub fn tolerance(self, tolerance: f32) -> Self {
-        self.map_ty(|ty| ty.tolerance(tolerance))
-    }
-
-    /// Specify the start point of the line.
-    pub fn start(self, start: Point2) -> Self {
-        self.map_ty(|ty| ty.start(start))
-    }
-
-    /// Specify the end point of the line.
-    pub fn end(self, end: Point2) -> Self {
-        self.map_ty(|ty| ty.end(end))
-    }
-
-    /// Specify the start and end points of the line.
-    pub fn points(self, start: Point2, end: Point2) -> Self {
-        self.map_ty(|ty| ty.points(start, end))
-    }
-}
-
-impl SetStroke for Line {
-    fn stroke_options_mut(&mut self) -> &mut StrokeOptions {
-        SetStroke::stroke_options_mut(&mut self.path)
-    }
-}
-
-impl SetOrientation for Line {
-    fn properties(&mut self) -> &mut orientation::Properties {
-        SetOrientation::properties(&mut self.path)
-    }
-}
-
-impl SetPosition for Line {
-    fn properties(&mut self) -> &mut position::Properties {
-        SetPosition::properties(&mut self.path)
-    }
-}
-
-impl SetColor<ColorScalar> for Line {
-    fn rgba_mut(&mut self) -> &mut Option<LinSrgba> {
-        SetColor::rgba_mut(&mut self.path)
-    }
-}
-
-impl From<Line> for Primitive {
-    fn from(prim: Line) -> Self {
-        Primitive::Line(prim)
-    }
-}
-
-impl Into<Option<Line>> for Primitive {
-    fn into(self) -> Option<Line> {
-        match self {
-            Primitive::Line(prim) => Some(prim),
-            _ => None,
-        }
-    }
-}
-
-impl draw::renderer::RenderPrimitive for Line {
-    fn render_primitive(
-        self,
-        mut ctxt: draw::renderer::RenderContext,
-        mesh: &mut draw::Mesh,
-    ) -> draw::renderer::PrimitiveRender {
-        let Line { path, start, end } = self;
-        let start = start.unwrap_or(pt2(0.0, 0.0));
-        let end = end.unwrap_or(pt2(0.0, 0.0));
-        if start == end {
-            return draw::renderer::PrimitiveRender::default();
-        }
-        let close = false;
-        let points = [start, end];
-        let points = points.iter().cloned().map(|p| p.to_array().into());
-        let events = lyon::path::iterator::FromPolyline::new(close, points);
-
-        // Determine the transform to apply to all points.
-        let global_transform = *ctxt.transform;
-        let local_transform = path.position.transform() * path.orientation.transform();
-        let transform = global_transform * local_transform;
-
-        path::render_path_events(
-            events,
-            path.color,
-            transform,
-            path::Options::Stroke(path.opts),
-            &ctxt.theme,
-            &draw::theme::Primitive::Line,
-            &mut ctxt.fill_tessellator,
-            &mut ctxt.stroke_tessellator,
-            mesh,
-        );
-
-        draw::renderer::PrimitiveRender::default()
-    }
-}
diff --git a/nannou/src/draw/primitive/mesh.rs b/nannou/src/draw/primitive/mesh.rs
deleted file mode 100644
index bbf2c03fe..000000000
--- a/nannou/src/draw/primitive/mesh.rs
+++ /dev/null
@@ -1,616 +0,0 @@
-use crate::color::conv::IntoLinSrgba;
-use crate::draw::mesh::vertex::{self, Point, TexCoords, Vertex};
-use crate::draw::primitive::Primitive;
-use crate::draw::properties::spatial::{orientation, position};
-use crate::draw::properties::{ColorScalar, LinSrgba, SetColor, SetOrientation, SetPosition};
-use crate::draw::{self, Drawing};
-use crate::geom;
-use crate::wgpu;
-use std::ops;
-
-/// The mesh type prior to being initialised with vertices or indices.
-#[derive(Clone, Debug, Default)]
-pub struct Vertexless;
-
-/// Properties related to drawing an arbitrary mesh of colours, geometry and texture.
-#[derive(Clone, Debug)]
-pub struct Mesh {
-    position: position::Properties,
-    orientation: orientation::Properties,
-    vertex_range: ops::Range<usize>,
-    index_range: ops::Range<usize>,
-    vertex_mode: draw::renderer::VertexMode,
-    fill_color: Option<FillColor>,
-    texture_view: Option<wgpu::TextureView>,
-}
-
-#[derive(Clone, Debug, Default)]
-struct FillColor(Option<LinSrgba>);
-
-// A simple iterator for flattening a fixed-size array of indices.
-struct FlattenIndices<I> {
-    iter: I,
-    index: usize,
-    vertex_start_index: usize,
-    current: [usize; 3],
-}
-
-pub type DrawingMesh<'a> = Drawing<'a, Mesh>;
-
-impl Vertexless {
-    /// Describe the mesh with a sequence of textured points.
-    ///
-    /// Each of the vertices must be represented as a tuple containing the point and tex
-    /// coordinates in that order, e.g. `(point, tex_coords)`. `point` may be of any type that
-    /// implements `Into<Point3>` and `tex_coords` may be of any type that implements
-    /// `Into<Point2>`.
-    pub fn points_textured<I, P, T>(
-        self,
-        inner_mesh: &mut draw::Mesh,
-        texture_view: &dyn wgpu::ToTextureView,
-        points: I,
-    ) -> Mesh
-    where
-        I: IntoIterator<Item = (P, T)>,
-        P: Into<Point>,
-        T: Into<TexCoords>,
-    {
-        let points = points.into_iter().map(|(p, t)| {
-            let point = p.into();
-            let color = vertex::DEFAULT_VERTEX_COLOR;
-            let tex_coords = t.into();
-            ((point, color), tex_coords).into()
-        });
-        let vertex_mode = draw::renderer::VertexMode::Texture;
-        self.points_inner(
-            inner_mesh,
-            points,
-            vertex_mode,
-            Some(texture_view.to_texture_view()),
-        )
-    }
-
-    /// Describe the mesh with a sequence of colored points.
-    ///
-    /// Each of the points must be represented as a tuple containing the point and the color in
-    /// that order, e.g. `(point, color)`. `point` may be of any type that implements
-    /// `Into<Point3>` and `color` may be of any type that implements `IntoLinSrgba`.
-    pub fn points_colored<I, P, C>(self, inner_mesh: &mut draw::Mesh, points: I) -> Mesh
-    where
-        I: IntoIterator<Item = (P, C)>,
-        P: Into<Point>,
-        C: IntoLinSrgba<ColorScalar>,
-    {
-        let vertices = points.into_iter().map(|(p, c)| {
-            let point = p.into();
-            let color = c.into_lin_srgba();
-            let tex_coords = vertex::default_tex_coords();
-            ((point, color), tex_coords).into()
-        });
-        let vertex_mode = draw::renderer::VertexMode::Color;
-        self.points_inner(inner_mesh, vertices, vertex_mode, None)
-    }
-
-    /// Describe the mesh with a sequence of points.
-    ///
-    /// The given iterator may yield any type that can be converted directly into `Point3`s.
-    ///
-    /// This method assumes that the entire mesh should be coloured with a single colour. If a
-    /// colour is not specified via one of the builder methods, a default colour will be retrieved
-    /// from the inner `Theme`.
-    pub fn points<I>(self, inner_mesh: &mut draw::Mesh, points: I) -> Mesh
-    where
-        I: IntoIterator,
-        I::Item: Into<Point>,
-    {
-        let vertices = points.into_iter().map(|p| {
-            let point = p.into();
-            let color = vertex::DEFAULT_VERTEX_COLOR;
-            let tex_coords = vertex::default_tex_coords();
-            ((point, color), tex_coords).into()
-        });
-        let vertex_mode = draw::renderer::VertexMode::Color;
-        let mut mesh = self.points_inner(inner_mesh, vertices, vertex_mode, None);
-        mesh.fill_color = Some(FillColor(None));
-        mesh
-    }
-
-    fn points_inner<I>(
-        self,
-        inner_mesh: &mut draw::Mesh,
-        vertices: I,
-        vertex_mode: draw::renderer::VertexMode,
-        texture_view: Option<wgpu::TextureView>,
-    ) -> Mesh
-    where
-        I: Iterator<Item = Vertex>,
-    {
-        let v_start = inner_mesh.points().len();
-        let i_start = inner_mesh.indices().len();
-        for (i, vertex) in vertices.enumerate() {
-            inner_mesh.push_vertex(vertex);
-            inner_mesh.push_index((v_start + i) as u32);
-        }
-        let v_end = inner_mesh.points().len();
-        let i_end = inner_mesh.indices().len();
-        Mesh::new(v_start..v_end, i_start..i_end, vertex_mode, texture_view)
-    }
-
-    /// Describe the mesh with a sequence of textured triangles.
-    ///
-    /// Each of the vertices must be represented as a tuple containing the point and tex
-    /// coordinates in that order, e.g. `(point, tex_coords)`. `point` may be of any type that
-    /// implements `Into<Point3>` and `tex_coords` may be of any type that implements
-    /// `Into<Point2>`.
-    pub fn tris_textured<I, P, T>(
-        self,
-        inner_mesh: &mut draw::Mesh,
-        texture_view: &dyn wgpu::ToTextureView,
-        tris: I,
-    ) -> Mesh
-    where
-        I: IntoIterator<Item = geom::Tri<(P, T)>>,
-        P: Into<Point>,
-        T: Into<TexCoords>,
-    {
-        let points = tris
-            .into_iter()
-            .map(|t| t.map_vertices(|(p, t)| (p.into(), t.into())))
-            .flat_map(geom::Tri::vertices);
-        self.points_textured(inner_mesh, texture_view, points)
-    }
-
-    /// Describe the mesh with a sequence of colored triangles.
-    ///
-    /// Each of the vertices must be represented as a tuple containing the point and the color in
-    /// that order, e.g. `(point, color)`. `point` may be of any type that implements `Into<Point3>`
-    /// and `color` may be of any type that implements `IntoLinSrgba`.
-    pub fn tris_colored<I, P, C>(self, inner_mesh: &mut draw::Mesh, tris: I) -> Mesh
-    where
-        I: IntoIterator<Item = geom::Tri<(P, C)>>,
-        P: Into<Point>,
-        C: IntoLinSrgba<ColorScalar>,
-    {
-        let points = tris
-            .into_iter()
-            .map(|t| t.map_vertices(|(p, c)| (p.into(), c.into_lin_srgba())))
-            .flat_map(geom::Tri::vertices);
-        self.points_colored(inner_mesh, points)
-    }
-
-    /// Describe the mesh with a sequence of triangles.
-    ///
-    /// Each triangle may be composed of any vertex type that may be converted directly into
-    /// `Point3`s.
-    ///
-    /// This method assumes that the entire mesh should be coloured with a single colour. If a
-    /// colour is not specified via one of the builder methods, a default colour will be retrieved
-    /// from the inner `Theme`.
-    pub fn tris<I, V>(self, inner_mesh: &mut draw::Mesh, tris: I) -> Mesh
-    where
-        I: IntoIterator<Item = geom::Tri<V>>,
-        V: Into<Point>,
-    {
-        let points = tris
-            .into_iter()
-            .map(|t| t.map_vertices(Into::into))
-            .flat_map(geom::Tri::vertices);
-        self.points(inner_mesh, points)
-    }
-
-    /// Describe the mesh with the given indexed, textured points.
-    ///
-    /// Each trio of `indices` describes a single triangle made up of colored `points`.
-    ///
-    /// Each of the `points` must be represented as a tuple containing the point and the texture
-    /// coordinates in that order, e.g. `(point, tex_coords)`. `point` may be of any type that
-    /// implements `Into<Point3>` and `tex_coords` may be of any type that implements
-    /// `Into<Point2>`.
-    pub fn indexed_textured<V, I, P, T>(
-        self,
-        inner_mesh: &mut draw::Mesh,
-        texture_view: &dyn wgpu::ToTextureView,
-        points: V,
-        indices: I,
-    ) -> Mesh
-    where
-        V: IntoIterator<Item = (P, T)>,
-        I: IntoIterator<Item = usize>,
-        P: Into<Point>,
-        T: Into<TexCoords>,
-    {
-        let vertices = points.into_iter().map(|(p, t)| {
-            let point = p.into();
-            let color = vertex::DEFAULT_VERTEX_COLOR;
-            let tex_coords = t.into();
-            ((point, color), tex_coords).into()
-        });
-        let vertex_mode = draw::renderer::VertexMode::Texture;
-        self.indexed_inner(
-            inner_mesh,
-            vertices,
-            indices,
-            vertex_mode,
-            Some(texture_view.to_texture_view()),
-        )
-    }
-
-    /// Describe the mesh with the given indexed, colored points.
-    ///
-    /// Each trio of `indices` describes a single triangle made up of colored `points`.
-    ///
-    /// Each of the `points` must be represented as a tuple containing the point and the color in
-    /// that order, e.g. `(point, color)`. `point` may be of any type that implements
-    /// `Into<Point3>` and `color` may be of any type that implements `IntoLinSrgba`.
-    pub fn indexed_colored<V, I, P, C>(
-        self,
-        inner_mesh: &mut draw::Mesh,
-        points: V,
-        indices: I,
-    ) -> Mesh
-    where
-        V: IntoIterator<Item = (P, C)>,
-        I: IntoIterator<Item = usize>,
-        P: Into<Point>,
-        C: IntoLinSrgba<ColorScalar>,
-    {
-        let vertices = points.into_iter().map(|(p, c)| {
-            let point = p.into();
-            let color = c.into_lin_srgba();
-            let tex_coords = vertex::default_tex_coords();
-            ((point, color), tex_coords).into()
-        });
-        let vertex_mode = draw::renderer::VertexMode::Color;
-        self.indexed_inner(inner_mesh, vertices, indices, vertex_mode, None)
-    }
-
-    /// Describe the mesh with the given indexed points.
-    ///
-    /// Each trio of `indices` describes a single triangle made up of `points`.
-    ///
-    /// Each point may be any type that may be converted directly into the `Point3` type.
-    pub fn indexed<V, I>(self, inner_mesh: &mut draw::Mesh, points: V, indices: I) -> Mesh
-    where
-        V: IntoIterator,
-        V::Item: Into<Point>,
-        I: IntoIterator<Item = usize>,
-    {
-        let vertices = points.into_iter().map(|p| {
-            let point = p.into();
-            let color = vertex::DEFAULT_VERTEX_COLOR;
-            let tex_coords = vertex::default_tex_coords();
-            ((point, color), tex_coords).into()
-        });
-        let vertex_mode = draw::renderer::VertexMode::Color;
-        let mut mesh = self.indexed_inner(inner_mesh, vertices, indices, vertex_mode, None);
-        mesh.fill_color = Some(FillColor(None));
-        mesh
-    }
-
-    fn indexed_inner<V, I>(
-        self,
-        inner_mesh: &mut draw::Mesh,
-        vertices: V,
-        indices: I,
-        vertex_mode: draw::renderer::VertexMode,
-        texture_view: Option<wgpu::TextureView>,
-    ) -> Mesh
-    where
-        V: IntoIterator<Item = Vertex>,
-        I: IntoIterator<Item = usize>,
-    {
-        let v_start = inner_mesh.points().len();
-        let i_start = inner_mesh.indices().len();
-        inner_mesh.extend_vertices(vertices);
-        inner_mesh.extend_indices(indices.into_iter().map(|ix| ix as u32));
-        let v_end = inner_mesh.points().len();
-        let i_end = inner_mesh.indices().len();
-        Mesh::new(v_start..v_end, i_start..i_end, vertex_mode, texture_view)
-    }
-}
-
-impl Mesh {
-    // Initialise a new `Mesh` with its ranges into the intermediary mesh, ready for drawing.
-    fn new(
-        vertex_range: ops::Range<usize>,
-        index_range: ops::Range<usize>,
-        vertex_mode: draw::renderer::VertexMode,
-        texture_view: Option<wgpu::TextureView>,
-    ) -> Self {
-        let orientation = Default::default();
-        let position = Default::default();
-        let fill_color = None;
-        Mesh {
-            orientation,
-            position,
-            vertex_range,
-            index_range,
-            vertex_mode,
-            fill_color,
-            texture_view,
-        }
-    }
-}
-
-impl<'a> Drawing<'a, Vertexless> {
-    /// Describe the mesh with a sequence of points.
-    ///
-    /// The given iterator may yield any type that can be converted directly into `Point3`s.
-    ///
-    /// This method assumes that the entire mesh should be coloured with a single colour. If a
-    /// colour is not specified via one of the builder methods, a default colour will be retrieved
-    /// from the inner `Theme`.
-    pub fn points<I>(self, points: I) -> DrawingMesh<'a>
-    where
-        I: IntoIterator,
-        I::Item: Into<Point>,
-    {
-        self.map_ty_with_context(|ty, ctxt| ty.points(ctxt.mesh, points))
-    }
-
-    /// Describe the mesh with a sequence of colored points.
-    ///
-    /// Each of the points must be represented as a tuple containing the point and the color in
-    /// that order, e.g. `(point, color)`. `point` may be of any type that implements
-    /// `Into<Point3>` and `color` may be of any type that implements `IntoLinSrgba`.
-    pub fn points_colored<I, P, C>(self, points: I) -> DrawingMesh<'a>
-    where
-        I: IntoIterator<Item = (P, C)>,
-        P: Into<Point>,
-        C: IntoLinSrgba<ColorScalar>,
-    {
-        self.map_ty_with_context(|ty, ctxt| ty.points_colored(ctxt.mesh, points))
-    }
-
-    /// Describe the mesh with a sequence of textured points.
-    ///
-    /// Each of the vertices must be represented as a tuple containing the point and tex
-    /// coordinates in that order, e.g. `(point, tex_coords)`. `point` may be of any type that
-    /// implements `Into<Point3>` and `tex_coords` may be of any type that implements
-    /// `Into<Point2>`.
-    pub fn points_textured<I, P, T>(
-        self,
-        view: &dyn wgpu::ToTextureView,
-        points: I,
-    ) -> DrawingMesh<'a>
-    where
-        I: IntoIterator<Item = (P, T)>,
-        P: Into<Point>,
-        T: Into<TexCoords>,
-    {
-        self.map_ty_with_context(|ty, ctxt| ty.points_textured(ctxt.mesh, view, points))
-    }
-
-    /// Describe the mesh with a sequence of triangles.
-    ///
-    /// Each triangle may be composed of any vertex type that may be converted directly into
-    /// `Point3`s.
-    ///
-    /// This method assumes that the entire mesh should be coloured with a single colour. If a
-    /// colour is not specified via one of the builder methods, a default colour will be retrieved
-    /// from the inner `Theme`.
-    pub fn tris<I, V>(self, tris: I) -> DrawingMesh<'a>
-    where
-        I: IntoIterator<Item = geom::Tri<V>>,
-        V: Into<Point>,
-    {
-        self.map_ty_with_context(|ty, ctxt| ty.tris(ctxt.mesh, tris))
-    }
-
-    /// Describe the mesh with a sequence of colored triangles.
-    ///
-    /// Each of the vertices must be represented as a tuple containing the point and the color in
-    /// that order, e.g. `(point, color)`. `point` may be of any type that implements `Into<Point3>`
-    /// and `color` may be of any type that implements `IntoLinSrgba`.
-    pub fn tris_colored<I, P, C>(self, tris: I) -> DrawingMesh<'a>
-    where
-        I: IntoIterator<Item = geom::Tri<(P, C)>>,
-        P: Into<Point>,
-        C: IntoLinSrgba<ColorScalar>,
-    {
-        self.map_ty_with_context(|ty, ctxt| ty.tris_colored(ctxt.mesh, tris))
-    }
-
-    /// Describe the mesh with a sequence of textured triangles.
-    ///
-    /// Each of the vertices must be represented as a tuple containing the point and tex
-    /// coordinates in that order, e.g. `(point, tex_coords)`. `point` may be of any type that
-    /// implements `Into<Point3>` and `tex_coords` may be of any type that implements
-    /// `Into<Point2>`.
-    pub fn tris_textured<I, P, T>(self, view: &dyn wgpu::ToTextureView, tris: I) -> DrawingMesh<'a>
-    where
-        I: IntoIterator<Item = geom::Tri<(P, T)>>,
-        P: Into<Point>,
-        T: Into<TexCoords>,
-    {
-        self.map_ty_with_context(|ty, ctxt| ty.tris_textured(ctxt.mesh, view, tris))
-    }
-
-    /// Describe the mesh with the given indexed points.
-    ///
-    /// Each trio of `indices` describes a single triangle made up of `points`.
-    ///
-    /// Each point may be any type that may be converted directly into the `Point3` type.
-    pub fn indexed<V, I>(self, points: V, indices: I) -> DrawingMesh<'a>
-    where
-        V: IntoIterator,
-        V::Item: Into<Point>,
-        I: IntoIterator<Item = usize>,
-    {
-        self.map_ty_with_context(|ty, ctxt| ty.indexed(ctxt.mesh, points, indices))
-    }
-
-    /// Describe the mesh with the given indexed, colored points.
-    ///
-    /// Each trio of `indices` describes a single triangle made up of colored `points`.
-    ///
-    /// Each of the `points` must be represented as a tuple containing the point and the color in
-    /// that order, e.g. `(point, color)`. `point` may be of any type that implements
-    /// `Into<Point3>` and `color` may be of any type that implements `IntoLinSrgba`.
-    pub fn indexed_colored<V, I, P, C>(self, points: V, indices: I) -> DrawingMesh<'a>
-    where
-        V: IntoIterator<Item = (P, C)>,
-        I: IntoIterator<Item = usize>,
-        P: Into<Point>,
-        C: IntoLinSrgba<ColorScalar>,
-    {
-        self.map_ty_with_context(|ty, ctxt| ty.indexed_colored(ctxt.mesh, points, indices))
-    }
-
-    /// Describe the mesh with the given indexed, textured points.
-    ///
-    /// Each trio of `indices` describes a single triangle made up of colored `points`.
-    ///
-    /// Each of the `points` must be represented as a tuple containing the point and the texture
-    /// coordinates in that order, e.g. `(point, tex_coords)`. `point` may be of any type that
-    /// implements `Into<Point3>` and `tex_coords` may be of any type that implements
-    /// `Into<Point2>`.
-    pub fn indexed_textured<V, I, P, T>(
-        self,
-        view: &dyn wgpu::ToTextureView,
-        points: V,
-        indices: I,
-    ) -> DrawingMesh<'a>
-    where
-        V: IntoIterator<Item = (P, T)>,
-        I: IntoIterator<Item = usize>,
-        P: Into<Point>,
-        T: Into<TexCoords>,
-    {
-        self.map_ty_with_context(|ty, ctxt| ty.indexed_textured(ctxt.mesh, view, points, indices))
-    }
-}
-
-impl draw::renderer::RenderPrimitive for Mesh {
-    fn render_primitive(
-        self,
-        ctxt: draw::renderer::RenderContext,
-        mesh: &mut draw::Mesh,
-    ) -> draw::renderer::PrimitiveRender {
-        let Mesh {
-            orientation,
-            position,
-            vertex_range,
-            index_range,
-            vertex_mode,
-            fill_color,
-            texture_view,
-        } = self;
-
-        // Determine the transform to apply to vertices.
-        let global_transform = *ctxt.transform;
-        let local_transform = position.transform() * orientation.transform();
-        let transform = global_transform * local_transform;
-
-        // We need to update the indices to point to where vertices will be in the new mesh.
-        let old_mesh_vertex_start = vertex_range.start as u32;
-        let new_mesh_vertex_start = mesh.raw_vertex_count() as u32;
-        let indices = index_range
-            .map(|i| ctxt.intermediary_mesh.indices()[i])
-            .map(|i| new_mesh_vertex_start + i - old_mesh_vertex_start);
-
-        // A small function for transforming a point via the transform matrix.
-        let transform_point = |p: geom::Point3| -> geom::Point3 { transform.transform_point3(p) };
-
-        // Color the vertices based on whether or not we should fill, then extend the mesh!
-        match fill_color {
-            Some(fill) => {
-                let theme_prim = draw::theme::Primitive::Mesh;
-                let color = fill
-                    .0
-                    .unwrap_or_else(|| ctxt.theme.fill_lin_srgba(&theme_prim));
-                let vertices = vertex_range.map(|i| {
-                    let point = transform_point(ctxt.intermediary_mesh.points()[i]);
-                    let tex_coords = ctxt.intermediary_mesh.tex_coords()[i];
-                    ((point, color), tex_coords).into()
-                });
-                mesh.extend(vertices, indices);
-            }
-            None => {
-                let vertices = vertex_range.map(|i| {
-                    let point = transform_point(ctxt.intermediary_mesh.points()[i]);
-                    let color = ctxt.intermediary_mesh.colors()[i];
-                    let tex_coords = ctxt.intermediary_mesh.tex_coords()[i];
-                    ((point, color), tex_coords).into()
-                });
-                mesh.extend(vertices, indices);
-            }
-        }
-
-        draw::renderer::PrimitiveRender {
-            texture_view,
-            vertex_mode,
-        }
-    }
-}
-
-impl<I> Iterator for FlattenIndices<I>
-where
-    I: Iterator<Item = [usize; 3]>,
-{
-    type Item = usize;
-    fn next(&mut self) -> Option<Self::Item> {
-        loop {
-            if self.index < self.current.len() {
-                let ix = self.current[self.index];
-                self.index += 1;
-                return Some(self.vertex_start_index + ix);
-            }
-            match self.iter.next() {
-                None => return None,
-                Some(trio) => {
-                    self.current = trio;
-                    self.index = 0;
-                }
-            }
-        }
-    }
-}
-
-impl SetOrientation for Mesh {
-    fn properties(&mut self) -> &mut orientation::Properties {
-        SetOrientation::properties(&mut self.orientation)
-    }
-}
-
-impl SetPosition for Mesh {
-    fn properties(&mut self) -> &mut position::Properties {
-        SetPosition::properties(&mut self.position)
-    }
-}
-
-impl SetColor<ColorScalar> for Mesh {
-    fn rgba_mut(&mut self) -> &mut Option<LinSrgba> {
-        &mut self.fill_color.get_or_insert_with(Default::default).0
-    }
-}
-
-impl From<Vertexless> for Primitive {
-    fn from(prim: Vertexless) -> Self {
-        Primitive::MeshVertexless(prim)
-    }
-}
-
-impl From<Mesh> for Primitive {
-    fn from(prim: Mesh) -> Self {
-        Primitive::Mesh(prim)
-    }
-}
-
-impl Into<Option<Vertexless>> for Primitive {
-    fn into(self) -> Option<Vertexless> {
-        match self {
-            Primitive::MeshVertexless(prim) => Some(prim),
-            _ => None,
-        }
-    }
-}
-
-impl Into<Option<Mesh>> for Primitive {
-    fn into(self) -> Option<Mesh> {
-        match self {
-            Primitive::Mesh(prim) => Some(prim),
-            _ => None,
-        }
-    }
-}
diff --git a/nannou/src/draw/primitive/mod.rs b/nannou/src/draw/primitive/mod.rs
deleted file mode 100644
index 60272a10f..000000000
--- a/nannou/src/draw/primitive/mod.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-pub mod arrow;
-pub mod ellipse;
-pub mod line;
-pub mod mesh;
-pub mod path;
-pub mod polygon;
-pub mod quad;
-pub mod rect;
-pub mod text;
-pub mod texture;
-pub mod tri;
-
-pub use self::arrow::Arrow;
-pub use self::ellipse::Ellipse;
-pub use self::line::Line;
-pub use self::mesh::Mesh;
-pub use self::path::{Path, PathFill, PathInit, PathStroke};
-pub use self::polygon::{Polygon, PolygonInit};
-pub use self::quad::Quad;
-pub use self::rect::Rect;
-pub use self::text::Text;
-pub use self::texture::Texture;
-pub use self::tri::Tri;
-
-/// A wrapper around all primitive sets of properties so that they may be stored within the
-/// **Draw**'s `drawing` field while they are being drawn.
-///
-/// This also allows us to flush all pending drawings to the mesh if `Draw::to_frame` is called
-/// before their respective **Drawing** types are dropped.
-#[derive(Clone, Debug)]
-pub enum Primitive {
-    Arrow(Arrow),
-    Ellipse(Ellipse),
-    Line(Line),
-    MeshVertexless(mesh::Vertexless),
-    Mesh(Mesh),
-    PathInit(PathInit),
-    PathFill(PathFill),
-    PathStroke(PathStroke),
-    Path(Path),
-    PolygonInit(PolygonInit),
-    Polygon(Polygon),
-    Quad(Quad),
-    Rect(Rect),
-    Text(Text),
-    Texture(Texture),
-    Tri(Tri),
-}
diff --git a/nannou/src/draw/primitive/path.rs b/nannou/src/draw/primitive/path.rs
deleted file mode 100644
index 065efc311..000000000
--- a/nannou/src/draw/primitive/path.rs
+++ /dev/null
@@ -1,925 +0,0 @@
-use crate::color::conv::IntoLinSrgba;
-use crate::color::LinSrgba;
-use crate::draw::mesh::vertex::{Color, TexCoords};
-use crate::draw::primitive::Primitive;
-use crate::draw::properties::spatial::{orientation, position};
-use crate::draw::properties::{
-    ColorScalar, SetColor, SetFill, SetOrientation, SetPosition, SetStroke,
-};
-use crate::draw::{self, Drawing, DrawingContext};
-use crate::geom::Point2;
-use crate::glam::Mat4;
-use crate::wgpu;
-use lyon::path::PathEvent;
-use lyon::tessellation::{FillOptions, FillTessellator, StrokeOptions, StrokeTessellator};
-
-/// A set of path tessellation options (FillOptions or StrokeOptions).
-pub trait TessellationOptions {
-    /// The tessellator for which the options are built.
-    type Tessellator;
-    /// Convert the typed options instance to a dynamic one.
-    fn into_options(self) -> Options;
-}
-
-#[derive(Clone, Debug)]
-pub(crate) enum PathEventSource {
-    /// Fetch events from `path_events_buffer`.
-    Buffered(std::ops::Range<usize>),
-    /// Generate events from the `path_points_colored_buffer`.
-    ColoredPoints {
-        range: std::ops::Range<usize>,
-        close: bool,
-    },
-    /// Generate events from the `path_points_textured_buffer`.
-    TexturedPoints {
-        range: std::ops::Range<usize>,
-        close: bool,
-    },
-}
-
-pub(crate) enum PathEventSourceIter<'a> {
-    Events(&'a mut dyn Iterator<Item = lyon::path::PathEvent>),
-    ColoredPoints {
-        points: &'a mut dyn Iterator<Item = (Point2, Color)>,
-        close: bool,
-    },
-    TexturedPoints {
-        points: &'a mut dyn Iterator<Item = (Point2, TexCoords)>,
-        close: bool,
-    },
-}
-
-/// The beginning of the path building process, prior to choosing the tessellation mode (fill or
-/// stroke).
-#[derive(Clone, Debug, Default)]
-pub struct PathInit;
-
-/// A path drawing context ready to specify tessellation options.
-#[derive(Clone, Debug, Default)]
-pub struct PathOptions<T> {
-    pub(crate) opts: T,
-    pub(crate) color: Option<LinSrgba>,
-    pub(crate) position: position::Properties,
-    pub(crate) orientation: orientation::Properties,
-}
-
-/// Mutable access to stroke and fill tessellators.
-pub struct Tessellators<'a> {
-    pub fill: &'a mut FillTessellator,
-    pub stroke: &'a mut StrokeTessellator,
-}
-
-/// A filled path drawing context.
-pub type PathFill = PathOptions<FillOptions>;
-
-/// A stroked path drawing context.
-pub type PathStroke = PathOptions<StrokeOptions>;
-
-/// Properties related to drawing a **Path**.
-#[derive(Clone, Debug)]
-pub struct Path {
-    color: Option<LinSrgba>,
-    position: position::Properties,
-    orientation: orientation::Properties,
-    path_event_src: PathEventSource,
-    options: Options,
-    vertex_mode: draw::renderer::VertexMode,
-    texture_view: Option<wgpu::TextureView>,
-}
-
-/// The initial drawing context for a path.
-pub type DrawingPathInit<'a> = Drawing<'a, PathInit>;
-
-/// The drawing context for a path in the tessellation options state.
-pub type DrawingPathOptions<'a, T> = Drawing<'a, PathOptions<T>>;
-
-/// The drawing context for a stroked path, prior to path event submission.
-pub type DrawingPathStroke<'a> = Drawing<'a, PathStroke>;
-
-/// The drawing context for a filled path, prior to path event submission.
-pub type DrawingPathFill<'a> = Drawing<'a, PathFill>;
-
-/// The drawing context for a polyline whose vertices have been specified.
-pub type DrawingPath<'a> = Drawing<'a, Path>;
-
-/// Dynamically distinguish between fill and stroke tessellation options.
-#[derive(Clone, Debug)]
-pub enum Options {
-    Fill(FillOptions),
-    Stroke(StrokeOptions),
-}
-
-impl PathInit {
-    /// Specify that we want to use fill tessellation for the path.
-    ///
-    /// The returned building context allows for specifying the fill tessellation options.
-    pub fn fill(self) -> PathFill {
-        let opts = FillOptions::default();
-        PathFill::new(opts)
-    }
-
-    /// Specify that we want to use stroke tessellation for the path.
-    ///
-    /// The returned building context allows for specifying the stroke tessellation options.
-    pub fn stroke(self) -> PathStroke {
-        let opts = Default::default();
-        PathStroke::new(opts)
-    }
-}
-
-impl<T> PathOptions<T> {
-    /// Initialise the `PathOptions` builder.
-    pub fn new(opts: T) -> Self {
-        let orientation = Default::default();
-        let position = Default::default();
-        let color = Default::default();
-        PathOptions {
-            opts,
-            orientation,
-            position,
-            color,
-        }
-    }
-}
-
-impl PathFill {
-    /// Maximum allowed distance to the path when building an approximation.
-    ///
-    /// This method is shorthand for the `fill_tolerance` method.
-    pub fn tolerance(self, tolerance: f32) -> Self {
-        self.fill_tolerance(tolerance)
-    }
-
-    /// Specify the rule used to determine what is inside and what is outside of the shape.
-    ///
-    /// Currently, only the `EvenOdd` rule is implemented.
-    ///
-    /// This method is shorthand for the `fill_rule` method.
-    pub fn rule(self, rule: lyon::tessellation::FillRule) -> Self {
-        self.fill_rule(rule)
-    }
-}
-
-impl PathStroke {
-    /// Short-hand for the `stroke_weight` method.
-    pub fn weight(self, weight: f32) -> Self {
-        self.stroke_weight(weight)
-    }
-
-    /// Short-hand for the `stroke_tolerance` method.
-    pub fn tolerance(self, tolerance: f32) -> Self {
-        self.stroke_tolerance(tolerance)
-    }
-}
-
-impl<T> PathOptions<T>
-where
-    T: TessellationOptions,
-{
-    /// Submit the path events to be tessellated.
-    pub(crate) fn events<I>(self, ctxt: DrawingContext, events: I) -> Path
-    where
-        I: IntoIterator<Item = PathEvent>,
-    {
-        let DrawingContext {
-            path_event_buffer, ..
-        } = ctxt;
-        let start = path_event_buffer.len();
-        path_event_buffer.extend(events);
-        let end = path_event_buffer.len();
-        Path::new(
-            self.position,
-            self.orientation,
-            self.color,
-            PathEventSource::Buffered(start..end),
-            self.opts.into_options(),
-            draw::renderer::VertexMode::Color,
-            None,
-        )
-    }
-
-    /// Consumes an iterator of points and converts them to an iterator yielding path events.
-    pub fn points<I>(self, ctxt: DrawingContext, points: I) -> Path
-    where
-        I: IntoIterator,
-        I::Item: Into<Point2>,
-    {
-        self.points_inner(ctxt, false, points)
-    }
-
-    /// Consumes an iterator of points and converts them to an iterator yielding path events.
-    ///
-    /// Closes the start and end points.
-    pub fn points_closed<I>(self, ctxt: DrawingContext, points: I) -> Path
-    where
-        I: IntoIterator,
-        I::Item: Into<Point2>,
-    {
-        self.points_inner(ctxt, true, points)
-    }
-
-    /// Submit path events as a polyline of colored points.
-    pub fn points_colored<I, P, C>(self, ctxt: DrawingContext, points: I) -> Path
-    where
-        I: IntoIterator<Item = (P, C)>,
-        P: Into<Point2>,
-        C: IntoLinSrgba<ColorScalar>,
-    {
-        self.points_colored_inner(ctxt, false, points)
-    }
-
-    /// Submit path events as a polyline of colored points.
-    pub fn points_colored_closed<I, P, C>(self, ctxt: DrawingContext, points: I) -> Path
-    where
-        I: IntoIterator<Item = (P, C)>,
-        P: Into<Point2>,
-        C: IntoLinSrgba<ColorScalar>,
-    {
-        self.points_colored_inner(ctxt, true, points)
-    }
-
-    /// Submit path events as a polyline of textured points.
-    pub fn points_textured<I, P, TC>(
-        self,
-        ctxt: DrawingContext,
-        texture_view: &dyn wgpu::ToTextureView,
-        points: I,
-    ) -> Path
-    where
-        I: IntoIterator<Item = (P, TC)>,
-        P: Into<Point2>,
-        TC: Into<TexCoords>,
-    {
-        self.points_textured_inner(ctxt, texture_view.to_texture_view(), false, points)
-    }
-
-    /// Submit path events as a polyline of textured points.
-    pub fn points_textured_closed<I, P, TC>(
-        self,
-        ctxt: DrawingContext,
-        texture_view: &dyn wgpu::ToTextureView,
-        points: I,
-    ) -> Path
-    where
-        I: IntoIterator<Item = (P, TC)>,
-        P: Into<Point2>,
-        TC: Into<TexCoords>,
-    {
-        self.points_textured_inner(ctxt, texture_view.to_texture_view(), true, points)
-    }
-
-    // Consumes an iterator of points and converts them to an iterator yielding events.
-    fn points_inner<I>(self, ctxt: DrawingContext, close: bool, points: I) -> Path
-    where
-        I: IntoIterator,
-        I::Item: Into<Point2>,
-    {
-        let iter = points
-            .into_iter()
-            .map(Into::into)
-            .map(|p| lyon::math::point(p.x, p.y));
-        let events = lyon::path::iterator::FromPolyline::new(close, iter);
-        self.events(ctxt, events)
-    }
-
-    // Consumes an iterator of points and converts them to an iterator yielding events.
-    fn points_colored_inner<I, P, C>(self, ctxt: DrawingContext, close: bool, points: I) -> Path
-    where
-        I: IntoIterator<Item = (P, C)>,
-        P: Into<Point2>,
-        C: IntoLinSrgba<ColorScalar>,
-    {
-        let DrawingContext {
-            path_points_colored_buffer,
-            ..
-        } = ctxt;
-        let start = path_points_colored_buffer.len();
-        let points = points
-            .into_iter()
-            .map(|(p, c)| (p.into(), c.into_lin_srgba()));
-        path_points_colored_buffer.extend(points);
-        let end = path_points_colored_buffer.len();
-        let path_event_src = PathEventSource::ColoredPoints {
-            range: start..end,
-            close,
-        };
-        Path::new(
-            self.position,
-            self.orientation,
-            self.color,
-            path_event_src,
-            self.opts.into_options(),
-            draw::renderer::VertexMode::Color,
-            None,
-        )
-    }
-
-    // Consumes an iterator of textured points and buffers them for rendering.
-    fn points_textured_inner<I, P, TC>(
-        self,
-        ctxt: DrawingContext,
-        texture_view: wgpu::TextureView,
-        close: bool,
-        points: I,
-    ) -> Path
-    where
-        I: IntoIterator<Item = (P, TC)>,
-        P: Into<Point2>,
-        TC: Into<TexCoords>,
-    {
-        let DrawingContext {
-            path_points_textured_buffer,
-            ..
-        } = ctxt;
-        let start = path_points_textured_buffer.len();
-        let points = points.into_iter().map(|(p, tc)| (p.into(), tc.into()));
-        path_points_textured_buffer.extend(points);
-        let end = path_points_textured_buffer.len();
-        let path_event_src = PathEventSource::TexturedPoints {
-            range: start..end,
-            close,
-        };
-        Path::new(
-            self.position,
-            self.orientation,
-            self.color,
-            path_event_src,
-            self.opts.into_options(),
-            draw::renderer::VertexMode::Texture,
-            Some(texture_view),
-        )
-    }
-}
-
-pub(crate) fn render_path_events<I>(
-    events: I,
-    color: Option<LinSrgba>,
-    transform: Mat4,
-    options: Options,
-    theme: &draw::Theme,
-    theme_prim: &draw::theme::Primitive,
-    fill_tessellator: &mut lyon::tessellation::FillTessellator,
-    stroke_tessellator: &mut lyon::tessellation::StrokeTessellator,
-    mesh: &mut draw::Mesh,
-) where
-    I: IntoIterator<Item = lyon::path::PathEvent>,
-{
-    let res = match options {
-        Options::Fill(options) => {
-            let color = color.unwrap_or_else(|| theme.fill_lin_srgba(theme_prim));
-            let mut mesh_builder = draw::mesh::MeshBuilder::single_color(mesh, transform, color);
-            fill_tessellator.tessellate(events, &options, &mut mesh_builder)
-        }
-        Options::Stroke(options) => {
-            let color = color.unwrap_or_else(|| theme.stroke_lin_srgba(theme_prim));
-            let mut mesh_builder = draw::mesh::MeshBuilder::single_color(mesh, transform, color);
-            stroke_tessellator.tessellate(events, &options, &mut mesh_builder)
-        }
-    };
-    if let Err(err) = res {
-        eprintln!("failed to tessellate path: {:?}", err);
-    }
-}
-
-pub(crate) fn render_path_points_colored<I>(
-    points_colored: I,
-    close: bool,
-    transform: Mat4,
-    options: Options,
-    fill_tessellator: &mut lyon::tessellation::FillTessellator,
-    stroke_tessellator: &mut lyon::tessellation::StrokeTessellator,
-    mesh: &mut draw::Mesh,
-) where
-    I: IntoIterator<Item = (Point2, Color)>,
-{
-    let path = match points_colored_to_lyon_path(points_colored, close) {
-        None => return,
-        Some(p) => p,
-    };
-
-    // Extend the mesh with the built path.
-    let mut mesh_builder = draw::mesh::MeshBuilder::color_per_point(mesh, transform);
-    let res = match options {
-        Options::Fill(options) => fill_tessellator.tessellate_with_ids(
-            path.id_iter(),
-            &path,
-            Some(&path),
-            &options,
-            &mut mesh_builder,
-        ),
-        Options::Stroke(options) => stroke_tessellator.tessellate_with_ids(
-            path.id_iter(),
-            &path,
-            Some(&path),
-            &options,
-            &mut mesh_builder,
-        ),
-    };
-    if let Err(err) = res {
-        eprintln!("failed to tessellate path: {:?}", err);
-    }
-}
-
-pub(crate) fn render_path_points_textured<I>(
-    points_textured: I,
-    close: bool,
-    transform: Mat4,
-    options: Options,
-    fill_tessellator: &mut lyon::tessellation::FillTessellator,
-    stroke_tessellator: &mut lyon::tessellation::StrokeTessellator,
-    mesh: &mut draw::Mesh,
-) where
-    I: IntoIterator<Item = (Point2, TexCoords)>,
-{
-    let path = match points_textured_to_lyon_path(points_textured, close) {
-        None => return,
-        Some(p) => p,
-    };
-
-    // Extend the mesh with the built path.
-    let mut mesh_builder = draw::mesh::MeshBuilder::tex_coords_per_point(mesh, transform);
-    let res = match options {
-        Options::Fill(options) => fill_tessellator.tessellate_with_ids(
-            path.id_iter(),
-            &path,
-            Some(&path),
-            &options,
-            &mut mesh_builder,
-        ),
-        Options::Stroke(options) => stroke_tessellator.tessellate_with_ids(
-            path.id_iter(),
-            &path,
-            Some(&path),
-            &options,
-            &mut mesh_builder,
-        ),
-    };
-    if let Err(err) = res {
-        eprintln!("failed to tessellate path: {:?}", err);
-    }
-}
-
-pub(crate) fn render_path_source(
-    // TODO:
-    path_src: PathEventSourceIter,
-    color: Option<LinSrgba>,
-    transform: Mat4,
-    options: Options,
-    theme: &draw::Theme,
-    theme_prim: &draw::theme::Primitive,
-    fill_tessellator: &mut lyon::tessellation::FillTessellator,
-    stroke_tessellator: &mut lyon::tessellation::StrokeTessellator,
-    mesh: &mut draw::Mesh,
-) {
-    match path_src {
-        PathEventSourceIter::Events(events) => render_path_events(
-            events,
-            color,
-            transform,
-            options,
-            theme,
-            theme_prim,
-            fill_tessellator,
-            stroke_tessellator,
-            mesh,
-        ),
-        PathEventSourceIter::ColoredPoints { points, close } => render_path_points_colored(
-            points,
-            close,
-            transform,
-            options,
-            fill_tessellator,
-            stroke_tessellator,
-            mesh,
-        ),
-        PathEventSourceIter::TexturedPoints { points, close } => render_path_points_textured(
-            points,
-            close,
-            transform,
-            options,
-            fill_tessellator,
-            stroke_tessellator,
-            mesh,
-        ),
-    }
-}
-
-impl draw::renderer::RenderPrimitive for Path {
-    fn render_primitive(
-        self,
-        mut ctxt: draw::renderer::RenderContext,
-        mesh: &mut draw::Mesh,
-    ) -> draw::renderer::PrimitiveRender {
-        let Path {
-            color,
-            position,
-            orientation,
-            path_event_src,
-            options,
-            vertex_mode,
-            texture_view,
-        } = self;
-
-        // Determine the transform to apply to all points.
-        let global_transform = *ctxt.transform;
-        let local_transform = position.transform() * orientation.transform();
-        let transform = global_transform * local_transform;
-
-        // A function for rendering the path.
-        let render =
-            |src: PathEventSourceIter,
-             theme: &draw::Theme,
-             fill_tessellator: &mut lyon::tessellation::FillTessellator,
-             stroke_tessellator: &mut lyon::tessellation::StrokeTessellator| {
-                render_path_source(
-                    src,
-                    color,
-                    transform,
-                    options,
-                    theme,
-                    &draw::theme::Primitive::Path,
-                    fill_tessellator,
-                    stroke_tessellator,
-                    mesh,
-                )
-            };
-
-        match path_event_src {
-            PathEventSource::Buffered(range) => {
-                let mut events = ctxt.path_event_buffer[range].iter().cloned();
-                let src = PathEventSourceIter::Events(&mut events);
-                render(
-                    src,
-                    &ctxt.theme,
-                    &mut ctxt.fill_tessellator,
-                    &mut ctxt.stroke_tessellator,
-                );
-            }
-            PathEventSource::ColoredPoints { range, close } => {
-                let mut points_colored = ctxt.path_points_colored_buffer[range].iter().cloned();
-                let src = PathEventSourceIter::ColoredPoints {
-                    points: &mut points_colored,
-                    close,
-                };
-                render(
-                    src,
-                    &ctxt.theme,
-                    &mut ctxt.fill_tessellator,
-                    &mut ctxt.stroke_tessellator,
-                );
-            }
-            PathEventSource::TexturedPoints { range, close } => {
-                let mut points_textured = ctxt.path_points_textured_buffer[range].iter().cloned();
-                let src = PathEventSourceIter::TexturedPoints {
-                    points: &mut points_textured,
-                    close,
-                };
-                render(
-                    src,
-                    &ctxt.theme,
-                    &mut ctxt.fill_tessellator,
-                    &mut ctxt.stroke_tessellator,
-                );
-            }
-        }
-
-        draw::renderer::PrimitiveRender {
-            texture_view,
-            vertex_mode,
-        }
-    }
-}
-
-/// Create a lyon path for the given iterator of colored points.
-pub fn points_colored_to_lyon_path<I>(points_colored: I, close: bool) -> Option<lyon::path::Path>
-where
-    I: IntoIterator<Item = (Point2, Color)>,
-{
-    // Build a path with a color attribute for each channel.
-    let channels = draw::mesh::vertex::COLOR_CHANNEL_COUNT;
-    let mut path_builder = lyon::path::Path::builder_with_attributes(channels);
-
-    // Begin the path.
-    let mut iter = points_colored.into_iter();
-    let (first_point, first_color) = iter.next()?;
-    let p = first_point.to_array().into();
-    let (r, g, b, a) = first_color.into();
-    path_builder.begin(p, &[r, g, b, a]);
-
-    // Add the lines, keeping track of the last
-    for (point, color) in iter {
-        let p = point.to_array().into();
-        let (r, g, b, a) = color.into();
-        path_builder.line_to(p, &[r, g, b, a]);
-    }
-
-    // End the path, closing if necessary.
-    path_builder.end(close);
-
-    // Build it!
-    Some(path_builder.build())
-}
-
-/// Create a lyon path for the given iterator of textured points.
-pub fn points_textured_to_lyon_path<I>(points_textured: I, close: bool) -> Option<lyon::path::Path>
-where
-    I: IntoIterator<Item = (Point2, TexCoords)>,
-{
-    // Build a path with a texture coords attribute for each channel.
-    let channels = 2;
-    let mut path_builder = lyon::path::Path::builder_with_attributes(channels);
-
-    // Begin the path.
-    let mut iter = points_textured.into_iter();
-    let (first_point, first_tex_coords) = iter.next()?;
-    let p = first_point.to_array().into();
-    let (tc_x, tc_y) = first_tex_coords.into();
-    path_builder.begin(p, &[tc_x, tc_y]);
-
-    // Add the lines, keeping track of the last
-    for (point, tex_coords) in iter {
-        let p = point.to_array().into();
-        let (tc_x, tc_y) = tex_coords.into();
-        path_builder.line_to(p, &[tc_x, tc_y]);
-    }
-
-    // End the path, closing if necessary.
-    path_builder.end(close);
-
-    // Build it!
-    Some(path_builder.build())
-}
-
-impl Path {
-    // Initialise a new `Path` with its ranges into the intermediary mesh, ready for drawing.
-    fn new(
-        position: position::Properties,
-        orientation: orientation::Properties,
-        color: Option<LinSrgba>,
-        path_event_src: PathEventSource,
-        options: Options,
-        vertex_mode: draw::renderer::VertexMode,
-        texture_view: Option<wgpu::TextureView>,
-    ) -> Self {
-        Path {
-            color,
-            orientation,
-            position,
-            path_event_src,
-            options,
-            vertex_mode,
-            texture_view,
-        }
-    }
-}
-
-impl<'a> DrawingPathInit<'a> {
-    /// Specify that we want to use fill tessellation for the path.
-    ///
-    /// The returned building context allows for specifying the fill tessellation options.
-    pub fn fill(self) -> DrawingPathFill<'a> {
-        self.map_ty(|ty| ty.fill())
-    }
-
-    /// Specify that we want to use stroke tessellation for the path.
-    ///
-    /// The returned building context allows for specifying the stroke tessellation options.
-    pub fn stroke(self) -> DrawingPathStroke<'a> {
-        self.map_ty(|ty| ty.stroke())
-    }
-}
-
-impl<'a> DrawingPathFill<'a> {
-    /// Maximum allowed distance to the path when building an approximation.
-    pub fn tolerance(self, tolerance: f32) -> Self {
-        self.map_ty(|ty| ty.tolerance(tolerance))
-    }
-
-    /// Specify the rule used to determine what is inside and what is outside of the shape.
-    ///
-    /// Currently, only the `EvenOdd` rule is implemented.
-    pub fn rule(self, rule: lyon::tessellation::FillRule) -> Self {
-        self.map_ty(|ty| ty.rule(rule))
-    }
-}
-
-impl<'a> DrawingPathStroke<'a> {
-    /// Short-hand for the `stroke_weight` method.
-    pub fn weight(self, weight: f32) -> Self {
-        self.map_ty(|ty| ty.stroke_weight(weight))
-    }
-
-    /// Short-hand for the `stroke_tolerance` method.
-    pub fn tolerance(self, tolerance: f32) -> Self {
-        self.map_ty(|ty| ty.stroke_tolerance(tolerance))
-    }
-}
-
-impl<'a, T> DrawingPathOptions<'a, T>
-where
-    T: TessellationOptions,
-    PathOptions<T>: Into<Primitive>,
-    Primitive: Into<Option<PathOptions<T>>>,
-{
-    /// Submit the path events to be tessellated.
-    pub fn events<I>(self, events: I) -> DrawingPath<'a>
-    where
-        I: IntoIterator<Item = lyon::path::PathEvent>,
-    {
-        self.map_ty_with_context(|ty, ctxt| ty.events(ctxt, events))
-    }
-
-    /// Submit the path events as a polyline of points.
-    pub fn points<I>(self, points: I) -> DrawingPath<'a>
-    where
-        I: IntoIterator,
-        I::Item: Into<Point2>,
-    {
-        self.map_ty_with_context(|ty, ctxt| ty.points(ctxt, points))
-    }
-
-    /// Submit the path events as a polyline of points.
-    ///
-    /// An event will be generated that closes the start and end points.
-    pub fn points_closed<I>(self, points: I) -> DrawingPath<'a>
-    where
-        I: IntoIterator,
-        I::Item: Into<Point2>,
-    {
-        self.map_ty_with_context(|ty, ctxt| ty.points_closed(ctxt, points))
-    }
-
-    /// Submit path events as a polyline of colored points.
-    pub fn points_colored<I, P, C>(self, points: I) -> DrawingPath<'a>
-    where
-        I: IntoIterator<Item = (P, C)>,
-        P: Into<Point2>,
-        C: IntoLinSrgba<ColorScalar>,
-    {
-        self.map_ty_with_context(|ty, ctxt| ty.points_colored(ctxt, points))
-    }
-
-    /// Submit path events as a polyline of colored points.
-    ///
-    /// The path with automatically close from the end point to the start point.
-    pub fn points_colored_closed<I, P, C>(self, points: I) -> DrawingPath<'a>
-    where
-        I: IntoIterator<Item = (P, C)>,
-        P: Into<Point2>,
-        C: IntoLinSrgba<ColorScalar>,
-    {
-        self.map_ty_with_context(|ty, ctxt| ty.points_colored_closed(ctxt, points))
-    }
-
-    /// Submit path events as a polyline of textured points.
-    pub fn points_textured<I, P, TC>(
-        self,
-        view: &dyn wgpu::ToTextureView,
-        points: I,
-    ) -> DrawingPath<'a>
-    where
-        I: IntoIterator<Item = (P, TC)>,
-        P: Into<Point2>,
-        TC: Into<TexCoords>,
-    {
-        self.map_ty_with_context(|ty, ctxt| ty.points_textured(ctxt, view, points))
-    }
-
-    /// Submit path events as a polyline of textured points.
-    ///
-    /// The path with automatically close from the end point to the start point.
-    pub fn points_textured_closed<I, P, TC>(
-        self,
-        view: &dyn wgpu::ToTextureView,
-        points: I,
-    ) -> DrawingPath<'a>
-    where
-        I: IntoIterator<Item = (P, TC)>,
-        P: Into<Point2>,
-        TC: Into<TexCoords>,
-    {
-        self.map_ty_with_context(|ty, ctxt| ty.points_textured_closed(ctxt, view, points))
-    }
-}
-
-impl SetFill for PathFill {
-    fn fill_options_mut(&mut self) -> &mut FillOptions {
-        &mut self.opts
-    }
-}
-
-impl SetStroke for PathStroke {
-    fn stroke_options_mut(&mut self) -> &mut StrokeOptions {
-        &mut self.opts
-    }
-}
-
-impl TessellationOptions for FillOptions {
-    type Tessellator = FillTessellator;
-    fn into_options(self) -> Options {
-        Options::Fill(self)
-    }
-}
-
-impl TessellationOptions for StrokeOptions {
-    type Tessellator = StrokeTessellator;
-    fn into_options(self) -> Options {
-        Options::Stroke(self)
-    }
-}
-
-impl<T> SetOrientation for PathOptions<T> {
-    fn properties(&mut self) -> &mut orientation::Properties {
-        SetOrientation::properties(&mut self.orientation)
-    }
-}
-
-impl<T> SetPosition for PathOptions<T> {
-    fn properties(&mut self) -> &mut position::Properties {
-        SetPosition::properties(&mut self.position)
-    }
-}
-
-impl<T> SetColor<ColorScalar> for PathOptions<T> {
-    fn rgba_mut(&mut self) -> &mut Option<LinSrgba> {
-        SetColor::rgba_mut(&mut self.color)
-    }
-}
-
-impl SetOrientation for Path {
-    fn properties(&mut self) -> &mut orientation::Properties {
-        SetOrientation::properties(&mut self.orientation)
-    }
-}
-
-impl SetPosition for Path {
-    fn properties(&mut self) -> &mut position::Properties {
-        SetPosition::properties(&mut self.position)
-    }
-}
-
-impl SetColor<ColorScalar> for Path {
-    fn rgba_mut(&mut self) -> &mut Option<LinSrgba> {
-        SetColor::rgba_mut(&mut self.color)
-    }
-}
-
-impl From<PathInit> for Primitive {
-    fn from(prim: PathInit) -> Self {
-        Primitive::PathInit(prim)
-    }
-}
-
-impl From<PathStroke> for Primitive {
-    fn from(prim: PathStroke) -> Self {
-        Primitive::PathStroke(prim)
-    }
-}
-
-impl From<PathFill> for Primitive {
-    fn from(prim: PathFill) -> Self {
-        Primitive::PathFill(prim)
-    }
-}
-
-impl From<Path> for Primitive {
-    fn from(prim: Path) -> Self {
-        Primitive::Path(prim)
-    }
-}
-
-impl Into<Option<PathInit>> for Primitive {
-    fn into(self) -> Option<PathInit> {
-        match self {
-            Primitive::PathInit(prim) => Some(prim),
-            _ => None,
-        }
-    }
-}
-
-impl Into<Option<PathFill>> for Primitive {
-    fn into(self) -> Option<PathFill> {
-        match self {
-            Primitive::PathFill(prim) => Some(prim),
-            _ => None,
-        }
-    }
-}
-
-impl Into<Option<PathStroke>> for Primitive {
-    fn into(self) -> Option<PathStroke> {
-        match self {
-            Primitive::PathStroke(prim) => Some(prim),
-            _ => None,
-        }
-    }
-}
-
-impl Into<Option<Path>> for Primitive {
-    fn into(self) -> Option<Path> {
-        match self {
-            Primitive::Path(prim) => Some(prim),
-            _ => None,
-        }
-    }
-}
diff --git a/nannou/src/draw/primitive/polygon.rs b/nannou/src/draw/primitive/polygon.rs
deleted file mode 100644
index 754cf71e9..000000000
--- a/nannou/src/draw/primitive/polygon.rs
+++ /dev/null
@@ -1,607 +0,0 @@
-use crate::color::conv::IntoLinSrgba;
-use crate::draw::drawing::DrawingContext;
-use crate::draw::mesh::vertex::TexCoords;
-use crate::draw::primitive::path::{self, PathEventSource};
-use crate::draw::primitive::Primitive;
-use crate::draw::properties::spatial::{orientation, position};
-use crate::draw::properties::{
-    ColorScalar, LinSrgba, SetColor, SetOrientation, SetPosition, SetStroke,
-};
-use crate::draw::{self, Drawing};
-use crate::geom::Point2;
-use crate::wgpu;
-use lyon::path::PathEvent;
-use lyon::tessellation::StrokeOptions;
-
-/// A trait implemented for all polygon draw primitives.
-pub trait SetPolygon: Sized {
-    /// Access to the polygon builder parameters.
-    fn polygon_options_mut(&mut self) -> &mut PolygonOptions;
-
-    /// Specify no fill color and in turn no fill tessellation for the polygon.
-    fn no_fill(mut self) -> Self {
-        self.polygon_options_mut().no_fill = true;
-        self
-    }
-
-    /// Specify a color to use for stroke tessellation.
-    ///
-    /// Stroke tessellation will only be performed if this method or one of the `SetStroke` methods
-    /// are called.
-    fn stroke_color<C>(mut self, color: C) -> Self
-    where
-        C: IntoLinSrgba<ColorScalar>,
-    {
-        self.polygon_options_mut().stroke_color = Some(color.into_lin_srgba());
-        self
-    }
-
-    /// Specify the whole set of polygon options.
-    fn polygon_options(mut self, opts: PolygonOptions) -> Self {
-        *self.polygon_options_mut() = opts;
-        self
-    }
-}
-
-/// State related to drawing a **Polygon**.
-#[derive(Clone, Debug, Default)]
-pub struct PolygonInit {
-    pub(crate) opts: PolygonOptions,
-}
-
-/// The set of options shared by all polygon types.
-#[derive(Clone, Debug, Default)]
-pub struct PolygonOptions {
-    pub position: position::Properties,
-    pub orientation: orientation::Properties,
-    pub no_fill: bool,
-    pub stroke_color: Option<LinSrgba>,
-    pub color: Option<LinSrgba>,
-    pub stroke: Option<StrokeOptions>,
-}
-
-/// A polygon with vertices already submitted.
-#[derive(Clone, Debug)]
-pub struct Polygon {
-    opts: PolygonOptions,
-    path_event_src: PathEventSource,
-    texture_view: Option<wgpu::TextureView>,
-}
-
-/// Initialised drawing state for a polygon.
-pub type DrawingPolygonInit<'a> = Drawing<'a, PolygonInit>;
-
-/// Initialised drawing state for a polygon.
-pub type DrawingPolygon<'a> = Drawing<'a, Polygon>;
-
-impl PolygonInit {
-    /// Stroke the outline with the given color.
-    pub fn stroke<C>(self, color: C) -> Self
-    where
-        C: IntoLinSrgba<ColorScalar>,
-    {
-        self.stroke_color(color)
-    }
-
-    /// Submit the path events to be tessellated.
-    pub(crate) fn events<I>(self, ctxt: DrawingContext, events: I) -> Polygon
-    where
-        I: IntoIterator<Item = PathEvent>,
-    {
-        let DrawingContext {
-            path_event_buffer, ..
-        } = ctxt;
-        let start = path_event_buffer.len();
-        path_event_buffer.extend(events);
-        let end = path_event_buffer.len();
-        Polygon {
-            opts: self.opts,
-            path_event_src: PathEventSource::Buffered(start..end),
-            texture_view: None,
-        }
-    }
-
-    /// Consumes an iterator of points and converts them to an iterator yielding path events.
-    pub fn points<I>(self, ctxt: DrawingContext, points: I) -> Polygon
-    where
-        I: IntoIterator,
-        I::Item: Into<Point2>,
-    {
-        let points = points.into_iter().map(|p| {
-            let p: Point2 = p.into();
-            p.to_array().into()
-        });
-        let close = true;
-        let events = lyon::path::iterator::FromPolyline::new(close, points);
-        self.events(ctxt, events)
-    }
-
-    /// Consumes an iterator of points and converts them to an iterator yielding path events.
-    pub fn points_colored<I, P, C>(self, ctxt: DrawingContext, points: I) -> Polygon
-    where
-        I: IntoIterator<Item = (P, C)>,
-        P: Into<Point2>,
-        C: IntoLinSrgba<ColorScalar>,
-    {
-        let DrawingContext {
-            path_points_colored_buffer,
-            ..
-        } = ctxt;
-        let start = path_points_colored_buffer.len();
-        let points = points
-            .into_iter()
-            .map(|(p, c)| (p.into(), c.into_lin_srgba()));
-        path_points_colored_buffer.extend(points);
-        let end = path_points_colored_buffer.len();
-        Polygon {
-            opts: self.opts,
-            path_event_src: PathEventSource::ColoredPoints {
-                range: start..end,
-                close: true,
-            },
-            texture_view: None,
-        }
-    }
-
-    /// Consumes an iterator of points and converts them to an iterator yielding path events.
-    pub fn points_textured<I, P, T>(
-        self,
-        ctxt: DrawingContext,
-        view: &dyn wgpu::ToTextureView,
-        points: I,
-    ) -> Polygon
-    where
-        I: IntoIterator<Item = (P, T)>,
-        P: Into<Point2>,
-        T: Into<TexCoords>,
-    {
-        let DrawingContext {
-            path_points_textured_buffer,
-            ..
-        } = ctxt;
-        let start = path_points_textured_buffer.len();
-        let points = points.into_iter().map(|(p, c)| (p.into(), c.into()));
-        path_points_textured_buffer.extend(points);
-        let end = path_points_textured_buffer.len();
-        Polygon {
-            opts: self.opts,
-            path_event_src: PathEventSource::TexturedPoints {
-                range: start..end,
-                close: true,
-            },
-            texture_view: Some(view.to_texture_view()),
-        }
-    }
-}
-
-pub fn render_events_themed<F, I>(
-    opts: PolygonOptions,
-    events: F,
-    mut ctxt: draw::renderer::RenderContext,
-    theme_primitive: &draw::theme::Primitive,
-    mesh: &mut draw::Mesh,
-) where
-    F: Fn() -> I,
-    I: Iterator<Item = lyon::path::PathEvent>,
-{
-    let PolygonOptions {
-        position,
-        orientation,
-        no_fill,
-        stroke_color,
-        color,
-        stroke,
-    } = opts;
-
-    // Determine the transform to apply to all points.
-    let global_transform = *ctxt.transform;
-    let local_transform = position.transform() * orientation.transform();
-    let transform = global_transform * local_transform;
-
-    // A function for rendering the path.
-    let mut render =
-        |opts: path::Options,
-         color: Option<LinSrgba>,
-         theme: &draw::Theme,
-         fill_tessellator: &mut lyon::tessellation::FillTessellator,
-         stroke_tessellator: &mut lyon::tessellation::StrokeTessellator| {
-            path::render_path_events(
-                events(),
-                color,
-                transform,
-                opts,
-                theme,
-                theme_primitive,
-                fill_tessellator,
-                stroke_tessellator,
-                mesh,
-            )
-        };
-
-    // Do the fill tessellation first.
-    if !no_fill {
-        let opts = path::Options::Fill(lyon::tessellation::FillOptions::default());
-        render(
-            opts,
-            color,
-            &ctxt.theme,
-            &mut ctxt.fill_tessellator,
-            &mut ctxt.stroke_tessellator,
-        );
-    }
-
-    // Do the stroke tessellation on top.
-    if let Some(stroke_opts) = stroke {
-        let opts = path::Options::Stroke(stroke_opts);
-        let color = stroke_color;
-        render(
-            opts,
-            color,
-            &ctxt.theme,
-            &mut ctxt.fill_tessellator,
-            &mut ctxt.stroke_tessellator,
-        );
-    }
-}
-
-pub fn render_points_themed<I>(
-    opts: PolygonOptions,
-    points: I,
-    ctxt: draw::renderer::RenderContext,
-    theme_primitive: &draw::theme::Primitive,
-    mesh: &mut draw::Mesh,
-) where
-    I: Clone + Iterator<Item = Point2>,
-{
-    render_events_themed(
-        opts,
-        || lyon::path::iterator::FromPolyline::closed(points.clone().map(|p| p.to_array().into())),
-        ctxt,
-        theme_primitive,
-        mesh,
-    );
-}
-
-impl Polygon {
-    pub(crate) fn render_themed(
-        self,
-        ctxt: draw::renderer::RenderContext,
-        mesh: &mut draw::Mesh,
-        theme_primitive: &draw::theme::Primitive,
-    ) -> draw::renderer::PrimitiveRender {
-        let Polygon {
-            path_event_src,
-            opts:
-                PolygonOptions {
-                    position,
-                    orientation,
-                    no_fill,
-                    stroke_color,
-                    color,
-                    stroke,
-                },
-            texture_view,
-        } = self;
-        let draw::renderer::RenderContext {
-            fill_tessellator,
-            stroke_tessellator,
-            path_event_buffer,
-            path_points_colored_buffer,
-            path_points_textured_buffer,
-            transform,
-            theme,
-            ..
-        } = ctxt;
-
-        // Determine the transform to apply to all points.
-        let global_transform = *transform;
-        let local_transform = position.transform() * orientation.transform();
-        let transform = global_transform * local_transform;
-
-        // A function for rendering the path.
-        let mut render =
-            |src: path::PathEventSourceIter,
-             opts: path::Options,
-             color: Option<LinSrgba>,
-             theme: &draw::Theme,
-             fill_tessellator: &mut lyon::tessellation::FillTessellator,
-             stroke_tessellator: &mut lyon::tessellation::StrokeTessellator| {
-                path::render_path_source(
-                    src,
-                    color,
-                    transform,
-                    opts,
-                    theme,
-                    theme_primitive,
-                    fill_tessellator,
-                    stroke_tessellator,
-                    mesh,
-                )
-            };
-
-        // Do the fill tessellation first.
-        if !no_fill {
-            let opts = path::Options::Fill(lyon::tessellation::FillOptions::default());
-            match path_event_src {
-                PathEventSource::Buffered(ref range) => {
-                    let mut events = path_event_buffer[range.clone()].iter().cloned();
-                    let src = path::PathEventSourceIter::Events(&mut events);
-                    render(
-                        src,
-                        opts,
-                        color,
-                        theme,
-                        fill_tessellator,
-                        stroke_tessellator,
-                    );
-                }
-                PathEventSource::ColoredPoints { ref range, close } => {
-                    let mut points_colored =
-                        path_points_colored_buffer[range.clone()].iter().cloned();
-                    let src = path::PathEventSourceIter::ColoredPoints {
-                        points: &mut points_colored,
-                        close,
-                    };
-                    render(
-                        src,
-                        opts,
-                        color,
-                        theme,
-                        fill_tessellator,
-                        stroke_tessellator,
-                    );
-                }
-                PathEventSource::TexturedPoints { ref range, close } => {
-                    let mut textured_points =
-                        path_points_textured_buffer[range.clone()].iter().cloned();
-                    let src = path::PathEventSourceIter::TexturedPoints {
-                        points: &mut textured_points,
-                        close,
-                    };
-                    render(
-                        src,
-                        opts,
-                        color,
-                        theme,
-                        fill_tessellator,
-                        stroke_tessellator,
-                    );
-                }
-            }
-        }
-
-        // Then the the stroked outline.
-        if let Some(stroke_opts) = stroke {
-            let opts = path::Options::Stroke(stroke_opts);
-            match path_event_src {
-                PathEventSource::Buffered(range) => {
-                    let mut events = path_event_buffer[range].iter().cloned();
-                    let src = path::PathEventSourceIter::Events(&mut events);
-                    render(
-                        src,
-                        opts,
-                        stroke_color,
-                        theme,
-                        fill_tessellator,
-                        stroke_tessellator,
-                    );
-                }
-                PathEventSource::ColoredPoints { range, close } => {
-                    let color =
-                        stroke_color.unwrap_or_else(|| theme.stroke_lin_srgba(theme_primitive));
-                    let mut points_colored = path_points_colored_buffer[range]
-                        .iter()
-                        .cloned()
-                        .map(|(point, _)| (point, color));
-                    let src = path::PathEventSourceIter::ColoredPoints {
-                        points: &mut points_colored,
-                        close,
-                    };
-                    render(
-                        src,
-                        opts,
-                        stroke_color,
-                        theme,
-                        fill_tessellator,
-                        stroke_tessellator,
-                    );
-                }
-                PathEventSource::TexturedPoints { range, close } => {
-                    let mut textured_points = path_points_textured_buffer[range].iter().cloned();
-                    let src = path::PathEventSourceIter::TexturedPoints {
-                        points: &mut textured_points,
-                        close,
-                    };
-                    render(
-                        src,
-                        opts,
-                        stroke_color,
-                        theme,
-                        fill_tessellator,
-                        stroke_tessellator,
-                    );
-                }
-            }
-        }
-
-        match texture_view {
-            None => draw::renderer::PrimitiveRender::default(),
-            Some(texture_view) => draw::renderer::PrimitiveRender {
-                texture_view: Some(texture_view),
-                vertex_mode: draw::renderer::VertexMode::Texture,
-            },
-        }
-    }
-}
-
-impl draw::renderer::RenderPrimitive for Polygon {
-    fn render_primitive(
-        self,
-        ctxt: draw::renderer::RenderContext,
-        mesh: &mut draw::Mesh,
-    ) -> draw::renderer::PrimitiveRender {
-        self.render_themed(ctxt, mesh, &draw::theme::Primitive::Polygon)
-    }
-}
-
-impl<'a, T> Drawing<'a, T>
-where
-    T: SetPolygon + Into<Primitive>,
-    Primitive: Into<Option<T>>,
-{
-    /// Specify no fill color and in turn no fill tessellation for the polygon.
-    pub fn no_fill(self) -> Self {
-        self.map_ty(|ty| ty.no_fill())
-    }
-
-    /// Specify a color to use for stroke tessellation.
-    ///
-    /// Stroke tessellation will only be performed if this method or one of the `SetStroke` methods
-    /// are called.
-    pub fn stroke_color<C>(self, color: C) -> Self
-    where
-        C: IntoLinSrgba<ColorScalar>,
-    {
-        self.map_ty(|ty| ty.stroke_color(color))
-    }
-
-    /// Specify the whole set of polygon options.
-    pub fn polygon_options(self, opts: PolygonOptions) -> Self {
-        self.map_ty(|ty| ty.polygon_options(opts))
-    }
-}
-
-impl<'a> DrawingPolygonInit<'a> {
-    /// Stroke the outline with the given color.
-    pub fn stroke<C>(self, color: C) -> Self
-    where
-        C: IntoLinSrgba<ColorScalar>,
-    {
-        self.map_ty(|ty| ty.stroke(color))
-    }
-
-    /// Describe the polygon with a sequence of path events.
-    pub fn events<I>(self, events: I) -> DrawingPolygon<'a>
-    where
-        I: IntoIterator<Item = PathEvent>,
-    {
-        self.map_ty_with_context(|ty, ctxt| ty.events(ctxt, events))
-    }
-
-    /// Describe the polygon with a sequence of points.
-    pub fn points<I>(self, points: I) -> DrawingPolygon<'a>
-    where
-        I: IntoIterator,
-        I::Item: Into<Point2>,
-    {
-        self.map_ty_with_context(|ty, ctxt| ty.points(ctxt, points))
-    }
-
-    /// Consumes an iterator of points and converts them to an iterator yielding path events.
-    pub fn points_colored<I, P, C>(self, points: I) -> DrawingPolygon<'a>
-    where
-        I: IntoIterator<Item = (P, C)>,
-        P: Into<Point2>,
-        C: IntoLinSrgba<ColorScalar>,
-    {
-        self.map_ty_with_context(|ty, ctxt| ty.points_colored(ctxt, points))
-    }
-
-    /// Describe the polygon with an iterator yielding textured poings.
-    pub fn points_textured<I, P, T>(
-        self,
-        view: &dyn wgpu::ToTextureView,
-        points: I,
-    ) -> DrawingPolygon<'a>
-    where
-        I: IntoIterator<Item = (P, T)>,
-        P: Into<Point2>,
-        T: Into<TexCoords>,
-    {
-        self.map_ty_with_context(|ty, ctxt| ty.points_textured(ctxt, view, points))
-    }
-}
-
-impl SetPolygon for PolygonOptions {
-    fn polygon_options_mut(&mut self) -> &mut PolygonOptions {
-        self
-    }
-}
-
-impl SetOrientation for PolygonInit {
-    fn properties(&mut self) -> &mut orientation::Properties {
-        SetOrientation::properties(&mut self.opts.orientation)
-    }
-}
-
-impl SetPosition for PolygonInit {
-    fn properties(&mut self) -> &mut position::Properties {
-        SetPosition::properties(&mut self.opts.position)
-    }
-}
-
-impl SetColor<ColorScalar> for PolygonInit {
-    fn rgba_mut(&mut self) -> &mut Option<LinSrgba> {
-        SetColor::rgba_mut(&mut self.opts.color)
-    }
-}
-
-impl SetPolygon for PolygonInit {
-    fn polygon_options_mut(&mut self) -> &mut PolygonOptions {
-        SetPolygon::polygon_options_mut(&mut self.opts)
-    }
-}
-
-impl SetStroke for PolygonInit {
-    fn stroke_options_mut(&mut self) -> &mut StrokeOptions {
-        SetStroke::stroke_options_mut(&mut self.opts.stroke)
-    }
-}
-
-impl SetOrientation for Polygon {
-    fn properties(&mut self) -> &mut orientation::Properties {
-        SetOrientation::properties(&mut self.opts.orientation)
-    }
-}
-
-impl SetPosition for Polygon {
-    fn properties(&mut self) -> &mut position::Properties {
-        SetPosition::properties(&mut self.opts.position)
-    }
-}
-
-impl SetColor<ColorScalar> for Polygon {
-    fn rgba_mut(&mut self) -> &mut Option<LinSrgba> {
-        SetColor::rgba_mut(&mut self.opts.color)
-    }
-}
-
-impl From<PolygonInit> for Primitive {
-    fn from(prim: PolygonInit) -> Self {
-        Primitive::PolygonInit(prim)
-    }
-}
-
-impl From<Polygon> for Primitive {
-    fn from(prim: Polygon) -> Self {
-        Primitive::Polygon(prim)
-    }
-}
-
-impl Into<Option<PolygonInit>> for Primitive {
-    fn into(self) -> Option<PolygonInit> {
-        match self {
-            Primitive::PolygonInit(prim) => Some(prim),
-            _ => None,
-        }
-    }
-}
-
-impl Into<Option<Polygon>> for Primitive {
-    fn into(self) -> Option<Polygon> {
-        match self {
-            Primitive::Polygon(prim) => Some(prim),
-            _ => None,
-        }
-    }
-}
diff --git a/nannou/src/draw/primitive/quad.rs b/nannou/src/draw/primitive/quad.rs
deleted file mode 100644
index 04c47a41b..000000000
--- a/nannou/src/draw/primitive/quad.rs
+++ /dev/null
@@ -1,183 +0,0 @@
-use crate::color::conv::IntoLinSrgba;
-use crate::draw::primitive::polygon::{self, PolygonInit, PolygonOptions, SetPolygon};
-use crate::draw::primitive::Primitive;
-use crate::draw::properties::spatial::{dimension, orientation, position};
-use crate::draw::properties::{
-    spatial, ColorScalar, LinSrgba, SetColor, SetDimensions, SetOrientation, SetPosition, SetStroke,
-};
-use crate::draw::{self, Drawing};
-use crate::geom::{self, pt2, Point2};
-use crate::glam::vec2;
-use lyon::tessellation::StrokeOptions;
-
-/// Properties related to drawing a **Quad**.
-#[derive(Clone, Debug)]
-pub struct Quad {
-    quad: geom::Quad<Point2>,
-    polygon: PolygonInit,
-    dimensions: spatial::dimension::Properties,
-}
-
-/// The drawing context for a `Quad`.
-pub type DrawingQuad<'a> = Drawing<'a, Quad>;
-
-// Quad-specific methods.
-
-impl Quad {
-    /// Stroke the outline with the given color.
-    pub fn stroke<C>(self, color: C) -> Self
-    where
-        C: IntoLinSrgba<ColorScalar>,
-    {
-        self.stroke_color(color)
-    }
-
-    /// Use the given four points as the vertices (corners) of the quad.
-    pub fn points<P>(mut self, a: P, b: P, c: P, d: P) -> Self
-    where
-        P: Into<Point2>,
-    {
-        let a = a.into();
-        let b = b.into();
-        let c = c.into();
-        let d = d.into();
-        self.quad = geom::Quad([a, b, c, d]);
-        self
-    }
-}
-
-// Trait implementations.
-impl draw::renderer::RenderPrimitive for Quad {
-    fn render_primitive(
-        self,
-        ctxt: draw::renderer::RenderContext,
-        mesh: &mut draw::Mesh,
-    ) -> draw::renderer::PrimitiveRender {
-        let Quad {
-            mut quad,
-            polygon,
-            dimensions,
-        } = self;
-
-        // If dimensions were specified, scale the points to those dimensions.
-        let (maybe_x, maybe_y, _maybe_z) = (dimensions.x, dimensions.y, dimensions.z);
-        if maybe_x.is_some() || maybe_y.is_some() {
-            let cuboid = quad.bounding_rect();
-            let centroid = quad.centroid();
-            let x_scale = maybe_x.map(|x| x / cuboid.w()).unwrap_or(1.0);
-            let y_scale = maybe_y.map(|y| y / cuboid.h()).unwrap_or(1.0);
-            let scale = vec2(x_scale, y_scale);
-            let (a, b, c, d) = quad.into();
-            let translate = |v: Point2| centroid + ((v - centroid) * scale);
-            let new_a = translate(a);
-            let new_b = translate(b);
-            let new_c = translate(c);
-            let new_d = translate(d);
-            quad = geom::Quad([new_a, new_b, new_c, new_d]);
-        }
-
-        let points = quad.vertices();
-        polygon::render_points_themed(
-            polygon.opts,
-            points,
-            ctxt,
-            &draw::theme::Primitive::Quad,
-            mesh,
-        );
-
-        draw::renderer::PrimitiveRender::default()
-    }
-}
-
-impl From<geom::Quad<Point2>> for Quad {
-    fn from(quad: geom::Quad<Point2>) -> Self {
-        let polygon = Default::default();
-        let dimensions = Default::default();
-        Quad {
-            polygon,
-            dimensions,
-            quad,
-        }
-    }
-}
-
-impl Default for Quad {
-    fn default() -> Self {
-        // Create a quad pointing towards 0.0 radians.
-        let fifty = 50.0;
-        let left = -fifty;
-        let bottom = -fifty;
-        let right = fifty;
-        let top = fifty;
-        let a = pt2(left, bottom);
-        let b = pt2(left, top);
-        let c = pt2(right, top);
-        let d = pt2(right, bottom);
-        Quad::from(geom::Quad([a, b, c, d]))
-    }
-}
-
-impl SetOrientation for Quad {
-    fn properties(&mut self) -> &mut orientation::Properties {
-        SetOrientation::properties(&mut self.polygon)
-    }
-}
-
-impl SetPosition for Quad {
-    fn properties(&mut self) -> &mut position::Properties {
-        SetPosition::properties(&mut self.polygon)
-    }
-}
-
-impl SetDimensions for Quad {
-    fn properties(&mut self) -> &mut dimension::Properties {
-        SetDimensions::properties(&mut self.dimensions)
-    }
-}
-
-impl SetColor<ColorScalar> for Quad {
-    fn rgba_mut(&mut self) -> &mut Option<LinSrgba> {
-        SetColor::rgba_mut(&mut self.polygon)
-    }
-}
-
-impl SetStroke for Quad {
-    fn stroke_options_mut(&mut self) -> &mut StrokeOptions {
-        SetStroke::stroke_options_mut(&mut self.polygon)
-    }
-}
-
-impl SetPolygon for Quad {
-    fn polygon_options_mut(&mut self) -> &mut PolygonOptions {
-        SetPolygon::polygon_options_mut(&mut self.polygon)
-    }
-}
-
-// Primitive conversions.
-
-impl From<Quad> for Primitive {
-    fn from(prim: Quad) -> Self {
-        Primitive::Quad(prim)
-    }
-}
-
-impl Into<Option<Quad>> for Primitive {
-    fn into(self) -> Option<Quad> {
-        match self {
-            Primitive::Quad(prim) => Some(prim),
-            _ => None,
-        }
-    }
-}
-
-// Drawing methods.
-
-impl<'a> DrawingQuad<'a> {
-    /// Use the given points as the vertices (corners) of the quad.
-    pub fn points<P>(self, a: P, b: P, c: P, d: P) -> Self
-    where
-        P: Into<Point2>,
-    {
-        self.map_ty(|ty| ty.points(a, b, c, d))
-    }
-}
diff --git a/nannou/src/draw/primitive/rect.rs b/nannou/src/draw/primitive/rect.rs
deleted file mode 100644
index b52c8cf18..000000000
--- a/nannou/src/draw/primitive/rect.rs
+++ /dev/null
@@ -1,147 +0,0 @@
-use crate::color::conv::IntoLinSrgba;
-use crate::draw::primitive::polygon::{self, PolygonInit, PolygonOptions, SetPolygon};
-use crate::draw::primitive::Primitive;
-use crate::draw::properties::spatial::{dimension, orientation, position};
-use crate::draw::properties::{
-    ColorScalar, LinSrgba, SetColor, SetDimensions, SetOrientation, SetPosition, SetStroke,
-};
-use crate::draw::{self, Drawing};
-use crate::geom;
-use crate::glam::Vec2;
-use lyon::tessellation::StrokeOptions;
-
-/// Properties related to drawing a **Rect**.
-#[derive(Clone, Debug)]
-pub struct Rect {
-    dimensions: dimension::Properties,
-    polygon: PolygonInit,
-}
-
-/// The drawing context for a Rect.
-pub type DrawingRect<'a> = Drawing<'a, Rect>;
-
-// Trait implementations.
-
-impl Rect {
-    /// Stroke the outline with the given color.
-    pub fn stroke<C>(self, color: C) -> Self
-    where
-        C: IntoLinSrgba<ColorScalar>,
-    {
-        self.stroke_color(color)
-    }
-}
-
-impl<'a> DrawingRect<'a> {
-    /// Stroke the outline with the given color.
-    pub fn stroke<C>(self, color: C) -> Self
-    where
-        C: IntoLinSrgba<ColorScalar>,
-    {
-        self.map_ty(|ty| ty.stroke(color))
-    }
-}
-
-impl draw::renderer::RenderPrimitive for Rect {
-    fn render_primitive(
-        self,
-        ctxt: draw::renderer::RenderContext,
-        mesh: &mut draw::Mesh,
-    ) -> draw::renderer::PrimitiveRender {
-        let Rect {
-            polygon,
-            dimensions,
-        } = self;
-
-        // If dimensions were specified, scale the points to those dimensions.
-        let (maybe_x, maybe_y, maybe_z) = (dimensions.x, dimensions.y, dimensions.z);
-        assert!(
-            maybe_z.is_none(),
-            "z dimension support for rect is unimplemented"
-        );
-        let w = maybe_x.unwrap_or(100.0);
-        let h = maybe_y.unwrap_or(100.0);
-        let rect = geom::Rect::from_wh([w, h].into());
-        let points = rect.corners().vertices().map(Vec2::from);
-        polygon::render_points_themed(
-            polygon.opts,
-            points,
-            ctxt,
-            &draw::theme::Primitive::Rect,
-            mesh,
-        );
-
-        draw::renderer::PrimitiveRender::default()
-    }
-}
-
-impl From<geom::Rect<f32>> for Rect {
-    fn from(r: geom::Rect<f32>) -> Self {
-        let (x, y, w, h) = r.x_y_w_h();
-        Self::default().x_y(x, y).w_h(w, h)
-    }
-}
-
-impl Default for Rect {
-    fn default() -> Self {
-        let dimensions = <_>::default();
-        let polygon = <_>::default();
-        Rect {
-            dimensions,
-            polygon,
-        }
-    }
-}
-
-impl SetOrientation for Rect {
-    fn properties(&mut self) -> &mut orientation::Properties {
-        SetOrientation::properties(&mut self.polygon)
-    }
-}
-
-impl SetPosition for Rect {
-    fn properties(&mut self) -> &mut position::Properties {
-        SetPosition::properties(&mut self.polygon)
-    }
-}
-
-impl SetDimensions for Rect {
-    fn properties(&mut self) -> &mut dimension::Properties {
-        SetDimensions::properties(&mut self.dimensions)
-    }
-}
-
-impl SetColor<ColorScalar> for Rect {
-    fn rgba_mut(&mut self) -> &mut Option<LinSrgba> {
-        SetColor::rgba_mut(&mut self.polygon)
-    }
-}
-
-impl SetStroke for Rect {
-    fn stroke_options_mut(&mut self) -> &mut StrokeOptions {
-        SetStroke::stroke_options_mut(&mut self.polygon)
-    }
-}
-
-impl SetPolygon for Rect {
-    fn polygon_options_mut(&mut self) -> &mut PolygonOptions {
-        SetPolygon::polygon_options_mut(&mut self.polygon)
-    }
-}
-
-// Primitive conversions.
-
-impl From<Rect> for Primitive {
-    fn from(prim: Rect) -> Self {
-        Primitive::Rect(prim)
-    }
-}
-
-impl Into<Option<Rect>> for Primitive {
-    fn into(self) -> Option<Rect> {
-        match self {
-            Primitive::Rect(prim) => Some(prim),
-            _ => None,
-        }
-    }
-}
diff --git a/nannou/src/draw/primitive/text.rs b/nannou/src/draw/primitive/text.rs
deleted file mode 100644
index f031bcc57..000000000
--- a/nannou/src/draw/primitive/text.rs
+++ /dev/null
@@ -1,458 +0,0 @@
-use crate::color::conv::IntoLinSrgba;
-use crate::draw::drawing::DrawingContext;
-use crate::draw::primitive::Primitive;
-use crate::draw::properties::spatial::{self, dimension, orientation, position};
-use crate::draw::properties::{
-    ColorScalar, LinSrgba, SetColor, SetDimensions, SetOrientation, SetPosition,
-};
-use crate::draw::{self, theme, Drawing};
-use crate::geom::{self, Point2};
-use crate::text::{self, Align, Font, FontSize, Justify, Layout, Scalar, Wrap};
-
-/// Properties related to drawing the **Text** primitive.
-#[derive(Clone, Debug)]
-pub struct Text {
-    spatial: spatial::Properties,
-    style: Style,
-    // The byte range into the `Draw` context's text buffer.
-    text: std::ops::Range<usize>,
-}
-
-/// Styling properties for the **Text** primitive.
-#[derive(Clone, Debug, Default)]
-pub struct Style {
-    pub color: Option<LinSrgba>,
-    pub glyph_colors: Vec<LinSrgba>, // Overrides `color` if non-empty.
-    pub layout: text::layout::Builder,
-}
-
-/// The drawing context for the **Text** primitive.
-pub type DrawingText<'a> = Drawing<'a, Text>;
-
-impl Text {
-    /// Begin drawing some text.
-    pub fn new(ctxt: DrawingContext, text: &str) -> Self {
-        let start = ctxt.text_buffer.len();
-        ctxt.text_buffer.push_str(text);
-        let end = ctxt.text_buffer.len();
-        let text = start..end;
-        let spatial = Default::default();
-        let style = Default::default();
-        Text {
-            spatial,
-            style,
-            text,
-        }
-    }
-
-    // Apply the given function to the inner text layout.
-    fn map_layout<F>(mut self, map: F) -> Self
-    where
-        F: FnOnce(text::layout::Builder) -> text::layout::Builder,
-    {
-        self.style.layout = map(self.style.layout);
-        self
-    }
-
-    /// The font size to use for the text.
-    pub fn font_size(self, size: FontSize) -> Self {
-        self.map_layout(|l| l.font_size(size))
-    }
-
-    /// Specify whether or not text should be wrapped around some width and how to do so.
-    ///
-    /// The default value is `DEFAULT_LINE_WRAP`.
-    pub fn line_wrap(self, line_wrap: Option<Wrap>) -> Self {
-        self.map_layout(|l| l.line_wrap(line_wrap))
-    }
-
-    /// Specify that the **Text** should not wrap lines around the width.
-    ///
-    /// Shorthand for `builder.line_wrap(None)`.
-    pub fn no_line_wrap(self) -> Self {
-        self.map_layout(|l| l.no_line_wrap())
-    }
-
-    /// Line wrap the **Text** at the beginning of the first word that exceeds the width.
-    ///
-    /// Shorthand for `builder.line_wrap(Some(Wrap::Whitespace))`.
-    pub fn wrap_by_word(self) -> Self {
-        self.map_layout(|l| l.wrap_by_word())
-    }
-
-    /// Line wrap the **Text** at the beginning of the first character that exceeds the width.
-    ///
-    /// Shorthand for `builder.line_wrap(Some(Wrap::Character))`.
-    pub fn wrap_by_character(self) -> Self {
-        self.map_layout(|l| l.wrap_by_character())
-    }
-
-    /// A method for specifying the `Font` used for displaying the `Text`.
-    pub fn font(self, font: Font) -> Self {
-        self.map_layout(|l| l.font(font))
-    }
-
-    /// Describe the end along the *x* axis to which the text should be aligned.
-    pub fn justify(self, justify: Justify) -> Self {
-        self.map_layout(|l| l.justify(justify))
-    }
-
-    /// Align the text to the left of its bounding **Rect**'s *x* axis range.
-    pub fn left_justify(self) -> Self {
-        self.map_layout(|l| l.left_justify())
-    }
-
-    /// Align the text to the middle of its bounding **Rect**'s *x* axis range.
-    pub fn center_justify(self) -> Self {
-        self.map_layout(|l| l.center_justify())
-    }
-
-    /// Align the text to the right of its bounding **Rect**'s *x* axis range.
-    pub fn right_justify(self) -> Self {
-        self.map_layout(|l| l.right_justify())
-    }
-
-    /// Specify how much vertical space should separate each line of text.
-    pub fn line_spacing(self, spacing: Scalar) -> Self {
-        self.map_layout(|l| l.line_spacing(spacing))
-    }
-
-    /// Specify how the whole text should be aligned along the y axis of its bounding rectangle
-    pub fn y_align(self, align: Align) -> Self {
-        self.map_layout(|l| l.y_align(align))
-    }
-
-    /// Align the top edge of the text with the top edge of its bounding rectangle.
-    pub fn align_top(self) -> Self {
-        self.map_layout(|l| l.align_top())
-    }
-
-    /// Align the middle of the text with the middle of the bounding rect along the y axis.
-    ///
-    /// This is the default behaviour.
-    pub fn align_middle_y(self) -> Self {
-        self.map_layout(|l| l.align_middle_y())
-    }
-
-    /// Align the bottom edge of the text with the bottom edge of its bounding rectangle.
-    pub fn align_bottom(self) -> Self {
-        self.map_layout(|l| l.align_bottom())
-    }
-
-    /// Set all the parameters via an existing `Layout`
-    pub fn layout(self, layout: &Layout) -> Self {
-        self.map_layout(|l| l.layout(layout))
-    }
-
-    /// Specify the entire styling for the **Text**.
-    pub fn with_style(mut self, style: Style) -> Self {
-        self.style = style;
-        self
-    }
-
-    /// Set a color for each glyph.
-    /// Colors unspecified glyphs using the drawing color.
-    pub fn glyph_colors(mut self, colors: Vec<LinSrgba>) -> Self {
-        self.style.glyph_colors = colors;
-        self
-    }
-}
-
-impl<'a> DrawingText<'a> {
-    /// The font size to use for the text.
-    pub fn font_size(self, size: text::FontSize) -> Self {
-        self.map_ty(|ty| ty.font_size(size))
-    }
-
-    /// Specify that the **Text** should not wrap lines around the width.
-    pub fn no_line_wrap(self) -> Self {
-        self.map_ty(|ty| ty.no_line_wrap())
-    }
-
-    /// Line wrap the **Text** at the beginning of the first word that exceeds the width.
-    pub fn wrap_by_word(self) -> Self {
-        self.map_ty(|ty| ty.wrap_by_word())
-    }
-
-    /// Line wrap the **Text** at the beginning of the first character that exceeds the width.
-    pub fn wrap_by_character(self) -> Self {
-        self.map_ty(|ty| ty.wrap_by_character())
-    }
-
-    /// A method for specifying the `Font` used for displaying the `Text`.
-    pub fn font(self, font: text::Font) -> Self {
-        self.map_ty(|ty| ty.font(font))
-    }
-
-    /// Build the **Text** with the given **Style**.
-    pub fn with_style(self, style: Style) -> Self {
-        self.map_ty(|ty| ty.with_style(style))
-    }
-
-    /// Describe the end along the *x* axis to which the text should be aligned.
-    pub fn justify(self, justify: text::Justify) -> Self {
-        self.map_ty(|ty| ty.justify(justify))
-    }
-
-    /// Align the text to the left of its bounding **Rect**'s *x* axis range.
-    pub fn left_justify(self) -> Self {
-        self.map_ty(|ty| ty.left_justify())
-    }
-
-    /// Align the text to the middle of its bounding **Rect**'s *x* axis range.
-    pub fn center_justify(self) -> Self {
-        self.map_ty(|ty| ty.center_justify())
-    }
-
-    /// Align the text to the right of its bounding **Rect**'s *x* axis range.
-    pub fn right_justify(self) -> Self {
-        self.map_ty(|ty| ty.right_justify())
-    }
-
-    /// Specify how much vertical space should separate each line of text.
-    pub fn line_spacing(self, spacing: text::Scalar) -> Self {
-        self.map_ty(|ty| ty.line_spacing(spacing))
-    }
-
-    /// Specify how the whole text should be aligned along the y axis of its bounding rectangle
-    pub fn y_align_text(self, align: Align) -> Self {
-        self.map_ty(|ty| ty.y_align(align))
-    }
-
-    /// Align the top edge of the text with the top edge of its bounding rectangle.
-    pub fn align_text_top(self) -> Self {
-        self.map_ty(|ty| ty.align_top())
-    }
-
-    /// Align the middle of the text with the middle of the bounding rect along the y axis.
-    ///
-    /// This is the default behaviour.
-    pub fn align_text_middle_y(self) -> Self {
-        self.map_ty(|ty| ty.align_middle_y())
-    }
-
-    /// Align the bottom edge of the text with the bottom edge of its bounding rectangle.
-    pub fn align_text_bottom(self) -> Self {
-        self.map_ty(|ty| ty.align_bottom())
-    }
-
-    /// Set all the parameters via an existing `Layout`
-    pub fn layout(self, layout: &Layout) -> Self {
-        self.map_ty(|ty| ty.layout(layout))
-    }
-
-    /// Set a color for each glyph, which is typically one character.
-    /// Colors unspecified glyphs using the drawing color.
-    /// NOTE: Sometimes, a glyph can represent multiple characters,
-    ///       or be a part in other glyphs.
-    pub fn glyph_colors<I, C>(self, glyph_colors: I) -> Self
-    where
-        I: IntoIterator<Item = C>,
-        C: IntoLinSrgba<ColorScalar>,
-    {
-        let glyph_colors = glyph_colors
-            .into_iter()
-            .map(|c| c.into_lin_srgba())
-            .collect();
-
-        self.map_ty(|ty| ty.glyph_colors(glyph_colors))
-    }
-}
-
-impl draw::renderer::RenderPrimitive for Text {
-    fn render_primitive(
-        self,
-        ctxt: draw::renderer::RenderContext,
-        mesh: &mut draw::Mesh,
-    ) -> draw::renderer::PrimitiveRender {
-        let Text {
-            spatial,
-            style,
-            text,
-        } = self;
-        let Style {
-            color,
-            glyph_colors,
-            layout,
-        } = style;
-        let layout = layout.build();
-        let (maybe_x, maybe_y, maybe_z) = (
-            spatial.dimensions.x,
-            spatial.dimensions.y,
-            spatial.dimensions.z,
-        );
-        assert!(
-            maybe_z.is_none(),
-            "z dimension support for text is unimplemented"
-        );
-        let w = maybe_x.unwrap_or(200.0);
-        let h = maybe_y.unwrap_or(200.0);
-        let rect: geom::Rect = geom::Rect::from_wh([w, h].into());
-        let color = color.unwrap_or_else(|| ctxt.theme.fill_lin_srgba(&theme::Primitive::Text));
-
-        let text_str = &ctxt.text_buffer[text.clone()];
-        let text = text::text(text_str).layout(&layout).build(rect);
-
-        // Queue the glyphs to be cached
-        let font_id = text::font::id(text.font());
-        let positioned_glyphs: Vec<_> = text
-            .rt_glyphs(
-                ctxt.output_attachment_size,
-                ctxt.output_attachment_scale_factor,
-            )
-            .collect();
-        for glyph in positioned_glyphs.iter() {
-            ctxt.glyph_cache.queue_glyph(font_id.index(), glyph.clone());
-        }
-
-        // Cache the enqueued glyphs within the pixel buffer.
-        let (glyph_cache_w, _) = ctxt.glyph_cache.dimensions();
-        {
-            let draw::renderer::RenderContext {
-                glyph_cache:
-                    &mut draw::renderer::GlyphCache {
-                        ref mut cache,
-                        ref mut pixel_buffer,
-                        ref mut requires_upload,
-                        ..
-                    },
-                ..
-            } = ctxt;
-            let glyph_cache_w = glyph_cache_w as usize;
-            let res = cache.cache_queued(|rect, data| {
-                let width = (rect.max.x - rect.min.x) as usize;
-                let height = (rect.max.y - rect.min.y) as usize;
-                let mut dst_ix = rect.min.y as usize * glyph_cache_w + rect.min.x as usize;
-                let mut src_ix = 0;
-                for _ in 0..height {
-                    let dst_range = dst_ix..dst_ix + width;
-                    let src_range = src_ix..src_ix + width;
-                    let dst_slice = &mut pixel_buffer[dst_range];
-                    let src_slice = &data[src_range];
-                    dst_slice.copy_from_slice(src_slice);
-                    dst_ix += glyph_cache_w;
-                    src_ix += width;
-                }
-                *requires_upload = true;
-            });
-            if let Err(err) = res {
-                eprintln!("failed to cache queued glyphs: {}", err);
-            }
-        }
-
-        // Determine the transform to apply to all points.
-        let global_transform = *ctxt.transform;
-        let local_transform = spatial.position.transform() * spatial.orientation.transform();
-        let transform = global_transform * local_transform;
-
-        // A function for converting RustType rects to nannou rects.
-        let scale_factor = ctxt.output_attachment_scale_factor;
-        let (out_w, out_h) = ctxt.output_attachment_size.into();
-        let [half_out_w, half_out_h] = [out_w as f32 / 2.0, out_h as f32 / 2.0];
-        let to_nannou_rect = |screen_rect: text::rt::Rect<i32>| {
-            let l = screen_rect.min.x as f32 / scale_factor - half_out_w;
-            let r = screen_rect.max.x as f32 / scale_factor - half_out_w;
-            let t = -(screen_rect.min.y as f32 / scale_factor - half_out_h);
-            let b = -(screen_rect.max.y as f32 / scale_factor - half_out_h);
-            geom::Rect::from_corners([l, b].into(), [r, t].into())
-        };
-
-        // Skips non-rendered colors (e.g. due to line breaks),
-        //   assuming LineInfos are ordered by ascending character position.
-        let glyph_colors_iter = text
-            .line_infos()
-            .iter()
-            .flat_map(|li| li.char_range())
-            .take_while(|&i| i < glyph_colors.len())
-            .map(|i| &glyph_colors[i])
-            // Repeat `color` if more glyphs than glyph_colors
-            .chain(std::iter::repeat(&color));
-
-        // Extend the mesh with a rect for each displayed glyph.
-        for (g, g_color) in positioned_glyphs.iter().zip(glyph_colors_iter) {
-            if let Ok(Some((uv_rect, screen_rect))) = ctxt.glyph_cache.rect_for(font_id.index(), &g)
-            {
-                let rect = to_nannou_rect(screen_rect);
-
-                // Create a mesh-compatible vertex from the position and tex_coords.
-                let v = |p: Point2, tex_coords: [f32; 2]| -> draw::mesh::Vertex {
-                    let p = transform.transform_point3([p.x, p.y, 0.0].into());
-                    let point = draw::mesh::vertex::Point::from(p);
-                    draw::mesh::vertex::new(point, g_color.to_owned(), tex_coords.into())
-                };
-
-                // The sides of the UV rect.
-                let uv_l = uv_rect.min.x;
-                let uv_t = uv_rect.min.y;
-                let uv_r = uv_rect.max.x;
-                let uv_b = uv_rect.max.y;
-
-                // Insert the vertices.
-                let bottom_left = v(rect.bottom_left(), [uv_l, uv_b]);
-                let bottom_right = v(rect.bottom_right(), [uv_r, uv_b]);
-                let top_left = v(rect.top_left(), [uv_l, uv_t]);
-                let top_right = v(rect.top_right(), [uv_r, uv_t]);
-                let start_ix = mesh.points().len() as u32;
-                mesh.push_vertex(top_left);
-                mesh.push_vertex(bottom_left);
-                mesh.push_vertex(bottom_right);
-                mesh.push_vertex(top_right);
-
-                // Now the indices.
-                let tl_ix = start_ix;
-                let bl_ix = start_ix + 1;
-                let br_ix = start_ix + 2;
-                let tr_ix = start_ix + 3;
-                mesh.push_index(tl_ix);
-                mesh.push_index(bl_ix);
-                mesh.push_index(br_ix);
-                mesh.push_index(tl_ix);
-                mesh.push_index(br_ix);
-                mesh.push_index(tr_ix);
-            }
-        }
-
-        draw::renderer::PrimitiveRender::text()
-    }
-}
-
-impl SetOrientation for Text {
-    fn properties(&mut self) -> &mut orientation::Properties {
-        SetOrientation::properties(&mut self.spatial)
-    }
-}
-
-impl SetPosition for Text {
-    fn properties(&mut self) -> &mut position::Properties {
-        SetPosition::properties(&mut self.spatial)
-    }
-}
-
-impl SetDimensions for Text {
-    fn properties(&mut self) -> &mut dimension::Properties {
-        SetDimensions::properties(&mut self.spatial)
-    }
-}
-
-impl SetColor<ColorScalar> for Text {
-    fn rgba_mut(&mut self) -> &mut Option<LinSrgba> {
-        SetColor::rgba_mut(&mut self.style.color)
-    }
-}
-
-// Primitive conversions.
-
-impl From<Text> for Primitive {
-    fn from(prim: Text) -> Self {
-        Primitive::Text(prim)
-    }
-}
-
-impl Into<Option<Text>> for Primitive {
-    fn into(self) -> Option<Text> {
-        match self {
-            Primitive::Text(prim) => Some(prim),
-            _ => None,
-        }
-    }
-}
diff --git a/nannou/src/draw/primitive/texture.rs b/nannou/src/draw/primitive/texture.rs
deleted file mode 100644
index 5b86714a9..000000000
--- a/nannou/src/draw/primitive/texture.rs
+++ /dev/null
@@ -1,164 +0,0 @@
-use crate::draw::primitive::path;
-use crate::draw::primitive::Primitive;
-use crate::draw::properties::spatial::{self, dimension, orientation, position};
-use crate::draw::properties::{SetDimensions, SetOrientation, SetPosition};
-use crate::draw::{self, Drawing};
-use crate::geom;
-use crate::glam::Vec2;
-use crate::wgpu;
-
-/// Properties related to drawing a **Rect**.
-#[derive(Clone, Debug)]
-pub struct Texture {
-    texture_view: wgpu::TextureView,
-    spatial: spatial::Properties,
-    area: geom::Rect,
-}
-
-/// The drawing context for a Rect.
-pub type DrawingTexture<'a> = Drawing<'a, Texture>;
-
-// Trait implementations.
-
-impl Texture {
-    pub(crate) fn new(view: &dyn wgpu::ToTextureView) -> Self {
-        let texture_view = view.to_texture_view();
-        let [w, h] = texture_view.size();
-        let w = w as f32;
-        let h = h as f32;
-        let spatial = spatial::Properties::default().w_h(w, h);
-        let x = geom::Range {
-            start: 0.0,
-            end: 1.0,
-        };
-        let y = geom::Range {
-            start: 0.0,
-            end: 1.0,
-        };
-        let area = geom::Rect { x, y };
-        Self {
-            texture_view,
-            spatial,
-            area,
-        }
-    }
-}
-
-impl Texture {
-    /// Specify the area of the texture to draw.
-    ///
-    /// The bounds of the rectangle should represent the desired area as texture coordinates of the
-    /// underlying texture.
-    ///
-    /// Texture coordinates range from (0.0, 0.0) in the bottom left of the texture, to (1.0, 1.0)
-    /// in the top right of the texture.
-    ///
-    /// By default, the area represents the full extent of the texture.
-    pub fn area(mut self, rect: geom::Rect) -> Self {
-        self.area = rect;
-        self
-    }
-}
-
-impl<'a> DrawingTexture<'a> {
-    /// Specify the area of the texture to draw.
-    ///
-    /// The bounds of the rectangle should represent the desired area as texture coordinates of the
-    /// underlying texture.
-    ///
-    /// Texture coordinates range from (0.0, 0.0) in the bottom left of the texture, to (1.0, 1.0)
-    /// in the top right of the texture.
-    ///
-    /// By default, the area represents the full extent of the texture.
-    pub fn area(self, rect: geom::Rect) -> Self {
-        self.map_ty(|ty| ty.area(rect))
-    }
-}
-
-impl draw::renderer::RenderPrimitive for Texture {
-    fn render_primitive(
-        self,
-        mut ctxt: draw::renderer::RenderContext,
-        mesh: &mut draw::Mesh,
-    ) -> draw::renderer::PrimitiveRender {
-        let Texture {
-            texture_view,
-            spatial,
-            area,
-        } = self;
-        let spatial::Properties {
-            dimensions,
-            position,
-            orientation,
-        } = spatial;
-
-        // If dimensions were specified, scale the points to those dimensions.
-        let (maybe_x, maybe_y, maybe_z) = (dimensions.x, dimensions.y, dimensions.z);
-        assert!(
-            maybe_z.is_none(),
-            "z dimension support for rect is unimplemented"
-        );
-        let w = maybe_x.unwrap_or(100.0);
-        let h = maybe_y.unwrap_or(100.0);
-        let rect = geom::Rect::from_w_h(w, h);
-
-        // Determine the transform to apply to all points.
-        let global_transform = *ctxt.transform;
-        let local_transform = position.transform() * orientation.transform();
-        let transform = global_transform * local_transform;
-
-        // Create an iterator yielding texture points.
-        let points_textured = rect
-            .corners()
-            .vertices()
-            .map(Vec2::from)
-            .zip(area.invert_y().corners().vertices().map(Vec2::from));
-
-        path::render_path_points_textured(
-            points_textured,
-            true,
-            transform,
-            path::Options::Fill(Default::default()),
-            &mut ctxt.fill_tessellator,
-            &mut ctxt.stroke_tessellator,
-            mesh,
-        );
-
-        draw::renderer::PrimitiveRender::texture(texture_view)
-    }
-}
-
-impl SetOrientation for Texture {
-    fn properties(&mut self) -> &mut orientation::Properties {
-        SetOrientation::properties(&mut self.spatial)
-    }
-}
-
-impl SetPosition for Texture {
-    fn properties(&mut self) -> &mut position::Properties {
-        SetPosition::properties(&mut self.spatial)
-    }
-}
-
-impl SetDimensions for Texture {
-    fn properties(&mut self) -> &mut dimension::Properties {
-        SetDimensions::properties(&mut self.spatial)
-    }
-}
-
-// Primitive conversions.
-
-impl From<Texture> for Primitive {
-    fn from(prim: Texture) -> Self {
-        Primitive::Texture(prim)
-    }
-}
-
-impl Into<Option<Texture>> for Primitive {
-    fn into(self) -> Option<Texture> {
-        match self {
-            Primitive::Texture(prim) => Some(prim),
-            _ => None,
-        }
-    }
-}
diff --git a/nannou/src/draw/primitive/tri.rs b/nannou/src/draw/primitive/tri.rs
deleted file mode 100644
index 8b0f96e70..000000000
--- a/nannou/src/draw/primitive/tri.rs
+++ /dev/null
@@ -1,184 +0,0 @@
-use crate::color::conv::IntoLinSrgba;
-use crate::draw::primitive::polygon::{self, PolygonInit, PolygonOptions, SetPolygon};
-use crate::draw::primitive::Primitive;
-use crate::draw::properties::spatial::{dimension, orientation, position};
-use crate::draw::properties::{
-    ColorScalar, LinSrgba, SetColor, SetDimensions, SetOrientation, SetPosition, SetStroke,
-};
-use crate::draw::{self, Drawing};
-use crate::geom::{self, pt2, Point2};
-use crate::glam::vec2;
-use lyon::tessellation::StrokeOptions;
-
-/// Properties related to drawing a **Tri**.
-#[derive(Clone, Debug)]
-pub struct Tri {
-    tri: geom::Tri<Point2>,
-    dimensions: dimension::Properties,
-    polygon: PolygonInit,
-}
-
-/// The drawing context for a `Tri`.
-pub type DrawingTri<'a> = Drawing<'a, Tri>;
-
-// Tri-specific methods.
-
-impl Tri {
-    /// Stroke the outline with the given color.
-    pub fn stroke<C>(self, color: C) -> Self
-    where
-        C: IntoLinSrgba<ColorScalar>,
-    {
-        self.stroke_color(color)
-    }
-
-    /// Use the given three points as the vertices (corners) of the triangle.
-    pub fn points<P>(mut self, a: P, b: P, c: P) -> Self
-    where
-        P: Into<Point2>,
-    {
-        let a = a.into();
-        let b = b.into();
-        let c = c.into();
-        self.tri = geom::Tri([a, b, c]);
-        self
-    }
-}
-
-// Drawing methods.
-
-impl<'a> DrawingTri<'a> {
-    /// Stroke the outline with the given color.
-    pub fn stroke<C>(self, color: C) -> Self
-    where
-        C: IntoLinSrgba<ColorScalar>,
-    {
-        self.map_ty(|ty| ty.stroke(color))
-    }
-
-    /// Use the given points as the vertices (corners) of the triangle.
-    pub fn points<P>(self, a: P, b: P, c: P) -> Self
-    where
-        P: Into<Point2>,
-    {
-        self.map_ty(|ty| ty.points(a, b, c))
-    }
-}
-
-// Trait implementations.
-
-impl draw::renderer::RenderPrimitive for Tri {
-    fn render_primitive(
-        self,
-        ctxt: draw::renderer::RenderContext,
-        mesh: &mut draw::Mesh,
-    ) -> draw::renderer::PrimitiveRender {
-        let Tri {
-            mut tri,
-            dimensions,
-            polygon,
-        } = self;
-        let (maybe_x, maybe_y, _maybe_z) = (dimensions.x, dimensions.y, dimensions.z);
-        // If dimensions were specified, scale the points to those dimensions.
-        if maybe_x.is_some() || maybe_y.is_some() {
-            let cuboid = tri.bounding_rect();
-            let centroid = tri.centroid();
-            let x_scale = maybe_x.map(|x| x / cuboid.w()).unwrap_or(1.0);
-            let y_scale = maybe_y.map(|y| y / cuboid.h()).unwrap_or(1.0);
-            let scale = vec2(x_scale, y_scale);
-            let (a, b, c) = tri.into();
-            let translate = |v: Point2| centroid + ((v - centroid) * scale);
-            let new_a = translate(a);
-            let new_b = translate(b);
-            let new_c = translate(c);
-            tri = geom::Tri([new_a, new_b, new_c]);
-        }
-        let points = tri.vertices();
-        polygon::render_points_themed(
-            polygon.opts,
-            points,
-            ctxt,
-            &draw::theme::Primitive::Tri,
-            mesh,
-        );
-
-        draw::renderer::PrimitiveRender::default()
-    }
-}
-
-impl From<geom::Tri<Point2>> for Tri {
-    fn from(tri: geom::Tri<Point2>) -> Self {
-        let dimensions = <_>::default();
-        let polygon = <_>::default();
-        Tri {
-            tri,
-            dimensions,
-            polygon,
-        }
-    }
-}
-
-impl Default for Tri {
-    fn default() -> Self {
-        // Create a triangle pointing towards 0.0 radians.
-        let fifty = 50.0;
-        let thirty_three = 33.0;
-        let a = pt2(-fifty, thirty_three);
-        let b = pt2(fifty, 0.0);
-        let c = pt2(-fifty, -thirty_three);
-        Tri::from(geom::Tri([a, b, c]))
-    }
-}
-
-impl SetOrientation for Tri {
-    fn properties(&mut self) -> &mut orientation::Properties {
-        SetOrientation::properties(&mut self.polygon)
-    }
-}
-
-impl SetPosition for Tri {
-    fn properties(&mut self) -> &mut position::Properties {
-        SetPosition::properties(&mut self.polygon)
-    }
-}
-
-impl SetDimensions for Tri {
-    fn properties(&mut self) -> &mut dimension::Properties {
-        SetDimensions::properties(&mut self.dimensions)
-    }
-}
-
-impl SetColor<ColorScalar> for Tri {
-    fn rgba_mut(&mut self) -> &mut Option<LinSrgba> {
-        SetColor::rgba_mut(&mut self.polygon)
-    }
-}
-
-impl SetStroke for Tri {
-    fn stroke_options_mut(&mut self) -> &mut StrokeOptions {
-        SetStroke::stroke_options_mut(&mut self.polygon)
-    }
-}
-
-impl SetPolygon for Tri {
-    fn polygon_options_mut(&mut self) -> &mut PolygonOptions {
-        SetPolygon::polygon_options_mut(&mut self.polygon)
-    }
-}
-
-// Primitive conversions.
-
-impl From<Tri> for Primitive {
-    fn from(prim: Tri) -> Self {
-        Primitive::Tri(prim)
-    }
-}
-
-impl Into<Option<Tri>> for Primitive {
-    fn into(self) -> Option<Tri> {
-        match self {
-            Primitive::Tri(prim) => Some(prim),
-            _ => None,
-        }
-    }
-}
diff --git a/nannou/src/draw/properties/color.rs b/nannou/src/draw/properties/color.rs
deleted file mode 100644
index 6d395f999..000000000
--- a/nannou/src/draw/properties/color.rs
+++ /dev/null
@@ -1,152 +0,0 @@
-use crate::color::{self, Component, IntoLinSrgba, LinSrgba};
-use crate::math::num_traits::Float;
-
-/// A **Srgba** type with the default Scalar.
-pub type DefaultSrgba = color::Srgba<color::DefaultScalar>;
-
-/// A **LinSrgba** type with the default Scalar.
-pub type DefaultLinSrgba = color::LinSrgba<color::DefaultScalar>;
-
-/// Nodes that support setting colors.
-pub trait SetColor<S>: Sized
-where
-    S: Component,
-{
-    /// Provide a mutable reference to the RGBA field which can be used for setting colors.
-    fn rgba_mut(&mut self) -> &mut Option<LinSrgba<S>>;
-
-    /// Specify a color.
-    ///
-    /// This method supports any color type that can be converted into RGBA.
-    ///
-    /// Colors that have no alpha channel will be given an opaque alpha channel value `1.0`.
-    fn color<C>(mut self, color: C) -> Self
-    where
-        C: IntoLinSrgba<S>,
-    {
-        *self.rgba_mut() = Some(color.into_lin_srgba());
-        self
-    }
-
-    /// Specify the color via red, green and blue channels.
-    fn rgb<T>(self, r: T, g: T, b: T) -> Self
-    where
-        T: Component,
-        S: Float,
-    {
-        self.color(color::Srgb::new(r, g, b))
-    }
-
-    /// Specify the color via red, green and blue channels as bytes
-    fn rgb8(self, r: u8, g: u8, b: u8) -> Self
-    where
-        S: Float,
-    {
-        self.color(color::Srgb::<u8>::new(r, g, b))
-    }
-
-    /// Specify the color via red, green, blue and alpha channels.
-    fn rgba<T>(self, r: T, g: T, b: T, a: T) -> Self
-    where
-        T: Component,
-        S: Float,
-    {
-        self.color(color::Srgba::new(r, g, b, a))
-    }
-
-    /// Specify the color via red, green, blue and alpha channels as bytes
-    fn rgba8(self, r: u8, g: u8, b: u8, a: u8) -> Self
-    where
-        S: Float,
-    {
-        self.color(color::Srgba::<u8>::new(r, g, b, a))
-    }
-
-    /// Specify the color via hue, saturation and luminance.
-    ///
-    /// If you're looking for HSV or HSB, use the `hsv` method instead.
-    ///
-    /// The given hue expects a value between `0.0` and `1.0` where `0.0` is 0 degress and `1.0` is
-    /// 360 degrees (or 2 PI radians).
-    ///
-    /// See the [wikipedia entry](https://en.wikipedia.org/wiki/HSL_and_HSV) for more details on
-    /// this color space.
-    fn hsl(self, h: S, s: S, l: S) -> Self
-    where
-        S: Float + Into<color::RgbHue<S>>,
-    {
-        let hue = color::RgbHue::from_degrees(h * S::from(360.0).unwrap());
-        self.color(color::Hsl::new(hue, s, l))
-    }
-
-    /// Specify the color via hue, saturation, luminance and an alpha channel.
-    ///
-    /// If you're looking for HSVA or HSBA, use the `hsva` method instead.
-    ///
-    /// The given hue expects a value between `0.0` and `1.0` where `0.0` is 0 degress and `1.0` is
-    /// 360 degrees (or 2 PI radians).
-    ///
-    /// See the [wikipedia entry](https://en.wikipedia.org/wiki/HSL_and_HSV) for more details on
-    /// this color space.
-    fn hsla(self, h: S, s: S, l: S, a: S) -> Self
-    where
-        S: Float + Into<color::RgbHue<S>>,
-    {
-        let hue = color::RgbHue::from_degrees(h * S::from(360.0).unwrap());
-        self.color(color::Hsla::new(hue, s, l, a))
-    }
-
-    /// Specify the color via hue, saturation and *value* (brightness).
-    ///
-    /// This is sometimes also known as "hsb".
-    ///
-    /// The given hue expects a value between `0.0` and `1.0` where `0.0` is 0 degress and `1.0` is
-    /// 360 degrees (or 2 PI radians).
-    ///
-    /// See the [wikipedia entry](https://en.wikipedia.org/wiki/HSL_and_HSV) for more details on
-    /// this color space.
-    fn hsv(self, h: S, s: S, v: S) -> Self
-    where
-        S: Float,
-    {
-        let hue = color::RgbHue::from_degrees(h * S::from(360.0).unwrap());
-        self.color(color::Hsv::new(hue, s, v))
-    }
-
-    /// Specify the color via hue, saturation, *value* (brightness) and an alpha channel.
-    ///
-    /// This is sometimes also known as "hsba".
-    ///
-    /// The given hue expects a value between `0.0` and `1.0` where `0.0` is 0 degress and `1.0` is
-    /// 360 degrees (or 2 PI radians).
-    ///
-    /// See the [wikipedia entry](https://en.wikipedia.org/wiki/HSL_and_HSV) for more details on
-    /// this color space.
-    fn hsva(self, h: S, s: S, v: S, a: S) -> Self
-    where
-        S: Float,
-    {
-        let hue = color::RgbHue::from_degrees(h * S::from(360.0).unwrap());
-        self.color(color::Hsva::new(hue, s, v, a))
-    }
-
-    /// Specify the color as gray scale
-    ///
-    /// The given g expects a value between `0.0` and `1.0` where `0.0` is black and `1.0` is white
-    fn gray<T>(self, g: T) -> Self
-    where
-        T: Component,
-        S: Float,
-    {
-        self.color(color::Srgb::new(g, g, g))
-    }
-}
-
-impl<S> SetColor<S> for Option<LinSrgba<S>>
-where
-    S: Component,
-{
-    fn rgba_mut(&mut self) -> &mut Option<LinSrgba<S>> {
-        self
-    }
-}
diff --git a/nannou/src/draw/properties/fill.rs b/nannou/src/draw/properties/fill.rs
deleted file mode 100644
index 090bf7222..000000000
--- a/nannou/src/draw/properties/fill.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-use lyon::tessellation::FillOptions;
-
-/// Nodes that support fill tessellation.
-///
-/// This trait allows the `Drawing` context to automatically provide an implementation of the
-/// following builder methods for all primitives that provide some fill tessellation options.
-pub trait SetFill: Sized {
-    /// Provide a mutable reference to the `FillOptions` field.
-    fn fill_options_mut(&mut self) -> &mut FillOptions;
-
-    /// Specify the whole set of fill tessellation options.
-    fn fill_opts(mut self, opts: FillOptions) -> Self {
-        *self.fill_options_mut() = opts;
-        self
-    }
-
-    /// Maximum allowed distance to the path when building an approximation.
-    fn fill_tolerance(mut self, tolerance: f32) -> Self {
-        self.fill_options_mut().tolerance = tolerance;
-        self
-    }
-
-    /// Specify the rule used to determine what is inside and what is outside of the shape.
-    ///
-    /// Currently, only the `EvenOdd` rule is implemented.
-    fn fill_rule(mut self, rule: lyon::tessellation::FillRule) -> Self {
-        self.fill_options_mut().fill_rule = rule;
-        self
-    }
-
-    /// Whether to perform a vertical or horizontal traversal of the geometry.
-    ///
-    /// Default value: `Vertical`.
-    fn fill_sweep_orientation(mut self, orientation: lyon::tessellation::Orientation) -> Self {
-        self.fill_options_mut().sweep_orientation = orientation;
-        self
-    }
-
-    /// A fast path to avoid some expensive operations if the path is known to not have any
-    /// self-intersections.
-    ///
-    /// Do not set this to `false` if the path may have intersecting edges else the tessellator may
-    /// panic or produce incorrect results. In doubt, do not change the default value.
-    ///
-    /// Default value: `true`.
-    fn handle_intersections(mut self, handle: bool) -> Self {
-        self.fill_options_mut().handle_intersections = handle;
-        self
-    }
-}
-
-impl SetFill for Option<FillOptions> {
-    fn fill_options_mut(&mut self) -> &mut FillOptions {
-        self.get_or_insert_with(Default::default)
-    }
-}
diff --git a/nannou/src/draw/properties/mod.rs b/nannou/src/draw/properties/mod.rs
deleted file mode 100644
index 392376f2a..000000000
--- a/nannou/src/draw/properties/mod.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-//! Parameters which a **Drawing** instance may use to describe certain properties of a drawing.
-//!
-//! Each time a new method is chained onto a **Drawing** instance, it uses the given values to set
-//! one or more properties for the drawing.
-//!
-//! Each **Drawing** instance is associated with a specific **Node** in the geometry graph and has
-//! a unique **node::Index** to simplify this.
-
-pub mod color;
-pub mod fill;
-pub mod spatial;
-pub mod stroke;
-
-pub use self::color::SetColor;
-pub use self::fill::SetFill;
-pub use self::spatial::dimension::SetDimensions;
-pub use self::spatial::orientation::SetOrientation;
-pub use self::spatial::position::SetPosition;
-pub use self::stroke::SetStroke;
-
-/// The scalar type used for the color channel values.
-pub type ColorScalar = crate::color::DefaultScalar;
-
-/// The RGBA type used by the `Common` params.
-pub type Srgba = color::DefaultSrgba;
-
-/// The RGBA type used by the `Common` params.
-pub type LinSrgba = color::DefaultLinSrgba;
diff --git a/nannou/src/draw/properties/spatial/dimension.rs b/nannou/src/draw/properties/spatial/dimension.rs
deleted file mode 100644
index 3ad341760..000000000
--- a/nannou/src/draw/properties/spatial/dimension.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-use crate::glam::{Vec2, Vec3};
-
-/// Dimension properties for **Drawing** a **Primitive**.
-#[derive(Copy, Clone, Debug, Default, PartialEq)]
-pub struct Properties {
-    pub x: Option<f32>,
-    pub y: Option<f32>,
-    pub z: Option<f32>,
-}
-
-/// Primitives that support different dimensions.
-pub trait SetDimensions: Sized {
-    /// Provide a mutable reference to the **dimension::Properties** for updating.
-    fn properties(&mut self) -> &mut Properties;
-
-    /// Set the absolute width for the primitive.
-    fn width(mut self, w: f32) -> Self {
-        self.properties().x = Some(w);
-        self
-    }
-
-    /// Set the absolute height for the primitive.
-    fn height(mut self, h: f32) -> Self {
-        self.properties().y = Some(h);
-        self
-    }
-
-    /// Set the absolute depth for the primitive.
-    fn depth(mut self, d: f32) -> Self {
-        self.properties().z = Some(d);
-        self
-    }
-
-    /// Short-hand for the **width** method.
-    fn w(self, w: f32) -> Self {
-        self.width(w)
-    }
-
-    /// Short-hand for the **height** method.
-    fn h(self, h: f32) -> Self {
-        self.height(h)
-    }
-
-    /// Short-hand for the **depth** method.
-    fn d(self, d: f32) -> Self {
-        self.depth(d)
-    }
-
-    /// Set the **x** and **y** dimensions for the primitive.
-    fn wh(self, v: Vec2) -> Self {
-        self.w(v.x).h(v.y)
-    }
-
-    /// Set the **x**, **y** and **z** dimensions for the primitive.
-    fn whd(self, v: Vec3) -> Self {
-        self.w(v.x).h(v.y).d(v.z)
-    }
-
-    /// Set the width and height for the primitive.
-    fn w_h(self, x: f32, y: f32) -> Self {
-        self.wh([x, y].into())
-    }
-
-    /// Set the width and height for the primitive.
-    fn w_h_d(self, x: f32, y: f32, z: f32) -> Self {
-        self.whd([x, y, z].into())
-    }
-}
-
-impl SetDimensions for Properties {
-    fn properties(&mut self) -> &mut Properties {
-        self
-    }
-}
diff --git a/nannou/src/draw/properties/spatial/mod.rs b/nannou/src/draw/properties/spatial/mod.rs
deleted file mode 100644
index d7aa8fa57..000000000
--- a/nannou/src/draw/properties/spatial/mod.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-pub mod dimension;
-pub mod orientation;
-pub mod position;
-
-pub use self::dimension::SetDimensions;
-pub use self::orientation::SetOrientation;
-pub use self::position::SetPosition;
-
-/// Types that may be positioned, sized and oriented within 3D space.
-pub trait SetSpatial: SetDimensions + SetPosition + SetOrientation {}
-
-impl<T> SetSpatial for T where T: SetDimensions + SetPosition + SetOrientation {}
-
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub struct Properties {
-    pub position: position::Properties,
-    pub dimensions: dimension::Properties,
-    pub orientation: orientation::Properties,
-}
-
-impl Default for Properties {
-    fn default() -> Self {
-        let position = Default::default();
-        let dimensions = Default::default();
-        let orientation = Default::default();
-        Properties {
-            position,
-            dimensions,
-            orientation,
-        }
-    }
-}
-
-impl SetPosition for Properties {
-    fn properties(&mut self) -> &mut position::Properties {
-        self.position.properties()
-    }
-}
-
-impl SetDimensions for Properties {
-    fn properties(&mut self) -> &mut dimension::Properties {
-        self.dimensions.properties()
-    }
-}
-
-impl SetOrientation for Properties {
-    fn properties(&mut self) -> &mut orientation::Properties {
-        self.orientation.properties()
-    }
-}
diff --git a/nannou/src/draw/properties/spatial/orientation.rs b/nannou/src/draw/properties/spatial/orientation.rs
deleted file mode 100644
index c312189eb..000000000
--- a/nannou/src/draw/properties/spatial/orientation.rs
+++ /dev/null
@@ -1,189 +0,0 @@
-use crate::geom::Point3;
-use crate::glam::{EulerRot, Mat4, Quat, Vec3};
-use crate::math::{deg_to_rad, turns_to_rad};
-
-/// Orientation properties for **Drawing** a **Primitive**.
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub enum Properties {
-    /// The orientation described by an angle along each axis.
-    Axes(Vec3),
-    /// The orientation described by looking at some other point.
-    LookAt(Point3),
-    /// Angle described by quarternion.
-    Quat(Quat),
-}
-
-impl Properties {
-    pub fn transform(&self) -> Mat4 {
-        match *self {
-            Properties::Axes(v) => Mat4::from_euler(EulerRot::XYZ, v.x, v.y, v.z),
-            Properties::LookAt(p) => {
-                let eye = Vec3::ZERO;
-                let up = Vec3::Y;
-                Mat4::look_at_rh(eye, p, up)
-            }
-            Properties::Quat(q) => Mat4::from_quat(q),
-        }
-    }
-
-    /// If the `Properties` was set to the `LookAt` variant, this method switches to the `Axes`
-    /// variant.
-    ///
-    /// If the `Properties` is already `Axes`, nothing changes.
-    pub fn switch_to_axes(&mut self) {
-        if let Properties::LookAt(_) = *self {
-            *self = Properties::Axes(Vec3::ZERO);
-        }
-    }
-}
-
-/// An API for setting the **orientation::Properties**.
-pub trait SetOrientation: Sized {
-    /// Provide a mutable reference to the **orientation::Properties** for updating.
-    fn properties(&mut self) -> &mut Properties;
-
-    // Describing orientation via a target.
-
-    /// Describe orientation via the vector that points to the given target.
-    fn look_at(mut self, target: Point3) -> Self {
-        *self.properties() = Properties::LookAt(target);
-        self
-    }
-
-    // Absolute orientation.
-
-    /// Specify the orientation around the *x* axis as an absolute value in radians.
-    fn x_radians(mut self, x: f32) -> Self {
-        self.properties().switch_to_axes();
-        expect_axes(self.properties()).x = x;
-        self
-    }
-
-    /// Specify the orientation around the *y* axis as an absolute value in radians.
-    fn y_radians(mut self, y: f32) -> Self {
-        self.properties().switch_to_axes();
-        expect_axes(self.properties()).y = y;
-        self
-    }
-
-    /// Specify the orientation around the *z* axis as an absolute value in radians.
-    fn z_radians(mut self, z: f32) -> Self {
-        self.properties().switch_to_axes();
-        expect_axes(self.properties()).z = z;
-        self
-    }
-
-    /// Specify the orientation around the *x* axis as an absolute value in degrees.
-    fn x_degrees(self, x: f32) -> Self {
-        self.x_radians(deg_to_rad(x))
-    }
-
-    /// Specify the orientation around the *y* axis as an absolute value in degrees.
-    fn y_degrees(self, y: f32) -> Self {
-        self.y_radians(deg_to_rad(y))
-    }
-
-    /// Specify the orientation around the *z* axis as an absolute value in degrees.
-    fn z_degrees(self, z: f32) -> Self {
-        self.z_radians(deg_to_rad(z))
-    }
-
-    /// Specify the orientation around the *x* axis as a number of turns around the axis.
-    fn x_turns(self, x: f32) -> Self {
-        self.x_radians(turns_to_rad(x))
-    }
-
-    /// Specify the orientation around the *y* axis as a number of turns around the axis.
-    fn y_turns(self, y: f32) -> Self {
-        self.y_radians(turns_to_rad(y))
-    }
-
-    /// Specify the orientation around the *z* axis as a number of turns around the axis.
-    fn z_turns(self, z: f32) -> Self {
-        self.z_radians(turns_to_rad(z))
-    }
-
-    /// Specify the orientation along each axis with the given **Vector** of radians.
-    ///
-    /// This has the same affect as calling `self.x_radians(v.x).y_radians(v.y).z_radians(v.z)`.
-    fn radians(self, v: Vec3) -> Self {
-        self.x_radians(v.x).y_radians(v.y).z_radians(v.z)
-    }
-
-    /// Specify the orientation along each axis with the given **Vector** of degrees.
-    ///
-    /// This has the same affect as calling `self.x_degrees(v.x).y_degrees(v.y).z_degrees(v.z)`.
-    fn degrees(self, v: Vec3) -> Self {
-        self.x_degrees(v.x).y_degrees(v.y).z_degrees(v.z)
-    }
-
-    /// Specify the orientation along each axis with the given **Vector** of "turns".
-    ///
-    /// This has the same affect as calling `self.x_turns(v.x).y_turns(v.y).z_turns(v.z)`.
-    fn turns(self, v: Vec3) -> Self {
-        self.x_turns(v.x).y_turns(v.y).z_turns(v.z)
-    }
-
-    /// Specify the orientation with the given euler orientation in radians.
-    fn euler(self, e: Vec3) -> Self {
-        self.radians(e)
-    }
-
-    /// Specify the orientation with the given **Quaternion**.
-    fn quaternion(mut self, q: Quat) -> Self {
-        *self.properties() = Properties::Quat(q);
-        self
-    }
-
-    // Higher level methods.
-
-    /// Specify the "pitch" of the orientation in radians.
-    ///
-    /// This has the same effect as calling `x_radians`.
-    fn pitch(self, pitch: f32) -> Self {
-        self.x_radians(pitch)
-    }
-
-    /// Specify the "yaw" of the orientation in radians.
-    ///
-    /// This has the same effect as calling `y_radians`.
-    fn yaw(self, yaw: f32) -> Self {
-        self.y_radians(yaw)
-    }
-
-    /// Specify the "roll" of the orientation in radians.
-    ///
-    /// This has the same effect as calling `z_radians`.
-    fn roll(self, roll: f32) -> Self {
-        self.z_radians(roll)
-    }
-
-    /// Assuming we're looking at a 2D plane, positive values cause a clockwise rotation where the
-    /// given value is specified in radians.
-    ///
-    /// This is equivalent to calling the `z_radians` or `roll` methods.
-    fn rotate(self, radians: f32) -> Self {
-        self.z_radians(radians)
-    }
-}
-
-impl SetOrientation for Properties {
-    fn properties(&mut self) -> &mut Properties {
-        self
-    }
-}
-
-impl Default for Properties {
-    fn default() -> Self {
-        Properties::Axes(Vec3::ZERO)
-    }
-}
-
-// Expects the `Axes` variant from the given properties.
-fn expect_axes(p: &mut Properties) -> &mut Vec3 {
-    match *p {
-        Properties::Axes(ref mut axes) => axes,
-        Properties::LookAt(_) => panic!("expected `Axes`, found `LookAt`"),
-        Properties::Quat(_) => panic!("expected `Axes`, found `Quat`"),
-    }
-}
diff --git a/nannou/src/draw/properties/spatial/position.rs b/nannou/src/draw/properties/spatial/position.rs
deleted file mode 100644
index 413c09907..000000000
--- a/nannou/src/draw/properties/spatial/position.rs
+++ /dev/null
@@ -1,73 +0,0 @@
-//! Items related to describing positioning along each axis as
-
-use crate::geom::{Point2, Point3};
-use crate::glam::Mat4;
-
-/// Position properties for **Drawing** a **Primitive**.
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub struct Properties {
-    pub point: Point3,
-}
-
-/// An API for setting the **position::Properties**.
-pub trait SetPosition: Sized {
-    /// Provide a mutable reference to the **position::Properties** for updating.
-    fn properties(&mut self) -> &mut Properties;
-
-    /// Build with the given **Absolute** **Position** along the *x* axis.
-    fn x(mut self, x: f32) -> Self {
-        self.properties().point.x = x;
-        self
-    }
-
-    /// Build with the given **Absolute** **Position** along the *y* axis.
-    fn y(mut self, y: f32) -> Self {
-        self.properties().point.y = y;
-        self
-    }
-
-    /// Build with the given **Absolute** **Position** along the *z* axis.
-    fn z(mut self, z: f32) -> Self {
-        self.properties().point.z = z;
-        self
-    }
-
-    /// Set the **Position** with some two-dimensional point.
-    fn xy(self, p: Point2) -> Self {
-        self.x(p.x).y(p.y)
-    }
-
-    /// Set the **Position** with some three-dimensional point.
-    fn xyz(self, p: Point3) -> Self {
-        self.x(p.x).y(p.y).z(p.z)
-    }
-
-    /// Set the **Position** with *x* *y* coordinates.
-    fn x_y(self, x: f32, y: f32) -> Self {
-        self.xy([x, y].into())
-    }
-
-    /// Set the **Position** with *x* *y* *z* coordinates.
-    fn x_y_z(self, x: f32, y: f32, z: f32) -> Self {
-        self.xyz([x, y, z].into())
-    }
-}
-
-impl Properties {
-    pub fn transform(&self) -> Mat4 {
-        Mat4::from_translation(self.point.into())
-    }
-}
-
-impl SetPosition for Properties {
-    fn properties(&mut self) -> &mut Properties {
-        self
-    }
-}
-
-impl Default for Properties {
-    fn default() -> Self {
-        let point = Point3::ZERO;
-        Self { point }
-    }
-}
diff --git a/nannou/src/draw/properties/stroke.rs b/nannou/src/draw/properties/stroke.rs
deleted file mode 100644
index 20009f67c..000000000
--- a/nannou/src/draw/properties/stroke.rs
+++ /dev/null
@@ -1,158 +0,0 @@
-use lyon::tessellation::{LineCap, LineJoin, StrokeOptions};
-
-/// Nodes that support stroke tessellation.
-///
-/// This trait allows the `Drawing` context to automatically provide an implementation of the
-/// following builder methods for all primitives that provide some stroke tessellation options.
-pub trait SetStroke: Sized {
-    /// Provide a mutable reference to the `StrokeOptions` field.
-    fn stroke_options_mut(&mut self) -> &mut StrokeOptions;
-
-    /// Specify the whole set of stroke tessellation options.
-    fn stroke_opts(mut self, opts: StrokeOptions) -> Self {
-        *self.stroke_options_mut() = opts;
-        self
-    }
-
-    /// The start line cap as specified by the SVG spec.
-    fn start_cap(mut self, cap: LineCap) -> Self {
-        self.stroke_options_mut().start_cap = cap;
-        self
-    }
-
-    /// The end line cap as specified by the SVG spec.
-    fn end_cap(mut self, cap: LineCap) -> Self {
-        self.stroke_options_mut().end_cap = cap;
-        self
-    }
-
-    /// The start and end line cap as specified by the SVG spec.
-    fn caps(self, cap: LineCap) -> Self {
-        self.start_cap(cap).end_cap(cap)
-    }
-
-    /// The stroke for each sub-path does not extend beyond its two endpoints. A zero length
-    /// sub-path will therefore not have any stroke.
-    fn start_cap_butt(self) -> Self {
-        self.start_cap(LineCap::Butt)
-    }
-
-    /// At the end of each sub-path, the shape representing the stroke will be extended by a
-    /// rectangle with the same width as the stroke width and whose length is half of the stroke
-    /// width. If a sub-path has zero length, then the resulting effect is that the stroke for that
-    /// sub-path consists solely of a square with side length equal to the stroke width, centered
-    /// at the sub-path's point.
-    fn start_cap_square(self) -> Self {
-        self.start_cap(LineCap::Square)
-    }
-
-    /// At each end of each sub-path, the shape representing the stroke will be extended by a half
-    /// circle with a radius equal to the stroke width. If a sub-path has zero length, then the
-    /// resulting effect is that the stroke for that sub-path consists solely of a full circle
-    /// centered at the sub-path's point.
-    fn start_cap_round(self) -> Self {
-        self.start_cap(LineCap::Round)
-    }
-
-    /// The stroke for each sub-path does not extend beyond its two endpoints. A zero length
-    /// sub-path will therefore not have any stroke.
-    fn end_cap_butt(self) -> Self {
-        self.end_cap(LineCap::Butt)
-    }
-
-    /// At the end of each sub-path, the shape representing the stroke will be extended by a
-    /// rectangle with the same width as the stroke width and whose length is half of the stroke
-    /// width. If a sub-path has zero length, then the resulting effect is that the stroke for that
-    /// sub-path consists solely of a square with side length equal to the stroke width, centered
-    /// at the sub-path's point.
-    fn end_cap_square(self) -> Self {
-        self.end_cap(LineCap::Square)
-    }
-
-    /// At each end of each sub-path, the shape representing the stroke will be extended by a half
-    /// circle with a radius equal to the stroke width. If a sub-path has zero length, then the
-    /// resulting effect is that the stroke for that sub-path consists solely of a full circle
-    /// centered at the sub-path's point.
-    fn end_cap_round(self) -> Self {
-        self.end_cap(LineCap::Round)
-    }
-
-    /// The stroke for each sub-path does not extend beyond its two endpoints. A zero length
-    /// sub-path will therefore not have any stroke.
-    fn caps_butt(self) -> Self {
-        self.caps(LineCap::Butt)
-    }
-
-    /// At the end of each sub-path, the shape representing the stroke will be extended by a
-    /// rectangle with the same width as the stroke width and whose length is half of the stroke
-    /// width. If a sub-path has zero length, then the resulting effect is that the stroke for that
-    /// sub-path consists solely of a square with side length equal to the stroke width, centered
-    /// at the sub-path's point.
-    fn caps_square(self) -> Self {
-        self.caps(LineCap::Square)
-    }
-
-    /// At each end of each sub-path, the shape representing the stroke will be extended by a half
-    /// circle with a radius equal to the stroke width. If a sub-path has zero length, then the
-    /// resulting effect is that the stroke for that sub-path consists solely of a full circle
-    /// centered at the sub-path's point.
-    fn caps_round(self) -> Self {
-        self.caps(LineCap::Round)
-    }
-
-    /// The way in which lines are joined at the vertices, matching the SVG spec.
-    ///
-    /// Default value is `MiterClip`.
-    fn join(mut self, join: LineJoin) -> Self {
-        self.stroke_options_mut().line_join = join;
-        self
-    }
-
-    /// A sharp corner is to be used to join path segments.
-    fn join_miter(self) -> Self {
-        self.join(LineJoin::Miter)
-    }
-
-    /// Same as a `join_miter`, but if the miter limit is exceeded, the miter is clipped at a miter
-    /// length equal to the miter limit value multiplied by the stroke width.
-    fn join_miter_clip(self) -> Self {
-        self.join(LineJoin::MiterClip)
-    }
-
-    /// A round corner is to be used to join path segments.
-    fn join_round(self) -> Self {
-        self.join(LineJoin::Round)
-    }
-
-    /// A bevelled corner is to be used to join path segments. The bevel shape is a triangle that
-    /// fills the area between the two stroked segments.
-    fn join_bevel(self) -> Self {
-        self.join(LineJoin::Bevel)
-    }
-
-    /// The total stroke_weight (aka width) of the line.
-    fn stroke_weight(mut self, stroke_weight: f32) -> Self {
-        self.stroke_options_mut().line_width = stroke_weight;
-        self
-    }
-
-    /// Describes the limit before miter lines will clip, as described in the SVG spec.
-    ///
-    /// Must be greater than or equal to `1.0`.
-    fn miter_limit(mut self, limit: f32) -> Self {
-        self.stroke_options_mut().miter_limit = limit;
-        self
-    }
-
-    /// Maximum allowed distance to the path when building an approximation.
-    fn stroke_tolerance(mut self, tolerance: f32) -> Self {
-        self.stroke_options_mut().tolerance = tolerance;
-        self
-    }
-}
-
-impl SetStroke for Option<StrokeOptions> {
-    fn stroke_options_mut(&mut self) -> &mut StrokeOptions {
-        self.get_or_insert_with(Default::default)
-    }
-}
diff --git a/nannou/src/draw/renderer/mod.rs b/nannou/src/draw/renderer/mod.rs
deleted file mode 100644
index c58284ce8..000000000
--- a/nannou/src/draw/renderer/mod.rs
+++ /dev/null
@@ -1,1192 +0,0 @@
-use crate::draw;
-use crate::draw::mesh::vertex::{Color, TexCoords};
-use crate::frame::Frame;
-use crate::geom::{self, Point2, Rect};
-use crate::glam::{Mat4, Vec2, Vec3};
-use crate::math::map_range;
-use crate::text;
-use crate::wgpu;
-use lyon::path::PathEvent;
-use lyon::tessellation::{FillTessellator, StrokeTessellator};
-use std::collections::HashMap;
-use std::fmt;
-use std::hash::{Hash, Hasher};
-use std::ops::{Deref, DerefMut};
-use wgpu::util::{BufferInitDescriptor, DeviceExt};
-
-/// Draw API primitives that may be rendered via the **Renderer** type.
-pub trait RenderPrimitive {
-    /// Render self into the given mesh.
-    fn render_primitive(self, ctxt: RenderContext, mesh: &mut draw::Mesh) -> PrimitiveRender;
-}
-
-/// Information about the way in which a primitive was rendered.
-pub struct PrimitiveRender {
-    /// Whether or not a specific texture must be available when this primitive is drawn.
-    ///
-    /// If `Some` and the given texture is different than the currently set texture, a render
-    /// command will be encoded that switches from the previous texture's bind group to the new
-    /// one.
-    pub texture_view: Option<wgpu::TextureView>,
-    /// The way in which vertices should be coloured in the fragment shader.
-    pub vertex_mode: VertexMode,
-}
-
-/// The context provided to primitives to assist with the rendering process.
-pub struct RenderContext<'a> {
-    pub transform: &'a Mat4,
-    pub intermediary_mesh: &'a draw::Mesh,
-    pub path_event_buffer: &'a [PathEvent],
-    pub path_points_colored_buffer: &'a [(Point2, Color)],
-    pub path_points_textured_buffer: &'a [(Point2, TexCoords)],
-    pub text_buffer: &'a str,
-    pub theme: &'a draw::Theme,
-    pub glyph_cache: &'a mut GlyphCache,
-    pub fill_tessellator: &'a mut FillTessellator,
-    pub stroke_tessellator: &'a mut StrokeTessellator,
-    pub output_attachment_size: Vec2, // logical coords
-    pub output_attachment_scale_factor: f32,
-}
-
-pub struct GlyphCache {
-    /// Tracks glyphs and their location within the cache.
-    pub cache: text::GlyphCache<'static>,
-    /// The buffer used to store the pixels of the glyphs.
-    pub pixel_buffer: Vec<u8>,
-    /// Will be set to `true` after the cache has been updated if the texture requires re-uploading.
-    pub requires_upload: bool,
-}
-
-/// A top-level indicator of whether or not
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
-#[repr(u32)]
-pub enum VertexMode {
-    /// Use the color values and ignore the texture coordinates.
-    Color = 0,
-    /// Use the texture color and ignore the color values.
-    Texture = 1,
-    /// A special mode used by the text primitive.
-    ///
-    /// Uses the color values, but multiplies the alpha by the glyph cache texture's red value.
-    Text = 2,
-}
-
-/// A helper type aimed at simplifying the rendering of nannou primitives via wgpu.
-#[derive(Debug)]
-pub struct Renderer {
-    glyph_cache: GlyphCache,
-    vs_mod: wgpu::ShaderModule,
-    fs_mod: wgpu::ShaderModule,
-    // One pipeline per unique Pipeline ID (combination of blend, topology and component type).
-    pipelines: HashMap<PipelineId, wgpu::RenderPipeline>,
-    glyph_cache_texture: wgpu::Texture,
-    depth_texture: wgpu::Texture,
-    depth_texture_view: wgpu::TextureView,
-    _default_texture: wgpu::Texture,
-    default_texture_view: wgpu::TextureView,
-    uniform_bind_group_layout: wgpu::BindGroupLayout,
-    uniform_bind_group: wgpu::BindGroup,
-    text_bind_group_layout: wgpu::BindGroupLayout,
-    text_bind_group: wgpu::BindGroup,
-    texture_samplers: HashMap<SamplerId, wgpu::Sampler>,
-    texture_bind_group_layouts: HashMap<wgpu::TextureSampleType, wgpu::BindGroupLayout>,
-    texture_bind_groups: HashMap<BindGroupId, wgpu::BindGroup>,
-    output_color_format: wgpu::TextureFormat,
-    sample_count: u32,
-    scale_factor: f32,
-    render_commands: Vec<RenderCommand>,
-    mesh: draw::Mesh,
-    vertex_mode_buffer: Vec<VertexMode>,
-    uniform_buffer: wgpu::Buffer,
-}
-
-/// A type aimed at simplifying construction of a `draw::Renderer`.
-#[derive(Clone, Debug)]
-pub struct Builder {
-    pub depth_format: wgpu::TextureFormat,
-    pub glyph_cache_size: [u32; 2],
-    pub glyph_cache_scale_tolerance: f32,
-    pub glyph_cache_position_tolerance: f32,
-}
-
-/// Commands that map to wgpu encodable commands.
-#[derive(Debug)]
-enum RenderCommand {
-    /// Change pipeline for the new blend mode and topology.
-    SetPipeline(PipelineId),
-    /// Change bind group for a new image.
-    SetBindGroup(BindGroupId),
-    /// Set the rectangular scissor.
-    SetScissor(Scissor),
-    /// Draw the given vertex range.
-    DrawIndexed {
-        start_vertex: i32,
-        index_range: std::ops::Range<u32>,
-    },
-}
-
-/// The position and dimensions of the scissor.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct Scissor {
-    left: u32,
-    bottom: u32,
-    width: u32,
-    height: u32,
-}
-
-#[derive(Debug)]
-pub struct DrawError;
-
-#[repr(C)]
-#[derive(Copy, Clone, Debug)]
-struct Uniforms {
-    /// Translates from "logical pixel coordinate space" (our "world space") to screen space.
-    ///
-    /// Specifically:
-    ///
-    /// - x is transformed from (-half_logical_win_w, half_logical_win_w) to (-1, 1).
-    /// - y is transformed from (-half_logical_win_h, half_logical_win_h) to (1, -1).
-    /// - z is transformed from (-max_logical_win_side, max_logical_win_side) to (0, 1).
-    proj: Mat4,
-}
-
-type SamplerId = u64;
-type BindGroupId = (SamplerId, wgpu::TextureViewId);
-type BlendId = u64;
-type ColorId = BlendId;
-type AlphaId = BlendId;
-
-/// Each of the properties that indicate a unique pipeline.
-#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
-struct PipelineId {
-    color_id: ColorId,
-    alpha_id: AlphaId,
-    topology: wgpu::PrimitiveTopology,
-    texture_sample_type: wgpu::TextureSampleType,
-}
-
-impl Default for PrimitiveRender {
-    fn default() -> Self {
-        Self::color()
-    }
-}
-
-impl RenderPrimitive for draw::Primitive {
-    fn render_primitive(self, ctxt: RenderContext, mesh: &mut draw::Mesh) -> PrimitiveRender {
-        match self {
-            draw::Primitive::Arrow(prim) => prim.render_primitive(ctxt, mesh),
-            draw::Primitive::Mesh(prim) => prim.render_primitive(ctxt, mesh),
-            draw::Primitive::Path(prim) => prim.render_primitive(ctxt, mesh),
-            draw::Primitive::Polygon(prim) => prim.render_primitive(ctxt, mesh),
-            draw::Primitive::Tri(prim) => prim.render_primitive(ctxt, mesh),
-            draw::Primitive::Ellipse(prim) => prim.render_primitive(ctxt, mesh),
-            draw::Primitive::Quad(prim) => prim.render_primitive(ctxt, mesh),
-            draw::Primitive::Rect(prim) => prim.render_primitive(ctxt, mesh),
-            draw::Primitive::Line(prim) => prim.render_primitive(ctxt, mesh),
-            draw::Primitive::Text(prim) => prim.render_primitive(ctxt, mesh),
-            draw::Primitive::Texture(prim) => prim.render_primitive(ctxt, mesh),
-            _ => PrimitiveRender::default(),
-        }
-    }
-}
-
-impl fmt::Debug for GlyphCache {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("GlyphCache")
-            .field("cache", &self.cache.dimensions())
-            .field("pixel_buffer", &self.pixel_buffer.len())
-            .field("requires_upload", &self.requires_upload)
-            .finish()
-    }
-}
-
-impl PrimitiveRender {
-    /// Specify a vertex mode for the primitive render.
-    pub fn vertex_mode(vertex_mode: VertexMode) -> Self {
-        PrimitiveRender {
-            texture_view: None,
-            vertex_mode,
-        }
-    }
-
-    pub fn color() -> Self {
-        Self::vertex_mode(VertexMode::Color)
-    }
-
-    pub fn texture(texture_view: wgpu::TextureView) -> Self {
-        PrimitiveRender {
-            vertex_mode: VertexMode::Texture,
-            texture_view: Some(texture_view),
-        }
-    }
-
-    pub fn text() -> Self {
-        Self::vertex_mode(VertexMode::Text)
-    }
-}
-
-impl Builder {
-    /// The default depth format
-    pub const DEFAULT_DEPTH_FORMAT: wgpu::TextureFormat = Renderer::DEFAULT_DEPTH_FORMAT;
-    /// The default size for the inner glyph cache.
-    pub const DEFAULT_GLYPH_CACHE_SIZE: [u32; 2] = Renderer::DEFAULT_GLYPH_CACHE_SIZE;
-    /// The default scale tolerance for the glyph cache.
-    pub const DEFAULT_GLYPH_CACHE_SCALE_TOLERANCE: f32 =
-        Renderer::DEFAULT_GLYPH_CACHE_SCALE_TOLERANCE;
-    /// The default position tolerance for the glyph cache.
-    pub const DEFAULT_GLYPH_CACHE_POSITION_TOLERANCE: f32 =
-        Renderer::DEFAULT_GLYPH_CACHE_POSITION_TOLERANCE;
-
-    /// Begin building a new **draw::Renderer**.
-    pub fn new() -> Self {
-        Self {
-            depth_format: Self::DEFAULT_DEPTH_FORMAT,
-            glyph_cache_size: Self::DEFAULT_GLYPH_CACHE_SIZE,
-            glyph_cache_scale_tolerance: Self::DEFAULT_GLYPH_CACHE_SCALE_TOLERANCE,
-            glyph_cache_position_tolerance: Self::DEFAULT_GLYPH_CACHE_POSITION_TOLERANCE,
-        }
-    }
-
-    /// Specify the texture format that should be used to represent depth data in the renderer's
-    /// inner `depth_texture`.
-    pub fn depth_format(mut self, format: wgpu::TextureFormat) -> Self {
-        self.depth_format = format;
-        self
-    }
-
-    /// The dimensions of the texture used to cache glyphs.
-    ///
-    /// Some text-heavy apps may require a text cache larger than the default size in order to run
-    /// efficiently without text glitching. If the texture is insufficiently large for all text
-    /// currently appearing within the output attachment, artifacts will appear in the text.
-    pub fn glyph_cache_size(mut self, size: [u32; 2]) -> Self {
-        self.glyph_cache_size = size;
-        self
-    }
-
-    /// Specifies the tolerances (maximum allowed difference) for judging whether an existing glyph
-    /// in the cache is close enough to the requested glyph in scale to be used in its place.
-    ///
-    /// Due to floating point inaccuracies a min value of 0.001 is enforced.
-    pub fn glyph_cache_scale_tolerance(mut self, tolerance: f32) -> Self {
-        self.glyph_cache_scale_tolerance = tolerance;
-        self
-    }
-
-    /// Specifies the tolerances (maximum allowed difference) for judging whether an existing glyph
-    /// in the cache is close enough to the requested glyph in subpixel offset to be used in its
-    /// place.
-    ///
-    /// Due to floating point inaccuracies a min value of 0.001 is enforced.
-    pub fn glyph_cache_position_tolerance(mut self, tolerance: f32) -> Self {
-        self.glyph_cache_position_tolerance = tolerance;
-        self
-    }
-
-    /// Build the **draw::Renderer** ready to target an output attachment of the given descriptor.
-    pub fn build_from_texture_descriptor(
-        self,
-        device: &wgpu::Device,
-        descriptor: &wgpu::TextureDescriptor,
-    ) -> Renderer {
-        let scale_factor = 1.0;
-        self.build(
-            device,
-            [descriptor.size.width, descriptor.size.height],
-            scale_factor,
-            descriptor.sample_count,
-            descriptor.format,
-        )
-    }
-
-    /// Build the **draw::Renderer** ready to target an output attachment with the given size,
-    /// sample count and format.
-    pub fn build(
-        self,
-        device: &wgpu::Device,
-        output_attachment_size: [u32; 2],
-        output_scale_factor: f32,
-        sample_count: u32,
-        output_color_format: wgpu::TextureFormat,
-    ) -> Renderer {
-        Renderer::new(
-            device,
-            output_attachment_size,
-            output_scale_factor,
-            sample_count,
-            output_color_format,
-            self.depth_format,
-            self.glyph_cache_size,
-            self.glyph_cache_scale_tolerance,
-            self.glyph_cache_position_tolerance,
-        )
-    }
-}
-
-impl GlyphCache {
-    fn new(size: [u32; 2], scale_tolerance: f32, position_tolerance: f32) -> Self {
-        let [w, h] = size;
-        let cache = text::GlyphCache::builder()
-            .dimensions(w, h)
-            .scale_tolerance(scale_tolerance)
-            .position_tolerance(position_tolerance)
-            .build()
-            .into();
-        let pixel_buffer = vec![0u8; w as usize * h as usize];
-        let requires_upload = false;
-        GlyphCache {
-            cache,
-            pixel_buffer,
-            requires_upload,
-        }
-    }
-}
-
-impl Renderer {
-    /// The default depth format
-    pub const DEFAULT_DEPTH_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Depth32Float;
-    /// The default size for the inner glyph cache.
-    pub const DEFAULT_GLYPH_CACHE_SIZE: [u32; 2] = [1024; 2];
-    /// The default scale tolerance for the glyph cache.
-    pub const DEFAULT_GLYPH_CACHE_SCALE_TOLERANCE: f32 = 0.1;
-    /// The default position tolerance for the glyph cache.
-    pub const DEFAULT_GLYPH_CACHE_POSITION_TOLERANCE: f32 = 0.1;
-    /// The texture format of the inner glyph cache.
-    pub const GLYPH_CACHE_TEXTURE_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::R8Unorm;
-    /// The index format used to index into vertices.
-    pub const INDEX_FORMAT: wgpu::IndexFormat = wgpu::IndexFormat::Uint32;
-
-    /// Create a new **Renderer**, ready to target an output attachment with the given size, sample
-    /// count and color format.
-    ///
-    /// See the **RendererBuilder** type for a simplified approach to building a renderer that will
-    /// fall back to a set of reasonable defaults.
-    ///
-    /// The `depth_format` will be used to construct a depth texture for depth testing.
-    ///
-    /// The `glyph_cache_size` will be used to create a texture on which glyphs will be stored for
-    /// efficient look-up.
-    pub fn new(
-        device: &wgpu::Device,
-        output_attachment_size: [u32; 2],
-        output_scale_factor: f32,
-        sample_count: u32,
-        output_color_format: wgpu::TextureFormat,
-        depth_format: wgpu::TextureFormat,
-        glyph_cache_size: [u32; 2],
-        glyph_cache_scale_tolerance: f32,
-        glyph_cache_position_tolerance: f32,
-    ) -> Self {
-        // Construct the glyph cache.
-        let glyph_cache = GlyphCache::new(
-            glyph_cache_size,
-            glyph_cache_scale_tolerance,
-            glyph_cache_position_tolerance,
-        );
-
-        // Load shader modules.
-        let vs_desc = wgpu::include_wgsl!("shaders/vs.wgsl");
-        let fs_desc = wgpu::include_wgsl!("shaders/fs.wgsl");
-        let vs_mod = device.create_shader_module(vs_desc);
-        let fs_mod = device.create_shader_module(fs_desc);
-
-        // Create the glyph cache texture.
-        let text_sampler_desc = wgpu::SamplerBuilder::new().into_descriptor();
-        let text_sampler_filtering = wgpu::sampler_filtering(&text_sampler_desc);
-        let text_sampler = device.create_sampler(&text_sampler_desc);
-        let glyph_cache_texture = wgpu::TextureBuilder::new()
-            .size(glyph_cache_size)
-            .usage(wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST)
-            .format(Self::GLYPH_CACHE_TEXTURE_FORMAT)
-            .build(device);
-        let glyph_cache_texture_view =
-            glyph_cache_texture.create_view(&wgpu::TextureViewDescriptor::default());
-
-        // Create the depth texture.
-        let depth_texture =
-            create_depth_texture(device, output_attachment_size, depth_format, sample_count);
-        let depth_texture_view = depth_texture.view().build();
-
-        // The default texture for the case where the user has not specified one.
-        let default_texture = wgpu::TextureBuilder::new()
-            .size([64; 2])
-            .usage(wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST)
-            .build(device);
-        let default_texture_view = default_texture.view().build();
-
-        // Initial uniform buffer values. These will be overridden on draw.
-        let uniforms = create_uniforms(output_attachment_size, output_scale_factor);
-        let contents = uniforms_as_bytes(&uniforms);
-        let usage = wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST;
-        let uniform_buffer = device.create_buffer_init(&wgpu::BufferInitDescriptor {
-            label: Some("nannou Renderer uniform_buffer"),
-            contents,
-            usage,
-        });
-
-        // Bind group for uniforms.
-        let uniform_bind_group_layout = create_uniform_bind_group_layout(device);
-        let uniform_bind_group =
-            create_uniform_bind_group(device, &uniform_bind_group_layout, &uniform_buffer);
-
-        // Bind group for text.
-        let text_bind_group_layout = create_text_bind_group_layout(device, text_sampler_filtering);
-        let text_bind_group = create_text_bind_group(
-            device,
-            &text_bind_group_layout,
-            &text_sampler,
-            &glyph_cache_texture_view,
-        );
-
-        // Initialise the sampler set with the default sampler.
-        let sampler_desc = wgpu::SamplerBuilder::new().into_descriptor();
-        let sampler_id = sampler_descriptor_hash(&sampler_desc);
-        let texture_sampler = device.create_sampler(&sampler_desc);
-
-        // Bind group per user-uploaded texture.
-        let texture_bind_group_layouts = Default::default();
-        let texture_bind_groups = Default::default();
-
-        // Pipeline per unique pipelin ID.
-        let pipelines = HashMap::default();
-
-        let texture_samplers = Some((sampler_id, texture_sampler)).into_iter().collect();
-        let render_commands = vec![];
-        let mesh = Default::default();
-        let vertex_mode_buffer = vec![];
-
-        Self {
-            vs_mod,
-            fs_mod,
-            glyph_cache,
-            glyph_cache_texture,
-            depth_texture,
-            depth_texture_view,
-            _default_texture: default_texture,
-            default_texture_view,
-            uniform_bind_group_layout,
-            uniform_bind_group,
-            text_bind_group_layout,
-            text_bind_group,
-            texture_samplers,
-            texture_bind_group_layouts,
-            texture_bind_groups,
-            pipelines,
-            output_color_format,
-            sample_count,
-            scale_factor: output_scale_factor,
-            render_commands,
-            mesh,
-            vertex_mode_buffer,
-            uniform_buffer,
-        }
-    }
-
-    /// Clear all pending render commands vertex data.
-    pub fn clear(&mut self) {
-        self.render_commands.clear();
-        self.mesh.clear();
-        self.vertex_mode_buffer.clear();
-    }
-
-    /// Generate a list of `RenderCommand`s from the given **Draw** instance and prepare any
-    /// necessary vertex data.
-    ///
-    /// Note that the given **Draw** instance will be *drained* of its commands.
-    pub fn fill(
-        &mut self,
-        device: &wgpu::Device,
-        draw: &draw::Draw,
-        scale_factor: f32,
-        output_attachment_size: [u32; 2],
-    ) {
-        // Pushes a draw command and updates the `curr_start_index`.
-        //
-        // Returns `true` if the command was added, `false` if there was nothing to
-        // draw.
-        fn push_draw_cmd(
-            curr_start_index: &mut u32,
-            end_index: u32,
-            render_commands: &mut Vec<RenderCommand>,
-        ) -> bool {
-            let index_range = *curr_start_index..end_index;
-            if index_range.len() != 0 {
-                let start_vertex = 0;
-                *curr_start_index = index_range.end;
-                let cmd = RenderCommand::DrawIndexed {
-                    start_vertex,
-                    index_range,
-                };
-                render_commands.push(cmd);
-                true
-            } else {
-                false
-            }
-        }
-
-        let [w_px, h_px] = output_attachment_size;
-
-        // Converting between pixels and points.
-        let px_to_pt = |s: u32| s as f32 / scale_factor;
-        let pt_to_px = |s: f32| (s * scale_factor).round() as u32;
-        let full_rect = Rect::from_w_h(px_to_pt(w_px), px_to_pt(h_px));
-
-        let window_to_scissor = |v: Vec2| -> [u32; 2] {
-            let x = map_range(v.x, full_rect.left(), full_rect.right(), 0u32, w_px);
-            let y = map_range(v.y, full_rect.bottom(), full_rect.top(), 0u32, h_px);
-            [x, y]
-        };
-
-        // TODO: Store these in `Renderer`.
-        let mut fill_tessellator = FillTessellator::new();
-        let mut stroke_tessellator = StrokeTessellator::new();
-
-        // Keep track of context changes.
-        let mut curr_ctxt = draw::Context::default();
-        let mut new_pipeline_ids = HashMap::new();
-        let mut curr_start_index = 0;
-        let mut new_tex_views = HashMap::new();
-        let mut new_tex_sampler_combos = HashMap::new();
-        // Track whether new commands are required.
-        let mut curr_pipeline_id = None;
-        let mut curr_scissor = None;
-        let mut curr_tex_sampler_id = None;
-
-        // Collect all draw commands to avoid borrow errors.
-        let draw_cmds: Vec<_> = draw.drain_commands().collect();
-        let draw_state = draw.state.borrow_mut();
-        let intermediary_state = draw_state.intermediary_state.borrow();
-        for cmd in draw_cmds {
-            match cmd {
-                draw::DrawCommand::Context(ctxt) => curr_ctxt = ctxt,
-                draw::DrawCommand::Primitive(prim) => {
-                    // Track the prev index and vertex counts.
-                    let prev_index_count = self.mesh.indices().len() as u32;
-                    let prev_vert_count = self.mesh.vertex_count();
-
-                    // Info required during rendering.
-                    let ctxt = RenderContext {
-                        intermediary_mesh: &intermediary_state.intermediary_mesh,
-                        path_event_buffer: &intermediary_state.path_event_buffer,
-                        path_points_colored_buffer: &intermediary_state.path_points_colored_buffer,
-                        path_points_textured_buffer: &intermediary_state
-                            .path_points_textured_buffer,
-                        text_buffer: &intermediary_state.text_buffer,
-                        theme: &draw_state.theme,
-                        transform: &curr_ctxt.transform,
-                        fill_tessellator: &mut fill_tessellator,
-                        stroke_tessellator: &mut stroke_tessellator,
-                        glyph_cache: &mut self.glyph_cache,
-                        output_attachment_size: Vec2::new(px_to_pt(w_px), px_to_pt(h_px)),
-                        output_attachment_scale_factor: scale_factor,
-                    };
-
-                    // Render the primitive.
-                    let render = prim.render_primitive(ctxt, &mut self.mesh);
-
-                    // If the mesh indices are unchanged, there's nothing to be drawn.
-                    if prev_index_count == self.mesh.indices().len() as u32 {
-                        assert_eq!(
-                            prev_vert_count,
-                            self.mesh.vertex_count(),
-                            "vertices were submitted during `render` without submitting indices",
-                        );
-                        continue;
-                    }
-
-                    // Retrieve the current texture view and texture view ID. These are necessary
-                    // for producing the current pipeline and bind group IDs. Also ensure we have
-                    // an entry for them in our map.
-                    let tex_view = match render.texture_view {
-                        Some(tex_view) => tex_view,
-                        None => self.default_texture_view.clone(),
-                    };
-                    let tex_view_id = tex_view.id();
-                    let texture_sample_type = tex_view.sample_type();
-                    new_tex_views.insert(tex_view_id, tex_view);
-
-                    // Determine the new current bind group layout ID, pipeline ID, bind group ID
-                    // and scissor required for drawing this primitive.
-                    let new_pipeline_id = {
-                        let color_id = blend_component_hash(&curr_ctxt.blend.color);
-                        let alpha_id = blend_component_hash(&curr_ctxt.blend.alpha);
-                        let topology = curr_ctxt.topology;
-                        PipelineId {
-                            color_id,
-                            alpha_id,
-                            topology,
-                            texture_sample_type,
-                        }
-                    };
-                    let new_bind_group_id = {
-                        let sampler_id = sampler_descriptor_hash(&curr_ctxt.sampler);
-                        (sampler_id, tex_view_id)
-                    };
-                    let new_scissor = curr_ctxt.scissor;
-
-                    // Determine which have changed and in turn which require submitting new
-                    // commands.
-                    let pipeline_changed = Some(new_pipeline_id) != curr_pipeline_id;
-                    let bind_group_changed = Some(new_bind_group_id) != curr_tex_sampler_id;
-                    let scissor_changed = Some(new_scissor) != curr_scissor;
-
-                    // If we require submitting a scissor, pipeline or bind group command, first
-                    // draw whatever pending vertices we have collected so far. If there have been
-                    // no graphics yet, this will do nothing.
-                    if scissor_changed || pipeline_changed || bind_group_changed {
-                        push_draw_cmd(
-                            &mut curr_start_index,
-                            prev_index_count,
-                            &mut self.render_commands,
-                        );
-                    }
-
-                    // If necessary, push a new pipeline command.
-                    if pipeline_changed {
-                        curr_pipeline_id = Some(new_pipeline_id);
-                        let color_blend = curr_ctxt.blend.color.clone();
-                        let alpha_blend = curr_ctxt.blend.alpha.clone();
-                        let sampler_filtering = wgpu::sampler_filtering(&curr_ctxt.sampler);
-                        new_pipeline_ids.insert(
-                            new_pipeline_id,
-                            (color_blend, alpha_blend, sampler_filtering),
-                        );
-                        let cmd = RenderCommand::SetPipeline(new_pipeline_id);
-                        self.render_commands.push(cmd);
-                    }
-
-                    // If necessary, push a new bind group command.
-                    if bind_group_changed {
-                        curr_tex_sampler_id = Some(new_bind_group_id);
-                        new_tex_sampler_combos.insert(new_bind_group_id, new_pipeline_id);
-                        let cmd = RenderCommand::SetBindGroup(new_bind_group_id);
-                        self.render_commands.push(cmd);
-                    }
-
-                    // If necessary, push a new scissor command.
-                    if scissor_changed {
-                        curr_scissor = Some(new_scissor);
-                        let rect = match curr_ctxt.scissor {
-                            draw::Scissor::Full => full_rect,
-                            draw::Scissor::Rect(rect) => full_rect
-                                .overlap(rect)
-                                .unwrap_or(geom::Rect::from_w_h(0.0, 0.0)),
-                            draw::Scissor::NoOverlap => geom::Rect::from_w_h(0.0, 0.0),
-                        };
-                        let [left, bottom] = window_to_scissor(rect.bottom_left().into());
-                        let (width, height) = rect.w_h();
-                        let (width, height) = (pt_to_px(width), pt_to_px(height));
-                        let scissor = Scissor {
-                            left,
-                            bottom,
-                            width,
-                            height,
-                        };
-                        let cmd = RenderCommand::SetScissor(scissor);
-                        self.render_commands.push(cmd);
-                    }
-
-                    // Extend the vertex mode channel.
-                    let mode = render.vertex_mode;
-                    let new_vs = self.mesh.points().len() - self.vertex_mode_buffer.len();
-                    self.vertex_mode_buffer.extend((0..new_vs).map(|_| mode));
-                }
-            }
-        }
-
-        // Insert the final draw command if there is still some drawing to be done.
-        push_draw_cmd(
-            &mut curr_start_index,
-            self.mesh.indices().len() as u32,
-            &mut self.render_commands,
-        );
-
-        // Clear out unnecessary pipelines.
-        self.pipelines
-            .retain(|id, _| new_pipeline_ids.contains_key(id));
-        // Clear new combos that we already have.
-        new_pipeline_ids.retain(|id, _| !self.pipelines.contains_key(id));
-        // Create new render pipelines as necessary.
-        for (new_id, (color_blend, alpha_blend, sampler_filtering)) in new_pipeline_ids {
-            let bind_group_layout = self
-                .texture_bind_group_layouts
-                .entry(new_id.texture_sample_type)
-                .or_insert_with(|| {
-                    create_texture_bind_group_layout(
-                        device,
-                        sampler_filtering,
-                        new_id.texture_sample_type,
-                    )
-                });
-            let new_pipeline = create_render_pipeline(
-                device,
-                &self.uniform_bind_group_layout,
-                &self.text_bind_group_layout,
-                &bind_group_layout,
-                &self.vs_mod,
-                &self.fs_mod,
-                self.output_color_format,
-                self.depth_texture.format(),
-                self.sample_count,
-                color_blend,
-                alpha_blend,
-                new_id.topology,
-            );
-            self.pipelines.insert(new_id, new_pipeline);
-        }
-
-        // Clear out unnecessary bind groups.
-        self.texture_bind_groups
-            .retain(|id, _| new_tex_sampler_combos.contains_key(id));
-        // Clear new combos that we already have.
-        new_tex_sampler_combos.retain(|id, _| !self.texture_bind_groups.contains_key(id));
-        // Only keep the samplers around that we need.
-        self.texture_samplers
-            .retain(|id, _| new_tex_sampler_combos.keys().any(|(s_id, _)| id == s_id));
-        // Ensure we have a bind group for each of the texture views, but no more.
-        for (new_id, pipeline_id) in new_tex_sampler_combos {
-            let (new_sampler_id, new_tex_view_id) = new_id;
-            // Retrieve the sampler or create it if necessary.
-            let sampler = self
-                .texture_samplers
-                .entry(new_sampler_id)
-                .or_insert_with(|| device.create_sampler(&curr_ctxt.sampler));
-            // Retrieve the texture view.
-            let texture_view = &new_tex_views[&new_tex_view_id];
-            // Retrieve the associated bind group layout.
-            let bind_group_layout =
-                &self.texture_bind_group_layouts[&pipeline_id.texture_sample_type];
-            // Create the bind group.
-            let bind_group =
-                create_texture_bind_group(device, bind_group_layout, sampler, texture_view);
-            self.texture_bind_groups.insert(new_id, bind_group);
-        }
-    }
-
-    /// Encode a render pass with the given **Draw**ing to the given `output_attachment`.
-    ///
-    /// If the **Draw**ing has been scaled for handling DPI, specify the necessary `scale_factor`
-    /// for scaling back to the `output_attachment_size` (physical dimensions).
-    ///
-    /// If the `output_attachment` is multisampled and should be resolved to another texture,
-    /// include the `resolve_target`.
-    pub fn encode_render_pass(
-        &mut self,
-        device: &wgpu::Device,
-        encoder: &mut wgpu::CommandEncoder,
-        draw: &draw::Draw,
-        scale_factor: f32,
-        output_attachment_size: [u32; 2],
-        output_attachment: &wgpu::TextureView,
-        resolve_target: Option<&wgpu::TextureView>,
-    ) {
-        self.clear();
-        self.fill(device, draw, scale_factor, output_attachment_size);
-
-        let Renderer {
-            ref pipelines,
-            ref glyph_cache,
-            ref glyph_cache_texture,
-            ref mut depth_texture,
-            ref mut depth_texture_view,
-            ref uniform_bind_group,
-            ref text_bind_group,
-            ref texture_bind_groups,
-            ref mesh,
-            ref vertex_mode_buffer,
-            ref mut render_commands,
-            ref uniform_buffer,
-            scale_factor: ref mut old_scale_factor,
-            ..
-        } = *self;
-
-        // Update glyph cache texture if necessary.
-        if glyph_cache.requires_upload {
-            glyph_cache_texture.upload_data(device, encoder, &glyph_cache.pixel_buffer);
-        }
-
-        // Resize the depth texture if the output attachment size has changed.
-        let depth_size = depth_texture.size();
-        if output_attachment_size != depth_size {
-            let depth_format = depth_texture.format();
-            let sample_count = depth_texture.sample_count();
-            *depth_texture =
-                create_depth_texture(device, output_attachment_size, depth_format, sample_count);
-            *depth_texture_view = depth_texture.view().build();
-        }
-
-        // Retrieve the clear values based on the bg color.
-        let bg_color = draw.state.borrow().background_color;
-        let load_op = match bg_color {
-            None => wgpu::LoadOp::Load,
-            Some(color) => {
-                let (r, g, b, a) = color.into();
-                let (r, g, b, a) = (r as f64, g as f64, b as f64, a as f64);
-                let clear_color = wgpu::Color { r, g, b, a };
-                wgpu::LoadOp::Clear(clear_color)
-            }
-        };
-
-        // Create render pass builder.
-        let render_pass_builder = wgpu::RenderPassBuilder::new()
-            .color_attachment(output_attachment, |color| {
-                color.resolve_target(resolve_target).load_op(load_op)
-            })
-            .depth_stencil_attachment(&*depth_texture_view, |depth| depth);
-
-        // Guard for empty mesh.
-        if mesh.points().is_empty() {
-            // Encode the render pass. Only clears the frame.
-            render_pass_builder.begin(encoder);
-            return;
-        }
-
-        // Create the vertex and index buffers.
-        let vertex_usage = wgpu::BufferUsages::VERTEX;
-        let points_bytes = points_as_bytes(mesh.points());
-        let colors_bytes = colors_as_bytes(mesh.colors());
-        let tex_coords_bytes = tex_coords_as_bytes(mesh.tex_coords());
-        let modes_bytes = vertex_modes_as_bytes(vertex_mode_buffer);
-        let indices_bytes = indices_as_bytes(mesh.indices());
-        let point_buffer = device.create_buffer_init(&BufferInitDescriptor {
-            label: Some("nannou Renderer point_buffer"),
-            contents: points_bytes,
-            usage: vertex_usage,
-        });
-        let color_buffer = device.create_buffer_init(&BufferInitDescriptor {
-            label: Some("nannou Renderer color_buffer"),
-            contents: colors_bytes,
-            usage: vertex_usage,
-        });
-        let tex_coords_buffer = device.create_buffer_init(&BufferInitDescriptor {
-            label: Some("nannou Renderer tex_coords_buffer"),
-            contents: tex_coords_bytes,
-            usage: vertex_usage,
-        });
-        let mode_buffer = device.create_buffer_init(&BufferInitDescriptor {
-            label: Some("nannou Renderer mode_buffer"),
-            contents: modes_bytes,
-            usage: vertex_usage,
-        });
-        let index_buffer = device.create_buffer_init(&BufferInitDescriptor {
-            label: Some("nannou Renderer index_buffer"),
-            contents: indices_bytes,
-            usage: wgpu::BufferUsages::INDEX,
-        });
-
-        // If the scale factor or window size has changed, update the uniforms for vertex scaling.
-        if *old_scale_factor != scale_factor || output_attachment_size != depth_size {
-            *old_scale_factor = scale_factor;
-            // Upload uniform data for vertex scaling.
-            let uniforms = create_uniforms(output_attachment_size, scale_factor);
-            let uniforms_size = std::mem::size_of::<Uniforms>() as wgpu::BufferAddress;
-            let uniforms_bytes = uniforms_as_bytes(&uniforms);
-            let usage = wgpu::BufferUsages::COPY_SRC;
-            let new_uniform_buffer = device.create_buffer_init(&BufferInitDescriptor {
-                label: Some("nannou Renderer uniform_buffer"),
-                contents: uniforms_bytes,
-                usage,
-            });
-            // Copy new uniform buffer state.
-            encoder.copy_buffer_to_buffer(&new_uniform_buffer, 0, uniform_buffer, 0, uniforms_size);
-        }
-
-        // Encode the render pass.
-        let mut render_pass = render_pass_builder.begin(encoder);
-
-        // Set the buffers.
-        render_pass.set_index_buffer(index_buffer.slice(..), Self::INDEX_FORMAT);
-        render_pass.set_vertex_buffer(0, point_buffer.slice(..));
-        render_pass.set_vertex_buffer(1, color_buffer.slice(..));
-        render_pass.set_vertex_buffer(2, tex_coords_buffer.slice(..));
-        render_pass.set_vertex_buffer(3, mode_buffer.slice(..));
-
-        // Set the uniform and text bind groups here.
-        render_pass.set_bind_group(0, uniform_bind_group, &[]);
-        render_pass.set_bind_group(1, text_bind_group, &[]);
-
-        // Follow the render commands.
-        for cmd in render_commands.drain(..) {
-            match cmd {
-                RenderCommand::SetPipeline(id) => {
-                    let pipeline = &pipelines[&id];
-                    render_pass.set_pipeline(pipeline);
-                }
-
-                RenderCommand::SetBindGroup(tex_view_id) => {
-                    let bind_group = &texture_bind_groups[&tex_view_id];
-                    render_pass.set_bind_group(2, bind_group, &[]);
-                }
-
-                RenderCommand::SetScissor(Scissor {
-                    left,
-                    bottom,
-                    width,
-                    height,
-                }) => {
-                    render_pass.set_scissor_rect(left, bottom, width, height);
-                }
-
-                RenderCommand::DrawIndexed {
-                    start_vertex,
-                    index_range,
-                } => {
-                    let instance_range = 0..1u32;
-                    render_pass.draw_indexed(index_range, start_vertex, instance_range);
-                }
-            }
-        }
-    }
-
-    /// Encode the necessary commands to render the contents of the given **Draw**ing to the given
-    /// **Texture**.
-    pub fn render_to_texture(
-        &mut self,
-        device: &wgpu::Device,
-        encoder: &mut wgpu::CommandEncoder,
-        draw: &draw::Draw,
-        texture: &wgpu::Texture,
-    ) {
-        let size = texture.size();
-        let view = texture.view().build();
-        // TODO: Should we expose this for rendering to textures?
-        let scale_factor = 1.0;
-        let resolve_target = None;
-        self.encode_render_pass(
-            device,
-            encoder,
-            draw,
-            scale_factor,
-            size,
-            &view,
-            resolve_target,
-        );
-    }
-
-    /// Encode the necessary commands to render the contents of the given **Draw**ing to the given
-    /// **Frame**.
-    pub fn render_to_frame(
-        &mut self,
-        device: &wgpu::Device,
-        draw: &draw::Draw,
-        scale_factor: f32,
-        frame: &Frame,
-    ) {
-        let size = frame.texture().size();
-        let attachment = frame.texture_view();
-        let resolve_target = None;
-        let mut command_encoder = frame.command_encoder();
-        self.encode_render_pass(
-            device,
-            &mut *command_encoder,
-            draw,
-            scale_factor,
-            size,
-            attachment,
-            resolve_target,
-        );
-    }
-}
-
-impl Default for Builder {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl Deref for GlyphCache {
-    type Target = text::GlyphCache<'static>;
-    fn deref(&self) -> &Self::Target {
-        &self.cache
-    }
-}
-
-impl DerefMut for GlyphCache {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.cache
-    }
-}
-
-fn create_depth_texture(
-    device: &wgpu::Device,
-    size: [u32; 2],
-    depth_format: wgpu::TextureFormat,
-    sample_count: u32,
-) -> wgpu::Texture {
-    wgpu::TextureBuilder::new()
-        .size(size)
-        .format(depth_format)
-        .usage(wgpu::TextureUsages::RENDER_ATTACHMENT)
-        .sample_count(sample_count)
-        .build(device)
-}
-
-fn create_uniforms([img_w, img_h]: [u32; 2], scale_factor: f32) -> Uniforms {
-    let right = img_w as f32 * 0.5 / scale_factor;
-    let left = -right;
-    let top = img_h as f32 * 0.5 / scale_factor;
-    let bottom = -top;
-    let far = std::cmp::max(img_w, img_h) as f32 / scale_factor;
-    let near = -far;
-    let proj = Mat4::orthographic_rh_gl(left, right, bottom, top, near, far);
-    // By default, ortho scales z values to the range -1.0 to 1.0. We want to scale and translate
-    // the z axis so that it is in the range of 0.0 to 1.0.
-    // TODO: Can possibly solve this more easily by using `Mat4::orthographic_rh` above instead.
-    let trans = Mat4::from_translation(Vec3::Z);
-    let scale = Mat4::from_scale([1.0, 1.0, 0.5].into());
-    let proj = scale * trans * proj;
-    let proj = proj.into();
-    Uniforms { proj }
-}
-
-fn create_uniform_bind_group_layout(device: &wgpu::Device) -> wgpu::BindGroupLayout {
-    wgpu::BindGroupLayoutBuilder::new()
-        .uniform_buffer(wgpu::ShaderStages::VERTEX, false)
-        .build(device)
-}
-
-fn create_text_bind_group_layout(device: &wgpu::Device, filtering: bool) -> wgpu::BindGroupLayout {
-    wgpu::BindGroupLayoutBuilder::new()
-        .sampler(wgpu::ShaderStages::FRAGMENT, filtering)
-        .texture(
-            wgpu::ShaderStages::FRAGMENT,
-            false,
-            wgpu::TextureViewDimension::D2,
-            Renderer::GLYPH_CACHE_TEXTURE_FORMAT
-                .sample_type(None)
-                .expect("Expected format to have sample type"),
-        )
-        .build(device)
-}
-
-fn create_texture_bind_group_layout(
-    device: &wgpu::Device,
-    filtering: bool,
-    texture_sample_type: wgpu::TextureSampleType,
-) -> wgpu::BindGroupLayout {
-    wgpu::BindGroupLayoutBuilder::new()
-        .sampler(wgpu::ShaderStages::FRAGMENT, filtering)
-        .texture(
-            wgpu::ShaderStages::FRAGMENT,
-            false,
-            wgpu::TextureViewDimension::D2,
-            texture_sample_type,
-        )
-        .build(device)
-}
-
-fn create_uniform_bind_group(
-    device: &wgpu::Device,
-    layout: &wgpu::BindGroupLayout,
-    uniform_buffer: &wgpu::Buffer,
-) -> wgpu::BindGroup {
-    wgpu::BindGroupBuilder::new()
-        .buffer::<Uniforms>(uniform_buffer, 0..1)
-        .build(device, layout)
-}
-
-fn create_text_bind_group(
-    device: &wgpu::Device,
-    layout: &wgpu::BindGroupLayout,
-    sampler: &wgpu::Sampler,
-    glyph_cache_texture_view: &wgpu::TextureViewHandle,
-) -> wgpu::BindGroup {
-    wgpu::BindGroupBuilder::new()
-        .sampler(sampler)
-        .texture_view(glyph_cache_texture_view)
-        .build(device, layout)
-}
-
-fn create_texture_bind_group(
-    device: &wgpu::Device,
-    layout: &wgpu::BindGroupLayout,
-    sampler: &wgpu::Sampler,
-    texture_view: &wgpu::TextureViewHandle,
-) -> wgpu::BindGroup {
-    wgpu::BindGroupBuilder::new()
-        .sampler(sampler)
-        .texture_view(texture_view)
-        .build(device, layout)
-}
-
-fn create_render_pipeline(
-    device: &wgpu::Device,
-    uniform_layout: &wgpu::BindGroupLayout,
-    text_layout: &wgpu::BindGroupLayout,
-    texture_layout: &wgpu::BindGroupLayout,
-    vs_mod: &wgpu::ShaderModule,
-    fs_mod: &wgpu::ShaderModule,
-    dst_format: wgpu::TextureFormat,
-    depth_format: wgpu::TextureFormat,
-    sample_count: u32,
-    color_blend: wgpu::BlendComponent,
-    alpha_blend: wgpu::BlendComponent,
-    topology: wgpu::PrimitiveTopology,
-) -> wgpu::RenderPipeline {
-    let bind_group_layouts = &[uniform_layout, text_layout, texture_layout];
-    wgpu::RenderPipelineBuilder::from_layout_descriptor(&bind_group_layouts[..], vs_mod)
-        .fragment_shader(fs_mod)
-        .color_format(dst_format)
-        .add_vertex_buffer::<draw::mesh::vertex::Point>(&wgpu::vertex_attr_array![0 => Float32x3])
-        .add_vertex_buffer::<draw::mesh::vertex::Color>(&wgpu::vertex_attr_array![1 => Float32x4])
-        .add_vertex_buffer::<draw::mesh::vertex::TexCoords>(
-            &wgpu::vertex_attr_array![2 => Float32x2],
-        )
-        .add_vertex_buffer::<VertexMode>(&wgpu::vertex_attr_array![3 => Uint32])
-        .depth_format(depth_format)
-        .sample_count(sample_count)
-        .color_blend(color_blend)
-        .alpha_blend(alpha_blend)
-        .primitive_topology(topology)
-        .build(device)
-}
-
-fn sampler_descriptor_hash(desc: &wgpu::SamplerDescriptor) -> SamplerId {
-    let mut s = std::collections::hash_map::DefaultHasher::new();
-    desc.address_mode_u.hash(&mut s);
-    desc.address_mode_v.hash(&mut s);
-    desc.address_mode_w.hash(&mut s);
-    desc.mag_filter.hash(&mut s);
-    desc.min_filter.hash(&mut s);
-    desc.mipmap_filter.hash(&mut s);
-    desc.lod_min_clamp.to_bits().hash(&mut s);
-    desc.lod_max_clamp.to_bits().hash(&mut s);
-    desc.compare.hash(&mut s);
-    desc.anisotropy_clamp.hash(&mut s);
-    desc.border_color.hash(&mut s);
-    s.finish()
-}
-
-fn blend_component_hash(desc: &wgpu::BlendComponent) -> BlendId {
-    let mut s = std::collections::hash_map::DefaultHasher::new();
-    desc.src_factor.hash(&mut s);
-    desc.dst_factor.hash(&mut s);
-    desc.operation.hash(&mut s);
-    s.finish()
-}
-
-// See `nannou::wgpu::bytes` docs for why these are necessary.
-
-fn uniforms_as_bytes(uniforms: &Uniforms) -> &[u8] {
-    unsafe { wgpu::bytes::from(uniforms) }
-}
-
-fn points_as_bytes(data: &[draw::mesh::vertex::Point]) -> &[u8] {
-    unsafe { wgpu::bytes::from_slice(data) }
-}
-
-fn colors_as_bytes(data: &[draw::mesh::vertex::Color]) -> &[u8] {
-    unsafe { wgpu::bytes::from_slice(data) }
-}
-
-fn tex_coords_as_bytes(data: &[draw::mesh::vertex::TexCoords]) -> &[u8] {
-    unsafe { wgpu::bytes::from_slice(data) }
-}
-
-fn vertex_modes_as_bytes(data: &[VertexMode]) -> &[u8] {
-    unsafe { wgpu::bytes::from_slice(data) }
-}
-
-fn indices_as_bytes(data: &[u32]) -> &[u8] {
-    unsafe { wgpu::bytes::from_slice(data) }
-}
diff --git a/nannou/src/draw/renderer/shaders/fs.wgsl b/nannou/src/draw/renderer/shaders/fs.wgsl
deleted file mode 100644
index c75a2b6da..000000000
--- a/nannou/src/draw/renderer/shaders/fs.wgsl
+++ /dev/null
@@ -1,38 +0,0 @@
-struct FragmentOutput {
-    @location(0) color: vec4<f32>,
-};
-
-@group(1) @binding(0)
-var text_sampler: sampler;
-@group(1) @binding(1)
-var text: texture_2d<f32>;
-@group(2) @binding(0)
-var tex_sampler: sampler;
-@group(2) @binding(1)
-var tex: texture_2d<f32>;
-
-@fragment
-fn main(
-    @location(0) color: vec4<f32>,
-    @location(1) tex_coords: vec2<f32>,
-    @location(2) mode: u32,
-) -> FragmentOutput {
-    let tex_color: vec4<f32> = textureSample(tex, tex_sampler, tex_coords);
-    let text_color: vec4<f32> = textureSample(text, text_sampler, tex_coords);
-    let text_alpha: f32 = text_color.x;
-    var out_color: vec4<f32>;
-    if (mode == u32(0)) {
-        out_color = color;
-    } else {
-        if (mode == u32(1)) {
-            out_color = tex_color;
-        } else {
-            if (mode == u32(2)) {
-                out_color = vec4<f32>(color.xyz, color.w * text_alpha);
-            } else {
-                out_color = vec4<f32>(1.0, 0.0, 0.0, 1.0);
-            }
-        }
-    }
-    return FragmentOutput(out_color);
-}
diff --git a/nannou/src/draw/renderer/shaders/vs.wgsl b/nannou/src/draw/renderer/shaders/vs.wgsl
deleted file mode 100644
index f50b85a77..000000000
--- a/nannou/src/draw/renderer/shaders/vs.wgsl
+++ /dev/null
@@ -1,24 +0,0 @@
-struct Data {
-    proj: mat4x4<f32>,
-};
-
-struct VertexOutput {
-    @location(0) color: vec4<f32>,
-    @location(1) tex_coords: vec2<f32>,
-    @location(2) mode: u32,
-    @builtin(position) pos: vec4<f32>,
-};
-
-@group(0) @binding(0)
-var<uniform> uniforms: Data;
-
-@vertex
-fn main(
-    @location(0) position: vec3<f32>,
-    @location(1) color: vec4<f32>,
-    @location(2) tex_coords: vec2<f32>,
-    @location(3) mode: u32,
-) -> VertexOutput {
-    let out_pos: vec4<f32> = uniforms.proj * vec4<f32>(position, 1.0);
-    return VertexOutput(color, tex_coords, mode, out_pos);
-}
diff --git a/nannou/src/draw/theme.rs b/nannou/src/draw/theme.rs
deleted file mode 100644
index b51f7ea2d..000000000
--- a/nannou/src/draw/theme.rs
+++ /dev/null
@@ -1,93 +0,0 @@
-use crate::color::{LinSrgba, Srgba};
-use std::collections::HashMap;
-
-/// A set of styling defaults used for coloring texturing geometric primitives that have no entry
-/// within the **Draw**'s inner **ColorMap**.
-#[derive(Clone, Debug)]
-pub struct Theme {
-    /// Fill color defaults.
-    pub fill_color: Color,
-    /// Stroke color defaults.
-    pub stroke_color: Color,
-}
-
-/// A set of defaults used for coloring.
-#[derive(Clone, Debug)]
-pub struct Color {
-    pub default: Srgba,
-    pub primitive: HashMap<Primitive, Srgba>,
-}
-
-/// Primitive geometry types that may have unique default styles.
-///
-/// These are used as keys into the **Theme**'s geometry primitive default values.
-#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
-pub enum Primitive {
-    Arrow,
-    Cuboid,
-    Ellipse,
-    Line,
-    Mesh,
-    Path,
-    Polygon,
-    Quad,
-    Rect,
-    Text,
-    Texture,
-    Tri,
-}
-
-impl Theme {
-    /// Retrieve the non-linear sRGBA fill color representation for the given primitive.
-    pub fn fill_srgba(&self, prim: &Primitive) -> Srgba {
-        self.fill_color
-            .primitive
-            .get(prim)
-            .map(|&c| c)
-            .unwrap_or(self.fill_color.default)
-    }
-
-    /// Retrieve the linaer sRGBA fill color representation for the given primitive.
-    pub fn fill_lin_srgba(&self, prim: &Primitive) -> LinSrgba {
-        self.fill_srgba(prim).into_linear()
-    }
-
-    /// Retrieve the non-linear sRGBA stroke color representation for the given primitive.
-    pub fn stroke_srgba(&self, prim: &Primitive) -> Srgba {
-        self.stroke_color
-            .primitive
-            .get(prim)
-            .map(|&c| c)
-            .unwrap_or(self.stroke_color.default)
-    }
-
-    /// Retrieve the linaer sRGBA stroke color representation for the given primitive.
-    pub fn stroke_lin_srgba(&self, prim: &Primitive) -> LinSrgba {
-        self.stroke_srgba(prim).into_linear()
-    }
-}
-
-impl Default for Theme {
-    fn default() -> Self {
-        // TODO: This should be pub const.
-        let default_fill = Srgba::new(1.0, 1.0, 1.0, 1.0);
-        let default_stroke = Srgba::new(0.0, 0.0, 0.0, 1.0);
-
-        let fill_color = Color {
-            default: default_fill,
-            primitive: Default::default(),
-        };
-        let mut stroke_color = Color {
-            default: default_stroke,
-            primitive: Default::default(),
-        };
-        stroke_color
-            .primitive
-            .insert(Primitive::Arrow, default_fill);
-
-        Theme {
-            fill_color,
-            stroke_color,
-        }
-    }
-}
diff --git a/nannou/src/ease.rs b/nannou/src/ease.rs
index 682acf109..b2f512459 100644
--- a/nannou/src/ease.rs
+++ b/nannou/src/ease.rs
@@ -2,3 +2,4 @@
 //! functions. This API is provided by the [pennereq crate](https://docs.rs/pennereq).
 
 pub use pennereq::*;
+
diff --git a/nannou/src/event.rs b/nannou/src/event.rs
deleted file mode 100644
index 1849bc5ac..000000000
--- a/nannou/src/event.rs
+++ /dev/null
@@ -1,366 +0,0 @@
-//! Application, event loop and window event definitions and implementations.
-//!
-//! - [**Event**](./enum.Event.html) - the default application event type.
-//! - [**winit::event::WindowEvent**](https://docs.rs/winit/latest/winit/event/enum.WindowEvent.html) -
-//!   events related to a single window.
-//! - [**WindowEvent**](./enum.WindowEvent.html) - a stripped-back, simplified, newcomer-friendly
-//!   version of the **raw**, low-level winit event.
-
-use crate::geom::{self, Point2};
-use crate::glam::Vec2;
-use crate::window;
-use crate::App;
-use std::path::PathBuf;
-use winit;
-
-pub use winit::event::{
-    ElementState, KeyboardInput, ModifiersState, MouseButton, MouseScrollDelta, TouchPhase,
-    VirtualKeyCode as Key,
-};
-
-/// Event types that are compatible with the nannou app loop.
-pub trait LoopEvent: 'static + From<Update> {
-    /// Produce a loop event from the given winit event.
-    fn from_winit_event<'a, T>(_: &winit::event::Event<'a, T>, _: &App) -> Option<Self>;
-}
-
-/// Update event, emitted on each pass of an application loop.
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub struct Update {
-    /// The duration since the last update was emitted.
-    ///
-    /// The first update's delta will be the time since the given `model` function returned.
-    pub since_last: std::time::Duration,
-    /// The duration since the start of the app loop.
-    ///
-    /// Specifically, this is the duration of time since the given `model` function returned.
-    pub since_start: std::time::Duration,
-}
-
-/// The default application **Event** type.
-#[derive(Debug)]
-pub enum Event {
-    /// A window-specific event has occurred for the window with the given Id.
-    ///
-    /// The event is available as a **WindowEvent**, a more user-friendly form of
-    /// **winit::event::WindowEvent**. Once
-    /// [winit#1387](https://github.com/rust-windowing/winit/issues/1387) is fixed, its "raw" form
-    /// will also be available.
-    WindowEvent {
-        id: window::Id,
-        simple: Option<WindowEvent>,
-        // TODO: Re-add this when winit#1387 is resolved.
-        // raw: winit::event::WindowEvent,
-    },
-
-    /// A device-specific event has occurred for the device with the given Id.
-    DeviceEvent(winit::event::DeviceId, winit::event::DeviceEvent),
-
-    /// A timed update alongside the duration since the last update was emitted.
-    ///
-    /// The first update's delta will be the time since the `model` function returned.
-    Update(Update),
-
-    /// The application has been suspended or resumed.
-    Suspended,
-    /// The application has been awakened.
-    Resumed,
-}
-
-/// The event associated with a touch at a single point.
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub struct TouchEvent {
-    /// The unique ID associated with this touch, e.g. useful for distinguishing between fingers.
-    pub id: u64,
-    /// The state of the touch.
-    pub phase: TouchPhase,
-    /// The position of the touch.
-    pub position: Point2,
-}
-
-/// Pressure on a touch pad.
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub struct TouchpadPressure {
-    /// The unique ID associated with the device that emitted this event.
-    pub device_id: winit::event::DeviceId,
-    /// The amount of pressure applied.
-    pub pressure: f32,
-    /// Integer representing the click level.
-    pub stage: i64,
-}
-
-/// Motion along some axis of a device e.g. joystick or gamepad.
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub struct AxisMotion {
-    /// The unique ID of the device that emitted this event.
-    pub device_id: winit::event::DeviceId,
-    /// The axis on which motion occurred.
-    pub axis: winit::event::AxisId,
-    /// The motion value.
-    pub value: geom::scalar::Default,
-}
-
-/// A simplified version of winit's `WindowEvent` type to make it easier to get started.
-///
-/// All co-ordinates and dimensions are DPI-agnostic scalar values.
-///
-/// Co-ordinates for each window are as follows:
-///
-/// - `(0.0, 0.0)` is the centre of the window.
-/// - positive `x` points to the right, negative `x` points to the left.
-/// - positive `y` points upwards, negative `y` points downwards.
-/// - positive `z` points into the screen, negative `z` points out of the screen.
-#[derive(Clone, Debug, PartialEq)]
-pub enum WindowEvent {
-    /// The window has been moved to a new position.
-    Moved(Point2),
-
-    /// The given keyboard key was pressed.
-    KeyPressed(Key),
-
-    /// The given keyboard key was released.
-    KeyReleased(Key),
-
-    /// Character input received event.
-    ReceivedCharacter(char),
-
-    /// The mouse moved to the given x, y position.
-    MouseMoved(Point2),
-
-    /// The given mouse button was pressed.
-    MousePressed(MouseButton),
-
-    /// The given mouse button was released.
-    MouseReleased(MouseButton),
-
-    /// The mouse entered the window.
-    MouseEntered,
-
-    /// The mouse exited the window.
-    MouseExited,
-
-    /// A mouse wheel movement or touchpad scroll occurred.
-    MouseWheel(MouseScrollDelta, TouchPhase),
-
-    /// The window was resized to the given dimensions (in DPI-agnostic points, not pixels).
-    Resized(Vec2),
-
-    /// A file at the given path was hovered over the window.
-    HoveredFile(PathBuf),
-
-    /// A file at the given path was dropped onto the window.
-    DroppedFile(PathBuf),
-
-    /// A file at the given path that was hovered over the window was cancelled.
-    HoveredFileCancelled,
-
-    /// Received a touch event.
-    Touch(TouchEvent),
-
-    /// Touchpad pressure event.
-    ///
-    /// At the moment, only supported on Apple forcetouch-capable macbooks.
-    /// The parameters are: pressure level (value between 0 and 1 representing how hard the touchpad
-    /// is being pressed) and stage (integer representing the click level).
-    TouchPressure(TouchpadPressure),
-
-    /// The window gained focus.
-    Focused,
-
-    /// The window lost focus.
-    Unfocused,
-
-    /// The window was closed and is no longer stored in the `App`.
-    Closed,
-}
-
-impl WindowEvent {
-    /// Produce a simplified, new-user-friendly version of the given `winit::event::WindowEvent`.
-    ///
-    /// This strips rarely needed technical information from the event type such as information
-    /// about the source device, scancodes for keyboard events, etc to make the experience of
-    /// pattern matching on window events nicer for new users.
-    ///
-    /// This also interprets the raw pixel positions and dimensions of the raw event into a
-    /// dpi-agnostic scalar value where (0, 0, 0) is the centre of the screen with the `y` axis
-    /// increasing in the upwards direction.
-    ///
-    /// If the user requires this extra information, they should use the `raw` field of the
-    /// `WindowEvent` type rather than the `simple` one.
-    pub fn from_winit_window_event(
-        event: &winit::event::WindowEvent,
-        win_w: f64,
-        win_h: f64,
-        scale_factor: f64,
-    ) -> Option<Self> {
-        use self::WindowEvent::*;
-
-        // Translate the coordinates from top-left-origin-with-y-down to centre-origin-with-y-up.
-        //
-        // winit produces input events in pixels, so these positions need to be divided by the
-        // width and height of the window in order to be DPI agnostic.
-        let tw = |w: f64| w as f32;
-        let th = |h: f64| h as f32;
-        let tx = |x: f64| (x - win_w / 2.0) as f32;
-        let ty = |y: f64| (-(y - win_h / 2.0)) as f32;
-
-        let event = match event {
-            winit::event::WindowEvent::Resized(new_size) => {
-                let (new_w, new_h) = new_size.to_logical::<f64>(scale_factor).into();
-                let x = tw(new_w);
-                let y = th(new_h);
-                Resized([x, y].into())
-            }
-
-            winit::event::WindowEvent::Moved(new_pos) => {
-                let (new_x, new_y) = new_pos.to_logical::<f64>(scale_factor).into();
-                let x = tx(new_x);
-                let y = ty(new_y);
-                Moved([x, y].into())
-            }
-
-            // TODO: Should separate the behaviour of close requested and destroyed.
-            winit::event::WindowEvent::CloseRequested | winit::event::WindowEvent::Destroyed => {
-                Closed
-            }
-
-            winit::event::WindowEvent::DroppedFile(path) => DroppedFile(path.clone()),
-
-            winit::event::WindowEvent::HoveredFile(path) => HoveredFile(path.clone()),
-
-            winit::event::WindowEvent::HoveredFileCancelled => HoveredFileCancelled,
-
-            winit::event::WindowEvent::Focused(b) => {
-                if b.clone() {
-                    Focused
-                } else {
-                    Unfocused
-                }
-            }
-
-            winit::event::WindowEvent::CursorMoved { position, .. } => {
-                let (x, y) = position.to_logical::<f64>(scale_factor).into();
-                let x = tx(x);
-                let y = ty(y);
-                MouseMoved([x, y].into())
-            }
-
-            winit::event::WindowEvent::CursorEntered { .. } => MouseEntered,
-
-            winit::event::WindowEvent::CursorLeft { .. } => MouseExited,
-
-            winit::event::WindowEvent::MouseWheel { delta, phase, .. } => {
-                MouseWheel(delta.clone(), phase.clone())
-            }
-
-            winit::event::WindowEvent::MouseInput { state, button, .. } => match state {
-                ElementState::Pressed => MousePressed(button.clone()),
-                ElementState::Released => MouseReleased(button.clone()),
-            },
-
-            winit::event::WindowEvent::Touch(winit::event::Touch {
-                phase,
-                location,
-                id,
-                ..
-            }) => {
-                let (x, y) = location.to_logical::<f64>(scale_factor).into();
-                let x = tx(x);
-                let y = ty(y);
-                let position = [x, y].into();
-                let touch = TouchEvent {
-                    phase: phase.clone(),
-                    position,
-                    id: id.clone(),
-                };
-                WindowEvent::Touch(touch)
-            }
-
-            winit::event::WindowEvent::TouchpadPressure {
-                device_id,
-                pressure,
-                stage,
-            } => TouchPressure(TouchpadPressure {
-                device_id: device_id.clone(),
-                pressure: pressure.clone(),
-                stage: stage.clone(),
-            }),
-
-            winit::event::WindowEvent::KeyboardInput { input, .. } => match input.virtual_keycode {
-                Some(key) => match input.state {
-                    ElementState::Pressed => KeyPressed(key),
-                    ElementState::Released => KeyReleased(key),
-                },
-                None => return None,
-            },
-
-            winit::event::WindowEvent::ReceivedCharacter(char) => {
-                WindowEvent::ReceivedCharacter(char.clone())
-            }
-
-            winit::event::WindowEvent::ModifiersChanged(_) => {
-                return None;
-            }
-
-            winit::event::WindowEvent::AxisMotion { .. }
-            | winit::event::WindowEvent::ThemeChanged(_)
-            | winit::event::WindowEvent::ScaleFactorChanged { .. } => {
-                return None;
-            }
-            // new 0.28 events
-            winit::event::WindowEvent::Ime(_)
-            | winit::event::WindowEvent::TouchpadMagnify { .. }
-            | winit::event::WindowEvent::SmartMagnify { .. }
-            | winit::event::WindowEvent::TouchpadRotate { .. }
-            | winit::event::WindowEvent::Occluded(_) => return None,
-        };
-
-        Some(event)
-    }
-}
-
-impl LoopEvent for Event {
-    /// Convert the given `winit::event::Event` to a nannou `Event`.
-    fn from_winit_event<'a, T>(event: &winit::event::Event<'a, T>, app: &App) -> Option<Self> {
-        let event = match event {
-            winit::event::Event::WindowEvent { window_id, event } => {
-                let windows = app.windows.borrow();
-                let (win_w, win_h, scale_factor) = match windows.get(&window_id) {
-                    None => (0.0, 0.0, 1.0), // The window was likely closed, these will be ignored.
-                    Some(window) => {
-                        let sf = window.tracked_state.scale_factor;
-                        let size = window.tracked_state.physical_size;
-                        let (w, h) = size.to_logical::<f64>(sf).into();
-                        (w, h, sf)
-                    }
-                };
-                let simple =
-                    WindowEvent::from_winit_window_event(event, win_w, win_h, scale_factor);
-                Event::WindowEvent {
-                    id: window_id.clone(),
-                    simple,
-                    // TODO: Re-add this when winit#1387 is resolved.
-                    // raw,
-                }
-            }
-            winit::event::Event::DeviceEvent { device_id, event } => {
-                Event::DeviceEvent(device_id.clone(), event.clone())
-            }
-            winit::event::Event::Suspended => Event::Suspended,
-            winit::event::Event::Resumed => Event::Resumed,
-            winit::event::Event::NewEvents(_)
-            | winit::event::Event::UserEvent(_)
-            | winit::event::Event::MainEventsCleared
-            | winit::event::Event::RedrawRequested(_)
-            | winit::event::Event::RedrawEventsCleared
-            | winit::event::Event::LoopDestroyed => return None,
-        };
-        Some(event)
-    }
-}
-
-impl From<Update> for Event {
-    fn from(update: Update) -> Self {
-        Event::Update(update)
-    }
-}
diff --git a/nannou/src/frame/mod.rs b/nannou/src/frame/mod.rs
deleted file mode 100644
index dac4608e7..000000000
--- a/nannou/src/frame/mod.rs
+++ /dev/null
@@ -1,374 +0,0 @@
-//! Items related to the **Frame** type, describing a single frame of graphics for a single window.
-
-use crate::color::IntoLinSrgba;
-use crate::wgpu;
-use std::ops;
-use std::path::PathBuf;
-use std::sync::Mutex;
-use std::time::Duration;
-
-pub mod raw;
-
-pub use self::raw::RawFrame;
-
-/// A **Frame** to which the user can draw graphics before it is presented to the display.
-///
-/// **Frame**s are delivered to the user for drawing via the user's **view** function.
-///
-/// See the **RawFrame** docs for more details on how the implementation works under the hood. The
-/// **Frame** type differs in that rather than drawing directly to the swapchain image the user may
-/// draw to an intermediary linear sRGBA image. There are several advantages of drawing to an
-/// intermediary image.
-pub struct Frame<'swap_chain> {
-    raw_frame: RawFrame<'swap_chain>,
-    render_data: &'swap_chain RenderData,
-    capture_data: &'swap_chain CaptureData,
-}
-
-/// Data specific to the intermediary textures.
-#[derive(Debug)]
-pub struct RenderData {
-    intermediary_lin_srgba: IntermediaryLinSrgba,
-    msaa_samples: u32,
-    size: [u32; 2],
-    // For writing the intermediary linear sRGBA texture to the swap chain texture.
-    texture_reshaper: wgpu::TextureReshaper,
-}
-
-/// Data related to the capturing of a frame.
-#[derive(Debug)]
-pub(crate) struct CaptureData {
-    // If `Some`, indicates a path to which the current frame should be written.
-    pub(crate) next_frame_path: Mutex<Option<PathBuf>>,
-    // The `TextureCapturer` used to capture the frame.
-    pub(crate) texture_capturer: wgpu::TextureCapturer,
-}
-
-/// Intermediary textures used as a target before resolving multisampling and writing to the
-/// swapchain texture.
-#[derive(Debug)]
-pub(crate) struct IntermediaryLinSrgba {
-    msaa_texture: Option<(wgpu::Texture, wgpu::TextureView)>,
-    texture: wgpu::Texture,
-    texture_view: wgpu::TextureView,
-}
-
-impl<'swap_chain> ops::Deref for Frame<'swap_chain> {
-    type Target = RawFrame<'swap_chain>;
-    fn deref(&self) -> &Self::Target {
-        &self.raw_frame
-    }
-}
-
-impl<'swap_chain> Frame<'swap_chain> {
-    /// The default number of multisample anti-aliasing samples used if the window with which the
-    /// `Frame` is associated supports it.
-    pub const DEFAULT_MSAA_SAMPLES: u32 = 4;
-    /// The texture format used by the intermediary linear sRGBA image.
-    ///
-    /// We use a high bit depth format in order to retain as much information as possible when
-    /// converting from the linear representation to the swapchain format (normally a non-linear
-    /// representation).
-    // TODO: Kvark recommends trying `Rgb10A2Unorm`.
-    pub const TEXTURE_FORMAT: wgpu::TextureFormat =
-        wgpu::RenderPipelineBuilder::DEFAULT_COLOR_FORMAT;
-
-    // Initialise a new empty frame ready for "drawing".
-    pub(crate) fn new_empty(
-        raw_frame: RawFrame<'swap_chain>,
-        render_data: &'swap_chain RenderData,
-        capture_data: &'swap_chain CaptureData,
-    ) -> Self {
-        Frame {
-            raw_frame,
-            render_data,
-            capture_data,
-        }
-    }
-
-    // The private implementation of `submit`, allowing it to be called during `drop` if submission
-    // has not yet occurred.
-    fn submit_inner(&mut self) {
-        let Frame {
-            ref capture_data,
-            ref render_data,
-            ref mut raw_frame,
-        } = *self;
-
-        // Resolve the MSAA if necessary.
-        if let Some((_, ref msaa_texture_view)) = render_data.intermediary_lin_srgba.msaa_texture {
-            let mut encoder = raw_frame.command_encoder();
-            wgpu::resolve_texture(
-                msaa_texture_view,
-                &render_data.intermediary_lin_srgba.texture_view,
-                &mut *encoder,
-            );
-        }
-
-        // Check to see if the user specified capturing the frame.
-        let mut snapshot_capture = None;
-        if let Ok(mut guard) = capture_data.next_frame_path.lock() {
-            if let Some(path) = guard.take() {
-                let device = raw_frame.device_queue_pair().device();
-                let mut encoder = raw_frame.command_encoder();
-                let snapshot = capture_data.texture_capturer.capture(
-                    device,
-                    &mut *encoder,
-                    &render_data.intermediary_lin_srgba.texture,
-                );
-                snapshot_capture = Some((path, snapshot));
-            }
-        }
-
-        // Convert the linear sRGBA image to the swapchain image.
-        //
-        // To do so, we sample the linear sRGBA image and draw it to the swapchain image using
-        // two triangles and a fragment shader.
-        {
-            let mut encoder = raw_frame.command_encoder();
-            render_data
-                .texture_reshaper
-                .encode_render_pass(raw_frame.swap_chain_texture(), &mut *encoder);
-        }
-
-        // Submit all commands on the device queue.
-        raw_frame.submit_inner();
-
-        // If the user did specify capturing the frame, submit the asynchronous read.
-        if let Some((path, snapshot)) = snapshot_capture {
-            let result = snapshot.read(move |result| match result {
-                // TODO: Log errors, don't print to stderr.
-                Err(e) => eprintln!("failed to async read captured frame: {:?}", e),
-                Ok(image) => {
-                    let image = image.to_owned();
-                    if let Err(e) = image.save(&path) {
-                        // TODO: Log errors, don't print to stderr.
-                        eprintln!(
-                            "failed to save captured frame to \"{}\": {}",
-                            path.display(),
-                            e
-                        );
-                    }
-                }
-            });
-            if let Err(wgpu::TextureCapturerAwaitWorkerTimeout(_)) = result {
-                // TODO: Log errors, don't print to stderr.
-                eprintln!("timed out while waiting for a worker thread to capture the frame");
-            }
-        }
-    }
-
-    /// The texture to which all graphics should be drawn this frame.
-    ///
-    /// This is **not** the swapchain texture, but rather an intermediary linear sRGBA image. This
-    /// intermediary image is used in order to:
-    ///
-    /// - Ensure consistent MSAA resolve behaviour across platforms.
-    /// - Avoid the need for multiple implicit conversions to and from linear sRGBA for each
-    /// graphics pipeline render pass that is used.
-    /// - Allow for the user's rendered image to persist between frames.
-    ///
-    /// The exact format of the texture is equal to `Frame::TEXTURE_FORMAT`.
-    ///
-    /// If the number of MSAA samples specified is greater than `1` (which it is by default if
-    /// supported by the platform), this will be a multisampled texture. After the **view**
-    /// function returns, this texture will be resolved to a non-multisampled linear sRGBA texture.
-    /// After the texture has been resolved if necessary, it will then be used as a shader input
-    /// within a graphics pipeline used to draw the swapchain texture.
-    pub fn texture(&self) -> &wgpu::Texture {
-        self.render_data
-            .intermediary_lin_srgba
-            .msaa_texture
-            .as_ref()
-            .map(|(tex, _)| tex)
-            .unwrap_or(&self.render_data.intermediary_lin_srgba.texture)
-    }
-
-    /// A full view into the frame's texture.
-    ///
-    /// See `texture` for details.
-    pub fn texture_view(&self) -> &wgpu::TextureView {
-        self.render_data.texture_view()
-    }
-
-    /// Returns the resolve target texture in the case that MSAA is enabled.
-    pub fn resolve_target(&self) -> Option<&wgpu::TextureView> {
-        if self.render_data.msaa_samples <= 1 {
-            None
-        } else {
-            Some(&self.render_data.intermediary_lin_srgba.texture_view)
-        }
-    }
-
-    /// The color format of the `Frame`'s intermediary linear sRGBA texture (equal to
-    /// `Frame::TEXTURE_FORMAT`).
-    pub fn texture_format(&self) -> wgpu::TextureFormat {
-        Self::TEXTURE_FORMAT
-    }
-
-    /// The number of MSAA samples of the `Frame`'s intermediary linear sRGBA texture.
-    pub fn texture_msaa_samples(&self) -> u32 {
-        self.render_data.msaa_samples
-    }
-
-    /// The size of the frame's texture in pixels.
-    pub fn texture_size(&self) -> [u32; 2] {
-        self.render_data.size
-    }
-
-    /// Short-hand for constructing a `wgpu::RenderPassColorAttachment` for use within a
-    /// render pass that targets this frame's texture. The returned descriptor's `attachment` will
-    /// the same `wgpu::TextureView` returned by the `Frame::texture` method.
-    ///
-    /// Note that this method will not perform any resolving. In the case that `msaa_samples` is
-    /// greater than `1`, a render pass will be automatically added after the `view` completes and
-    /// before the texture is drawn to the swapchain.
-    pub fn color_attachment_descriptor(&self) -> wgpu::RenderPassColorAttachment {
-        let load = wgpu::LoadOp::Load;
-        let store = true;
-        let attachment = match self.render_data.intermediary_lin_srgba.msaa_texture {
-            None => &self.render_data.intermediary_lin_srgba.texture_view,
-            Some((_, ref msaa_texture_view)) => msaa_texture_view,
-        };
-        let resolve_target = None;
-        wgpu::RenderPassColorAttachment {
-            view: attachment,
-            resolve_target,
-            ops: wgpu::Operations { load, store },
-        }
-    }
-
-    /// Clear the texture with the given color.
-    pub fn clear<C>(&self, color: C)
-    where
-        C: IntoLinSrgba<f32>,
-    {
-        let lin_srgba = color.into_lin_srgba();
-        let (r, g, b, a) = lin_srgba.into_components();
-        let (r, g, b, a) = (r as f64, g as f64, b as f64, a as f64);
-        let color = wgpu::Color { r, g, b, a };
-
-        self.raw_frame.clear(self.texture_view(), color);
-    }
-
-    /// Submit the frame to the GPU!
-    ///
-    /// Note that you do not need to call this manually as submission will occur automatically when
-    /// the **Frame** is dropped.
-    ///
-    /// Before submission, the frame does the following:
-    ///
-    /// - If the frame's intermediary linear sRGBA texture is multisampled, resolve it.
-    /// - Write the intermediary linear sRGBA image to the swap chain texture.
-    ///
-    /// It can sometimes be useful to submit the **Frame** before `view` completes in order to read
-    /// the frame's texture back to the CPU (e.g. for screen shots, recordings, etc).
-    pub fn submit(mut self) {
-        self.submit_inner();
-    }
-}
-
-impl CaptureData {
-    pub(crate) fn new(max_jobs: u32, timeout: Option<Duration>) -> Self {
-        CaptureData {
-            next_frame_path: Default::default(),
-            texture_capturer: wgpu::TextureCapturer::new(Some(max_jobs), timeout),
-        }
-    }
-}
-
-impl RenderData {
-    /// Initialise the render data.
-    ///
-    /// Creates an `wgpu::TextureView` with the given parameters.
-    ///
-    /// If `msaa_samples` is greater than 1 a `multisampled` texture will also be created. Otherwise the
-    /// a regular non-multisampled image will be created.
-    pub(crate) fn new(
-        device: &wgpu::Device,
-        swap_chain_dims: [u32; 2],
-        swap_chain_format: wgpu::TextureFormat,
-        msaa_samples: u32,
-    ) -> Self {
-        let intermediary_lin_srgba =
-            create_intermediary_lin_srgba(device, swap_chain_dims, msaa_samples);
-        let src_sample_count = 1;
-        let swap_chain_sample_count = 1;
-        let texture_reshaper = wgpu::TextureReshaper::new(
-            device,
-            &intermediary_lin_srgba.texture_view,
-            src_sample_count,
-            intermediary_lin_srgba.texture_view.sample_type(),
-            swap_chain_sample_count,
-            swap_chain_format,
-        );
-        RenderData {
-            intermediary_lin_srgba,
-            texture_reshaper,
-            size: swap_chain_dims,
-            msaa_samples,
-        }
-    }
-
-    /// A full view into the associated texture.
-    ///
-    /// See `texture` for details.
-    pub(crate) fn texture_view(&self) -> &wgpu::TextureView {
-        self.intermediary_lin_srgba
-            .msaa_texture
-            .as_ref()
-            .map(|(_, view)| view)
-            .unwrap_or(&self.intermediary_lin_srgba.texture_view)
-    }
-}
-
-impl<'swap_chain> Drop for Frame<'swap_chain> {
-    fn drop(&mut self) {
-        if !self.raw_frame.is_submitted() {
-            self.submit_inner();
-        }
-    }
-}
-
-fn create_lin_srgba_msaa_texture(
-    device: &wgpu::Device,
-    swap_chain_dims: [u32; 2],
-    msaa_samples: u32,
-) -> wgpu::Texture {
-    wgpu::TextureBuilder::new()
-        .size(swap_chain_dims)
-        .sample_count(msaa_samples)
-        .usage(wgpu::TextureUsages::RENDER_ATTACHMENT)
-        .format(Frame::TEXTURE_FORMAT)
-        .build(device)
-}
-
-fn create_lin_srgba_texture(device: &wgpu::Device, swap_chain_dims: [u32; 2]) -> wgpu::Texture {
-    wgpu::TextureBuilder::new()
-        .size(swap_chain_dims)
-        .format(Frame::TEXTURE_FORMAT)
-        .usage(wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING)
-        .build(device)
-}
-
-fn create_intermediary_lin_srgba(
-    device: &wgpu::Device,
-    swap_chain_dims: [u32; 2],
-    msaa_samples: u32,
-) -> IntermediaryLinSrgba {
-    let msaa_texture = match msaa_samples {
-        0 | 1 => None,
-        _ => {
-            let texture = create_lin_srgba_msaa_texture(device, swap_chain_dims, msaa_samples);
-            let texture_view = texture.view().build();
-            Some((texture, texture_view))
-        }
-    };
-    let texture = create_lin_srgba_texture(device, swap_chain_dims);
-    let texture_view = texture.view().build();
-    IntermediaryLinSrgba {
-        msaa_texture,
-        texture,
-        texture_view,
-    }
-}
diff --git a/nannou/src/frame/raw.rs b/nannou/src/frame/raw.rs
deleted file mode 100644
index 224f5fc0a..000000000
--- a/nannou/src/frame/raw.rs
+++ /dev/null
@@ -1,160 +0,0 @@
-//! The lower-level "raw" frame type allowing to draw directly to the window's swap chain image.
-
-use crate::geom;
-use crate::wgpu;
-use crate::window;
-use std::cell::{RefCell, RefMut};
-use std::sync::Arc;
-
-/// Allows the user to draw a single **RawFrame** to the surface of a window.
-///
-/// The application's **view** function is called each time the application is ready to retrieve a
-/// new image that will be displayed to a window. The **RawFrame** type can be thought of as the
-/// canvas to which you draw this image.
-///
-/// ## Under the hood - WGPU
-///
-/// **RawFrame** provides access to the **wgpu::TextureViewHandle** associated with the swap
-/// chain's current target texture for a single window.
-///
-/// In the case that your **view** function is shared between multiple windows, can determine which
-/// window the **RawFrame** is associated with via the **RawFrame::window_id** method.
-///
-/// The user can draw to the swap chain texture by building a list of commands via a
-/// `wgpu::CommandEncoder` and submitting them to the `wgpu::Queue` associated with the
-/// `wgpu::Device` that was used to create the swap chain. It is important that the queue
-/// matches the device. In an effort to reduce the chance for errors to occur, **RawFrame**
-/// provides access to a `wgpu::CommandEncoder` whose commands are guaranteed to be submitted to
-/// the correct `wgpu::Queue` at the end of the **view** function.
-pub struct RawFrame<'swap_chain> {
-    command_encoder: Option<RefCell<wgpu::CommandEncoder>>,
-    window_id: window::Id,
-    nth: u64,
-    swap_chain_texture: &'swap_chain wgpu::TextureViewHandle,
-    device_queue_pair: Arc<wgpu::DeviceQueuePair>,
-    texture_format: wgpu::TextureFormat,
-    window_rect: geom::Rect,
-}
-
-impl<'swap_chain> RawFrame<'swap_chain> {
-    // Initialise a new empty frame ready for "drawing".
-    pub(crate) fn new_empty(
-        device_queue_pair: Arc<wgpu::DeviceQueuePair>,
-        window_id: window::Id,
-        nth: u64,
-        swap_chain_texture: &'swap_chain wgpu::TextureViewHandle,
-        texture_format: wgpu::TextureFormat,
-        window_rect: geom::Rect,
-    ) -> Self {
-        let ce_desc = wgpu::CommandEncoderDescriptor {
-            label: Some("nannou_raw_frame"),
-        };
-        let command_encoder = device_queue_pair.device().create_command_encoder(&ce_desc);
-        let command_encoder = Some(RefCell::new(command_encoder));
-        let frame = RawFrame {
-            command_encoder,
-            window_id,
-            nth,
-            swap_chain_texture,
-            device_queue_pair,
-            texture_format,
-            window_rect,
-        };
-        frame
-    }
-
-    // Submit the encoded commands to the queue of the device that was used to create the swap
-    // chain texture.
-    pub(crate) fn submit_inner(&mut self) {
-        let command_encoder = self
-            .command_encoder
-            .take()
-            .expect("the command encoder should always be `Some` at the time of submission")
-            .into_inner();
-        let command_buffer = command_encoder.finish();
-        let queue = self.device_queue_pair.queue();
-        queue.submit(std::iter::once(command_buffer));
-    }
-
-    // Allow the `Frame` to check if the raw frame has already been submitted on drop.
-    pub(crate) fn is_submitted(&self) -> bool {
-        self.command_encoder.is_none()
-    }
-
-    /// Access the command encoder in order to encode commands that will be submitted to the swap
-    /// chain queue at the end of the call to **view**.
-    pub fn command_encoder(&self) -> RefMut<wgpu::CommandEncoder> {
-        match self.command_encoder {
-            Some(ref ce) => ce.borrow_mut(),
-            None => unreachable!("`RawFrame`'s command_encoder was `None`"),
-        }
-    }
-
-    /// The `Id` of the window whose wgpu surface is associated with this frame.
-    pub fn window_id(&self) -> window::Id {
-        self.window_id
-    }
-
-    /// A **Rect** representing the full surface of the frame.
-    ///
-    /// The returned **Rect** is equivalent to the result of calling **Window::rect** on the window
-    /// associated with this **Frame**.
-    pub fn rect(&self) -> geom::Rect {
-        self.window_rect
-    }
-
-    /// The `nth` frame for the associated window since the application started.
-    ///
-    /// E.g. the first frame yielded will return `0`, the second will return `1`, and so on.
-    pub fn nth(&self) -> u64 {
-        self.nth
-    }
-
-    /// The swap chain texture that will be the target for drawing this frame.
-    pub fn swap_chain_texture(&self) -> &wgpu::TextureViewHandle {
-        &self.swap_chain_texture
-    }
-
-    /// The texture format of the frame's swap chain texture.
-    pub fn texture_format(&self) -> wgpu::TextureFormat {
-        self.texture_format
-    }
-
-    /// The device and queue on which the swap chain was created and which will be used to submit
-    /// the **RawFrame**'s encoded commands.
-    ///
-    /// This refers to the same **DeviceQueuePair** as held by the window associated with this
-    /// frame.
-    pub fn device_queue_pair(&self) -> &Arc<wgpu::DeviceQueuePair> {
-        &self.device_queue_pair
-    }
-
-    /// Submit the frame to the GPU!
-    ///
-    /// Specifically, this submits the encoded commands to the queue of the device that was used to
-    /// create the swap chain texture.
-    ///
-    /// Note: You do not need to call this manually as submission will occur automatically when
-    /// the **Frame** is dropped.
-    ///
-    /// Note: Be careful that you do not currently possess a lock to either the frame's command
-    /// encoder *or* the queue of the window associated with this frame or this method will lock
-    /// and block forever.
-    pub fn submit(mut self) {
-        self.submit_inner();
-    }
-
-    /// Clear the texture with the given color.
-    pub fn clear(&self, texture_view: &wgpu::TextureView, color: wgpu::Color) {
-        wgpu::clear_texture(texture_view, color, &mut *self.command_encoder())
-    }
-}
-
-impl<'swap_chain> Drop for RawFrame<'swap_chain> {
-    fn drop(&mut self) {
-        // Submit the commands if the user hasn't done so already.
-        if !self.is_submitted() {
-            self.submit_inner();
-        }
-    }
-}
diff --git a/nannou/src/geom/mod.rs b/nannou/src/geom/mod.rs
index 04632824c..c5afe3e5c 100644
--- a/nannou/src/geom/mod.rs
+++ b/nannou/src/geom/mod.rs
@@ -9,7 +9,8 @@
 //! - Functions for determining the bounding rectangle or cuboid.
 //! - A function for finding the centroid.
 
-pub mod path;
+pub use nannou_core::geom::*;
 
 pub use self::path::{path, Path};
-pub use nannou_core::geom::*;
+
+pub mod path;
diff --git a/nannou/src/geom/path.rs b/nannou/src/geom/path.rs
index 28bf762f3..6659e9d56 100644
--- a/nannou/src/geom/path.rs
+++ b/nannou/src/geom/path.rs
@@ -4,6 +4,9 @@
 //! offerred by `lyon` in a way that interoperates a little more fluidly and consistently with the
 //! rest of nannou's API.
 
+use lyon::lyon_tessellation::Attributes;
+use lyon::path::builder::NoAttributes;
+
 use crate::geom::Point2;
 
 /// A wrapper around a 2D lyon path exposing a nannou-friendly API.
@@ -13,7 +16,13 @@ pub struct Path {
 
 /// A type used for building a 2D lyon path.
 pub struct Builder {
-    builder: lyon::path::path::Builder,
+    builder: NoAttributes<lyon::path::Builder>,
+}
+
+impl Default for Path {
+    fn default() -> Self {
+        Self::new()
+    }
 }
 
 impl Path {
@@ -38,17 +47,17 @@ impl Path {
     }
 
     /// Iterates over the entire **Path** yielding **PathEvent**s.
-    pub fn iter(&self) -> lyon::path::path::Iter {
+    pub fn iter(&self) -> lyon::path::Iter {
         self.path.iter()
     }
 
     /// Iterates over the endpoint and control point ids of the **Path**.
-    pub fn id_iter(&self) -> lyon::path::path::IdIter {
+    pub fn id_iter(&self) -> lyon::path::IdIter {
         self.path.id_iter()
     }
 
     /// Iterate over points alongside their attributes.
-    pub fn iter_with_attributes(&self) -> lyon::path::path::IterWithAttributes {
+    pub fn iter_with_attributes(&self) -> lyon::path::IterWithAttributes {
         self.path.iter_with_attributes()
     }
 
@@ -63,7 +72,8 @@ impl Path {
 
     /// Reversed version of this path with edge loops specified in the opposite order.
     pub fn reversed(&self) -> Self {
-        self.path.reversed().into()
+        let path = self.path.reversed().collect();
+        Path { path }
     }
 
     /// Concatenate two paths.
@@ -74,15 +84,21 @@ impl Path {
     }
 }
 
+impl Default for Builder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Builder {
     /// Begin building a new path.
     pub fn new() -> Self {
-        lyon::path::path::Builder::new().into()
+        lyon::path::Builder::new().into()
     }
 
     /// Build a path with the given capacity for the inner path event storage.
     pub fn with_capacity(points: usize, edges: usize) -> Self {
-        lyon::path::path::Builder::with_capacity(points, edges).into()
+        lyon::path::Builder::with_capacity(points, edges).into()
     }
 
     /// Returns a lyon builder that supports SVG commands.
@@ -139,13 +155,13 @@ impl Builder {
     }
 
     /// Access to the inner `lyon::path::Builder`.
-    pub fn inner(&self) -> &lyon::path::path::Builder {
-        &self.builder
+    pub fn inner(&self) -> &lyon::path::Builder {
+        self.builder.inner()
     }
 
     /// Mutable access to the inner `lyon::path::Builder`.
-    pub fn inner_mut(&mut self) -> &mut lyon::path::path::Builder {
-        &mut self.builder
+    pub fn inner_mut(&mut self) -> &mut lyon::path::Builder {
+        self.builder.inner_mut()
     }
 }
 
@@ -160,10 +176,35 @@ impl lyon::path::builder::Build for Builder {
 }
 
 impl lyon::path::builder::PathBuilder for Builder {
+    fn num_attributes(&self) -> usize {
+        0
+    }
+
+    fn begin(
+        &mut self,
+        at: lyon::math::Point,
+        _custom_attributes: Attributes,
+    ) -> lyon::path::EndpointId {
+        self.builder.begin(at)
+    }
+
+    fn end(&mut self, close: bool) {
+        self.builder.end(close)
+    }
+
+    fn line_to(
+        &mut self,
+        to: lyon::math::Point,
+        _custom_attributes: Attributes,
+    ) -> lyon::path::EndpointId {
+        self.builder.line_to(to)
+    }
+
     fn quadratic_bezier_to(
         &mut self,
         ctrl: lyon::math::Point,
         to: lyon::math::Point,
+        _custom_attributes: Attributes,
     ) -> lyon::path::EndpointId {
         self.builder.quadratic_bezier_to(ctrl, to)
     }
@@ -173,21 +214,10 @@ impl lyon::path::builder::PathBuilder for Builder {
         ctrl1: lyon::math::Point,
         ctrl2: lyon::math::Point,
         to: lyon::math::Point,
+        _custom_attributes: Attributes,
     ) -> lyon::path::EndpointId {
         self.builder.cubic_bezier_to(ctrl1, ctrl2, to)
     }
-
-    fn begin(&mut self, at: lyon::math::Point) -> lyon::path::EndpointId {
-        self.builder.begin(at)
-    }
-
-    fn end(&mut self, close: bool) {
-        self.builder.end(close)
-    }
-
-    fn line_to(&mut self, to: lyon::math::Point) -> lyon::path::EndpointId {
-        self.builder.line_to(to)
-    }
 }
 
 // Indexing
@@ -210,7 +240,7 @@ impl std::ops::Index<lyon::path::EndpointId> for Path {
 
 impl<'a> IntoIterator for &'a Path {
     type Item = lyon::path::PathEvent;
-    type IntoIter = lyon::path::path::Iter<'a>;
+    type IntoIter = lyon::path::Iter<'a>;
 
     fn into_iter(self) -> Self::IntoIter {
         self.iter()
@@ -225,27 +255,29 @@ impl From<lyon::path::Path> for Path {
     }
 }
 
-impl From<lyon::path::path::Builder> for Builder {
-    fn from(builder: lyon::path::path::Builder) -> Self {
-        Builder { builder }
+impl From<lyon::path::Builder> for Builder {
+    fn from(builder: lyon::path::Builder) -> Self {
+        Builder {
+            builder: NoAttributes::wrap(builder),
+        }
     }
 }
 
-impl Into<lyon::path::Path> for Path {
-    fn into(self) -> lyon::path::Path {
-        self.path
+impl From<Path> for lyon::path::Path {
+    fn from(val: Path) -> Self {
+        val.path
     }
 }
 
-impl Into<lyon::path::path::Builder> for Builder {
-    fn into(self) -> lyon::path::path::Builder {
-        self.builder
+impl From<Builder> for lyon::path::Builder {
+    fn from(val: Builder) -> Self {
+        val.builder.into_inner()
     }
 }
 
-impl<'a> Into<lyon::path::PathSlice<'a>> for &'a Path {
-    fn into(self) -> lyon::path::PathSlice<'a> {
-        self.as_slice()
+impl<'a> From<&'a Path> for lyon::path::PathSlice<'a> {
+    fn from(val: &'a Path) -> Self {
+        val.as_slice()
     }
 }
 
diff --git a/nannou/src/io.rs b/nannou/src/io.rs
index 2a3df26d9..1c7c0d028 100644
--- a/nannou/src/io.rs
+++ b/nannou/src/io.rs
@@ -1,12 +1,13 @@
 //! An extension of the `std::io` module. Includes functions for safely saving and loading files
 //! from any serializable types, along with functions specifically for working with JSON and TOML.
 
-use serde;
-use serde_json;
 use std::error::Error;
 use std::io::{Read, Write};
 use std::path::Path;
 use std::{fmt, fs, io};
+
+use serde;
+use serde_json;
 use toml;
 
 /// Errors that might occur when saving a file.
@@ -105,7 +106,13 @@ where
     {
         let file = fs::File::create(&temp_path)?;
         let mut buffered = io::BufWriter::new(file);
-        buffered.write(content)?;
+        let written = buffered.write(content)?;
+        if written != content.len() {
+            return Err(io::Error::new(
+                io::ErrorKind::WriteZero,
+                "failed to write entire buffer to file",
+            ));
+        }
         match buffered.into_inner() {
             Err(err) => {
                 let io_err = err.error();
@@ -124,7 +131,7 @@ where
         if backup_path.exists() {
             fs::remove_file(&backup_path)?;
         }
-        fs::rename(&path, &backup_path)?;
+        fs::rename(path, &backup_path)?;
     }
 
     // Rename the temp file to the original path name.
diff --git a/nannou/src/lib.rs b/nannou/src/lib.rs
index f63e0f60e..d3e463d15 100644
--- a/nannou/src/lib.rs
+++ b/nannou/src/lib.rs
@@ -12,36 +12,27 @@
 //! If you're new to nannou, we recommend checking out [the
 //! examples](https://github.com/nannou-org/nannou/tree/master/examples) to get an idea of how
 //! nannou applications are structured and how the API works.
+#![cfg_attr(feature = "nightly", feature(adt_const_params))]
 
 pub use find_folder;
 pub use lyon;
-pub use winit;
 
-pub use self::app::{App, LoopMode};
-pub use self::draw::Draw;
-pub use self::event::Event;
-pub use self::frame::Frame;
 #[doc(inline)]
-pub use nannou_core::{color, glam, math, rand};
-#[doc(inline)]
-pub use nannou_mesh as mesh;
-#[doc(inline)]
-pub use nannou_wgpu as wgpu;
+pub use nannou_core::{glam, math, rand};
+
+pub use self::app::App;
 
 pub mod app;
-pub mod draw;
-pub mod ease;
-pub mod event;
-pub mod frame;
+mod camera;
 pub mod geom;
 pub mod image;
+#[cfg(feature = "serde")]
 pub mod io;
+mod light;
 pub mod noise;
 pub mod prelude;
-pub mod state;
-pub mod text;
 pub mod time;
-pub mod window;
+mod window;
 
 /// Begin building the `App`.
 ///
@@ -54,7 +45,7 @@ pub mod window;
 ///
 /// The Model that is returned by the function is the same model that will be passed to the
 /// given event and view functions.
-pub fn app<M: 'static>(model: app::ModelFn<M>) -> app::Builder<M, Event> {
+pub fn app<M: 'static + Send>(model: app::ModelFn<M>) -> app::Builder<M> {
     app::Builder::new(model)
 }
 
@@ -63,6 +54,6 @@ pub fn app<M: 'static>(model: app::ModelFn<M>) -> app::Builder<M, Event> {
 ///
 /// This is useful for late night hack sessions where you just don't care about all that other
 /// stuff, you just want to play around with some ideas or make something pretty.
-pub fn sketch(view: app::SketchViewFn) -> app::SketchBuilder<Event> {
+pub fn sketch(view: app::SketchViewFn) -> app::SketchBuilder {
     app::Builder::sketch(view)
 }
diff --git a/nannou/src/light.rs b/nannou/src/light.rs
new file mode 100644
index 000000000..946b29c4f
--- /dev/null
+++ b/nannou/src/light.rs
@@ -0,0 +1,180 @@
+use bevy::core_pipeline::bloom::BloomSettings;
+use bevy::pbr::DirectionalLight;
+use bevy::prelude::{Color, Transform, Vec2};
+use bevy::render::camera;
+use bevy::render::view::RenderLayers;
+
+use bevy_nannou::prelude::{default, Entity, Vec3};
+
+use crate::prelude::DirectionalLightBundle;
+use crate::App;
+
+pub struct Light<'a, 'w> {
+    entity: Entity,
+    app: &'a App<'w>,
+}
+
+pub struct Builder<'a, 'w> {
+    app: &'a App<'w>,
+    light: DirectionalLightBundle,
+    layer: Option<RenderLayers>,
+}
+
+pub trait SetLight: Sized {
+    fn x_y(mut self, x: f32, y: f32) -> Self {
+        self.map_light(|mut light| {
+            light.transform.translation = Vec3::new(x, y, light.transform.translation.z);
+            light
+        })
+    }
+
+    fn xy(mut self, p: Vec2) -> Self {
+        self.map_light(|mut light| {
+            light.transform.translation = p.extend(light.transform.translation.z);
+            light
+        })
+    }
+
+    fn x_y_z(mut self, x: f32, y: f32, z: f32) -> Self {
+        self.map_light(|mut light| {
+            light.transform.translation = Vec3::new(x, y, z);
+            light
+        })
+    }
+
+    fn xyz(mut self, p: Vec3) -> Self {
+        self.map_light(|mut light| {
+            light.transform.translation = p;
+            light
+        })
+    }
+
+    fn look_at(mut self, target: Vec2) -> Self {
+        self.map_light(|mut light| {
+            light.transform = Transform::from_translation(light.transform.translation)
+                .looking_at(target.extend(0.0), Vec3::Y);
+            light
+        })
+    }
+
+    fn color<C: Into<Color>>(mut self, color: C) -> Self {
+        self.map_light(|mut light| {
+            light.directional_light.color = color.into();
+            light
+        })
+    }
+
+    fn illuminance(mut self, illuminance: f32) -> Self {
+        self.map_light(|mut light| {
+            light.directional_light.illuminance = illuminance;
+            light
+        })
+    }
+
+    fn layer(mut self, layer: RenderLayers) -> Self {
+        self.map_layer(|_| layer)
+    }
+
+    fn map_layer<F>(self, f: F) -> Self
+    where
+        F: FnOnce(RenderLayers) -> RenderLayers;
+
+    fn map_light<F>(self, f: F) -> Self
+    where
+        F: FnOnce(DirectionalLightBundle) -> DirectionalLightBundle;
+}
+
+impl<'a, 'w> Builder<'a, 'w> {
+    pub fn new(app: &'a App<'w>) -> Self {
+        Self {
+            app,
+            light: DirectionalLightBundle {
+                transform: Transform::from_xyz(0.0, 0.0, 10.0).looking_at(Vec3::ZERO, Vec3::Y),
+                ..default()
+            },
+            layer: None,
+        }
+    }
+
+    pub fn build(self) -> Entity {
+        let entity = self.app.component_world_mut().spawn(self.light).id();
+        if let Some(layer) = self.layer {
+            self.app
+                .component_world_mut()
+                .entity_mut(entity)
+                .insert(layer);
+        } else {
+            self.app
+                .component_world_mut()
+                .entity_mut(entity)
+                .insert(RenderLayers::default());
+        }
+        entity
+    }
+}
+
+impl<'a, 'w> SetLight for Builder<'a, 'w> {
+    fn map_layer<F>(self, f: F) -> Self
+    where
+        F: FnOnce(RenderLayers) -> RenderLayers,
+    {
+        Self {
+            layer: Some(f(self.layer.unwrap_or(RenderLayers::default()))),
+            ..self
+        }
+    }
+
+    fn map_light<F>(self, f: F) -> Self
+    where
+        F: FnOnce(DirectionalLightBundle) -> DirectionalLightBundle,
+    {
+        Self {
+            light: f(self.light),
+            ..self
+        }
+    }
+}
+
+impl<'a, 'w> Light<'a, 'w> {
+    pub fn new(app: &'a App<'w>, entity: Entity) -> Self {
+        Self { entity, app }
+    }
+}
+
+impl<'a, 'w> SetLight for Light<'a, 'w> {
+    fn map_layer<F>(self, f: F) -> Self
+    where
+        F: FnOnce(RenderLayers) -> RenderLayers,
+    {
+        let mut world = self.app.component_world_mut();
+        let mut layer_q = world.query::<Option<&mut RenderLayers>>();
+        if let Ok(mut layer) = layer_q.get_mut(&mut world, self.entity) {
+            if let Some(mut layer) = layer {
+                *layer = f(layer.clone());
+            } else {
+                world
+                    .entity_mut(self.entity)
+                    .insert(f(RenderLayers::default()));
+            }
+        }
+        self
+    }
+
+    fn map_light<F>(self, f: F) -> Self
+    where
+        F: FnOnce(DirectionalLightBundle) -> DirectionalLightBundle,
+    {
+        let mut world = self.app.component_world_mut();
+        let mut camera_q = world.query::<(&mut Transform, &mut DirectionalLight)>();
+        let (transform, light) = camera_q.get_mut(&mut world, self.entity).unwrap();
+        let bundle = DirectionalLightBundle {
+            transform: transform.clone(),
+            directional_light: light.clone(),
+            ..default()
+        };
+
+        let bundle = f(bundle);
+        world.entity_mut(self.entity).insert(bundle);
+        self
+    }
+}
diff --git a/nannou/src/prelude.rs b/nannou/src/prelude.rs
index 6ac791a8c..dced60aa3 100644
--- a/nannou/src/prelude.rs
+++ b/nannou/src/prelude.rs
@@ -1,22 +1,18 @@
 //! A collection of commonly used items that we recommend importing for ease of use.
 
-pub use crate::app::{self, App, LoopMode};
-pub use crate::draw::Draw;
-pub use crate::event::WindowEvent::*;
-pub use crate::event::{
-    AxisMotion, Event, Key, MouseButton, MouseScrollDelta, TouchEvent, TouchPhase,
-    TouchpadPressure, Update, WindowEvent,
-};
-pub use crate::frame::{Frame, RawFrame};
+pub use bevy::asset as bevy_asset;
+pub use bevy::ecs as bevy_ecs;
+pub use bevy::reflect as bevy_reflect;
+pub use bevy::render as bevy_render;
+#[cfg(feature = "egui")]
+pub use bevy_egui::egui;
+
+pub use bevy_nannou::prelude::*;
+pub use nannou_core::prelude::*;
+
+pub use crate::app::{self, App, RunMode, UpdateModeExt};
+pub use crate::camera::SetCamera;
+#[cfg(feature = "serde")]
 pub use crate::io::{load_from_json, load_from_toml, safe_file_save, save_to_json, save_to_toml};
-pub use crate::text::{self, text};
+pub use crate::light::SetLight;
 pub use crate::time::DurationF64;
-pub use crate::wgpu;
-pub use crate::wgpu::blend::{
-    ADD as BLEND_ADD, DARKEST as BLEND_DARKEST, LIGHTEST as BLEND_LIGHTEST, NORMAL as BLEND_NORMAL,
-    REVERSE_SUBTRACT as BLEND_REVERSE_SUBTRACT, SUBTRACT as BLEND_SUBTRACT,
-};
-pub use crate::wgpu::util::{BufferInitDescriptor, DeviceExt};
-pub use crate::window::{self, Id as WindowId};
-pub use crate::window::{Fullscreen, Window};
-pub use nannou_core::prelude::*;
diff --git a/nannou/src/state.rs b/nannou/src/state.rs
deleted file mode 100644
index ea5ac4f79..000000000
--- a/nannou/src/state.rs
+++ /dev/null
@@ -1,253 +0,0 @@
-//! Small tracked parts of the application state. Includes **window**, **keys**, **mouse**, and
-//! **time** - each of which are stored in the **App**.
-
-pub use self::keys::Keys;
-pub use self::mouse::Mouse;
-pub use self::time::Time;
-pub use self::window::Window;
-
-/// Tracked state related to the focused window.
-pub mod window {
-    use crate::geom;
-    use crate::window;
-
-    /// The default scalar value used for window positioning and sizing.
-    pub type DefaultScalar = geom::scalar::Default;
-
-    /// State of the window in focus.
-    #[derive(Copy, Clone, Debug, PartialEq)]
-    pub struct Window {
-        /// ID of the window currently in focus.
-        pub id: Option<window::Id>,
-    }
-
-    impl Window {
-        /// Initialise the window state.
-        pub fn new() -> Self {
-            Window { id: None }
-        }
-
-        /// Expects that there will be a `window::Id` (the common case) and **panic!**s otherwise.
-        pub fn id(&self) -> window::Id {
-            self.id.unwrap()
-        }
-    }
-}
-
-/// Tracked state related to the keyboard.
-pub mod keys {
-    use crate::event::{Key, ModifiersState};
-    use std::collections::HashSet;
-    use std::ops::Deref;
-
-    /// The state of the keyboard.
-    #[derive(Clone, Debug, Default)]
-    pub struct Keys {
-        /// The state of the modifier keys as last indicated by winit.
-        pub mods: ModifiersState,
-        /// The state of all keys as tracked via the nannou App event handling.
-        pub down: Down,
-    }
-
-    /// The set of keys that are currently pressed.
-    #[derive(Clone, Debug, Default)]
-    pub struct Down {
-        pub(crate) keys: HashSet<Key>,
-    }
-
-    impl Deref for Down {
-        type Target = HashSet<Key>;
-        fn deref(&self) -> &Self::Target {
-            &self.keys
-        }
-    }
-}
-
-/// Tracked state related to the mouse.
-pub mod mouse {
-    use crate::geom::Point2;
-    use crate::window;
-    use std::collections::HashMap;
-
-    #[doc(inline)]
-    pub use crate::event::MouseButton as Button;
-
-    /// The state of the `Mouse` at a single moment in time.
-    #[derive(Clone, Debug, PartialEq)]
-    pub struct Mouse {
-        /// The ID of the last window currently in focus.
-        pub window: Option<window::Id>,
-        /// *x* position relative to the middle of `window`.
-        pub x: f32,
-        /// *y* position relative to the middle of `window`.
-        pub y: f32,
-        /// A map describing the state of each mouse button.
-        pub buttons: ButtonMap,
-    }
-
-    /// Whether the button is up or down.
-    #[derive(Copy, Clone, Debug, PartialEq)]
-    pub enum ButtonPosition {
-        /// The button is up (i.e. unpressed).
-        Up,
-        /// The button is down and was originally pressed down at the given `Point2`.
-        Down(Point2),
-    }
-
-    /// Stores the state of all mouse buttons.
-    ///
-    /// If the mouse button is down, it stores the position of the mouse when the button was pressed
-    #[derive(Clone, Debug, PartialEq)]
-    pub struct ButtonMap {
-        buttons: HashMap<Button, ButtonPosition>,
-    }
-
-    impl Mouse {
-        /// Construct a new default `Mouse`.
-        pub fn new() -> Self {
-            Mouse {
-                window: None,
-                buttons: ButtonMap::new(),
-                x: 0.0,
-                y: 0.0,
-            }
-        }
-
-        /// The position of the mouse relative to the middle of the window in focus..
-        pub fn position(&self) -> Point2 {
-            [self.x, self.y].into()
-        }
-    }
-
-    impl ButtonPosition {
-        /// If the mouse button is down, return a new one with position relative to the given `xy`.
-        pub fn relative_to(self, xy: Point2) -> Self {
-            match self {
-                ButtonPosition::Down(pos) => {
-                    let rel_p = pos - xy;
-                    ButtonPosition::Down([rel_p.x, rel_p.y].into())
-                }
-                button_pos => button_pos,
-            }
-        }
-
-        /// Is the `ButtonPosition` down.
-        pub fn is_down(&self) -> bool {
-            match *self {
-                ButtonPosition::Down(_) => true,
-                _ => false,
-            }
-        }
-
-        /// Is the `ButtonPosition` up.
-        pub fn is_up(&self) -> bool {
-            match *self {
-                ButtonPosition::Up => true,
-                _ => false,
-            }
-        }
-
-        /// Returns the position at which the button was pressed.
-        pub fn if_down(&self) -> Option<Point2> {
-            match *self {
-                ButtonPosition::Down(xy) => Some(xy),
-                _ => None,
-            }
-        }
-    }
-
-    impl ButtonMap {
-        /// Returns a new button map with all buttons unpressed
-        pub fn new() -> Self {
-            ButtonMap {
-                buttons: HashMap::with_capacity(5),
-            }
-        }
-
-        /// Returns a copy of the ButtonMap relative to the given `Point2`
-        pub fn relative_to(self, xy: Point2) -> Self {
-            Self {
-                buttons: self
-                    .buttons
-                    .iter()
-                    .map(|(&button, &point)| (button, point.relative_to(xy)))
-                    .collect(),
-            }
-        }
-
-        /// The state of the left mouse button.
-        pub fn left(&self) -> &ButtonPosition {
-            &self[Button::Left]
-        }
-
-        /// The state of the middle mouse button.
-        pub fn middle(&self) -> &ButtonPosition {
-            &self[Button::Middle]
-        }
-
-        /// The state of the right mouse button.
-        pub fn right(&self) -> &ButtonPosition {
-            &self[Button::Right]
-        }
-
-        /// Sets the `Button` in the `Down` position.
-        pub fn press(&mut self, button: Button, xy: Point2) {
-            self[button] = ButtonPosition::Down(xy);
-        }
-
-        /// Set's the `Button` in the `Up` position.
-        pub fn release(&mut self, button: Button) {
-            self[button] = ButtonPosition::Up;
-        }
-
-        /// An iterator yielding all pressed mouse buttons along with the location at which they
-        /// were originally pressed.
-        pub fn pressed<'a>(&'a self) -> impl Iterator<Item = (Button, Point2)> + 'a {
-            self.buttons
-                .iter()
-                .filter_map(|(&button, &point)| point.if_down().map(|point| (button, point)))
-        }
-    }
-
-    impl std::ops::Index<Button> for ButtonMap {
-        type Output = ButtonPosition;
-        fn index(&self, button: Button) -> &Self::Output {
-            self.buttons.get(&button).unwrap_or(&ButtonPosition::Up)
-        }
-    }
-
-    impl std::ops::IndexMut<Button> for ButtonMap {
-        fn index_mut(&mut self, button: Button) -> &mut Self::Output {
-            self.buttons.entry(button).or_insert(ButtonPosition::Up)
-        }
-    }
-}
-
-/// Tracked durations related to the App.
-pub mod time {
-    /// The state of time tracked by the App.
-    #[derive(Copy, Clone, Debug, Default, Eq, PartialEq, Hash)]
-    pub struct Time {
-        /// The duration since the app started running.
-        pub since_start: std::time::Duration,
-        /// The duration since the previous update.
-        pub since_prev_update: std::time::Duration,
-    }
-
-    impl Time {
-        /// The number of updates per second if `since_prev_update` were to remain constant
-        pub fn updates_per_second(&self) -> f32 {
-            if self.since_prev_update.as_secs() > 0 {
-                return 0.0;
-            }
-
-            let millis = self.since_prev_update.subsec_millis() as f32;
-
-            if millis == 0.0 {
-                return std::f32::MAX;
-            }
-
-            1000.0 / millis
-        }
-    }
-}
diff --git a/nannou/src/text/cursor.rs b/nannou/src/text/cursor.rs
deleted file mode 100644
index 203d573d7..000000000
--- a/nannou/src/text/cursor.rs
+++ /dev/null
@@ -1,461 +0,0 @@
-//! Logic related to the positioning of the cursor within text.
-
-use crate::geom::{Range, Rect};
-use crate::text::{self, FontSize, Point, Scalar};
-
-/// An index representing the position of a cursor within some text.
-#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
-pub struct Index {
-    /// The byte index of the line upon which the cursor is situated.
-    pub line: usize,
-    /// The index within all possible cursor positions for the line.
-    ///
-    /// For example, for the line `foo`, a `char` of `1` would indicate the cursor's position
-    /// as `f|oo` where `|` is the cursor.
-    pub char: usize,
-}
-
-/// Every possible cursor position within each line of text yielded by the given iterator.
-///
-/// Yields `(xs, y_range)`, where `y_range` is the `Range` occupied by the line across the *y*
-/// axis and `xs` is every possible cursor position along the *x* axis
-#[derive(Clone)]
-pub struct XysPerLine<'a, I> {
-    lines_with_rects: I,
-    font: &'a text::Font,
-    text: &'a str,
-    font_size: FontSize,
-}
-
-/// Similarly to `XysPerLine`, yields every possible cursor position within each line of text
-/// yielded by the given iterator.
-///
-/// Rather than taking an iterator type yielding lines and positioning data, this method
-/// constructs its own iterator to do so internally, saving some boilerplate involved in common
-/// `XysPerLine` use cases.
-///
-/// Yields `(xs, y_range)`, where `y_range` is the `Range` occupied by the line across the *y*
-/// axis and `xs` is every possible cursor position along the *x* axis.
-#[derive(Clone)]
-pub struct XysPerLineFromText<'a> {
-    xys_per_line: XysPerLine<
-        'a,
-        std::iter::Zip<
-            std::iter::Cloned<std::slice::Iter<'a, text::line::Info>>,
-            text::line::Rects<std::iter::Cloned<std::slice::Iter<'a, text::line::Info>>>,
-        >,
-    >,
-}
-
-/// Each possible cursor position along the *x* axis within a line of text.
-///
-/// `Xs` iterators are produced by the `XysPerLine` iterator.
-pub struct Xs<'a, 'b> {
-    next_x: Option<Scalar>,
-    layout: text::LayoutIter<'a, 'b>,
-}
-
-impl Index {
-    /// The cursor index of the beginning of the word (block of non-whitespace) before `self`.
-    ///
-    /// If `self` is at the beginning of the line, call previous, which returns the last
-    /// index position of the previous line, or None if it's the first line
-    ///
-    /// If `self` points to whitespace, skip past that whitespace, then return the index of
-    /// the start of the word that precedes the whitespace
-    ///
-    /// If `self` is in the middle or end of a word, return the index of the start of that word
-    pub fn previous_word_start<I>(self, text: &str, mut line_infos: I) -> Option<Self>
-    where
-        I: Iterator<Item = text::line::Info>,
-    {
-        let Index { line, char } = self;
-        if char > 0 {
-            line_infos.nth(line).and_then(|line_info| {
-                let line_count = line_info.char_range().count();
-                let mut chars_rev = (&text[line_info.byte_range()]).chars().rev();
-                if char != line_count {
-                    chars_rev.nth(line_count - char - 1);
-                }
-                let mut new_char = 0;
-                let mut hit_non_whitespace = false;
-                for (i, char_) in chars_rev.enumerate() {
-                    // loop until word starts, then continue until the word ends
-                    if !char_.is_whitespace() {
-                        hit_non_whitespace = true;
-                    }
-                    if char_.is_whitespace() && hit_non_whitespace {
-                        new_char = char - i;
-                        break;
-                    }
-                }
-                Some(Index {
-                    line: line,
-                    char: new_char,
-                })
-            })
-        } else {
-            self.previous(line_infos)
-        }
-    }
-
-    /// The cursor index of the end of the first word (block of non-whitespace) after `self`.
-    ///
-    /// If `self` is at the end of the text, this returns `None`.
-    ///
-    /// If `self` is at the end of a line other than the last, this returns the first index of
-    /// the next line.
-    ///
-    /// If `self` points to whitespace, skip past that whitespace, then return the index of
-    /// the end of the word after the whitespace
-    ///
-    /// If `self` is in the middle or start of a word, return the index of the end of that word
-    pub fn next_word_end<I>(self, text: &str, mut line_infos: I) -> Option<Self>
-    where
-        I: Iterator<Item = text::line::Info>,
-    {
-        let Index { line, char } = self;
-        line_infos.nth(line).and_then(|line_info| {
-            let line_count = line_info.char_range().count();
-            if char < line_count {
-                let mut chars = (&text[line_info.byte_range()]).chars();
-                let mut new_char = line_count;
-                let mut hit_non_whitespace = false;
-                if char != 0 {
-                    chars.nth(char - 1);
-                }
-                for (i, char_) in chars.enumerate() {
-                    // loop until word starts, then continue until the word ends
-                    if !char_.is_whitespace() {
-                        hit_non_whitespace = true;
-                    }
-                    if char_.is_whitespace() && hit_non_whitespace {
-                        new_char = char + i;
-                        break;
-                    }
-                }
-                Some(Index {
-                    line: line,
-                    char: new_char,
-                })
-            } else {
-                line_infos.next().map(|_| Index {
-                    line: line + 1,
-                    char: 0,
-                })
-            }
-        })
-    }
-
-    /// The cursor index that comes before `self`.
-    ///
-    /// If `self` is at the beginning of the text, this returns `None`.
-    ///
-    /// If `self` is at the beginning of a line other than the first, this returns the last
-    /// index position of the previous line.
-    ///
-    /// If `self` is a position other than the start of a line, it will return the position
-    /// that is immediately to the left.
-    pub fn previous<I>(self, mut line_infos: I) -> Option<Self>
-    where
-        I: Iterator<Item = text::line::Info>,
-    {
-        let Index { line, char } = self;
-        if char > 0 {
-            let new_char = char - 1;
-            line_infos.nth(line).and_then(|info| {
-                if new_char <= info.char_range().count() {
-                    Some(Index {
-                        line: line,
-                        char: new_char,
-                    })
-                } else {
-                    None
-                }
-            })
-        } else if line > 0 {
-            let new_line = line - 1;
-            line_infos.nth(new_line).map(|info| {
-                let new_char = info.end_char() - info.start_char;
-                Index {
-                    line: new_line,
-                    char: new_char,
-                }
-            })
-        } else {
-            None
-        }
-    }
-
-    /// The cursor index that follows `self`.
-    ///
-    /// If `self` is at the end of the text, this returns `None`.
-    ///
-    /// If `self` is at the end of a line other than the last, this returns the first index of
-    /// the next line.
-    ///
-    /// If `self` is a position other than the end of a line, it will return the position that
-    /// is immediately to the right.
-    pub fn next<I>(self, mut line_infos: I) -> Option<Self>
-    where
-        I: Iterator<Item = text::line::Info>,
-    {
-        let Index { line, char } = self;
-        line_infos.nth(line).and_then(|info| {
-            if char >= info.char_range().count() {
-                line_infos.next().map(|_| Index {
-                    line: line + 1,
-                    char: 0,
-                })
-            } else {
-                Some(Index {
-                    line: line,
-                    char: char + 1,
-                })
-            }
-        })
-    }
-
-    /// Clamps `self` to the given lines.
-    ///
-    /// If `self` would lie after the end of the last line, return the index at the end of the
-    /// last line.
-    ///
-    /// If `line_infos` is empty, returns cursor at line=0 char=0.
-    pub fn clamp_to_lines<I>(self, line_infos: I) -> Self
-    where
-        I: Iterator<Item = text::line::Info>,
-    {
-        let mut last = None;
-        for (i, info) in line_infos.enumerate() {
-            if i == self.line {
-                let num_chars = info.char_range().len();
-                let char = std::cmp::min(self.char, num_chars);
-                return Index {
-                    line: i,
-                    char: char,
-                };
-            }
-            last = Some((i, info));
-        }
-        match last {
-            Some((i, info)) => Index {
-                line: i,
-                char: info.char_range().len(),
-            },
-            None => Index { line: 0, char: 0 },
-        }
-    }
-}
-
-/// Every possible cursor position within each line of text yielded by the given iterator.
-///
-/// Yields `(xs, y_range)`, where `y_range` is the `Range` occupied by the line across the *y*
-/// axis and `xs` is every possible cursor position along the *x* axis
-pub fn xys_per_line<'a, I>(
-    lines_with_rects: I,
-    font: &'a text::Font,
-    text: &'a str,
-    font_size: FontSize,
-) -> XysPerLine<'a, I> {
-    XysPerLine {
-        lines_with_rects: lines_with_rects,
-        font: font,
-        text: text,
-        font_size: font_size,
-    }
-}
-
-/// Similarly to `xys_per_line`, this produces an iterator yielding every possible cursor
-/// position within each line of text yielded by the given iterator.
-///
-/// Rather than taking an iterator yielding lines and their positioning data, this method
-/// constructs its own iterator to do so internally, saving some boilerplate involved in common
-/// `xys_per_line` use cases.
-///
-/// Yields `(xs, y_range)`, where `y_range` is the `Range` occupied by the line across the *y*
-/// axis and `xs` is every possible cursor position along the *x* axis.
-pub fn xys_per_line_from_text<'a>(
-    text: &'a str,
-    line_infos: &'a [text::line::Info],
-    font: &'a text::Font,
-    font_size: FontSize,
-    max_width: Scalar,
-    x_align: text::Justify,
-    line_spacing: Scalar,
-) -> XysPerLineFromText<'a> {
-    let line_infos = line_infos.iter().cloned();
-    let line_rects = text::line::rects(
-        line_infos.clone(),
-        font_size,
-        max_width,
-        x_align,
-        line_spacing,
-    );
-    let lines = line_infos.clone();
-    let lines_with_rects = lines.zip(line_rects.clone());
-    XysPerLineFromText {
-        xys_per_line: text::cursor::xys_per_line(lines_with_rects, font, text, font_size),
-    }
-}
-
-/// Convert the given character index into a cursor `Index`.
-pub fn index_before_char<I>(line_infos: I, char_index: usize) -> Option<Index>
-where
-    I: Iterator<Item = text::line::Info>,
-{
-    for (i, line_info) in line_infos.enumerate() {
-        let start_char = line_info.start_char;
-        let end_char = line_info.end_char();
-        if start_char <= char_index && char_index <= end_char {
-            return Some(Index {
-                line: i,
-                char: char_index - start_char,
-            });
-        }
-    }
-    None
-}
-
-/// Determine the *xy* location of the cursor at the given cursor `Index`.
-pub fn xy_at<'a, I>(xys_per_line: I, idx: Index) -> Option<(Scalar, Range)>
-where
-    I: Iterator<Item = (Xs<'a, 'a>, Range)>,
-{
-    for (i, (xs, y)) in xys_per_line.enumerate() {
-        if i == idx.line {
-            for (j, x) in xs.enumerate() {
-                if j == idx.char {
-                    return Some((x, y));
-                }
-            }
-        }
-    }
-    None
-}
-
-/// Find the closest line for the given `y` position, and return the line index, Xs iterator, and y-range of that line
-///
-/// Returns `None` if there are no lines
-pub fn closest_line<'a, I>(y_pos: Scalar, xys_per_line: I) -> Option<(usize, Xs<'a, 'a>, Range)>
-where
-    I: Iterator<Item = (Xs<'a, 'a>, Range)>,
-{
-    let mut xys_per_line_enumerated = xys_per_line.enumerate();
-    xys_per_line_enumerated
-        .next()
-        .and_then(|(first_line_idx, (first_line_xs, first_line_y))| {
-            let mut closest_line = (first_line_idx, first_line_xs, first_line_y);
-            let mut closest_diff = (y_pos - first_line_y.middle()).abs();
-            for (line_idx, (line_xs, line_y)) in xys_per_line_enumerated {
-                if line_y.contains(y_pos) {
-                    closest_line = (line_idx, line_xs, line_y);
-                    break;
-                } else {
-                    let diff = (y_pos - line_y.middle()).abs();
-                    if diff < closest_diff {
-                        closest_line = (line_idx, line_xs, line_y);
-                        closest_diff = diff;
-                    } else {
-                        break;
-                    }
-                }
-            }
-            Some(closest_line)
-        })
-}
-
-/// Find the closest cursor index to the given `xy` position, and the center `Point` of that
-/// cursor.
-///
-/// Returns `None` if the given `text` is empty.
-pub fn closest_cursor_index_and_xy<'a, I>(xy: Point, xys_per_line: I) -> Option<(Index, Point)>
-where
-    I: Iterator<Item = (Xs<'a, 'a>, Range)>,
-{
-    closest_line(xy[1], xys_per_line).and_then(
-        |(closest_line_idx, closest_line_xs, closest_line_y)| {
-            let (closest_char_idx, closest_x) =
-                closest_cursor_index_on_line(xy[0], closest_line_xs);
-            let index = Index {
-                line: closest_line_idx,
-                char: closest_char_idx,
-            };
-            let point = [closest_x, closest_line_y.middle()].into();
-            Some((index, point))
-        },
-    )
-}
-
-/// Find the closest cursor index to the given `x` position on the given line along with the
-/// `x` position of that cursor.
-pub fn closest_cursor_index_on_line<'a>(x_pos: Scalar, line_xs: Xs<'a, 'a>) -> (usize, Scalar) {
-    let mut xs_enumerated = line_xs.enumerate();
-    // `xs` always yields at least one `x` (the start of the line).
-    let (first_idx, first_x) = xs_enumerated.next().unwrap();
-    let first_diff = (x_pos - first_x).abs();
-    let mut closest = (first_idx, first_x);
-    let mut closest_diff = first_diff;
-    for (i, x) in xs_enumerated {
-        let diff = (x_pos - x).abs();
-        if diff < closest_diff {
-            closest = (i, x);
-            closest_diff = diff;
-        } else {
-            break;
-        }
-    }
-    closest
-}
-
-impl<'a, I> Iterator for XysPerLine<'a, I>
-where
-    I: Iterator<Item = (text::line::Info, Rect)>,
-{
-    // The `Range` occupied by the line across the *y* axis, along with an iterator yielding
-    // each possible cursor position along the *x* axis.
-    type Item = (Xs<'a, 'a>, Range);
-    fn next(&mut self) -> Option<Self::Item> {
-        let XysPerLine {
-            ref mut lines_with_rects,
-            font,
-            text,
-            font_size,
-        } = *self;
-        let scale = text::pt_to_scale(font_size);
-        lines_with_rects.next().map(|(line_info, line_rect)| {
-            let line = &text[line_info.byte_range()];
-            let (x, y) = (line_rect.left() as f32, line_rect.top() as f32);
-            let point = text::rt::Point { x: x, y: y };
-            let y = line_rect.y;
-            let layout = font.layout(line, scale, point);
-            let xs = Xs {
-                next_x: Some(line_rect.x.start),
-                layout: layout,
-            };
-            (xs, y)
-        })
-    }
-}
-
-impl<'a> Iterator for XysPerLineFromText<'a> {
-    type Item = (Xs<'a, 'a>, Range);
-    fn next(&mut self) -> Option<Self::Item> {
-        self.xys_per_line.next()
-    }
-}
-
-impl<'a, 'b> Iterator for Xs<'a, 'b> {
-    // Each possible cursor position along the *x* axis.
-    type Item = Scalar;
-    fn next(&mut self) -> Option<Self::Item> {
-        self.next_x.map(|x| {
-            self.next_x = self.layout.next().map(|g| {
-                g.pixel_bounding_box()
-                    .map(|r| r.max.x as Scalar)
-                    .unwrap_or_else(|| x + g.unpositioned().h_metrics().advance_width as Scalar)
-            });
-            x
-        })
-    }
-}
diff --git a/nannou/src/text/font.rs b/nannou/src/text/font.rs
deleted file mode 100644
index 6cae49631..000000000
--- a/nannou/src/text/font.rs
+++ /dev/null
@@ -1,228 +0,0 @@
-//! The `font::Id` and `font::Map` types.
-
-use crate::text::{Font, FontCollection};
-use std::collections::HashMap;
-use std::hash::{Hash, Hasher};
-use std::path::{Path, PathBuf};
-
-/// A type-safe wrapper around the `FontId`.
-///
-/// This is used as both:
-///
-/// - The key for the `font::Map`'s inner `HashMap`.
-/// - The `font_id` field for the rusttype::gpu_cache::Cache.
-#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
-pub struct Id(usize);
-
-/// A collection of mappings from `font::Id`s to `rusttype::Font`s.
-#[derive(Debug)]
-pub struct Map {
-    next_index: usize,
-    map: HashMap<Id, Font>,
-}
-
-/// An iterator yielding an `Id` for each new `rusttype::Font` inserted into the `Map` via the
-/// `insert_collection` method.
-pub struct NewIds {
-    index_range: std::ops::Range<usize>,
-}
-
-/// Yields the `Id` for each `Font` within the `Map`.
-#[derive(Clone)]
-pub struct Ids<'a> {
-    keys: std::collections::hash_map::Keys<'a, Id, Font>,
-}
-
-/// Returned when loading new fonts from file or bytes.
-#[derive(Debug)]
-pub enum Error {
-    /// Some error occurred while loading a `FontCollection` from a file.
-    Io(std::io::Error),
-    /// No `Font`s could be yielded from the `FontCollection`.
-    NoFont,
-}
-
-/// The name of the default directory that is searched for fonts.
-pub const DEFAULT_DIRECTORY_NAME: &str = "fonts";
-
-impl Id {
-    /// Returns the inner `usize` from the `Id`.
-    pub fn index(self) -> usize {
-        self.0
-    }
-}
-
-impl Map {
-    /// Construct the new, empty `Map`.
-    pub fn new() -> Self {
-        Map {
-            next_index: 0,
-            map: HashMap::default(),
-        }
-    }
-
-    /// Borrow the `rusttype::Font` associated with the given `font::Id`.
-    pub fn get(&self, id: Id) -> Option<&Font> {
-        self.map.get(&id)
-    }
-
-    /// Adds the given `rusttype::Font` to the `Map` and returns a unique `Id` for it.
-    pub fn insert(&mut self, font: Font) -> Id {
-        let index = self.next_index;
-        self.next_index = index.wrapping_add(1);
-        let id = Id(index);
-        self.map.insert(id, font);
-        id
-    }
-
-    /// Insert a single `Font` into the map by loading it from the given file path.
-    pub fn insert_from_file<P>(&mut self, path: P) -> Result<Id, Error>
-    where
-        P: AsRef<std::path::Path>,
-    {
-        let font = from_file(path)?;
-        Ok(self.insert(font))
-    }
-
-    // /// Adds each font in the given `rusttype::FontCollection` to the `Map` and returns an
-    // /// iterator yielding a unique `Id` for each.
-    // pub fn insert_collection(&mut self, collection: FontCollection) -> NewIds {
-    //     let start_index = self.next_index;
-    //     let mut end_index = start_index;
-    //     for index in 0.. {
-    //         match collection.font_at(index) {
-    //             Some(font) => {
-    //                 self.insert(font);
-    //                 end_index += 1;
-    //             }
-    //             None => break,
-    //         }
-    //     }
-    //     NewIds { index_range: start_index..end_index }
-    // }
-
-    /// Produces an iterator yielding the `Id` for each `Font` within the `Map`.
-    pub fn ids(&self) -> Ids {
-        Ids {
-            keys: self.map.keys(),
-        }
-    }
-}
-
-/// Produce a unique ID for the given font.
-pub fn id(font: &Font) -> Id {
-    let mut hasher = std::collections::hash_map::DefaultHasher::new();
-    for name in font.font_name_strings() {
-        name.hash(&mut hasher);
-    }
-    Id((hasher.finish() % std::usize::MAX as u64) as usize)
-}
-
-/// Load a `FontCollection` from a file at a given path.
-pub fn collection_from_file<P>(path: P) -> Result<FontCollection, std::io::Error>
-where
-    P: AsRef<std::path::Path>,
-{
-    use std::io::Read;
-    let path = path.as_ref();
-    let mut file = std::fs::File::open(path)?;
-    let mut file_buffer = Vec::new();
-    file.read_to_end(&mut file_buffer)?;
-    Ok(FontCollection::from_bytes(file_buffer)?)
-}
-
-/// Load a single `Font` from a file at the given path.
-pub fn from_file<P>(path: P) -> Result<Font, Error>
-where
-    P: AsRef<std::path::Path>,
-{
-    let collection = collection_from_file(path)?;
-    collection.into_font().or(Err(Error::NoFont))
-}
-
-/// Load the default notosans font.
-///
-/// This function is only available if the `notosans` feature is enabled, which it is by default.
-#[cfg(feature = "notosans")]
-pub fn default_notosans() -> Font {
-    let collection = FontCollection::from_bytes(notosans::REGULAR_TTF)
-        .expect("failed to load the `notosans::REGULAR_TTF` font collection");
-    collection
-        .into_font()
-        .expect("the `notosans::REGULAR_TTF` font collection contained no fonts")
-}
-
-/// The directory that is searched for default fonts.
-pub fn default_directory(assets: &Path) -> PathBuf {
-    assets.join(DEFAULT_DIRECTORY_NAME)
-}
-
-/// Load the default font.
-///
-/// If the `notosans` feature is enabled, this will return the font loaded from
-/// `notosans::REGULAR_TTF`.
-///
-/// Otherwise this will attempt to locate the `assets/fonts` directory. If the directory exists,
-/// the first font that is found will be loaded. If no fonts are found, an error is returned.
-#[allow(unreachable_code, unused_variables)]
-pub fn default(assets: &Path) -> Result<Font, Error> {
-    #[cfg(feature = "notosans")]
-    {
-        return Ok(default_notosans());
-    }
-
-    // Find a font in `assets/fonts`.
-    let fonts_dir = default_directory(assets);
-    if fonts_dir.exists() && fonts_dir.is_dir() {
-        for res in crate::io::walk_dir(&fonts_dir) {
-            let entry = match res {
-                Ok(e) => e,
-                Err(_) => continue,
-            };
-            match from_file(entry.path()) {
-                Err(_) => continue,
-                Ok(font) => return Ok(font),
-            }
-        }
-    }
-
-    Err(Error::NoFont)
-}
-
-impl Iterator for NewIds {
-    type Item = Id;
-    fn next(&mut self) -> Option<Self::Item> {
-        self.index_range.next().map(|i| Id(i))
-    }
-}
-
-impl<'a> Iterator for Ids<'a> {
-    type Item = Id;
-    fn next(&mut self) -> Option<Self::Item> {
-        self.keys.next().map(|&id| id)
-    }
-}
-
-impl From<std::io::Error> for Error {
-    fn from(e: std::io::Error) -> Self {
-        Error::Io(e)
-    }
-}
-
-impl std::error::Error for Error {
-    fn cause(&self) -> Option<&dyn std::error::Error> {
-        match *self {
-            Error::Io(ref e) => Some(e),
-            Error::NoFont => None,
-        }
-    }
-}
-
-impl std::fmt::Display for Error {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
-        match *self {
-            Error::Io(ref e) => std::fmt::Display::fmt(e, f),
-            Error::NoFont => write!(f, "No `Font` found in the loaded `FontCollection`."),
-        }
-    }
-}
diff --git a/nannou/src/text/glyph.rs b/nannou/src/text/glyph.rs
deleted file mode 100644
index 785160788..000000000
--- a/nannou/src/text/glyph.rs
+++ /dev/null
@@ -1,344 +0,0 @@
-//! Logic and types specific to individual glyph layout.
-
-use crate::geom::{Range, Rect};
-use crate::text::{self, FontSize, Scalar, ScaledGlyph};
-
-/// Some position along the X axis (used within `CharXs`).
-pub type X = Scalar;
-
-/// The half of the width of some character (used within `CharXs`).
-pub type HalfW = Scalar;
-
-/// An iterator yielding the `Rect` for each `char`'s `Glyph` in the given `text`.
-pub struct Rects<'a, 'b> {
-    /// The *y* axis `Range` of the `Line` for which character `Rect`s are being yielded.
-    ///
-    /// Every yielded `Rect` will use this as its `y` `Range`.
-    y: Range,
-    /// `PositionedGlyphs` yielded by the RustType `LayoutIter`.
-    layout: text::LayoutIter<'a, 'b>,
-}
-
-/// An iterator that, for every `(line, line_rect)` pair yielded by the given iterator,
-/// produces an iterator that yields a `Rect` for every character in that line.
-pub struct RectsPerLine<'a, I> {
-    lines_with_rects: I,
-    font: &'a text::Font,
-    font_size: FontSize,
-}
-
-/// Yields a `Rect` for each selected character in a single line of text.
-///
-/// This iterator can only be produced by the `SelectedCharRectsPerLine` iterator.
-pub struct SelectedRects<'a, 'b> {
-    enumerated_rects: std::iter::Enumerate<Rects<'a, 'b>>,
-    end_char_idx: usize,
-}
-
-/// Yields an iteraor yielding `Rect`s for each selected character in each line of text within
-/// the given iterator yielding char `Rect`s.
-///
-/// Given some `start` and `end` indices, only `Rect`s for `char`s between these two indices
-/// will be produced.
-///
-/// All lines that have no selected `Rect`s will be skipped.
-pub struct SelectedRectsPerLine<'a, I> {
-    enumerated_rects_per_line: std::iter::Enumerate<RectsPerLine<'a, I>>,
-    start_cursor_idx: text::cursor::Index,
-    end_cursor_idx: text::cursor::Index,
-}
-
-struct ContourPathEvents {
-    segments: std::vec::IntoIter<rusttype::Segment>,
-    first: lyon::math::Point,
-    begin_event: Option<lyon::path::PathEvent>,
-    first_segment_event: Option<lyon::path::PathEvent>,
-    last: Option<lyon::math::Point>,
-}
-
-impl<'a, 'b> Iterator for Rects<'a, 'b> {
-    type Item = (ScaledGlyph<'a>, Rect);
-    fn next(&mut self) -> Option<Self::Item> {
-        let Rects { ref mut layout, y } = *self;
-        layout.next().map(|g| {
-            let left = g.position().x;
-            let (right, height) = g
-                .pixel_bounding_box()
-                .map(|bb| (bb.max.x as Scalar, (bb.max.y - bb.min.y) as Scalar))
-                .unwrap_or_else(|| {
-                    let w = g.unpositioned().h_metrics().advance_width as Scalar;
-                    let r = left + w;
-                    let h = 0.0;
-                    (r, h)
-                });
-            let x = Range::new(left, right);
-            let y = Range::new(y.start, y.start + height);
-            let r = Rect { x: x, y: y };
-            let g = g.into_unpositioned();
-            (g, r)
-        })
-    }
-}
-
-impl<'a, I> Iterator for RectsPerLine<'a, I>
-where
-    I: Iterator<Item = (&'a str, Rect)>,
-{
-    type Item = Rects<'a, 'a>;
-    fn next(&mut self) -> Option<Self::Item> {
-        let RectsPerLine {
-            ref mut lines_with_rects,
-            font,
-            font_size,
-        } = *self;
-        let scale = text::pt_to_scale(font_size);
-        lines_with_rects.next().map(|(line, line_rect)| {
-            let (x, y) = (line_rect.left() as f32, line_rect.top() as f32);
-            let point = text::rt::Point { x: x, y: y };
-            Rects {
-                layout: font.layout(line, scale, point),
-                y: line_rect.y,
-            }
-        })
-    }
-}
-
-impl<'a, 'b> Iterator for SelectedRects<'a, 'b> {
-    type Item = (ScaledGlyph<'a>, Rect);
-    fn next(&mut self) -> Option<Self::Item> {
-        let SelectedRects {
-            ref mut enumerated_rects,
-            end_char_idx,
-        } = *self;
-        enumerated_rects.next().and_then(
-            |(i, rect)| {
-                if i < end_char_idx {
-                    Some(rect)
-                } else {
-                    None
-                }
-            },
-        )
-    }
-}
-
-impl<'a, I> Iterator for SelectedRectsPerLine<'a, I>
-where
-    I: Iterator<Item = (&'a str, Rect)>,
-{
-    type Item = SelectedRects<'a, 'a>;
-    fn next(&mut self) -> Option<Self::Item> {
-        let SelectedRectsPerLine {
-            ref mut enumerated_rects_per_line,
-            start_cursor_idx,
-            end_cursor_idx,
-        } = *self;
-
-        enumerated_rects_per_line.next().map(|(i, rects)| {
-            let end_char_idx =
-                // If this is the last line, the end is the char after the final selected char.
-                if i == end_cursor_idx.line {
-                    end_cursor_idx.char
-                // Otherwise if in range, every char in the line is selected.
-                } else if start_cursor_idx.line <= i && i < end_cursor_idx.line {
-                    std::u32::MAX as usize
-                // Otherwise if out of range, no chars are selected.
-                } else {
-                    0
-                };
-
-            let mut enumerated_rects = rects.enumerate();
-
-            // If this is the first line, skip all non-selected chars.
-            if i == start_cursor_idx.line {
-                for _ in 0..start_cursor_idx.char {
-                    enumerated_rects.next();
-                }
-            }
-
-            SelectedRects {
-                enumerated_rects: enumerated_rects,
-                end_char_idx: end_char_idx,
-            }
-        })
-    }
-}
-
-impl Iterator for ContourPathEvents {
-    type Item = lyon::path::PathEvent;
-    fn next(&mut self) -> Option<Self::Item> {
-        if let Some(event) = self.begin_event.take() {
-            return Some(event);
-        }
-        if let Some(event) = self.first_segment_event.take() {
-            return Some(event);
-        }
-        match self.segments.next() {
-            None => self.last.take().map(|last| lyon::path::PathEvent::End {
-                first: self.first,
-                last,
-                close: true,
-            }),
-            Some(seg) => {
-                self.last = Some(tp(rt_segment_end(&seg)));
-                Some(segment_to_event(seg))
-            }
-        }
-    }
-}
-
-/// Produce an iterator that, for every `(line, line_rect)` pair yielded by the given iterator,
-/// produces an iterator that yields a `Rect` for every character in that line.
-///
-/// This is useful when information about character positioning is needed when reasoning about
-/// text layout.
-pub fn rects_per_line<'a, I>(
-    lines_with_rects: I,
-    font: &'a text::Font,
-    font_size: FontSize,
-) -> RectsPerLine<'a, I>
-where
-    I: Iterator<Item = (&'a str, Rect)>,
-{
-    RectsPerLine {
-        lines_with_rects: lines_with_rects,
-        font: font,
-        font_size: font_size,
-    }
-}
-
-/// Find the index of the character that directly follows the cursor at the given `cursor_idx`.
-///
-/// Returns `None` if either the given `cursor::Index` `line` or `idx` fields are out of bounds
-/// of the line information yielded by the `line_infos` iterator.
-pub fn index_after_cursor<I>(mut line_infos: I, cursor_idx: text::cursor::Index) -> Option<usize>
-where
-    I: Iterator<Item = text::line::Info>,
-{
-    line_infos.nth(cursor_idx.line).and_then(|line_info| {
-        let start_char = line_info.start_char;
-        let end_char = line_info.end_char();
-        let char_index = start_char + cursor_idx.char;
-        if char_index <= end_char {
-            Some(char_index)
-        } else {
-            None
-        }
-    })
-}
-
-/// Produces an iterator that yields iteraors yielding `Rect`s for each selected character in
-/// each line of text within the given iterator yielding char `Rect`s.
-///
-/// Given some `start` and `end` indices, only `Rect`s for `char`s between these two indices
-/// will be produced.
-///
-/// All lines that have no selected `Rect`s will be skipped.
-pub fn selected_rects_per_line<'a, I>(
-    lines_with_rects: I,
-    font: &'a text::Font,
-    font_size: FontSize,
-    start: text::cursor::Index,
-    end: text::cursor::Index,
-) -> SelectedRectsPerLine<'a, I>
-where
-    I: Iterator<Item = (&'a str, Rect)>,
-{
-    SelectedRectsPerLine {
-        enumerated_rects_per_line: rects_per_line(lines_with_rects, font, font_size).enumerate(),
-        start_cursor_idx: start,
-        end_cursor_idx: end,
-    }
-}
-
-fn rt_segment_start(s: &rusttype::Segment) -> rusttype::Point<f32> {
-    match *s {
-        rusttype::Segment::Line(ref line) => line.p[0],
-        rusttype::Segment::Curve(ref curve) => curve.p[0],
-    }
-}
-
-fn rt_segment_end(s: &rusttype::Segment) -> rusttype::Point<f32> {
-    match *s {
-        rusttype::Segment::Line(ref line) => line.p[1],
-        rusttype::Segment::Curve(ref curve) => curve.p[2],
-    }
-}
-
-// Translate the rusttype point to a nannou compatible one.
-fn tp(p: rusttype::Point<f32>) -> lyon::math::Point {
-    lyon::math::point(p.x, p.y)
-}
-
-// The event for moving to the start of a segment.
-fn segment_begin_event(s: &rusttype::Segment) -> lyon::path::PathEvent {
-    let at = tp(rt_segment_start(s));
-    lyon::path::PathEvent::Begin { at }
-}
-
-// Convert the rusttype line to a lyon line segment.
-fn conv_line_segment(l: &rusttype::Line) -> lyon::path::PathEvent {
-    let from = tp(l.p[0]);
-    let to = tp(l.p[1]);
-    lyon::path::PathEvent::Line { from, to }
-}
-
-// Convert the rusttype curve to a lyon quadratic bezier segment.
-fn conv_curve_segment(c: &rusttype::Curve) -> lyon::path::PathEvent {
-    let from = tp(c.p[0]);
-    let ctrl = tp(c.p[1]);
-    let to = tp(c.p[2]);
-    lyon::path::PathEvent::Quadratic { from, ctrl, to }
-}
-
-// Convert the given rusttype segment to a lyon path event.
-fn segment_to_event(s: rusttype::Segment) -> lyon::path::PathEvent {
-    match s {
-        rusttype::Segment::Line(ref l) => conv_line_segment(l),
-        rusttype::Segment::Curve(ref c) => conv_curve_segment(c),
-    }
-}
-
-/// Convert the given sequence of contours to a `geom::Path`.
-///
-/// In the resulting path events [0.0, 0.0] is the bottom left of the rect.
-pub fn contours_to_path<'a, I>(
-    _exact_bounding_box: rusttype::Rect<f32>,
-    contours: I,
-) -> impl Iterator<Item = lyon::path::PathEvent>
-where
-    I: IntoIterator<Item = rusttype::Contour>,
-{
-    contours.into_iter().flat_map(move |contour| {
-        let mut segs = contour.segments.into_iter();
-        let maybe_first = segs.next();
-        maybe_first
-            .map(move |first_seg| {
-                let first = tp(rt_segment_start(&first_seg));
-                let last = Some(tp(rt_segment_end(&first_seg)));
-                let begin_event = Some(segment_begin_event(&first_seg));
-                let first_segment_event = Some(segment_to_event(first_seg));
-                ContourPathEvents {
-                    segments: segs,
-                    first,
-                    last,
-                    begin_event,
-                    first_segment_event,
-                }
-            })
-            .into_iter()
-            .flat_map(move |it| it)
-    })
-}
-
-/// Produce the lyon path for the given scaled glyph.
-///
-/// Returns `None` if `glyph.shape()` or `glyph.exact_bounding_box()` returns `None`.
-///
-/// TODO: This could be optimised by caching path events glyph ID and using normalised glyphs.
-pub fn path_events(glyph: ScaledGlyph) -> Option<impl Iterator<Item = lyon::path::PathEvent>> {
-    glyph
-        .exact_bounding_box()
-        .and_then(|bb| glyph.shape().map(|ctrs| (bb, ctrs)))
-        .map(|(bb, ctrs)| contours_to_path(bb, ctrs))
-}
diff --git a/nannou/src/text/layout.rs b/nannou/src/text/layout.rs
deleted file mode 100644
index 785064d58..000000000
--- a/nannou/src/text/layout.rs
+++ /dev/null
@@ -1,159 +0,0 @@
-//! Items related to the styling of text.
-
-use crate::text::{Align, Font, FontSize, Justify, Scalar, Wrap};
-
-/// A context for building a text layout.
-#[derive(Clone, Debug, Default)]
-pub struct Builder {
-    pub line_spacing: Option<Scalar>,
-    pub line_wrap: Option<Option<Wrap>>,
-    pub font_size: Option<FontSize>,
-    pub justify: Option<Justify>,
-    pub font: Option<Option<Font>>,
-    pub y_align: Option<Align>,
-}
-
-/// Properties related to the layout of multi-line text for a single font and font size.
-#[derive(Clone, Debug)]
-pub struct Layout {
-    pub line_spacing: Scalar,
-    pub line_wrap: Option<Wrap>,
-    pub justify: Justify,
-    pub font_size: FontSize,
-    pub font: Option<Font>,
-    pub y_align: Align,
-}
-
-pub const DEFAULT_LINE_WRAP: Option<Wrap> = Some(Wrap::Whitespace);
-pub const DEFAULT_FONT_SIZE: u32 = 12;
-pub const DEFAULT_LINE_SPACING: f32 = 0.0;
-pub const DEFAULT_JUSTIFY: Justify = Justify::Center;
-pub const DEFAULT_Y_ALIGN: Align = Align::Middle;
-
-impl Builder {
-    /// The font size to use for the text.
-    pub fn font_size(mut self, size: FontSize) -> Self {
-        self.font_size = Some(size);
-        self
-    }
-
-    /// Specify whether or not text should be wrapped around some width and how to do so.
-    ///
-    /// The default value is `DEFAULT_LINE_WRAP`.
-    pub fn line_wrap(mut self, line_wrap: Option<Wrap>) -> Self {
-        self.line_wrap = Some(line_wrap);
-        self
-    }
-
-    /// Specify that the **Text** should not wrap lines around the width.
-    ///
-    /// Shorthand for `builder.line_wrap(None)`.
-    pub fn no_line_wrap(self) -> Self {
-        self.line_wrap(None)
-    }
-
-    /// Line wrap the **Text** at the beginning of the first word that exceeds the width.
-    ///
-    /// Shorthand for `builder.line_wrap(Some(Wrap::Whitespace))`.
-    pub fn wrap_by_word(self) -> Self {
-        self.line_wrap(Some(Wrap::Whitespace))
-    }
-
-    /// Line wrap the **Text** at the beginning of the first character that exceeds the width.
-    ///
-    /// Shorthand for `builder.line_wrap(Some(Wrap::Character))`.
-    pub fn wrap_by_character(self) -> Self {
-        self.line_wrap(Some(Wrap::Character))
-    }
-
-    /// A method for specifying the `Font` used for displaying the `Text`.
-    pub fn font(mut self, font: Font) -> Self {
-        self.font = Some(Some(font));
-        self
-    }
-
-    /// Describe the end along the *x* axis to which the text should be aligned.
-    pub fn justify(mut self, justify: Justify) -> Self {
-        self.justify = Some(justify);
-        self
-    }
-
-    /// Align the text to the left of its bounding **Rect**'s *x* axis range.
-    pub fn left_justify(self) -> Self {
-        self.justify(Justify::Left)
-    }
-
-    /// Align the text to the middle of its bounding **Rect**'s *x* axis range.
-    pub fn center_justify(self) -> Self {
-        self.justify(Justify::Center)
-    }
-
-    /// Align the text to the right of its bounding **Rect**'s *x* axis range.
-    pub fn right_justify(self) -> Self {
-        self.justify(Justify::Right)
-    }
-
-    /// Specify how much vertical space should separate each line of text.
-    pub fn line_spacing(mut self, spacing: Scalar) -> Self {
-        self.line_spacing = Some(spacing);
-        self
-    }
-
-    /// Specify how the whole text should be aligned along the y axis of its bounding rectangle
-    pub fn y_align(mut self, align: Align) -> Self {
-        self.y_align = Some(align);
-        self
-    }
-
-    /// Align the top edge of the text with the top edge of its bounding rectangle.
-    pub fn align_top(self) -> Self {
-        self.y_align(Align::End)
-    }
-
-    /// Align the middle of the text with the middle of the bounding rect along the y axis..
-    ///
-    /// This is the default behaviour.
-    pub fn align_middle_y(self) -> Self {
-        self.y_align(Align::Middle)
-    }
-
-    /// Align the bottom edge of the text with the bottom edge of its bounding rectangle.
-    pub fn align_bottom(self) -> Self {
-        self.y_align(Align::Start)
-    }
-
-    /// Set all the parameters via an existing `Layout`
-    pub fn layout(mut self, layout: &Layout) -> Self {
-        self.font = Some(layout.font.clone());
-        self.line_spacing(layout.line_spacing)
-            .line_wrap(layout.line_wrap)
-            .justify(layout.justify)
-            .font_size(layout.font_size)
-            .y_align(layout.y_align)
-    }
-
-    /// Build the text layout.
-    pub fn build(self) -> Layout {
-        Layout {
-            line_spacing: self.line_spacing.unwrap_or(DEFAULT_LINE_SPACING),
-            line_wrap: self.line_wrap.unwrap_or(DEFAULT_LINE_WRAP),
-            justify: self.justify.unwrap_or(DEFAULT_JUSTIFY),
-            font_size: self.font_size.unwrap_or(DEFAULT_FONT_SIZE),
-            font: self.font.unwrap_or(None),
-            y_align: self.y_align.unwrap_or(DEFAULT_Y_ALIGN),
-        }
-    }
-}
-
-impl Default for Layout {
-    fn default() -> Self {
-        Layout {
-            line_spacing: DEFAULT_LINE_SPACING,
-            line_wrap: DEFAULT_LINE_WRAP,
-            justify: DEFAULT_JUSTIFY,
-            font_size: DEFAULT_FONT_SIZE,
-            font: None,
-            y_align: DEFAULT_Y_ALIGN,
-        }
-    }
-}
diff --git a/nannou/src/text/line.rs b/nannou/src/text/line.rs
deleted file mode 100644
index 0221c72bc..000000000
--- a/nannou/src/text/line.rs
+++ /dev/null
@@ -1,807 +0,0 @@
-//! Text handling logic related to individual lines of text.
-//!
-//! This module is the core of multi-line text handling.
-
-use crate::geom::{Range, Rect};
-use crate::text::{self, FontSize, Scalar, Wrap};
-
-/// The two types of **Break** indices returned by the **WrapIndicesBy** iterators.
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub enum Break {
-    /// A break caused by the text exceeding some maximum width.
-    Wrap {
-        /// The byte index at which the break occurs.
-        byte: usize,
-        /// The char index at which the string should wrap due to exceeding a maximum width.
-        char: usize,
-        /// The byte length which should be skipped in order to reach the first non-whitespace
-        /// character to use as the beginning of the next line.
-        len_bytes: usize,
-        /// The number of chars which should be skipped in order to reach the first non-whitespace
-        /// character to use as the beginning of the next line.
-        len_chars: usize,
-    },
-    /// A break caused by a newline character.
-    Newline {
-        /// The byte index at which the string should wrap due to exceeding a maximum width.
-        byte: usize,
-        /// The char index at which the string should wrap due to exceeding a maximum width.
-        char: usize,
-        /// The width of the "newline" token in bytes.
-        len_bytes: usize,
-        /// The width of the "newline" token in chars.
-        len_chars: usize,
-    },
-    /// The end of the string has been reached, with the given length.
-    End {
-        /// The ending byte index.
-        byte: usize,
-        /// The ending char index.
-        char: usize,
-    },
-}
-
-/// The type yielded by functions dedicated to finding the next line break.
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub struct NextBreak {
-    /// The reason for the break.
-    pub break_: Break,
-    /// The total width of the line.
-    pub width: Scalar,
-    /// The maximum heigh of the line.
-    pub height: Scalar,
-}
-
-/// Information about a single line of text within a `&str`.
-///
-/// `Info` is a minimal amount of information that can be stored for efficient reasoning about
-/// blocks of text given some `&str`. The `start` and `end_break` can be used for indexing into
-/// the `&str`, and the `width` can be used for calculating line `Rect`s, alignment, etc.
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub struct Info {
-    /// The index into the `&str` that represents the first character within the line.
-    pub start_byte: usize,
-    /// The character index into the `&str` of the first character in the line.
-    pub start_char: usize,
-    /// The index within the `&str` at which this line breaks into a new line, along with the
-    /// index at which the following line begins. The variant describes whether the break is
-    /// caused by a `Newline` character or a `Wrap` by the given wrap function.
-    pub end_break: Break,
-    /// The total width of all characters within the line.
-    pub width: Scalar,
-    /// The greatest height of all characters yielded.
-    pub height: Scalar,
-}
-
-/// An iterator yielding an `Info` struct for each line in the given `text` wrapped by the
-/// given `next_break_fn`.
-///
-/// `Infos` is a fundamental part of performing lazy reasoning about text within nannou.
-///
-/// Construct an `Infos` iterator via the [infos function](./fn.infos.html) and its two builder
-/// methods, [wrap_by_character](./struct.Infos.html#method.wrap_by_character) and
-/// [wrap_by_whitespace](./struct.Infos.html#method.wrap_by_whitespace).
-pub struct Infos<'a, F> {
-    text: &'a str,
-    font: &'a text::Font,
-    font_size: FontSize,
-    max_width: Scalar,
-    next_break_fn: F,
-    /// The index that indicates the start of the next line to be yielded.
-    start_byte: usize,
-    /// The character index that indicates the start of the next line to be yielded.
-    start_char: usize,
-    /// The break type of the previously yielded line
-    last_break: Option<Break>,
-}
-
-/// An iterator yielding a `Rect` for each line in
-#[derive(Clone)]
-pub struct Rects<I> {
-    infos: I,
-    x_align: text::Justify,
-    line_spacing: Scalar,
-    last_line_top: Scalar,
-    font_size: FontSize,
-    next: Option<Rect>,
-}
-
-/// An iterator yielding a `Rect` for each selected line in a block of text.
-///
-/// The yielded `Rect`s represent the selected range within each line of text.
-///
-/// Lines that do not contain any selected text will be skipped.
-pub struct SelectedRects<'a, I> {
-    selected_char_rects_per_line: text::glyph::SelectedRectsPerLine<'a, I>,
-}
-
-/// An alias for function pointers that are compatible with the `Block`'s required text
-/// wrapping function.
-pub type NextBreakFnPtr = fn(&str, &text::Font, FontSize, Scalar) -> NextBreak;
-
-impl Break {
-    /// Return the index at which the break occurs.
-    pub fn byte_index(self) -> usize {
-        match self {
-            Break::Wrap { byte, .. } | Break::Newline { byte, .. } | Break::End { byte, .. } => {
-                byte
-            }
-        }
-    }
-
-    /// Return the index of the `char` at which the break occurs.
-    ///
-    /// To clarify, this index is to be used in relation to the `Chars` iterator.
-    pub fn char_index(self) -> usize {
-        match self {
-            Break::Wrap { char, .. } | Break::Newline { char, .. } | Break::End { char, .. } => {
-                char
-            }
-        }
-    }
-}
-
-impl<'a, F> Clone for Infos<'a, F>
-where
-    F: Clone,
-{
-    fn clone(&self) -> Self {
-        Infos {
-            text: self.text,
-            font: self.font,
-            font_size: self.font_size,
-            max_width: self.max_width,
-            next_break_fn: self.next_break_fn.clone(),
-            start_byte: self.start_byte,
-            start_char: self.start_char,
-            last_break: None,
-        }
-    }
-}
-
-impl Info {
-    /// The end of the byte index range for indexing into the slice.
-    pub fn end_byte(&self) -> usize {
-        self.end_break.byte_index()
-    }
-
-    /// The end of the index range for indexing into the slice.
-    pub fn end_char(&self) -> usize {
-        self.end_break.char_index()
-    }
-
-    /// The index range for indexing (via bytes) into the original str slice.
-    pub fn byte_range(self) -> std::ops::Range<usize> {
-        self.start_byte..self.end_byte()
-    }
-
-    /// The index range for indexing into a `char` iterator over the original str slice.
-    pub fn char_range(self) -> std::ops::Range<usize> {
-        self.start_char..self.end_char()
-    }
-}
-
-impl<'a> Infos<'a, NextBreakFnPtr> {
-    /// Converts `Self` into an `Infos` whose lines are wrapped at the character that first
-    /// causes the line width to exceed the given `max_width`.
-    pub fn wrap_by_character(mut self, max_width: Scalar) -> Self {
-        self.next_break_fn = next_break_by_character;
-        self.max_width = max_width;
-        self
-    }
-
-    /// Converts `Self` into an `Infos` whose lines are wrapped at the whitespace prior to the
-    /// character that causes the line width to exceed the given `max_width`.
-    pub fn wrap_by_whitespace(mut self, max_width: Scalar) -> Self {
-        self.next_break_fn = next_break_by_whitespace;
-        self.max_width = max_width;
-        self
-    }
-}
-
-/// A function for finding the advance width between the given character that also considers
-/// the kerning for some previous glyph.
-///
-/// This also updates the `last_glyph` with the glyph produced for the given `char`.
-///
-/// This is primarily for use within the `next_break` functions below.
-///
-/// The following code is adapted from the rusttype::LayoutIter::next src.
-fn advance_width_and_height(
-    ch: char,
-    font: &text::Font,
-    scale: text::Scale,
-    last_glyph: &mut Option<text::GlyphId>,
-) -> (Scalar, Scalar) {
-    let g = font.glyph(ch).scaled(scale);
-    let kern = last_glyph
-        .map(|last| font.pair_kerning(scale, last, g.id()))
-        .unwrap_or(0.0);
-    let advance_width = g.h_metrics().advance_width;
-    let height = g
-        .exact_bounding_box()
-        .map(|bb| bb.min.y.abs() as Scalar)
-        .unwrap_or(0.0);
-    *last_glyph = Some(g.id());
-    let adv_w = (kern + advance_width) as Scalar;
-    (adv_w, height)
-}
-
-/// Returns the next index at which the text naturally breaks via a newline character,
-/// along with the width of the line.
-fn next_break(text: &str, font: &text::Font, font_size: FontSize) -> NextBreak {
-    let scale = text::pt_to_scale(font_size);
-    let mut width = 0.0;
-    let mut height = 0.0;
-    let mut char_i = 0;
-    let mut char_indices = text.char_indices().peekable();
-    let mut last_glyph = None;
-    while let Some((byte_i, ch)) = char_indices.next() {
-        // Check for a newline.
-        if ch == '\r' {
-            if let Some(&(_, '\n')) = char_indices.peek() {
-                let break_ = Break::Newline {
-                    byte: byte_i,
-                    char: char_i,
-                    len_bytes: 2, // skip "\r\n"
-                    len_chars: 2,
-                };
-                return NextBreak {
-                    break_,
-                    width,
-                    height,
-                };
-            }
-        } else if ch == '\n' {
-            let break_ = Break::Newline {
-                byte: byte_i,
-                char: char_i,
-                len_bytes: 1, // skip "\n"
-                len_chars: 1,
-            };
-            return NextBreak {
-                break_,
-                width,
-                height,
-            };
-        }
-
-        // Update the width.
-        let (adv_w, h) = advance_width_and_height(ch, font, scale, &mut last_glyph);
-        width += adv_w;
-        height = height.max(h);
-        char_i += 1;
-    }
-    let break_ = Break::End {
-        byte: text.len(),
-        char: char_i,
-    };
-    NextBreak {
-        break_,
-        width,
-        height,
-    }
-}
-
-/// Returns the next index at which the text will break by either:
-/// - A newline character.
-/// - A line wrap at the beginning of the first character exceeding the `max_width`.
-///
-/// Also returns the width of each line alongside the Break.
-fn next_break_by_character(
-    text: &str,
-    font: &text::Font,
-    font_size: FontSize,
-    max_width: Scalar,
-) -> NextBreak {
-    let scale = text::pt_to_scale(font_size);
-    let mut width = 0.0;
-    let mut height = 0.0;
-    let mut char_i = 0;
-    let mut char_indices = text.char_indices().peekable();
-    let mut last_glyph = None;
-    while let Some((byte_i, ch)) = char_indices.next() {
-        // Check for a newline.
-        if ch == '\r' {
-            if let Some(&(_, '\n')) = char_indices.peek() {
-                let break_ = Break::Newline {
-                    byte: byte_i,
-                    char: char_i,
-                    len_bytes: 2, // skip "\r\n"
-                    len_chars: 2,
-                };
-                return NextBreak {
-                    break_,
-                    width,
-                    height,
-                };
-            }
-        } else if ch == '\n' {
-            let break_ = Break::Newline {
-                byte: byte_i,
-                char: char_i,
-                len_bytes: 1, // skip "\n"
-                len_chars: 1,
-            };
-            return NextBreak {
-                break_,
-                width,
-                height,
-            };
-        }
-
-        // Add the character's width to the width so far.
-        let (adv_w, h) = advance_width_and_height(ch, font, scale, &mut last_glyph);
-        let new_width = width + adv_w;
-
-        // Check for a line wrap.
-        if new_width > max_width {
-            let break_ = Break::Wrap {
-                byte: byte_i,
-                char: char_i,
-                len_bytes: 0, // skip nothing in middle of word
-                len_chars: 0,
-            };
-            return NextBreak {
-                break_,
-                width,
-                height,
-            };
-        }
-
-        height = height.max(h);
-        width = new_width;
-        char_i += 1;
-    }
-
-    let break_ = Break::End {
-        byte: text.len(),
-        char: char_i,
-    };
-    NextBreak {
-        break_,
-        width,
-        height,
-    }
-}
-
-/// Returns the next index at which the text will break by either:
-/// - A newline character.
-/// - A line wrap at the beginning of the whitespace that preceeds the first word
-/// exceeding the `max_width`.
-/// - A line wrap at the beginning of the first character exceeding the `max_width`,
-/// if no whitespace appears for `max_width` characters.
-///
-/// Also returns the width the line alongside the Break.
-fn next_break_by_whitespace(
-    text: &str,
-    font: &text::Font,
-    font_size: FontSize,
-    max_width: Scalar,
-) -> NextBreak {
-    struct Last {
-        byte: usize,
-        char: usize,
-        width_before: Scalar,
-    }
-    let scale = text::pt_to_scale(font_size);
-    let mut last_whitespace_start = None;
-    let mut width = 0.0;
-    let mut height = 0.0;
-    let mut char_i = 0;
-    let mut char_indices = text.char_indices().peekable();
-    let mut last_glyph = None;
-    while let Some((byte_i, ch)) = char_indices.next() {
-        // Check for a newline.
-        if ch == '\r' {
-            if let Some(&(_, '\n')) = char_indices.peek() {
-                let break_ = Break::Newline {
-                    byte: byte_i,
-                    char: char_i,
-                    len_bytes: 2, // skip "\r\n"
-                    len_chars: 2,
-                };
-                return NextBreak {
-                    break_,
-                    width,
-                    height,
-                };
-            }
-        } else if ch == '\n' {
-            let break_ = Break::Newline {
-                byte: byte_i,
-                char: char_i,
-                len_bytes: 1, // skip "\n"
-                len_chars: 1,
-            };
-            return NextBreak {
-                break_,
-                width,
-                height,
-            };
-        }
-
-        // Add the character's width to the width so far.
-        let (adv_w, h) = advance_width_and_height(ch, font, scale, &mut last_glyph);
-        let new_width = width + adv_w;
-
-        // Check for a line wrap.
-        if width > max_width {
-            match last_whitespace_start {
-                Some(Last {
-                    byte,
-                    char,
-                    width_before,
-                }) => {
-                    let break_ = Break::Wrap {
-                        byte: byte,
-                        char: char,
-                        len_bytes: 1, // skip one whitespace character
-                        len_chars: 1,
-                    };
-                    let width = width_before;
-                    return NextBreak {
-                        break_,
-                        width,
-                        height,
-                    };
-                }
-                None => {
-                    let break_ = Break::Wrap {
-                        byte: byte_i,
-                        char: char_i,
-                        len_bytes: 0, // skip nothing in middle of word
-                        len_chars: 0,
-                    };
-                    return NextBreak {
-                        break_,
-                        width,
-                        height,
-                    };
-                }
-            }
-        }
-
-        // Check for a new whitespace.
-        if ch.is_whitespace() {
-            last_whitespace_start = Some(Last {
-                byte: byte_i,
-                char: char_i,
-                width_before: width,
-            });
-        }
-
-        width = new_width;
-        height = height.max(h);
-        char_i += 1;
-    }
-
-    let break_ = Break::End {
-        byte: text.len(),
-        char: char_i,
-    };
-    NextBreak {
-        break_,
-        width,
-        height,
-    }
-}
-
-/// Produce the width of the given line of text including spaces (i.e. ' ').
-pub fn width(text: &str, font: &text::Font, font_size: FontSize) -> Scalar {
-    let scale = text::Scale::uniform(text::pt_to_px(font_size));
-    let point = text::rt::Point { x: 0.0, y: 0.0 };
-
-    let mut total_w = 0.0;
-    for g in font.layout(text, scale, point) {
-        match g.pixel_bounding_box() {
-            Some(bb) => total_w = bb.max.x as f32,
-            None => total_w += g.unpositioned().h_metrics().advance_width,
-        }
-    }
-
-    total_w as Scalar
-}
-
-/// Produce an `Infos` iterator wrapped by the given `next_break_fn`.
-pub fn infos_wrapped_by<'a, F>(
-    text: &'a str,
-    font: &'a text::Font,
-    font_size: FontSize,
-    max_width: Scalar,
-    next_break_fn: F,
-) -> Infos<'a, F>
-where
-    F: for<'b> FnMut(&'b str, &'b text::Font, FontSize, Scalar) -> NextBreak,
-{
-    Infos {
-        text: text,
-        font: font,
-        font_size: font_size,
-        max_width: max_width,
-        next_break_fn: next_break_fn,
-        start_byte: 0,
-        start_char: 0,
-        last_break: None,
-    }
-}
-
-/// Produce an `Infos` iterator that yields an `Info` for every line in the given text.
-///
-/// The produced `Infos` iterator will not wrap the text, and only break each line via newline
-/// characters within the text (either `\n` or `\r\n`).
-pub fn infos<'a>(
-    text: &'a str,
-    font: &'a text::Font,
-    font_size: FontSize,
-) -> Infos<'a, NextBreakFnPtr> {
-    fn no_wrap(
-        text: &str,
-        font: &text::Font,
-        font_size: FontSize,
-        _max_width: Scalar,
-    ) -> NextBreak {
-        next_break(text, font, font_size)
-    }
-
-    infos_wrapped_by(text, font, font_size, std::f32::MAX, no_wrap)
-}
-
-/// Simplify the retrieval of line information for text that may or may not be wrapped.
-pub fn infos_maybe_wrapped<'a>(
-    text: &'a str,
-    font: &'a text::Font,
-    font_size: FontSize,
-    maybe_wrap: Option<Wrap>,
-    max_width: Scalar,
-) -> Infos<'a, NextBreakFnPtr> {
-    match maybe_wrap {
-        None => infos(text, font, font_size),
-        Some(Wrap::Character) => infos(text, font, font_size).wrap_by_character(max_width),
-        Some(Wrap::Whitespace) => infos(text, font, font_size).wrap_by_whitespace(max_width),
-    }
-}
-
-/// Produce an iterator yielding the bounding `Rect` for each line in the text.
-///
-/// Yielded `Rect`s will begin with the top-left of the first line at a [0.0, 0.0].
-///
-/// This function assumes that `font_size` and `max_width` are the same as those used to produce
-/// the `Info`s yielded by the `infos` Iterator.
-pub fn rects<I>(
-    mut infos: I,
-    font_size: FontSize,
-    max_width: Scalar,
-    x_align: text::Justify,
-    line_spacing: Scalar,
-) -> Rects<I>
-where
-    I: Iterator<Item = Info>,
-{
-    let first_rect = infos.next().map(|first_info| {
-        // Calculate the `x` `Range` of the first line `Rect`.
-        let x_bounds = Range::new(0.0, max_width);
-        let range = Range::new(0.0, first_info.width);
-        let x = match x_align {
-            text::Justify::Left => range.align_start_of(x_bounds),
-            text::Justify::Center => range.align_middle_of(x_bounds),
-            text::Justify::Right => range.align_end_of(x_bounds),
-        };
-        let y_start = -(font_size as Scalar);
-        //let y_end = y_start + first_info.height;
-        let y_end = y_start + font_size as Scalar;
-        let y = Range::new(y_start, y_end);
-        Rect { x: x, y: y }
-    });
-    Rects {
-        infos: infos,
-        next: first_rect,
-        x_align: x_align,
-        last_line_top: 0.0,
-        font_size: font_size,
-        line_spacing: line_spacing,
-    }
-}
-
-/// Produces an iterator yielding a `Rect` for the selected range in each selected line in a block
-/// of text.
-///
-/// The yielded `Rect`s represent the selected range within each line of text.
-///
-/// Lines that do not contain any selected text will be skipped.
-pub fn selected_rects<'a, I>(
-    lines_with_rects: I,
-    font: &'a text::Font,
-    font_size: FontSize,
-    start: text::cursor::Index,
-    end: text::cursor::Index,
-) -> SelectedRects<'a, I>
-where
-    I: Iterator<Item = (&'a str, Rect)>,
-{
-    SelectedRects {
-        selected_char_rects_per_line: text::glyph::selected_rects_per_line(
-            lines_with_rects,
-            font,
-            font_size,
-            start,
-            end,
-        ),
-    }
-}
-
-impl<'a, F> Iterator for Infos<'a, F>
-where
-    F: for<'b> FnMut(&'b str, &'b text::Font, FontSize, Scalar) -> NextBreak,
-{
-    type Item = Info;
-    fn next(&mut self) -> Option<Self::Item> {
-        let Infos {
-            text,
-            font,
-            font_size,
-            max_width,
-            ref mut next_break_fn,
-            ref mut start_byte,
-            ref mut start_char,
-            ref mut last_break,
-        } = *self;
-
-        let next = next_break_fn(&text[*start_byte..], font, font_size, max_width);
-        match next.break_ {
-            Break::Newline { .. } | Break::Wrap { .. } => {
-                let next_break = match next.break_ {
-                    Break::Newline {
-                        byte,
-                        char,
-                        len_bytes,
-                        len_chars,
-                    } => Break::Newline {
-                        byte: *start_byte + byte,
-                        char: *start_char + char,
-                        len_bytes: len_bytes,
-                        len_chars: len_chars,
-                    },
-                    Break::Wrap {
-                        byte,
-                        char,
-                        len_bytes,
-                        len_chars,
-                    } => Break::Wrap {
-                        byte: *start_byte + byte,
-                        char: *start_char + char,
-                        len_bytes: len_bytes,
-                        len_chars: len_chars,
-                    },
-                    _ => unreachable!(),
-                };
-
-                let info = Info {
-                    start_byte: *start_byte,
-                    start_char: *start_char,
-                    end_break: next_break,
-                    width: next.width,
-                    height: next.height,
-                };
-
-                match next.break_ {
-                    Break::Newline {
-                        byte,
-                        char,
-                        len_bytes,
-                        len_chars,
-                    }
-                    | Break::Wrap {
-                        byte,
-                        char,
-                        len_bytes,
-                        len_chars,
-                    } => {
-                        // skip over end-of-break " ", "\n", or "\r\n"
-                        *start_byte = info.start_byte + byte + len_bytes;
-                        *start_char = info.start_char + char + len_chars;
-                    }
-                    _ => unreachable!(),
-                };
-                *last_break = Some(next_break);
-                Some(info)
-            }
-
-            Break::End { char, .. } => {
-                // if the last line ends in a new line, or the entire text is empty, return an
-                // empty line Info.
-                let empty_line = {
-                    match *last_break {
-                        Some(last_break_) => match last_break_ {
-                            Break::Newline { .. } => true,
-                            _ => false,
-                        },
-                        None => true,
-                    }
-                };
-                if *start_byte < text.len() || empty_line {
-                    let total_bytes = text.len();
-                    let total_chars = *start_char + char;
-                    let end_break = Break::End {
-                        byte: total_bytes,
-                        char: total_chars,
-                    };
-                    let info = Info {
-                        start_byte: *start_byte,
-                        start_char: *start_char,
-                        end_break: end_break,
-                        width: next.width,
-                        height: next.height,
-                    };
-                    *start_byte = total_bytes;
-                    *start_char = total_chars;
-                    *last_break = Some(end_break);
-                    Some(info)
-                } else {
-                    None
-                }
-            }
-        }
-    }
-}
-
-impl<I> Iterator for Rects<I>
-where
-    I: Iterator<Item = Info>,
-{
-    type Item = Rect;
-    fn next(&mut self) -> Option<Self::Item> {
-        let Rects {
-            ref mut next,
-            ref mut infos,
-            x_align,
-            ref mut last_line_top,
-            font_size,
-            line_spacing,
-        } = *self;
-        next.map(|line_rect| {
-            *next = infos.next().map(|info| {
-                let y = {
-                    let line_top = *last_line_top - font_size as Scalar - line_spacing;
-                    *last_line_top = line_top;
-                    let y_start = line_top - font_size as Scalar;
-                    //let y_end = y_start + info.height;
-                    let y_end = y_start + font_size as Scalar;
-                    Range::new(y_start, y_end)
-                };
-
-                let x = {
-                    let range = Range::new(0.0, info.width);
-                    match x_align {
-                        text::Justify::Left => range.align_start_of(line_rect.x),
-                        text::Justify::Center => range.align_middle_of(line_rect.x),
-                        text::Justify::Right => range.align_end_of(line_rect.x),
-                    }
-                };
-
-                Rect { x: x, y: y }
-            });
-
-            line_rect
-        })
-    }
-}
-
-impl<'a, I> Iterator for SelectedRects<'a, I>
-where
-    I: Iterator<Item = (&'a str, Rect)>,
-{
-    type Item = Rect;
-    fn next(&mut self) -> Option<Self::Item> {
-        while let Some(mut rects) = self.selected_char_rects_per_line.next() {
-            if let Some((_, first_rect)) = rects.next() {
-                let total_selected_rect = rects.fold(first_rect, |mut total, (_, next)| {
-                    total.x.end = next.x.end;
-                    total
-                });
-                return Some(total_selected_rect);
-            }
-        }
-        None
-    }
-}
diff --git a/nannou/src/text/mod.rs b/nannou/src/text/mod.rs
deleted file mode 100644
index fceb6e6fa..000000000
--- a/nannou/src/text/mod.rs
+++ /dev/null
@@ -1,679 +0,0 @@
-//! Text layout logic.
-//!
-//! Currently, this crate is used primarily by the `draw.text()` API but will also play an
-//! important role in future GUI work.
-
-pub mod cursor;
-pub mod font;
-pub mod glyph;
-pub mod layout;
-pub mod line;
-pub mod rt {
-    //! Re-exported RustType geometric types.
-    pub use rusttype::{gpu_cache, point, vector, Point, Rect, Vector};
-}
-
-// Re-export all relevant rusttype types here.
-pub use self::layout::Layout;
-pub use rusttype::gpu_cache::Cache as GlyphCache;
-pub use rusttype::{Glyph, GlyphId, GlyphIter, LayoutIter, Scale, ScaledGlyph};
-
-use crate::geom;
-use crate::glam::Vec2;
-use std::borrow::Cow;
-
-/// The RustType `FontCollection` type used by nannou.
-pub type FontCollection = rusttype::FontCollection<'static>;
-/// The RustType `Font` type used by nannou.
-pub type Font = rusttype::Font<'static>;
-/// The RustType `PositionedGlyph` type used by nannou.
-pub type PositionedGlyph = rusttype::PositionedGlyph<'static>;
-
-/// The type used for scalar values.
-pub type Scalar = crate::geom::scalar::Default;
-
-/// The point type used when working with text.
-pub type Point = crate::geom::Point2;
-
-/// The type used to specify `FontSize` in font points.
-pub type FontSize = u32;
-
-/// A context for building some **Text**.
-pub struct Builder<'a> {
-    text: Cow<'a, str>,
-    layout_builder: layout::Builder,
-}
-
-/// An instance of some multi-line text and its layout.
-#[derive(Clone)]
-pub struct Text<'a> {
-    text: Cow<'a, str>,
-    font: Font,
-    layout: Layout,
-    line_infos: Vec<line::Info>,
-    rect: geom::Rect,
-}
-
-/// An iterator yielding each line within the given `text` as a new `&str`, where the start and end
-/// indices into each line are provided by the given iterator.
-#[derive(Clone)]
-pub struct Lines<'a, I> {
-    text: &'a str,
-    ranges: I,
-}
-
-/// An alias for the line info iterator yielded by `Text::line_infos`.
-pub type TextLineInfos<'a> = line::Infos<'a, line::NextBreakFnPtr>;
-
-/// An alias for the line iterator yielded by `Text::lines`.
-pub type TextLines<'a> = Lines<
-    'a,
-    std::iter::Map<std::slice::Iter<'a, line::Info>, fn(&line::Info) -> std::ops::Range<usize>>,
->;
-
-/// An alias for the line rect iterator used internally within the `Text::line_rects` iterator.
-type LineRects<'a> = line::Rects<std::iter::Cloned<std::slice::Iter<'a, line::Info>>>;
-
-/// An alias for the line rect iterator yielded by `Text::line_rects`.
-#[derive(Clone)]
-pub struct TextLineRects<'a> {
-    line_rects: LineRects<'a>,
-    offset: Vec2,
-}
-
-/// An alias for the iterator yielded by `Text::lines_with_rects`.
-pub type TextLinesWithRects<'a> = std::iter::Zip<TextLines<'a>, TextLineRects<'a>>;
-
-/// An alias for the iterator yielded by `Text::glyphs_per_line`.
-pub type TextGlyphsPerLine<'a> = glyph::RectsPerLine<'a, TextLinesWithRects<'a>>;
-
-/// An alias for the iterator yielded by `Text::glyphs`.
-pub type TextGlyphs<'a> = std::iter::FlatMap<
-    TextGlyphsPerLine<'a>,
-    glyph::Rects<'a, 'a>,
-    fn(glyph::Rects<'a, 'a>) -> glyph::Rects<'a, 'a>,
->;
-
-/// Alignment along an axis.
-#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq, PartialOrd, Ord)]
-pub enum Align {
-    Start,
-    Middle,
-    End,
-}
-
-/// A type used for referring to typographic alignment of `Text`.
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub enum Justify {
-    /// Align text to the start of the bounding `Rect`'s *x* axis.
-    Left,
-    /// Symmetrically align text along the *y* axis.
-    Center,
-    /// Align text to the end of the bounding `Rect`'s *x* axis.
-    Right,
-    // /// Align wrapped text to both the start and end of the bounding `Rect`s *x* axis.
-    // ///
-    // /// Extra space is added between words in order to achieve this alignment.
-    // TODO: Full,
-}
-
-/// The way in which text should wrap around the width.
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub enum Wrap {
-    /// Wrap at the first character that exceeds the width.
-    Character,
-    /// Wrap at the first word that exceeds the width.
-    Whitespace,
-}
-
-impl<'a> From<Cow<'a, str>> for Builder<'a> {
-    fn from(text: Cow<'a, str>) -> Self {
-        let layout_builder = Default::default();
-        Builder {
-            text,
-            layout_builder,
-        }
-    }
-}
-
-impl<'a> From<&'a str> for Builder<'a> {
-    fn from(s: &'a str) -> Self {
-        let text = Cow::Borrowed(s);
-        Self::from(text)
-    }
-}
-
-impl From<String> for Builder<'static> {
-    fn from(s: String) -> Self {
-        let text = Cow::Owned(s);
-        Self::from(text)
-    }
-}
-
-impl<'a> Builder<'a> {
-    /// Apply the given function to the inner text layout.
-    fn map_layout<F>(mut self, map: F) -> Self
-    where
-        F: FnOnce(layout::Builder) -> layout::Builder,
-    {
-        self.layout_builder = map(self.layout_builder);
-        self
-    }
-
-    /// The font size to use for the text.
-    pub fn font_size(self, size: FontSize) -> Self {
-        self.map_layout(|l| l.font_size(size))
-    }
-
-    /// Specify whether or not text should be wrapped around some width and how to do so.
-    ///
-    /// The default value is `DEFAULT_LINE_WRAP`.
-    pub fn line_wrap(self, line_wrap: Option<Wrap>) -> Self {
-        self.map_layout(|l| l.line_wrap(line_wrap))
-    }
-
-    /// Specify that the **Text** should not wrap lines around the width.
-    ///
-    /// Shorthand for `builder.line_wrap(None)`.
-    pub fn no_line_wrap(self) -> Self {
-        self.map_layout(|l| l.no_line_wrap())
-    }
-
-    /// Line wrap the **Text** at the beginning of the first word that exceeds the width.
-    ///
-    /// Shorthand for `builder.line_wrap(Some(Wrap::Whitespace))`.
-    pub fn wrap_by_word(self) -> Self {
-        self.map_layout(|l| l.wrap_by_word())
-    }
-
-    /// Line wrap the **Text** at the beginning of the first character that exceeds the width.
-    ///
-    /// Shorthand for `builder.line_wrap(Some(Wrap::Character))`.
-    pub fn wrap_by_character(self) -> Self {
-        self.map_layout(|l| l.wrap_by_character())
-    }
-
-    /// A method for specifying the `Font` used for displaying the `Text`.
-    pub fn font(self, font: Font) -> Self {
-        self.map_layout(|l| l.font(font))
-    }
-
-    /// Describe the end along the *x* axis to which the text should be aligned.
-    pub fn justify(self, justify: Justify) -> Self {
-        self.map_layout(|l| l.justify(justify))
-    }
-
-    /// Align the text to the left of its bounding **Rect**'s *x* axis range.
-    pub fn left_justify(self) -> Self {
-        self.map_layout(|l| l.left_justify())
-    }
-
-    /// Align the text to the middle of its bounding **Rect**'s *x* axis range.
-    pub fn center_justify(self) -> Self {
-        self.map_layout(|l| l.center_justify())
-    }
-
-    /// Align the text to the right of its bounding **Rect**'s *x* axis range.
-    pub fn right_justify(self) -> Self {
-        self.map_layout(|l| l.right_justify())
-    }
-
-    /// Specify how much vertical space should separate each line of text.
-    pub fn line_spacing(self, spacing: Scalar) -> Self {
-        self.map_layout(|l| l.line_spacing(spacing))
-    }
-
-    /// Specify how the whole text should be aligned along the y axis of its bounding rectangle
-    pub fn y_align(self, align: Align) -> Self {
-        self.map_layout(|l| l.y_align(align))
-    }
-
-    /// Align the top edge of the text with the top edge of its bounding rectangle.
-    pub fn align_top(self) -> Self {
-        self.map_layout(|l| l.align_top())
-    }
-
-    /// Align the middle of the text with the middle of the bounding rect along the y axis..
-    ///
-    /// This is the default behaviour.
-    pub fn align_middle_y(self) -> Self {
-        self.map_layout(|l| l.align_middle_y())
-    }
-
-    /// Align the bottom edge of the text with the bottom edge of its bounding rectangle.
-    pub fn align_bottom(self) -> Self {
-        self.map_layout(|l| l.align_bottom())
-    }
-
-    /// Set all the parameters via an existing `Layout`
-    pub fn layout(self, layout: &Layout) -> Self {
-        self.map_layout(|l| l.layout(layout))
-    }
-
-    /// Build the text.
-    ///
-    /// This iterates over the text in order to pre-calculates the text's multi-line information
-    /// using the `line::infos` function.
-    ///
-    /// The given `rect` will be used for applying the layout including text alignment, positioning
-    /// of text, multi-line wrapping, etc,
-    pub fn build(self, rect: geom::Rect) -> Text<'a> {
-        let text = self.text;
-        let layout = self.layout_builder.build();
-        #[allow(unreachable_code)]
-        let font = layout.font.clone().unwrap_or_else(|| {
-            #[cfg(feature = "notosans")]
-            {
-                return font::default_notosans();
-            }
-            let assets = crate::app::find_assets_path()
-                .expect("failed to detect the assets directory when searching for a default font");
-            font::default(&assets).expect("failed to detect a default font")
-        });
-        let max_width = rect.w();
-        let line_infos =
-            line::infos_maybe_wrapped(&text, &font, layout.font_size, layout.line_wrap, max_width)
-                .collect();
-        Text {
-            text,
-            font,
-            layout,
-            line_infos,
-            rect,
-        }
-    }
-}
-
-impl<'a> Text<'a> {
-    /// Produce an iterator yielding information about each line.
-    pub fn line_infos(&self) -> &[line::Info] {
-        &self.line_infos
-    }
-
-    /// The full string of text as a slice.
-    pub fn text(&self) -> &str {
-        &self.text
-    }
-
-    /// The layout parameters for this text instance.
-    pub fn layout(&self) -> &Layout {
-        &self.layout
-    }
-
-    /// The font used for this text instance.
-    pub fn font(&self) -> &Font {
-        &self.font
-    }
-
-    /// The number of lines in the text.
-    pub fn num_lines(&self) -> usize {
-        self.line_infos.len()
-    }
-
-    /// The rectangle used to layout and build the text instance.
-    ///
-    /// This is the same `Rect` that was passed to the `text::Builder::build` method.
-    pub fn layout_rect(&self) -> geom::Rect {
-        self.rect
-    }
-
-    /// The rectangle that describes the min and max bounds along each axis reached by the text.
-    pub fn bounding_rect(&self) -> geom::Rect {
-        let mut r = self.bounding_rect_by_lines();
-        let info = match self.line_infos.first() {
-            None => return geom::Rect::from_w_h(0.0, 0.0),
-            Some(info) => info,
-        };
-        let line_h = self.layout.font_size as Scalar;
-        r.y.end -= line_h - info.height;
-        r
-    }
-
-    /// The rectangle that describes the min and max bounds along each axis reached by the text.
-    ///
-    /// This is similar to `bounding_rect` but assumes that all lines have a height equal to
-    /// `font_size`, rather than using the exact height.
-    pub fn bounding_rect_by_lines(&self) -> geom::Rect {
-        let mut lrs = self.line_rects();
-        let lr = match lrs.next() {
-            None => return geom::Rect::from_w_h(0.0, 0.0),
-            Some(lr) => lr,
-        };
-        lrs.fold(lr, |acc, lr| {
-            let x = geom::Range::new(acc.x.start.min(lr.x.start), acc.x.end.max(lr.x.end));
-            let y = geom::Range::new(acc.y.start.min(lr.y.start), acc.y.end.max(lr.y.end));
-            geom::Rect { x, y }
-        })
-    }
-
-    /// The width of the widest line of text.
-    pub fn width(&self) -> Scalar {
-        self.line_infos
-            .iter()
-            .fold(0.0, |max, info| max.max(info.width))
-    }
-
-    /// The exact height of the full text accounting for font size and line spacing..
-    pub fn height(&self) -> Scalar {
-        let info = match self.line_infos.first() {
-            None => return 0.0,
-            Some(info) => info,
-        };
-        exact_height(
-            info.height,
-            self.num_lines(),
-            self.layout.font_size,
-            self.layout.line_spacing,
-        )
-    }
-
-    /// Determine the total height of a block of text with the given number of lines, font size and
-    /// `line_spacing` (the space that separates each line of text).
-    ///
-    /// The height of all lines of text are assumed to match the `font_size`. If looking for the exact
-    /// height, see the `exact_height` function.
-    pub fn height_by_lines(&self) -> Scalar {
-        height_by_lines(
-            self.num_lines(),
-            self.layout.font_size,
-            self.layout.line_spacing,
-        )
-    }
-
-    /// Produce an iterator yielding each wrapped line within the **Text**.
-    pub fn lines(&self) -> TextLines {
-        fn info_byte_range(info: &line::Info) -> std::ops::Range<usize> {
-            info.byte_range()
-        }
-        lines(&self.text, self.line_infos.iter().map(info_byte_range))
-    }
-
-    /// The bounding rectangle for each line.
-    pub fn line_rects(&self) -> TextLineRects {
-        let offset = self.position_offset();
-        let line_rects = line::rects(
-            self.line_infos.iter().cloned(),
-            self.layout.font_size,
-            self.rect.w(),
-            self.layout.justify,
-            self.layout.line_spacing,
-        );
-        TextLineRects { line_rects, offset }
-    }
-
-    /// Produce an iterator yielding all lines of text alongside their bounding rects.
-    pub fn lines_with_rects(&self) -> TextLinesWithRects {
-        self.lines().zip(self.line_rects())
-    }
-
-    /// Produce an iterator yielding iterators yielding every glyph alongside its bounding rect for
-    /// each line.
-    pub fn glyphs_per_line(&self) -> TextGlyphsPerLine {
-        glyph::rects_per_line(self.lines_with_rects(), &self.font, self.layout.font_size)
-    }
-
-    /// Produce an iterator yielding every glyph alongside its bounding rect.
-    ///
-    /// This is the "flattened" version of the `glyphs_per_line` method.
-    pub fn glyphs(&self) -> TextGlyphs {
-        self.glyphs_per_line().flat_map(std::convert::identity)
-    }
-
-    /// Produce an iterator yielding the path events for every glyph in every line.
-    pub fn path_events<'b>(&'b self) -> impl 'b + Iterator<Item = lyon::path::PathEvent> {
-        use lyon::path::PathEvent;
-
-        // Translate the given lyon point by the given vector.
-        fn trans_lyon_point(p: &lyon::math::Point, v: Vec2) -> lyon::math::Point {
-            lyon::math::point(p.x + v.x, p.y + v.y)
-        }
-
-        // Translate the given path event in 2D space.
-        fn trans_path_event(e: &PathEvent, v: Vec2) -> PathEvent {
-            match *e {
-                PathEvent::Begin { ref at } => PathEvent::Begin {
-                    at: trans_lyon_point(at, v),
-                },
-                PathEvent::Line { ref from, ref to } => PathEvent::Line {
-                    from: trans_lyon_point(from, v),
-                    to: trans_lyon_point(to, v),
-                },
-                PathEvent::Quadratic {
-                    ref from,
-                    ref ctrl,
-                    ref to,
-                } => PathEvent::Quadratic {
-                    from: trans_lyon_point(from, v),
-                    ctrl: trans_lyon_point(ctrl, v),
-                    to: trans_lyon_point(to, v),
-                },
-                PathEvent::Cubic {
-                    ref from,
-                    ref ctrl1,
-                    ref ctrl2,
-                    ref to,
-                } => PathEvent::Cubic {
-                    from: trans_lyon_point(from, v),
-                    ctrl1: trans_lyon_point(ctrl1, v),
-                    ctrl2: trans_lyon_point(ctrl2, v),
-                    to: trans_lyon_point(to, v),
-                },
-                PathEvent::End {
-                    ref last,
-                    ref first,
-                    ref close,
-                } => PathEvent::End {
-                    last: trans_lyon_point(last, v),
-                    first: trans_lyon_point(first, v),
-                    close: *close,
-                },
-            }
-        }
-
-        self.glyphs().flat_map(|(g, r)| {
-            glyph::path_events(g)
-                .into_iter()
-                .flat_map(|es| es)
-                .map(move |e| trans_path_event(&e, r.bottom_left().into()))
-        })
-    }
-
-    /// Produce an iterator yielding positioned rusttype glyphs ready for caching.
-    ///
-    /// The window dimensions (in logical space) and scale_factor are required to transform glyph
-    /// positions into rusttype's pixel-space, ready for caching into the rusttype glyph cache
-    /// pixel buffer.
-    pub fn rt_glyphs<'b: 'a>(
-        &'b self,
-        window_size: Vec2,
-        scale_factor: Scalar,
-    ) -> impl 'a + 'b + Iterator<Item = PositionedGlyph> {
-        rt_positioned_glyphs(
-            self.lines_with_rects(),
-            &self.font,
-            self.layout.font_size,
-            window_size,
-            scale_factor,
-        )
-    }
-
-    /// Converts this `Text` instance into an instance that owns the inner text string.
-    pub fn into_owned(self) -> Text<'static> {
-        let Text {
-            text,
-            font,
-            layout,
-            line_infos,
-            rect,
-        } = self;
-        let text = Cow::Owned(text.into_owned());
-        Text {
-            text,
-            font,
-            layout,
-            line_infos,
-            rect,
-        }
-    }
-
-    fn position_offset(&self) -> Vec2 {
-        position_offset(
-            self.num_lines(),
-            self.layout.font_size,
-            self.layout.line_spacing,
-            self.rect,
-            self.layout.y_align,
-        )
-    }
-}
-
-impl<'a, I> Iterator for Lines<'a, I>
-where
-    I: Iterator<Item = std::ops::Range<usize>>,
-{
-    type Item = &'a str;
-    fn next(&mut self) -> Option<Self::Item> {
-        let Lines {
-            text,
-            ref mut ranges,
-        } = *self;
-        ranges.next().map(|range| &text[range])
-    }
-}
-
-impl<'a> Iterator for TextLineRects<'a> {
-    type Item = geom::Rect;
-    fn next(&mut self) -> Option<Self::Item> {
-        self.line_rects.next().map(|r| r.shift(self.offset.into()))
-    }
-}
-
-/// Determine the total height of a block of text with the given number of lines, font size and
-/// `line_spacing` (the space that separates each line of text).
-///
-/// The height of all lines of text are assumed to match the `font_size`. If looking for the exact
-/// height, see the `exact_height` function.
-pub fn height_by_lines(num_lines: usize, font_size: FontSize, line_spacing: Scalar) -> Scalar {
-    if num_lines > 0 {
-        num_lines as Scalar * font_size as Scalar + (num_lines - 1) as Scalar * line_spacing
-    } else {
-        0.0
-    }
-}
-
-/// Determine the exact height of a block of text.
-///
-/// The `first_line_height` can be retrieved via its `line::Info` which can be retrieved via the
-/// first element of a `line_infos` iterator.
-pub fn exact_height(
-    first_line_height: Scalar,
-    num_lines: usize,
-    font_size: FontSize,
-    line_spacing: Scalar,
-) -> Scalar {
-    if num_lines > 0 {
-        let lt_num_lines = num_lines - 1;
-        let other_lines_height = lt_num_lines as Scalar * font_size as Scalar;
-        let space_height = lt_num_lines as Scalar * line_spacing;
-        first_line_height + other_lines_height + space_height
-    } else {
-        0.0
-    }
-}
-
-/// Produce an iterator yielding each line within the given `text` as a new `&str`, where the
-/// start and end indices into each line are provided by the given iterator.
-pub fn lines<I>(text: &str, ranges: I) -> Lines<I>
-where
-    I: Iterator<Item = std::ops::Range<usize>>,
-{
-    Lines {
-        text: text,
-        ranges: ranges,
-    }
-}
-
-/// The position offset required to shift the associated text into the given bounding rectangle.
-///
-/// This function assumes the `max_width` used to produce the `line_infos` is equal to the given
-/// `bounding_rect` max width.
-pub fn position_offset(
-    num_lines: usize,
-    font_size: FontSize,
-    line_spacing: f32,
-    bounding_rect: geom::Rect,
-    y_align: Align,
-) -> Vec2 {
-    let x_offset = bounding_rect.x.start;
-    let y_offset = {
-        // Calculate the `y` `Range` of the first line `Rect`.
-        let total_text_height = height_by_lines(num_lines, font_size, line_spacing);
-        let total_text_y_range = geom::Range::new(0.0, total_text_height);
-        let total_text_y = match y_align {
-            Align::Start => total_text_y_range.align_start_of(bounding_rect.y),
-            Align::Middle => total_text_y_range.align_middle_of(bounding_rect.y),
-            Align::End => total_text_y_range.align_end_of(bounding_rect.y),
-        };
-        total_text_y.end
-    };
-    geom::vec2(x_offset, y_offset)
-}
-
-/// Produce the position of each glyph ready for the rusttype glyph cache.
-///
-/// Window dimensions are expected in logical coordinates.
-pub fn rt_positioned_glyphs<'a, I>(
-    lines_with_rects: I,
-    font: &'a Font,
-    font_size: FontSize,
-    window_size: Vec2,
-    scale_factor: Scalar,
-) -> impl 'a + Iterator<Item = PositionedGlyph>
-where
-    I: IntoIterator<Item = (&'a str, geom::Rect)>,
-    I::IntoIter: 'a,
-{
-    // Functions for converting nannou coordinates to rusttype pixel coordinates.
-    let trans_x = move |x: Scalar| (x + window_size.x / 2.0) * scale_factor as Scalar;
-    let trans_y = move |y: Scalar| ((-y) + window_size.y / 2.0) * scale_factor as Scalar;
-
-    // Clear the existing glyphs and fill the buffer with glyphs for this Text.
-    let scale = f32_pt_to_scale(font_size as f32 * scale_factor);
-    lines_with_rects
-        .into_iter()
-        .flat_map(move |(line, line_rect)| {
-            let (x, y) = (
-                trans_x(line_rect.left()) as f32,
-                trans_y(line_rect.bottom()) as f32,
-            );
-            let point = rt::Point { x: x, y: y };
-            font.layout(line, scale, point).map(|g| g.standalone())
-        })
-}
-
-/// Converts the given font size in "points" to its font size in pixels.
-/// This is useful for when the font size is not an integer.
-pub fn f32_pt_to_px(font_size_in_points: f32) -> f32 {
-    font_size_in_points * 4.0 / 3.0
-}
-
-/// Converts the given font size in "points" to a uniform `rusttype::Scale`.
-/// This is useful for when the font size is not an integer.
-pub fn f32_pt_to_scale(font_size_in_points: f32) -> Scale {
-    Scale::uniform(f32_pt_to_px(font_size_in_points))
-}
-
-/// Converts the given font size in "points" to its font size in pixels.
-pub fn pt_to_px(font_size_in_points: FontSize) -> f32 {
-    f32_pt_to_px(font_size_in_points as f32)
-}
-
-/// Converts the given font size in "points" to a uniform `rusttype::Scale`.
-pub fn pt_to_scale(font_size_in_points: FontSize) -> Scale {
-    Scale::uniform(pt_to_px(font_size_in_points))
-}
-
-/// Begin building a **Text** instance.
-pub fn text(s: &str) -> Builder {
-    Builder::from(s)
-}
diff --git a/nannou/src/window.rs b/nannou/src/window.rs
index be1695c4a..761de6d85 100644
--- a/nannou/src/window.rs
+++ b/nannou/src/window.rs
@@ -3,118 +3,184 @@
 //! Create a new window via `app.new_window()`. This produces a [**Builder**](./struct.Builder.html)
 //! which can be used to build a [**Window**](./struct.Window.html).
 
-use crate::color::IntoLinSrgba;
-use crate::event::{
-    Key, MouseButton, MouseScrollDelta, TouchEvent, TouchPhase, TouchpadPressure, WindowEvent,
-};
-use crate::frame::{self, Frame, RawFrame};
-use crate::geom;
+use std::cell::RefMut;
+use std::fmt;
+use std::path::{Path, PathBuf};
+
+use bevy::input::mouse::MouseWheel;
+use bevy::prelude::*;
+use bevy::render::camera::RenderTarget;
+use bevy::render::view::screenshot::ScreenshotManager;
+use bevy::render::view::RenderLayers;
+use bevy::window::{Cursor, CursorGrabMode, PrimaryWindow, WindowLevel, WindowMode, WindowRef};
+
+use bevy_nannou::prelude::render::NannouCamera;
+use bevy_nannou::prelude::MonitorSelection;
+use nannou_core::geom;
+
 use crate::geom::Point2;
 use crate::glam::Vec2;
-use crate::wgpu;
+use crate::prelude::WindowResizeConstraints;
 use crate::App;
-use std::any::Any;
-use std::path::{Path, PathBuf};
-use std::sync::Arc;
-use std::time::Duration;
-use std::{env, fmt};
-use wgpu_upstream::CompositeAlphaMode;
-use winit::dpi::{LogicalSize, PhysicalSize};
-#[cfg(target_os = "macos")]
-use winit::platform::macos::WindowBuilderExtMacOS;
-
-pub use winit::window::Fullscreen;
-pub use winit::window::WindowId as Id;
-use winit::window::{CursorGrabMode, WindowLevel};
-
-/// The default dimensions used for a window in the case that none are specified.
-pub const DEFAULT_DIMENSIONS: LogicalSize<geom::scalar::Default> = LogicalSize {
-    width: 1024.0,
-    height: 768.0,
-};
-
-/// The default minimum dimensions used for the surface
-pub const MIN_SC_PIXELS: PhysicalSize<u32> = PhysicalSize {
-    width: 2,
-    height: 2,
-};
+
+/// A nannou window.
+///
+/// The **Window** acts as a wrapper around the `winit::window::Window` and the `wgpu::Surface`
+/// types.
+pub struct Window<'a, 'w> {
+    entity: Entity,
+    app: &'a App<'w>,
+}
 
 /// A context for building a window.
-pub struct Builder<'app> {
-    app: &'app App,
-    window: winit::window::WindowBuilder,
+pub struct Builder<'a, 'w, M = ()> {
+    app: &'a App<'w>,
+    window: bevy::window::Window,
+    // TODO: make cameras and lights an array
+    camera: Option<Entity>,
+    light: Option<Entity>,
+    primary: bool,
     title_was_set: bool,
-    surface_conf_builder: SurfaceConfigurationBuilder,
-    power_preference: wgpu::PowerPreference,
-    force_fallback_adapter: bool,
-    device_desc: Option<wgpu::DeviceDescriptor<'static>>,
-    user_functions: UserFunctions,
-    msaa_samples: Option<u32>,
-    max_capture_frame_jobs: u32,
-    capture_frame_timeout: Option<Duration>,
-    clear_color: Option<wgpu::Color>,
+    user_functions: UserFunctions<M>,
+    clear_color: Option<Color>,
+    hdr: bool,
 }
 
 /// For storing all user functions within the window.
-#[derive(Debug, Default)]
-pub(crate) struct UserFunctions {
-    pub(crate) view: Option<View>,
-    pub(crate) event: Option<EventFnAny>,
-    pub(crate) raw_event: Option<RawEventFnAny>,
-    pub(crate) key_pressed: Option<KeyPressedFnAny>,
-    pub(crate) key_released: Option<KeyReleasedFnAny>,
-    pub(crate) received_character: Option<ReceivedCharacterFnAny>,
-    pub(crate) mouse_moved: Option<MouseMovedFnAny>,
-    pub(crate) mouse_pressed: Option<MousePressedFnAny>,
-    pub(crate) mouse_released: Option<MouseReleasedFnAny>,
-    pub(crate) mouse_entered: Option<MouseEnteredFnAny>,
-    pub(crate) mouse_exited: Option<MouseExitedFnAny>,
-    pub(crate) mouse_wheel: Option<MouseWheelFnAny>,
-    pub(crate) moved: Option<MovedFnAny>,
-    pub(crate) resized: Option<ResizedFnAny>,
-    pub(crate) touch: Option<TouchFnAny>,
-    pub(crate) touchpad_pressure: Option<TouchpadPressureFnAny>,
-    pub(crate) hovered_file: Option<HoveredFileFnAny>,
-    pub(crate) hovered_file_cancelled: Option<HoveredFileCancelledFnAny>,
-    pub(crate) dropped_file: Option<DroppedFileFnAny>,
-    pub(crate) focused: Option<FocusedFnAny>,
-    pub(crate) unfocused: Option<UnfocusedFnAny>,
-    pub(crate) closed: Option<ClosedFnAny>,
+#[derive(Debug)]
+pub(crate) struct UserFunctions<M> {
+    pub(crate) view: Option<View<M>>,
+    pub(crate) key_pressed: Option<KeyPressedFn<M>>,
+    pub(crate) key_released: Option<KeyReleasedFn<M>>,
+    pub(crate) received_character: Option<ReceivedCharacterFn<M>>,
+    pub(crate) mouse_moved: Option<MouseMovedFn<M>>,
+    pub(crate) mouse_pressed: Option<MousePressedFn<M>>,
+    pub(crate) mouse_released: Option<MouseReleasedFn<M>>,
+    pub(crate) mouse_entered: Option<MouseEnteredFn<M>>,
+    pub(crate) mouse_exited: Option<MouseExitedFn<M>>,
+    pub(crate) mouse_wheel: Option<MouseWheelFn<M>>,
+    pub(crate) moved: Option<MovedFn<M>>,
+    pub(crate) resized: Option<ResizedFn<M>>,
+    pub(crate) touch: Option<TouchFn<M>>,
+    // pub(crate) touchpad_pressure: Option<TouchpadPressureFn<M>>,
+    pub(crate) hovered_file: Option<HoveredFileFn<M>>,
+    pub(crate) hovered_file_cancelled: Option<HoveredFileCancelledFn<M>>,
+    pub(crate) dropped_file: Option<DroppedFileFn<M>>,
+    pub(crate) focused: Option<FocusedFn<M>>,
+    pub(crate) unfocused: Option<UnfocusedFn<M>>,
+    pub(crate) closed: Option<ClosedFn<M>>,
 }
 
-/// The user function type for drawing their model to the surface of a single window.
-pub type ViewFn<Model> = fn(&App, &Model, Frame);
+impl<'a, 'w> Window<'a, 'w> {
+    pub fn new(app: &'a App<'w>, entity: Entity) -> Self {
+        Window { app, entity }
+    }
+
+    fn window(&self) -> bevy_nannou::prelude::Window {
+        let world = self.app.component_world();
+        world
+            .get::<bevy::window::Window>(self.entity)
+            .unwrap()
+            .clone()
+    }
+
+    fn window_mut(&self) -> RefMut<'_, bevy_nannou::prelude::Window> {
+        let world = self.app.component_world_mut();
+
+        RefMut::map(world, |world| {
+            world
+                .get_mut::<bevy::window::Window>(self.entity)
+                .unwrap()
+                .into_inner()
+        })
+    }
+}
+
+impl<M> Default for UserFunctions<M> {
+    fn default() -> Self {
+        UserFunctions {
+            view: None,
+            key_pressed: None,
+            key_released: None,
+            received_character: None,
+            mouse_moved: None,
+            mouse_pressed: None,
+            mouse_released: None,
+            mouse_entered: None,
+            mouse_exited: None,
+            mouse_wheel: None,
+            moved: None,
+            resized: None,
+            touch: None,
+            // touchpad_pressure: None,
+            hovered_file: None,
+            hovered_file_cancelled: None,
+            dropped_file: None,
+            focused: None,
+            unfocused: None,
+            closed: None,
+        }
+    }
+}
+
+impl<M> Clone for UserFunctions<M> {
+    fn clone(&self) -> Self {
+        UserFunctions {
+            view: self.view.clone(),
+            key_pressed: self.key_pressed,
+            key_released: self.key_released,
+            received_character: self.received_character,
+            mouse_moved: self.mouse_moved,
+            mouse_pressed: self.mouse_pressed,
+            mouse_released: self.mouse_released,
+            mouse_entered: self.mouse_entered,
+            mouse_exited: self.mouse_exited,
+            mouse_wheel: self.mouse_wheel,
+            moved: self.moved,
+            resized: self.resized,
+            touch: self.touch,
+            // touchpad_pressure: self.touchpad_pressure,
+            hovered_file: self.hovered_file,
+            hovered_file_cancelled: self.hovered_file_cancelled,
+            dropped_file: self.dropped_file,
+            focused: self.focused,
+            unfocused: self.unfocused,
+            closed: self.closed,
+        }
+    }
+}
+
+#[derive(Component, Deref, DerefMut)]
+pub(crate) struct WindowUserFunctions<M>(pub(crate) UserFunctions<M>);
 
 /// The user function type for drawing their model to the surface of a single window.
-///
-/// Unlike the `ViewFn`, the `RawViewFn` is designed for drawing directly to a window's surface
-/// texture rather than to a convenient intermediary image.
-pub type RawViewFn<Model> = fn(&App, &Model, RawFrame);
+pub type ViewFn<Model> = fn(&App, &Model);
 
 /// The same as `ViewFn`, but provides no user model to draw from.
 ///
 /// Useful for simple, stateless sketching.
-pub type SketchFn = fn(&App, Frame);
+pub type SketchFn = fn(&App);
 
 /// The user's view function, whether with a model or without one.
-#[derive(Clone)]
-pub(crate) enum View {
-    WithModel(ViewFnAny),
-    WithModelRaw(RawViewFnAny),
+pub(crate) enum View<M> {
+    WithModel(ViewFn<M>),
     Sketch(SketchFn),
 }
 
-/// A function for processing raw winit window events.
-pub type RawEventFn<Model> = fn(&App, &mut Model, &winit::event::WindowEvent);
-
-/// A function for processing window events.
-pub type EventFn<Model> = fn(&App, &mut Model, WindowEvent);
+impl<M> Clone for View<M> {
+    fn clone(&self) -> Self {
+        match self {
+            View::WithModel(f) => View::WithModel(*f),
+            View::Sketch(f) => View::Sketch(*f),
+        }
+    }
+}
 
 /// A function for processing key press events.
-pub type KeyPressedFn<Model> = fn(&App, &mut Model, Key);
+pub type KeyPressedFn<Model> = fn(&App, &mut Model, KeyCode);
 
 /// A function for processing key release events.
-pub type KeyReleasedFn<Model> = fn(&App, &mut Model, Key);
+pub type KeyReleasedFn<Model> = fn(&App, &mut Model, KeyCode);
 
 /// A function for processing received characters.
 pub type ReceivedCharacterFn<Model> = fn(&App, &mut Model, char);
@@ -135,19 +201,20 @@ pub type MouseEnteredFn<Model> = fn(&App, &mut Model);
 pub type MouseExitedFn<Model> = fn(&App, &mut Model);
 
 /// A function for processing mouse wheel events.
-pub type MouseWheelFn<Model> = fn(&App, &mut Model, MouseScrollDelta, TouchPhase);
+pub type MouseWheelFn<Model> = fn(&App, &mut Model, MouseWheel);
 
 /// A function for processing window moved events.
-pub type MovedFn<Model> = fn(&App, &mut Model, Vec2);
+pub type MovedFn<Model> = fn(&App, &mut Model, IVec2);
 
 /// A function for processing window resized events.
 pub type ResizedFn<Model> = fn(&App, &mut Model, Vec2);
 
 /// A function for processing touch events.
-pub type TouchFn<Model> = fn(&App, &mut Model, TouchEvent);
+pub type TouchFn<Model> = fn(&App, &mut Model, TouchInput);
 
-/// A function for processing touchpad pressure events.
-pub type TouchpadPressureFn<Model> = fn(&App, &mut Model, TouchpadPressure);
+// https://github.com/bevyengine/bevy/issues/6174
+// A function for processing touchpad pressure events.
+// pub type TouchpadPressureFn<Model> = fn(&App, &mut Model, TouchpadPressure);
 
 /// A function for processing hovered file events.
 pub type HoveredFileFn<Model> = fn(&App, &mut Model, PathBuf);
@@ -167,282 +234,31 @@ pub type UnfocusedFn<Model> = fn(&App, &mut Model);
 /// A function for processing window closed events.
 pub type ClosedFn<Model> = fn(&App, &mut Model);
 
-/// Errors that might occur while building the window.
-#[derive(Debug)]
-pub enum BuildError {
-    NoAvailableAdapter,
-    WinitOsError(winit::error::OsError),
-}
-
-// A macro for generating a handle to a function that can be stored within the Window without
-// requiring a type param. $TFn is the function pointer type that will be wrapped by $TFnAny.
-macro_rules! fn_any {
-    ($TFn:ident<M>, $TFnAny:ident) => {
-        // A handle to a function that can be stored without requiring a type param.
-        #[derive(Clone)]
-        pub(crate) struct $TFnAny {
-            fn_ptr: Arc<dyn Any>,
-        }
-
-        impl $TFnAny {
-            // Create the `$TFnAny` from a view function pointer.
-            pub fn from_fn_ptr<M>(fn_ptr: $TFn<M>) -> Self
-            where
-                M: 'static,
-            {
-                let fn_ptr = Arc::new(fn_ptr) as Arc<dyn Any>;
-                $TFnAny { fn_ptr }
-            }
-
-            // Retrieve the view function pointer from the `$TFnAny`.
-            pub fn to_fn_ptr<M>(&self) -> Option<&$TFn<M>>
-            where
-                M: 'static,
-            {
-                self.fn_ptr.downcast_ref::<$TFn<M>>()
-            }
-        }
-
-        impl fmt::Debug for $TFnAny {
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                write!(f, "{}", stringify!($TFnAny))
-            }
-        }
-    };
-}
-
-fn_any!(ViewFn<M>, ViewFnAny);
-fn_any!(RawViewFn<M>, RawViewFnAny);
-fn_any!(EventFn<M>, EventFnAny);
-fn_any!(RawEventFn<M>, RawEventFnAny);
-fn_any!(KeyPressedFn<M>, KeyPressedFnAny);
-fn_any!(KeyReleasedFn<M>, KeyReleasedFnAny);
-fn_any!(ReceivedCharacterFn<M>, ReceivedCharacterFnAny);
-fn_any!(MouseMovedFn<M>, MouseMovedFnAny);
-fn_any!(MousePressedFn<M>, MousePressedFnAny);
-fn_any!(MouseReleasedFn<M>, MouseReleasedFnAny);
-fn_any!(MouseEnteredFn<M>, MouseEnteredFnAny);
-fn_any!(MouseExitedFn<M>, MouseExitedFnAny);
-fn_any!(MouseWheelFn<M>, MouseWheelFnAny);
-fn_any!(MovedFn<M>, MovedFnAny);
-fn_any!(ResizedFn<M>, ResizedFnAny);
-fn_any!(TouchFn<M>, TouchFnAny);
-fn_any!(TouchpadPressureFn<M>, TouchpadPressureFnAny);
-fn_any!(HoveredFileFn<M>, HoveredFileFnAny);
-fn_any!(HoveredFileCancelledFn<M>, HoveredFileCancelledFnAny);
-fn_any!(DroppedFileFn<M>, DroppedFileFnAny);
-fn_any!(FocusedFn<M>, FocusedFnAny);
-fn_any!(UnfocusedFn<M>, UnfocusedFnAny);
-fn_any!(ClosedFn<M>, ClosedFnAny);
-
-/// A nannou window.
-///
-/// The **Window** acts as a wrapper around the `winit::window::Window` and the `wgpu::Surface`
-/// types.
-#[derive(Debug)]
-pub struct Window {
-    pub(crate) window: winit::window::Window,
-    pub(crate) surface: wgpu::Surface,
-    pub(crate) surface_conf: wgpu::SurfaceConfiguration,
-    pub(crate) device_queue_pair: Arc<wgpu::DeviceQueuePair>,
-    msaa_samples: u32,
-    pub(crate) frame_data: Option<FrameData>,
-    pub(crate) frame_count: u64,
-    pub(crate) user_functions: UserFunctions,
-    pub(crate) tracked_state: TrackedState,
-    pub(crate) is_invalidated: bool, // Whether framebuffer must be cleared
-    pub(crate) clear_color: wgpu::Color,
-}
-
-// Data related to `Frame`s produced for this window's surface textures.
-#[derive(Debug)]
-pub(crate) struct FrameData {
-    // Data for rendering a `Frame`'s intermediary image to a surface texture.
-    pub(crate) render: frame::RenderData,
-    // Data for capturing a `Frame`'s intermediary image before submission.
-    pub(crate) capture: frame::CaptureData,
-}
-
-// Track and store some information about the window in order to avoid making repeated internal
-// queries to the platform-specific API. This is beneficial in some cases where queries to the
-// platform-specific API can be very slow (e.g. macOS cocoa).
-#[derive(Debug)]
-pub(crate) struct TrackedState {
-    // Updated on `ScaleFactorChanged`.
-    pub(crate) scale_factor: f64,
-    // Updated on `Resized`.
-    pub(crate) physical_size: winit::dpi::PhysicalSize<u32>,
-}
-
-/// Surface configuration for which nannou will provide a default if unspecified.
-///
-/// See the builder methods for more details on each parameter.
-#[derive(Clone, Debug, Default)]
-pub struct SurfaceConfigurationBuilder {
-    pub usage: Option<wgpu::TextureUsages>,
-    pub format: Option<wgpu::TextureFormat>,
-    pub present_mode: Option<wgpu::PresentMode>,
-}
-
-impl SurfaceConfigurationBuilder {
-    /// Only used in the case that the `wgpu::Surface::get_preferred_format` method returns `None`.
-    pub const DEFAULT_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Bgra8UnormSrgb;
-    pub const DEFAULT_PRESENT_MODE: wgpu::PresentMode = wgpu::PresentMode::Fifo;
-    pub const DEFAULT_USAGE: wgpu::TextureUsages = wgpu::TextureUsages::RENDER_ATTACHMENT;
-
-    /// A new empty **SurfaceConfigurationBuilder** with all parameters set to `None`.
-    pub fn new() -> Self {
-        Default::default()
-    }
-
-    /// Create a **SurfaceConfigurationBuilder** from an existing descriptor.
-    pub fn from_configuration(conf: &wgpu::SurfaceConfiguration) -> Self {
-        SurfaceConfigurationBuilder::new()
-            .usage(conf.usage)
-            .format(conf.format)
-            .present_mode(conf.present_mode)
-    }
-
-    /// Specify the texture usages for the surface.
-    pub fn usage(mut self, usage: wgpu::TextureUsages) -> Self {
-        self.usage = Some(usage);
-        self
-    }
-
-    /// Specify the texture format for the surface.
-    pub fn format(mut self, format: wgpu::TextureFormat) -> Self {
-        self.format = Some(format);
-        self
-    }
-
-    /// The way in which a surface's frames are presented to the display.
-    ///
-    /// By default, nannou will attempt to select the ideal present mode depending on the current
-    /// app `LoopMode`.
-    pub fn present_mode(mut self, present_mode: wgpu::PresentMode) -> Self {
-        self.present_mode = Some(present_mode);
-        self
-    }
-
-    /// Build the surface configuration.
-    pub(crate) fn build(
-        self,
-        surface: &wgpu::Surface,
-        adapter: &wgpu::Adapter,
-        [width_px, height_px]: [u32; 2],
-    ) -> wgpu::SurfaceConfiguration {
-        let usage = self.usage.unwrap_or(Self::DEFAULT_USAGE);
-        let format = self
-            .format
-            .or_else(|| {
-                surface
-                    .get_capabilities(&adapter)
-                    .formats
-                    .get(0)
-                    .map(|x| x.clone())
-            })
-            .unwrap_or(Self::DEFAULT_FORMAT);
-        let present_mode = self.present_mode.unwrap_or(Self::DEFAULT_PRESENT_MODE);
-        wgpu::SurfaceConfiguration {
-            usage,
-            format,
-            width: width_px,
-            height: height_px,
-            present_mode,
-            alpha_mode: CompositeAlphaMode::Auto,
-            view_formats: Vec::new(),
-        }
-    }
-}
-
-impl<'app> Builder<'app> {
-    /// The default power preference used to request the WGPU adapter.
-    pub const DEFAULT_POWER_PREFERENCE: wgpu::PowerPreference = wgpu::DEFAULT_POWER_PREFERENCE;
-    /// The default `force_fallback_adapter` field used to request the WGPU adapter.
-    pub const DEFAULT_FORCE_FALLBACK_ADAPTER: bool = false;
-
+impl<'a, 'w, M> Builder<'a, 'w, M>
+where
+    M: 'static,
+{
     /// Begin building a new window.
-    pub fn new(app: &'app App) -> Self {
+    pub fn new(app: &'a App<'w>) -> Self {
         Builder {
             app,
-            window: winit::window::WindowBuilder::new(),
+            window: bevy::window::Window::default(),
+            camera: None,
+            light: None,
+            primary: false,
             title_was_set: false,
-            surface_conf_builder: Default::default(),
-            power_preference: Self::DEFAULT_POWER_PREFERENCE,
-            force_fallback_adapter: Self::DEFAULT_FORCE_FALLBACK_ADAPTER,
-            device_desc: None,
-            user_functions: Default::default(),
-            msaa_samples: None,
-            max_capture_frame_jobs: Default::default(),
-            capture_frame_timeout: Default::default(),
+            user_functions: UserFunctions::<M>::default(),
             clear_color: None,
+            hdr: false,
         }
     }
 
     /// Build the window with some custom window parameters.
-    pub fn window(mut self, window: winit::window::WindowBuilder) -> Self {
+    pub fn window(mut self, window: bevy::window::Window) -> Self {
         self.window = window;
         self
     }
 
-    /// Specify a set of parameters for building the window surface.
-    pub fn surface_conf_builder(
-        mut self,
-        surface_conf_builder: SurfaceConfigurationBuilder,
-    ) -> Self {
-        self.surface_conf_builder = surface_conf_builder;
-        self
-    }
-
-    /// Specify the power preference desired for the WGPU adapter.
-    ///
-    /// By default, this is `wgpu::PowerPreference::HighPerformance`.
-    pub fn power_preference(mut self, pref: wgpu::PowerPreference) -> Self {
-        self.power_preference = pref;
-        self
-    }
-
-    /// Indicates that only a fallback adapter can be returned. This is generally a "software"
-    /// implementation on the system..
-    ///
-    /// By default, this is `false`.
-    pub fn force_fallback_adapter(mut self, force: bool) -> Self {
-        self.force_fallback_adapter = force;
-        self
-    }
-
-    /// Specify a device descriptor to use when requesting the logical device from the adapter.
-    /// This allows for specifying custom wgpu device extensions.
-    pub fn device_descriptor(mut self, device_desc: wgpu::DeviceDescriptor<'static>) -> Self {
-        self.device_desc = Some(device_desc);
-        self
-    }
-
-    /// Specify the number of samples per pixel for the multisample anti-aliasing render pass.
-    ///
-    /// If `msaa_samples` is unspecified, the first default value that nannou will attempt to use
-    /// can be found via the `Frame::DEFAULT_MSAA_SAMPLES` constant.
-    ///
-    /// **Note:** This parameter has no meaning if the window uses a **raw_view** function for
-    /// rendering graphics to the window rather than a **view** function. This is because the
-    /// **raw_view** function provides a **RawFrame** with direct access to the surface texture
-    /// itself and thus must manage their own MSAA pass.
-    ///
-    /// On the other hand, the `view` function provides the `Frame` type which allows the user to
-    /// render to a multisampled intermediary image allowing Nannou to take care of resolving the
-    /// multisampled texture to the surface texture. In order to avoid confusion, The
-    /// `Window::build` method will `panic!` if the user tries to specify `msaa_samples` as well as
-    /// a `raw_view` method.
-    ///
-    /// *TODO: Perhaps it would be worth adding two separate methods for specifying msaa samples.
-    /// One for forcing a certain number of samples and returning an error otherwise, and another
-    /// for attempting to use the given number of samples but falling back to a supported value in
-    /// the case that the specified number is not supported.*
-    pub fn msaa_samples(mut self, msaa_samples: u32) -> Self {
-        self.msaa_samples = Some(msaa_samples);
-        self
-    }
-
     /// Provide a simple function for drawing to the window.
     ///
     /// This is similar to `view` but does not provide access to user data via a Model type. This
@@ -454,25 +270,8 @@ impl<'app> Builder<'app> {
 
     /// The **view** function that the app will call to allow you to present your Model to the
     /// surface of the window on your display.
-    pub fn view<M>(mut self, view_fn: ViewFn<M>) -> Self
-    where
-        M: 'static,
-    {
-        self.user_functions.view = Some(View::WithModel(ViewFnAny::from_fn_ptr(view_fn)));
-        self
-    }
-
-    /// The **view** function that the app will call to allow you to present your Model to the
-    /// surface of the window on your display.
-    ///
-    /// Unlike the **ViewFn**, the **RawViewFn** provides a **RawFrame** that is designed for
-    /// drawing directly to a window's surface texture, rather than to a convenient intermediary
-    /// image.
-    pub fn raw_view<M>(mut self, raw_view_fn: RawViewFn<M>) -> Self
-    where
-        M: 'static,
-    {
-        self.user_functions.view = Some(View::WithModelRaw(RawViewFnAny::from_fn_ptr(raw_view_fn)));
+    pub fn view(mut self, view_fn: ViewFn<M>) -> Self {
+        self.user_functions.view = Some(View::WithModel(view_fn));
         self
     }
 
@@ -480,577 +279,261 @@ impl<'app> Builder<'app> {
     /// when its contents are invalidated, e.g. upon window resize.
     pub fn clear_color<C>(mut self, color: C) -> Self
     where
-        C: IntoLinSrgba<f32>,
-    {
-        let lin_srgba = color.into_lin_srgba();
-        let (r, g, b, a) = lin_srgba.into_components();
-        let (r, g, b, a) = (r as f64, g as f64, b as f64, a as f64);
-
-        self.clear_color = Some(wgpu::Color { r, g, b, a });
-        self
-    }
-
-    /// A function for updating your model on `WindowEvent`s associated with this window.
-    ///
-    /// These include events such as key presses, mouse movement, clicks, resizing, etc.
-    ///
-    /// ## Event Function Call Order
-    ///
-    /// In nannou, if multiple functions require being called for a single kind of event, the more
-    /// general event function will always be called before the more specific event function.
-    ///
-    /// If an `event` function was also submitted to the `App`, that function will always be called
-    /// immediately before window-specific event functions. Similarly, if a function associated
-    /// with a more specific event type (e.g. `key_pressed`) was given, that function will be
-    /// called *after* this function will be called.
-    ///
-    /// ## Specific Events Variants
-    ///
-    /// Note that if you only care about a certain kind of event, you can submit a function that
-    /// only gets called for that specific event instead. For example, if you only care about key
-    /// presses, you may wish to use the `key_pressed` method instead.
-    pub fn event<M>(mut self, event_fn: EventFn<M>) -> Self
-    where
-        M: 'static,
-    {
-        self.user_functions.event = Some(EventFnAny::from_fn_ptr(event_fn));
-        self
-    }
-
-    /// The same as the `event` method, but allows for processing raw `winit::event::WindowEvent`s rather
-    /// than Nannou's simplified `event::WindowEvent`s.
-    ///
-    /// ## Event Function Call Order
-    ///
-    /// If both `raw_event` and `event` functions have been provided, the given `raw_event`
-    /// function will always be called immediately before the given `event` function.
-    pub fn raw_event<M>(mut self, raw_event_fn: RawEventFn<M>) -> Self
-    where
-        M: 'static,
+        C: Into<Color>,
     {
-        self.user_functions.raw_event = Some(RawEventFnAny::from_fn_ptr(raw_event_fn));
+        let color = color.into();
+        self.clear_color = Some(color);
         self
     }
 
     /// A function for processing key press events associated with this window.
-    pub fn key_pressed<M>(mut self, f: KeyPressedFn<M>) -> Self
-    where
-        M: 'static,
-    {
-        self.user_functions.key_pressed = Some(KeyPressedFnAny::from_fn_ptr(f));
+    pub fn key_pressed(mut self, f: KeyPressedFn<M>) -> Self {
+        self.user_functions.key_pressed = Some(f);
         self
     }
 
     /// A function for processing key release events associated with this window.
-    pub fn key_released<M>(mut self, f: KeyReleasedFn<M>) -> Self
-    where
-        M: 'static,
-    {
-        self.user_functions.key_released = Some(KeyReleasedFnAny::from_fn_ptr(f));
+    pub fn key_released(mut self, f: KeyReleasedFn<M>) -> Self {
+        self.user_functions.key_released = Some(f);
         self
     }
 
-    pub fn received_character<M>(mut self, f: ReceivedCharacterFn<M>) -> Self
-    where
-        M: 'static,
-    {
-        self.user_functions.received_character = Some(ReceivedCharacterFnAny::from_fn_ptr(f));
+    pub fn received_character(mut self, f: ReceivedCharacterFn<M>) -> Self {
+        self.user_functions.received_character = Some(f);
         self
     }
 
     /// A function for processing mouse moved events associated with this window.
-    pub fn mouse_moved<M>(mut self, f: MouseMovedFn<M>) -> Self
-    where
-        M: 'static,
-    {
-        self.user_functions.mouse_moved = Some(MouseMovedFnAny::from_fn_ptr(f));
+    pub fn mouse_moved(mut self, f: MouseMovedFn<M>) -> Self {
+        self.user_functions.mouse_moved = Some(f);
         self
     }
 
     /// A function for processing mouse pressed events associated with this window.
-    pub fn mouse_pressed<M>(mut self, f: MousePressedFn<M>) -> Self
-    where
-        M: 'static,
-    {
-        self.user_functions.mouse_pressed = Some(MousePressedFnAny::from_fn_ptr(f));
+    pub fn mouse_pressed(mut self, f: MousePressedFn<M>) -> Self {
+        self.user_functions.mouse_pressed = Some(f);
         self
     }
 
     /// A function for processing mouse released events associated with this window.
-    pub fn mouse_released<M>(mut self, f: MouseReleasedFn<M>) -> Self
-    where
-        M: 'static,
-    {
-        self.user_functions.mouse_released = Some(MouseReleasedFnAny::from_fn_ptr(f));
+    pub fn mouse_released(mut self, f: MouseReleasedFn<M>) -> Self {
+        self.user_functions.mouse_released = Some(f);
         self
     }
 
     /// A function for processing mouse wheel events associated with this window.
-    pub fn mouse_wheel<M>(mut self, f: MouseWheelFn<M>) -> Self
-    where
-        M: 'static,
-    {
-        self.user_functions.mouse_wheel = Some(MouseWheelFnAny::from_fn_ptr(f));
+    pub fn mouse_wheel(mut self, f: MouseWheelFn<M>) -> Self {
+        self.user_functions.mouse_wheel = Some(f);
         self
     }
 
     /// A function for processing mouse entered events associated with this window.
-    pub fn mouse_entered<M>(mut self, f: MouseEnteredFn<M>) -> Self
-    where
-        M: 'static,
-    {
-        self.user_functions.mouse_entered = Some(MouseEnteredFnAny::from_fn_ptr(f));
+    pub fn mouse_entered(mut self, f: MouseEnteredFn<M>) -> Self {
+        self.user_functions.mouse_entered = Some(f);
         self
     }
 
     /// A function for processing mouse exited events associated with this window.
-    pub fn mouse_exited<M>(mut self, f: MouseExitedFn<M>) -> Self
-    where
-        M: 'static,
-    {
-        self.user_functions.mouse_exited = Some(MouseExitedFnAny::from_fn_ptr(f));
+    pub fn mouse_exited(mut self, f: MouseExitedFn<M>) -> Self {
+        self.user_functions.mouse_exited = Some(f);
         self
     }
 
     /// A function for processing touch events associated with this window.
-    pub fn touch<M>(mut self, f: TouchFn<M>) -> Self
-    where
-        M: 'static,
-    {
-        self.user_functions.touch = Some(TouchFnAny::from_fn_ptr(f));
-        self
-    }
-
-    /// A function for processing touchpad pressure events associated with this window.
-    pub fn touchpad_pressure<M>(mut self, f: TouchpadPressureFn<M>) -> Self
-    where
-        M: 'static,
-    {
-        self.user_functions.touchpad_pressure = Some(TouchpadPressureFnAny::from_fn_ptr(f));
+    pub fn touch(mut self, f: TouchFn<M>) -> Self {
+        self.user_functions.touch = Some(f);
         self
     }
+    //
+    // /// A function for processing touchpad pressure events associated with this window.
+    // pub fn touchpad_pressure<M>(mut self, f: TouchpadPressureFn<M>) -> Self
+    // where
+    //     M: 'static,
+    // {
+    //     self.user_functions.touchpad_pressure = Some(f);
+    //     self
+    // }
 
     /// A function for processing window moved events associated with this window.
-    pub fn moved<M>(mut self, f: MovedFn<M>) -> Self
-    where
-        M: 'static,
-    {
-        self.user_functions.moved = Some(MovedFnAny::from_fn_ptr(f));
+    pub fn moved(mut self, f: MovedFn<M>) -> Self {
+        self.user_functions.moved = Some(f);
         self
     }
 
     /// A function for processing window resized events associated with this window.
-    pub fn resized<M>(mut self, f: ResizedFn<M>) -> Self
-    where
-        M: 'static,
-    {
-        self.user_functions.resized = Some(ResizedFnAny::from_fn_ptr(f));
+    pub fn resized(mut self, f: ResizedFn<M>) -> Self {
+        self.user_functions.resized = Some(f);
         self
     }
 
     /// A function for processing hovered file events associated with this window.
-    pub fn hovered_file<M>(mut self, f: HoveredFileFn<M>) -> Self
-    where
-        M: 'static,
-    {
-        self.user_functions.hovered_file = Some(HoveredFileFnAny::from_fn_ptr(f));
+    pub fn hovered_file(mut self, f: HoveredFileFn<M>) -> Self {
+        self.user_functions.hovered_file = Some(f);
         self
     }
 
     /// A function for processing hovered file cancelled events associated with this window.
-    pub fn hovered_file_cancelled<M>(mut self, f: HoveredFileCancelledFn<M>) -> Self
-    where
-        M: 'static,
-    {
-        self.user_functions.hovered_file_cancelled =
-            Some(HoveredFileCancelledFnAny::from_fn_ptr(f));
+    pub fn hovered_file_cancelled(mut self, f: HoveredFileCancelledFn<M>) -> Self {
+        self.user_functions.hovered_file_cancelled = Some(f);
         self
     }
 
     /// A function for processing dropped file events associated with this window.
-    pub fn dropped_file<M>(mut self, f: DroppedFileFn<M>) -> Self
-    where
-        M: 'static,
-    {
-        self.user_functions.dropped_file = Some(DroppedFileFnAny::from_fn_ptr(f));
+    pub fn dropped_file(mut self, f: DroppedFileFn<M>) -> Self {
+        self.user_functions.dropped_file = Some(f);
         self
     }
 
     /// A function for processing the focused event associated with this window.
-    pub fn focused<M>(mut self, f: FocusedFn<M>) -> Self
-    where
-        M: 'static,
-    {
-        self.user_functions.focused = Some(FocusedFnAny::from_fn_ptr(f));
+    pub fn focused(mut self, f: FocusedFn<M>) -> Self {
+        self.user_functions.focused = Some(f);
         self
     }
 
     /// A function for processing the unfocused event associated with this window.
-    pub fn unfocused<M>(mut self, f: UnfocusedFn<M>) -> Self
-    where
-        M: 'static,
-    {
-        self.user_functions.unfocused = Some(UnfocusedFnAny::from_fn_ptr(f));
+    pub fn unfocused(mut self, f: UnfocusedFn<M>) -> Self {
+        self.user_functions.unfocused = Some(f);
         self
     }
 
     /// A function for processing the window closed event associated with this window.
-    pub fn closed<M>(mut self, f: ClosedFn<M>) -> Self
-    where
-        M: 'static,
-    {
-        self.user_functions.closed = Some(ClosedFnAny::from_fn_ptr(f));
-        self
-    }
-
-    /// The maximum number of simultaneous capture frame jobs that can be run for this window
-    /// before we block and wait for the existing jobs to complete.
-    ///
-    /// A "capture frame job" refers to the combind process of waiting to read a frame from the GPU
-    /// and then writing that frame to an image file on the disk. Each call to
-    /// `window.capture_frame(path)` spawns a new "capture frame job" on an internal thread pool.
-    ///
-    /// By default, this value is equal to the number of physical cpu threads available on the
-    /// system. However, keep in mind that this means there must be room in both RAM and VRAM for
-    /// this number of textures to exist at any moment in time. If you run into an "out of memory"
-    /// error, try reducing the number of max jobs to a lower value, though never lower than `1`.
-    ///
-    /// **Panics** if the specified value is less than `1`.
-    pub fn max_capture_frame_jobs(mut self, max_jobs: u32) -> Self {
-        assert!(
-            max_jobs >= 1,
-            "must allow for at least one capture frame job at a time"
-        );
-        self.max_capture_frame_jobs = max_jobs;
+    pub fn closed(mut self, f: ClosedFn<M>) -> Self {
+        self.user_functions.closed = Some(f);
         self
     }
 
-    /// In the case that `max_capture_frame_jobs` is reached and the main thread must block, this
-    /// specifies how long to wait for a running capture job to complete. See the
-    /// `max_capture_frame_jobs` docs for more details.
-    ///
-    /// By default, the timeout used is equal to `app::Builder::DEFAULT_CAPTURE_FRAME_TIMEOUT`.
-    ///
-    /// If `None` is specified, the capture process will never time out. This may be necessary on
-    /// extremely low-powered machines that take a long time to write each frame to disk.
-    pub fn capture_frame_timeout(mut self, timeout: Option<std::time::Duration>) -> Self {
-        self.capture_frame_timeout = timeout;
+    pub fn hdr(mut self, hdr: bool) -> Self {
+        self.hdr = hdr;
         self
     }
 
     #[cfg(not(target_os = "unknown"))]
     /// Builds the window, inserts it into the `App`'s display map and returns the unique ID.
-    pub fn build(self) -> Result<Id, BuildError> {
-        tokio::task::block_in_place(move || {
-            tokio::runtime::Handle::current().block_on(async move { self.build_async().await })
-        })
-    }
-
-    pub async fn build_async(self) -> Result<Id, BuildError> {
-        let Builder {
-            app,
-            mut window,
-            title_was_set,
-            surface_conf_builder,
-            power_preference,
-            force_fallback_adapter,
-            device_desc,
-            user_functions,
-            msaa_samples,
-            max_capture_frame_jobs,
-            capture_frame_timeout,
-            clear_color,
-        } = self;
-
-        // If the title was not set, default to the "nannou - <exe_name>".
-        if !title_was_set {
-            if let Ok(exe_path) = env::current_exe() {
-                if let Some(os_str) = exe_path.file_stem() {
-                    if let Some(exe_name) = os_str.to_str() {
-                        let title = format!("nannou - {}", exe_name);
-                        window = window.with_title(title);
-                    }
-                }
+    pub fn build(self) -> Entity {
+        let entity = self
+            .app
+            .component_world_mut()
+            .spawn((self.window, WindowUserFunctions(self.user_functions)))
+            .id();
+
+        if self.primary {
+            let mut q = self.app.component_world_mut().query::<&PrimaryWindow>();
+            if q.get_single(&mut self.app.component_world_mut()).is_ok() {
+                panic!("Only one primary window can be created");
             }
-        }
 
-        // Set the class type for X11 if WindowExtUnix trait is compiled in winit
-        // (see lines https://docs.rs/winit/0.26.0/src/winit/platform/unix.rs.html#1-7)
-        #[cfg(any(
-            target_os = "linux",
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "netbsd",
-            target_os = "openbsd"
-        ))]
-        #[cfg(not(feature = "wayland"))]
-        {
-            use winit::platform::x11::WindowBuilderExtX11;
-            window = window.with_name("nannou".to_string(), "nannou".to_string());
+            self.app
+                .component_world_mut()
+                .entity_mut(entity)
+                .insert(PrimaryWindow);
         }
 
-        #[cfg(any(
-            target_os = "linux",
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "netbsd",
-            target_os = "openbsd"
-        ))]
-        #[cfg(feature = "wayland")]
-        {
-            use winit::platform::wayland::WindowBuilderExtWayland;
-            window = window.with_name("nannou".to_string(), "nannou".to_string());
-        }
+        let layer = RenderLayers::layer(self.app.window_count());
 
-        // Set default dimensions in the case that none were given.
-        let initial_window_size = window
-            .window_attributes()
-            .inner_size
-            .or_else(|| {
-                window
-                    .window_attributes()
-                    .fullscreen
-                    .as_ref()
-                    .and_then(|fullscreen| match fullscreen {
-                        Fullscreen::Exclusive(video_mode) => {
-                            let monitor = video_mode.monitor();
-                            Some(
-                                video_mode
-                                    .size()
-                                    .to_logical::<f32>(monitor.scale_factor())
-                                    .into(),
-                            )
-                        }
-                        Fullscreen::Borderless(monitor) => monitor.as_ref().map(|monitor| {
-                            monitor
-                                .size()
-                                .to_logical::<f32>(monitor.scale_factor())
-                                .into()
-                        }),
-                    })
-            })
-            .unwrap_or_else(|| {
-                let mut dim = DEFAULT_DIMENSIONS;
-                if let Some(min) = window.window_attributes().min_inner_size {
-                    match min {
-                        winit::dpi::Size::Logical(min) => {
-                            dim.width = dim.width.max(min.width as _);
-                            dim.height = dim.height.max(min.height as _);
-                        }
-                        winit::dpi::Size::Physical(min) => {
-                            dim.width = dim.width.max(min.width as _);
-                            dim.height = dim.height.max(min.height as _);
-                            unimplemented!("consider scale factor");
-                        }
-                    }
-                }
-                if let Some(max) = window.window_attributes().max_inner_size {
-                    match max {
-                        winit::dpi::Size::Logical(max) => {
-                            dim.width = dim.width.min(max.width as _);
-                            dim.height = dim.height.min(max.height as _);
-                        }
-                        winit::dpi::Size::Physical(max) => {
-                            dim.width = dim.width.min(max.width as _);
-                            dim.height = dim.height.min(max.height as _);
-                            unimplemented!("consider scale factor");
-                        }
-                    }
+        if let Some(camera) = self.camera {
+            // Update the camera's render target to be the window.
+            let mut q = self
+                .app
+                .component_world_mut()
+                .query::<(&mut Camera, Option<&mut RenderLayers>)>();
+            if let Ok((mut camera, layers)) = q.get_mut(&mut self.app.component_world_mut(), camera)
+            {
+                camera.target = RenderTarget::Window(WindowRef::Entity(entity));
+                if let None = layers {
+                    self.app
+                        .component_world_mut()
+                        .entity_mut(self.camera.unwrap())
+                        .insert(layer.clone());
                 }
-                dim.into()
-            });
-
-        // Use the `initial_window_size` as the default dimensions for the window if none
-        // were specified.
-        if window.window_attributes().inner_size.is_none()
-            && window.window_attributes().fullscreen.is_none()
-        {
-            window = window.with_inner_size(initial_window_size);
-        }
-
-        // Set a default minimum window size for configuring the surface.
-        if window.window_attributes().min_inner_size.is_none()
-            && window.window_attributes().fullscreen.is_none()
-        {
-            window = window.with_min_inner_size(winit::dpi::Size::Physical(MIN_SC_PIXELS));
-        }
-
-        // Background must be initially cleared
-        let is_invalidated = true;
-
-        let clear_color = clear_color.unwrap_or_else(|| {
-            let mut color: wgpu::Color = Default::default();
-            color.a = if window.window_attributes().transparent {
-                0.0
-            } else {
-                1.0
-            };
-            color
-        });
-
-        // Build the window.
-        let window = {
-            let window_target = app
-                .event_loop_window_target
-                .as_ref()
-                .expect("unexpected invalid App.event_loop_window_target state - please report")
-                .as_ref();
-            window.build(window_target)?
-        };
-
-        #[cfg(target_arch = "wasm32")]
-        {
-            use winit::platform::web::WindowExtWebSys;
-            let canvas = window.canvas();
-
-            web_sys::window()
-                .expect("window")
-                .document()
-                .expect("document")
-                .body()
-                .expect("body")
-                .append_child(&canvas)
-                .expect("append_child");
-        }
-
-        // Build the wgpu surface.
-        let surface = unsafe {
-            app.instance()
-                .create_surface(&window)
-                .expect("Could not create surface")
-        };
-
-        // Request the adapter.
-        let request_adapter_opts = wgpu::RequestAdapterOptions {
-            power_preference,
-            compatible_surface: Some(&surface),
-            force_fallback_adapter,
-        };
-        let adapter = app
-            .wgpu_adapters()
-            .get_or_request_async(request_adapter_opts, app.instance())
-            .await
-            .ok_or(BuildError::NoAvailableAdapter)?;
-
-        // Instantiate the logical device.
-        let device_desc = device_desc.unwrap_or_else(wgpu::default_device_descriptor);
-        let device_queue_pair = adapter.get_or_request_device_async(device_desc).await;
-
-        // Configure the surface.
-        let win_physical_size = window.inner_size();
-        let win_dims_px: [u32; 2] = win_physical_size.into();
-        let device = device_queue_pair.device();
-        let surface_conf = surface_conf_builder.build(&surface, &*adapter, win_dims_px);
-        surface.configure(&device, &surface_conf);
-
-        // If we're using an intermediary image for rendering frames to surface textures, create
-        // the necessary render data.
-        let (frame_data, msaa_samples) = match user_functions.view {
-            Some(View::WithModel(_)) | Some(View::Sketch(_)) | None => {
-                let msaa_samples = msaa_samples.unwrap_or(Frame::DEFAULT_MSAA_SAMPLES);
-                // TODO: Verity that requested sample count is valid for surface?
-                let surface_dims = [surface_conf.width, surface_conf.height];
-                let render = frame::RenderData::new(
-                    &device,
-                    surface_dims,
-                    surface_conf.format,
-                    msaa_samples,
-                );
-                let capture =
-                    frame::CaptureData::new(max_capture_frame_jobs, capture_frame_timeout);
-                let frame_data = FrameData { render, capture };
-                (Some(frame_data), msaa_samples)
             }
-            Some(View::WithModelRaw(_)) => (None, 1),
-        };
-
-        let window_id = window.id();
-        let frame_count = 0;
-
-        let tracked_state = TrackedState {
-            scale_factor: window.scale_factor(),
-            physical_size: win_physical_size,
-        };
-
-        let window = Window {
-            window,
-            surface,
-            surface_conf,
-            device_queue_pair,
-            msaa_samples,
-            frame_data,
-            frame_count,
-            user_functions,
-            tracked_state,
-            is_invalidated,
-            clear_color,
-        };
-        app.windows.borrow_mut().insert(window_id, window);
+        } else {
+            info!("No camera provided for window, creating a default camera");
+            self.app.component_world_mut().spawn((
+                Camera3dBundle {
+                    camera: Camera {
+                        hdr: self.hdr,
+                        target: RenderTarget::Window(WindowRef::Entity(entity)),
+                        clear_color: self
+                            .clear_color
+                            .map(ClearColorConfig::Custom)
+                            .unwrap_or(ClearColorConfig::None),
+                        ..default()
+                    },
+                    transform: Transform::from_xyz(0.0, 0.0, 10.0).looking_at(Vec3::ZERO, Vec3::Y),
+                    projection: OrthographicProjection::default().into(),
+                    ..default()
+                },
+                layer.clone(),
+                NannouCamera,
+            ));
+        }
 
-        // If this is the first window, set it as the app's "focused" window.
-        if app.windows.borrow().len() == 1 {
-            *app.focused_window.borrow_mut() = Some(window_id);
+        if let Some(light) = self.light {
+            self.app
+                .component_world_mut()
+                .entity_mut(light)
+                .insert(layer.clone());
         }
 
-        Ok(window_id)
+        entity
     }
 
     fn map_window<F>(self, map: F) -> Self
     where
-        F: FnOnce(winit::window::WindowBuilder) -> winit::window::WindowBuilder,
+        F: FnOnce(bevy::window::Window) -> bevy::window::Window,
     {
-        let Builder {
-            app,
-            window,
-            title_was_set,
-            device_desc,
-            power_preference,
-            force_fallback_adapter,
-            surface_conf_builder,
-            user_functions,
-            msaa_samples,
-            max_capture_frame_jobs,
-            capture_frame_timeout,
-            clear_color,
-        } = self;
-        let window = map(window);
         Builder {
-            app,
-            window,
-            title_was_set,
-            device_desc,
-            power_preference,
-            force_fallback_adapter,
-            surface_conf_builder,
-            user_functions,
-            msaa_samples,
-            max_capture_frame_jobs,
-            capture_frame_timeout,
-            clear_color,
+            window: map(self.window),
+            ..self
         }
     }
 
-    // Window builder methods.
-    //
-    // NOTE: On new versions of winit, we should check whether or not new `WindowBuilder` methods
-    // have been added that we should expose.
+    /// The camera to use for rendering to this window. Setting the camera will override the
+    /// default camera that would be created for this window. The camera's render target
+    /// will be set to the window when the window is built.
+    pub fn camera(mut self, camera: Entity) -> Self {
+        self.camera = Some(camera);
+        self
+    }
+
+    pub fn light(mut self, light: Entity) -> Self {
+        self.light = Some(light);
+        self
+    }
 
     /// Requests the window to be a specific size in points.
     ///
     /// This describes to the "inner" part of the window, not including desktop decorations like the
     /// title bar.
     pub fn size(self, width: u32, height: u32) -> Self {
-        self.map_window(|w| w.with_inner_size(winit::dpi::LogicalSize { width, height }))
+        self.map_window(|mut w| {
+            w.resolution.set(width as f32, height as f32);
+            w
+        })
     }
 
     /// Set the minimum size in points for the window.
-    pub fn min_size(self, width: u32, height: u32) -> Self {
-        self.map_window(|w| w.with_min_inner_size(winit::dpi::LogicalSize { width, height }))
+    pub fn min_size(self, width: f32, height: f32) -> Self {
+        self.map_window(|mut w| {
+            w.resize_constraints = WindowResizeConstraints {
+                min_width: width,
+                min_height: height,
+                ..w.resize_constraints
+            };
+            w
+        })
     }
 
     /// Set the maximum size in points for the window.
-    pub fn max_size(self, width: u32, height: u32) -> Self {
-        self.map_window(|w| w.with_max_inner_size(winit::dpi::LogicalSize { width, height }))
+    pub fn max_size(self, width: f32, height: f32) -> Self {
+        self.map_window(|mut w| {
+            w.resize_constraints = WindowResizeConstraints {
+                max_width: width,
+                max_height: height,
+                ..w.resize_constraints
+            };
+            w
+        })
     }
 
     /// Requests the window to be a specific size in points.
@@ -1058,12 +541,18 @@ impl<'app> Builder<'app> {
     /// This describes to the "inner" part of the window, not including desktop decorations like the
     /// title bar.
     pub fn size_pixels(self, width: u32, height: u32) -> Self {
-        self.map_window(|w| w.with_inner_size(winit::dpi::PhysicalSize { width, height }))
+        self.map_window(|mut w| {
+            w.resolution.set_physical_resolution(width, height);
+            w
+        })
     }
 
     /// Whether or not the window should be resizable after creation.
     pub fn resizable(self, resizable: bool) -> Self {
-        self.map_window(|w| w.with_resizable(resizable))
+        self.map_window(|mut w| {
+            w.resizable = resizable;
+            w
+        })
     }
 
     /// Requests a specific title for the window.
@@ -1072,70 +561,90 @@ impl<'app> Builder<'app> {
         T: Into<String>,
     {
         self.title_was_set = true;
-        self.map_window(|w| w.with_title(title))
+        self.map_window(|mut w| {
+            w.title = title.into();
+            w
+        })
     }
 
-    /// Create the window fullscreened on the current monitor.
-    pub fn fullscreen(self) -> Self {
-        let fullscreen = Fullscreen::Borderless(self.app.primary_monitor());
-        self.fullscreen_with(Some(fullscreen))
+    pub fn primary(mut self) -> Self {
+        self.primary = true;
+        self
     }
 
-    /// Set the window fullscreen state with the given settings.
-    ///
-    /// - `None` indicates a normal window. This is the default case.
-    /// - `Some(Fullscreen)` means fullscreen with the desired settings.
-    pub fn fullscreen_with(self, fullscreen: Option<Fullscreen>) -> Self {
-        self.map_window(|w| w.with_fullscreen(fullscreen))
+    /// Create the window fullscreened on the current monitor.
+    pub fn fullscreen(self) -> Self {
+        self.map_window(|mut w| {
+            w.position = WindowPosition::Centered(MonitorSelection::Primary);
+            w
+        })
     }
 
     /// Requests maximized mode.
     pub fn maximized(self, maximized: bool) -> Self {
-        self.map_window(|w| w.with_maximized(maximized))
+        self.map_window(|mut w| {
+            w.set_maximized(maximized);
+            w
+        })
     }
 
     /// Sets whether the window will be initially hidden or visible.
     pub fn visible(self, visible: bool) -> Self {
-        self.map_window(|w| w.with_visible(visible))
+        self.map_window(|mut w| {
+            w.visible = visible;
+            w
+        })
     }
 
     /// Sets whether the background of the window should be transparent.
     pub fn transparent(self, transparent: bool) -> Self {
-        self.map_window(|w| w.with_transparent(transparent))
+        self.map_window(|mut w| {
+            w.transparent = transparent;
+            w
+        })
     }
 
     /// Sets whether the window should have a border, a title bar, etc.
     pub fn decorations(self, decorations: bool) -> Self {
-        self.map_window(|w| w.with_decorations(decorations))
+        self.map_window(|mut w| {
+            w.decorations = decorations;
+            w
+        })
     }
 
     /// Sets whether or not the window will always be on top of other windows.
     pub fn always_on_top(self, always_on_top: bool) -> Self {
-        self.map_window(|w| {
-            w.with_window_level(if always_on_top {
-                WindowLevel::AlwaysOnBottom
+        self.map_window(|mut w| {
+            w.window_level = if always_on_top {
+                WindowLevel::AlwaysOnTop
             } else {
                 WindowLevel::Normal
-            })
+            };
+            w
         })
     }
+}
+
+impl<M> fmt::Debug for View<M> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let variant = match *self {
+            View::WithModel(ref v) => format!("WithModel({:?})", v),
+            View::Sketch(_) => "Sketch".to_string(),
+        };
 
-    /// Sets the window icon.
-    pub fn window_icon(self, window_icon: Option<winit::window::Icon>) -> Self {
-        self.map_window(|w| w.with_window_icon(window_icon))
+        write!(f, "View::{}", variant)
     }
 }
 
-impl Window {
-    // `winit::window::Window` methods.
-    //
-    // NOTE: On new versions of winit, we should check whether or not new `Window` methods have
-    // been added that we should expose. Most of the following method docs are copied from the
-    // winit documentation. It would be nice if we could automate this inlining somehow.
-
+impl<'a, 'w> Window<'a, 'w> {
     /// A unique identifier associated with this window.
-    pub fn id(&self) -> Id {
-        self.window.id()
+    pub fn id(&self) -> Entity {
+        self.entity
+    }
+
+    pub fn layer(&self) -> Option<RenderLayers> {
+        let world = self.app.component_world();
+        world.get::<RenderLayers>(self.entity).cloned()
     }
 
     /// Returns the scale factor that can be used to map logical pixels to physical pixels and vice
@@ -1157,117 +666,69 @@ impl Window {
     /// - **Android:** Always returns 1.0.
     /// - **iOS:** Can only be called on the main thread. Returns the underlying `UiView`'s
     ///   `contentScaleFactor`.
-    pub fn scale_factor(&self) -> geom::scalar::Default {
-        self.window.scale_factor() as _
-    }
-
-    /// The position of the top-left hand corner of the window relative to the top-left hand corner
-    /// of the desktop.
-    ///
-    /// Note that the top-left hand corner of the desktop is not necessarily the same as the
-    /// screen. If the user uses a desktop with multiple monitors, the top-left hand corner of the
-    /// desktop is the top-left hand corner of the monitor at the top-left of the desktop.
-    ///
-    /// The coordinates can be negative if the top-left hand corner of the window is outside of the
-    /// visible screen region.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **iOS:** Can only be called on the main thread. Returns the top left coordinates of the
-    /// window in the screen space coordinate system.
-    /// - **Web:** Returns the top-left coordinates relative to the viewport.
-    pub fn outer_position_pixels(&self) -> Result<(i32, i32), winit::error::NotSupportedError> {
-        self.window.outer_position().map(Into::into)
-    }
-
-    /// Modifies the position of the window.
-    ///
-    /// See `outer_position_pixels` for more information about the returned coordinates. This
-    /// automatically un-maximizes the window if it is maximized.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **iOS:** Can only be called on the main thread. Sets the top left coordinates of the
-    ///   window in the screen space coordinate system.
-    /// - **Web:** Sets the top-left coordinates relative to the viewport.
-    pub fn set_outer_position_pixels(&self, x: i32, y: i32) {
-        self.window
-            .set_outer_position(winit::dpi::PhysicalPosition { x, y })
+    pub fn scale_factor(&self) -> f32 {
+        self.window_mut().scale_factor()
     }
 
     /// The width and height in pixels of the client area of the window.
     ///
     /// The client area is the content of the window, excluding the title bar and borders.
-    pub fn inner_size_pixels(&self) -> (u32, u32) {
-        self.window.inner_size().into()
+    pub fn size_pixels(&self) -> UVec2 {
+        self.window_mut().physical_size()
     }
 
     /// The width and height in points of the client area of the window.
     ///
     /// The client area is the content of the window, excluding the title bar and borders.
     ///
-    /// This is the same as dividing the result  of `inner_size_pixels()` by `scale_factor()`.
-    pub fn inner_size_points(&self) -> (geom::scalar::Default, geom::scalar::Default) {
-        self.window
-            .inner_size()
-            .to_logical::<f32>(self.tracked_state.scale_factor)
-            .into()
+    /// This is the same as dividing the result  of `size_pixels()` by `scale_factor()`.
+    pub fn size_points(&self) -> Vec2 {
+        self.window_mut().size()
     }
 
     /// Modifies the inner size of the window.
     ///
-    /// See the `inner_size` methods for more informations about the values.
-    pub fn set_inner_size_pixels(&self, width: u32, height: u32) {
-        self.window
-            .set_inner_size(winit::dpi::PhysicalSize { width, height })
+    /// See the `size` methods for more informations about the values.
+    pub fn set_size_pixels(&self, width: u32, height: u32) {
+        self.window_mut()
+            .resolution
+            .set_physical_resolution(width, height)
     }
 
     /// Modifies the inner size of the window using point values.
     ///
-    /// See the `inner_size` methods for more informations about the values.
-    pub fn set_inner_size_points(&self, width: f32, height: f32) {
-        self.window
-            .set_inner_size(winit::dpi::LogicalSize { width, height })
-    }
-
-    /// The width and height of the window in pixels.
-    ///
-    /// These dimensions include title bar and borders. If you don't want these, you should use
-    /// `inner_size_pixels` instead.
-    pub fn outer_size_pixels(&self) -> (u32, u32) {
-        self.window.outer_size().into()
-    }
-
-    /// The width and height of the window in points.
-    ///
-    /// These dimensions include title bar and borders. If you don't want these, you should use
-    /// `inner_size_points` instead.
-    ///
-    /// This is the same as dividing the result  of `outer_size_pixels()` by `scale_factor()`.
-    pub fn outer_size_points(&self) -> (f32, f32) {
-        self.window
-            .outer_size()
-            .to_logical::<f32>(self.tracked_state.scale_factor)
-            .into()
+    /// See the `size` methods for more informations about the values.
+    pub fn set_size_points(&self, width: f32, height: f32) {
+        self.window_mut().resolution.set(width, height)
     }
 
     /// Sets a minimum size for the window.
-    pub fn set_min_inner_size_points(&self, size: Option<(f32, f32)>) {
-        let size = size.map(|(width, height)| winit::dpi::LogicalSize { width, height });
-        self.window.set_min_inner_size(size)
+    pub fn set_min_size_points(&self, size: Option<Vec2>) {
+        if let Some(size) = size {
+            self.window_mut().resize_constraints.min_width = size.x;
+            self.window_mut().resize_constraints.min_height = size.y;
+        } else {
+            self.window_mut().resize_constraints.min_width = f32::INFINITY;
+            self.window_mut().resize_constraints.min_height = f32::INFINITY;
+        }
     }
 
     /// Sets a maximum size for the window.
-    pub fn set_max_inner_size_points(&self, size: Option<(f32, f32)>) {
-        let size = size.map(|(width, height)| winit::dpi::LogicalSize { width, height });
-        self.window.set_max_inner_size(size)
+    pub fn set_max_size_points(&self, size: Option<Vec2>) {
+        if let Some(size) = size {
+            self.window_mut().resize_constraints.max_width = size.x;
+            self.window_mut().resize_constraints.max_height = size.y;
+        } else {
+            self.window_mut().resize_constraints.max_width = f32::INFINITY;
+            self.window_mut().resize_constraints.max_height = f32::INFINITY;
+        }
     }
 
     /// Modifies the title of the window.
     ///
     /// This is a no-op if the window has already been closed.
-    pub fn set_title(&self, title: &str) {
-        self.window.set_title(title);
+    pub fn set_title(&self, title: String) {
+        self.window_mut().title = title;
     }
 
     /// Set the visibility of the window.
@@ -1278,7 +739,7 @@ impl Window {
     /// - iOS: Can only be called on the main thread.
     /// - Web: Has no effect.
     pub fn set_visible(&self, visible: bool) {
-        self.window.set_visible(visible)
+        self.window_mut().visible = visible;
     }
 
     /// Sets whether the window is resizable or not.
@@ -1286,17 +747,17 @@ impl Window {
     /// Note that making the window unresizable doesn't exempt you from handling **Resized**, as
     /// that event can still be triggered by DPI scaling, entering fullscreen mode, etc.
     pub fn set_resizable(&self, resizable: bool) {
-        self.window.set_resizable(resizable)
+        self.window_mut().resizable = resizable
     }
 
     /// Sets the window to minimized or back.
     pub fn set_minimized(&self, minimized: bool) {
-        self.window.set_minimized(minimized)
+        self.window_mut().set_minimized(minimized)
     }
 
     /// Sets the window to maximized or back.
     pub fn set_maximized(&self, maximized: bool) {
-        self.window.set_maximized(maximized)
+        self.window_mut().set_maximized(maximized)
     }
 
     /// Set the window to fullscreen on the primary monitor.
@@ -1307,36 +768,15 @@ impl Window {
     /// to fullscreen.
     pub fn set_fullscreen(&self, fullscreen: bool) {
         if fullscreen {
-            let monitor = self.current_monitor();
-            let fullscreen = Fullscreen::Borderless(monitor);
-            self.set_fullscreen_with(Some(fullscreen));
+            self.window_mut().mode = WindowMode::BorderlessFullscreen;
         } else {
-            self.set_fullscreen_with(None);
+            self.window_mut().mode = WindowMode::Windowed;
         }
     }
 
-    /// Set the window to fullscreen.
-    ///
-    /// Call this method again with `None` to revert back from fullscreen.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - macOS: `Fullscreen::Exclusive` provides true exclusive mode with a video mode change.
-    ///   Caveat! macOS doesn't provide task switching (or spaces!) while in exclusive fullscreen
-    ///   mode. This mode should be used when a video mode change is desired, but for a better user
-    ///   experience, borderless fullscreen might be preferred.
-    ///
-    ///   `Fullscreen::Borderless` provides a borderless fullscreen window on a separate space.
-    ///   This is the idiomatic way for fullscreen games to work on macOS. See
-    ///   WindowExtMacOs::set_simple_fullscreen if separate spaces are not preferred.
-    ///
-    ///   The dock and the menu bar are always disabled in fullscreen mode.
-    ///
-    /// - iOS: Can only be called on the main thread.
-    /// - Wayland: Does not support exclusive fullscreen mode.
-    /// - Windows: Screen saver is disabled in fullscreen mode.
-    pub fn set_fullscreen_with(&self, fullscreen: Option<Fullscreen>) {
-        self.window.set_fullscreen(fullscreen)
+    /// Sets the window mode
+    pub fn set_mode(&self, mode: WindowMode) {
+        self.window_mut().mode = mode;
     }
 
     /// Gets the window's current fullscreen state.
@@ -1344,8 +784,8 @@ impl Window {
     /// ## Platform-specific
     ///
     /// - **iOS:** Can only be called on the main thread.
-    pub fn fullscreen(&self) -> Option<Fullscreen> {
-        self.window.fullscreen()
+    pub fn mode(&self) -> WindowMode {
+        self.window_mut().mode
     }
 
     /// Turn window decorations on or off.
@@ -1356,16 +796,16 @@ impl Window {
     ///   via `setPrefersStatusBarHidden`.
     /// - **Web:** Has no effect.
     pub fn set_decorations(&self, decorations: bool) {
-        self.window.set_decorations(decorations)
+        self.window_mut().decorations = decorations;
     }
 
     /// Change whether or not the window will always be on top of other windows.
     pub fn set_always_on_top(&self, always_on_top: bool) {
-        self.window.set_window_level(if always_on_top {
+        self.window_mut().window_level = if always_on_top {
             WindowLevel::AlwaysOnTop
         } else {
             WindowLevel::Normal
-        })
+        }
     }
 
     /// Sets the window icon. On Windows and X11, this is typically the small icon in the top-left
@@ -1380,8 +820,8 @@ impl Window {
     ///
     /// X11 has no universal guidelines for icon sizes, so you're at the whims of the WM. That
     /// said, it's usually in the same ballpark as on Windows.
-    pub fn set_window_icon(&self, window_icon: Option<winit::window::Icon>) {
-        self.window.set_window_icon(window_icon)
+    pub fn set_window_icon(&self, _window_icon: Option<()>) {
+        todo!("https://github.com/bevyengine/bevy/issues/1031")
     }
 
     /// Sets the location of IME candidate box in client area coordinates relative to the top left.
@@ -1391,8 +831,7 @@ impl Window {
     /// - **iOS:** Has no effect.
     /// - **Web:** Has no effect.
     pub fn set_ime_position_points(&self, x: f32, y: f32) {
-        self.window
-            .set_ime_position(winit::dpi::LogicalPosition { x, y })
+        self.window_mut().ime_position = Vec2::new(x, y);
     }
 
     /// Modifies the mouse cursor of the window.
@@ -1401,8 +840,8 @@ impl Window {
     ///
     /// - **iOS:** Has no effect.
     /// - **Android:** Has no effect.
-    pub fn set_cursor_icon(&self, state: winit::window::CursorIcon) {
-        self.window.set_cursor_icon(state);
+    pub fn set_cursor_icon(&self, cursor: Cursor) {
+        self.window_mut().cursor = cursor;
     }
 
     /// Changes the position of the cursor in logical window coordinates.
@@ -1411,13 +850,8 @@ impl Window {
     ///
     /// - **iOS:** Always returns an `Err`.
     /// - **Web:** Has no effect.
-    pub fn set_cursor_position_points(
-        &self,
-        x: f32,
-        y: f32,
-    ) -> Result<(), winit::error::ExternalError> {
-        self.window
-            .set_cursor_position(winit::dpi::LogicalPosition { x, y })
+    pub fn set_cursor_position_points(&self, x: f32, y: f32) {
+        self.window_mut().set_cursor_position(Some(Vec2::new(x, y)));
     }
 
     /// Grabs the cursor, preventing it from leaving the window.
@@ -1429,12 +863,12 @@ impl Window {
     /// - **Android:** Has no effect.
     /// - **iOS:** Always returns an Err.
     /// - **Web:** Has no effect.
-    pub fn set_cursor_grab(&self, grab: bool) -> Result<(), winit::error::ExternalError> {
-        self.window.set_cursor_grab(if grab {
+    pub fn set_cursor_grab(&self, grab: bool) {
+        self.window_mut().cursor.grab_mode = if grab {
             CursorGrabMode::Locked
         } else {
             CursorGrabMode::None
-        })
+        };
     }
 
     /// Set the cursor's visibility.
@@ -1451,88 +885,12 @@ impl Window {
     ///
     /// This has no effect on **Android** or **iOS**.
     pub fn set_cursor_visible(&self, visible: bool) {
-        self.window.set_cursor_visible(visible)
-    }
-
-    /// The current monitor that the window is, on or the primary monitor if nothing matches.
-    /// If there's neither a current nor a primary monitor, returns none.
-    pub fn current_monitor(&self) -> Option<winit::monitor::MonitorHandle> {
-        self.window.current_monitor()
-    }
-
-    // Access to wgpu API.
-
-    /// Returns a reference to the window's wgpu surface.
-    pub fn surface(&self) -> &wgpu::Surface {
-        &self.surface
-    }
-
-    /// The current configuration of the window's wgpu surface.
-    pub fn surface_configuration(&self) -> &wgpu::SurfaceConfiguration {
-        &self.surface_conf
-    }
-
-    /// The wgpu logical device on which the window's wgpu surface is running.
-    pub fn device(&self) -> &wgpu::Device {
-        self.device_queue_pair.device()
-    }
-
-    /// The wgpu graphics queue to which the window's wgpu surface frames are submitted.
-    pub fn queue(&self) -> &wgpu::Queue {
-        self.device_queue_pair.queue()
-    }
-
-    /// Provides access to the device queue pair and the `Arc` behind which it is stored. This can
-    /// be useful in cases where using references provided by the `device` or `queue` methods cause
-    /// awkward ownership problems.
-    pub fn device_queue_pair(&self) -> &Arc<wgpu::DeviceQueuePair> {
-        &self.device_queue_pair
-    }
-
-    /// The number of samples used in the MSAA for the image associated with the `view` function's
-    /// `Frame` type.
-    ///
-    /// **Note:** If the user specified a `raw_view` function rather than a `view` function, this
-    /// value will always return `1`.
-    pub fn msaa_samples(&self) -> u32 {
-        self.msaa_samples
-    }
-
-    // Custom methods.
-
-    // A utility function to simplify the reconfiguration of the window's wgpu surface.
-    //
-    // Upon resizing of the window, the window's surface needs to be reconfigured to match.
-    //
-    // Also syncs the window tracked size with the surface size.
-    pub(crate) fn reconfigure_surface(&mut self, [w_px, h_px]: [u32; 2]) {
-        self.tracked_state.physical_size.width = w_px.max(MIN_SC_PIXELS.width);
-        self.tracked_state.physical_size.height = h_px.max(MIN_SC_PIXELS.height);
-        self.surface_conf.width = self.tracked_state.physical_size.width;
-        self.surface_conf.height = self.tracked_state.physical_size.height;
-        self.surface.configure(self.device(), &self.surface_conf);
-        if self.frame_data.is_some() {
-            let render_data = frame::RenderData::new(
-                self.device(),
-                self.tracked_state.physical_size.into(),
-                self.surface_conf.format,
-                self.msaa_samples,
-            );
-            self.frame_data.as_mut().unwrap().render = render_data;
-        }
-
-        // May contain uninitialized or previous contents, so must be cleared
-        self.is_invalidated = true;
+        self.window_mut().cursor.visible = visible;
     }
 
     /// Attempts to determine whether or not the window is currently fullscreen.
     pub fn is_fullscreen(&self) -> bool {
-        self.fullscreen().is_some()
-    }
-
-    /// The number of times `view` has been called with a `Frame` for this window.
-    pub fn elapsed_frames(&self) -> u64 {
-        self.frame_count
+        self.window_mut().mode == WindowMode::Fullscreen
     }
 
     /// The rectangle representing the position and dimensions of the window.
@@ -1540,115 +898,22 @@ impl Window {
     /// The window's position will always be `[0.0, 0.0]`, as positions are generally described
     /// relative to the centre of the window itself.
     ///
-    /// The dimensions will be equal to the result of `inner_size_points`. This represents the area
+    /// The dimensions will be equal to the result of `size_points`. This represents the area
     /// of the that we can draw to in a DPI-agnostic manner, typically useful for drawing and UI
     /// positioning.
     pub fn rect(&self) -> geom::Rect {
-        let (w, h) = self.inner_size_points();
-        geom::Rect::from_w_h(w, h)
-    }
-
-    /// Capture the next frame right before it is drawn to this window and write it to an image
-    /// file at the given path. If a frame already exists, it will be captured before its `submit`
-    /// method is called or before it is `drop`ped.
-    ///
-    /// The destination image file type will be inferred from the extension given in the path.
-    pub fn capture_frame<P>(&self, path: P)
-    where
-        P: AsRef<Path>,
-    {
-        self.capture_frame_inner(path.as_ref());
-    }
-
-    /// Produces a reference to the inner winit window.
-    ///
-    /// This is sometimes useful for integration with other winit-aware libraries (e.g. UI).
-    pub fn winit_window(&self) -> &winit::window::Window {
-        &self.window
-    }
-
-    fn capture_frame_inner(&self, path: &Path) {
-        // If the parent directory does not exist, create it.
-        let dir = path.parent().expect("capture_frame path has no directory");
-        if !dir.exists() {
-            std::fs::create_dir_all(&dir).expect("failed to create `capture_frame` directory");
-        }
-
-        let mut capture_next_frame_path = self
-            .frame_data
-            .as_ref()
-            .expect("window capture requires that `view` draws to a `Frame` (not a `RawFrame`)")
-            .capture
-            .next_frame_path
-            .lock()
-            .expect("failed to lock `capture_next_frame_path`");
-        *capture_next_frame_path = Some(path.to_path_buf());
-    }
-
-    /// Block and wait for all active capture frame jobs to complete.
-    ///
-    /// This is called implicitly when the window is dropped to ensure any pending captures
-    /// complete.
-    pub fn await_capture_frame_jobs(
-        &self,
-    ) -> Result<(), wgpu::TextureCapturerAwaitWorkerTimeout<()>> {
-        if let Some(frame_data) = self.frame_data.as_ref() {
-            let capture_data = &frame_data.capture;
-            let device = self.device();
-            return capture_data.texture_capturer.await_active_snapshots(device);
-        }
-        Ok(())
-    }
-}
-
-// Drop implementations.
-
-impl Drop for Window {
-    fn drop(&mut self) {
-        if self.await_capture_frame_jobs().is_err() {
-            // TODO: Replace eprintlns with proper logging.
-            eprintln!("timed out while waiting for capture jobs to complete");
-        }
-    }
-}
-
-// Debug implementations for function wrappers.
-
-impl fmt::Debug for View {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let variant = match *self {
-            View::WithModel(ref v) => format!("WithModel({:?})", v),
-            View::WithModelRaw(ref v) => format!("WithModelRaw({:?})", v),
-            View::Sketch(_) => "Sketch".to_string(),
-        };
-        write!(f, "View::{}", variant)
-    }
-}
-
-// Error implementations.
-
-impl fmt::Display for BuildError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            BuildError::NoAvailableAdapter => write!(f, "no available wgpu adapter detected"),
-            BuildError::WinitOsError(ref e) => e.fmt(f),
-        }
-    }
-}
-
-impl From<winit::error::OsError> for BuildError {
-    fn from(e: winit::error::OsError) -> Self {
-        BuildError::WinitOsError(e)
-    }
-}
-
-// Some WGPU helper implementations.
-
-impl<'a> wgpu::WithDeviceQueuePair for &'a crate::window::Window {
-    fn with_device_queue_pair<F, O>(self, f: F) -> O
-    where
-        F: FnOnce(&wgpu::Device, &wgpu::Queue) -> O,
-    {
-        self.device_queue_pair().with_device_queue_pair(f)
+        let size = self.size_points();
+        geom::Rect::from_x_y_w_h(0.0, 0.0, size.x, size.y)
+    }
+
+    /// Saves a screenshot of the window to the given path.
+    pub fn save_screenshot<P: AsRef<Path>>(&mut self, path: P) {
+        let mut world = self.app.resource_world_mut();
+        let mut screenshot_manager = world
+            .get_resource_mut::<ScreenshotManager>()
+            .expect("ScreenshotManager resource not found");
+        screenshot_manager
+            .save_screenshot_to_disk(self.entity, path)
+            .expect("Failed to save screenshot");
     }
 }
diff --git a/nannou/src/world.rs b/nannou/src/world.rs
new file mode 100644
index 000000000..7cadbe5fe
--- /dev/null
+++ b/nannou/src/world.rs
@@ -0,0 +1,86 @@
+use std::cell::RefCell;
+use std::ops::{Deref, DerefMut};
+use std::rc::Rc;
+use bevy_nannou::prelude::{Asset, Assets, AssetServer, Deref, DerefMut, Mut};
+use crate::prelude::bevy_ecs::world::unsafe_world_cell::UnsafeWorldCell;
+
+#[derive(Deref, DerefMut)]
+pub struct WorldAcess<'w>(pub UnsafeWorldCell<'w>);
+
+impl <'w> WorldAcess<'w> {
+    pub fn asset_server(&self) -> Mut<AssetServer> {
+        unsafe {
+            let world = self.world_mut();
+            world.resource_mut::<AssetServer>()
+        }
+    }
+
+    pub fn assets_mut<T: Asset>(&self) -> Mut<'_, Assets<T>> {
+        unsafe {
+            let world = self.world_mut();
+            world.resource_mut::<Assets<T>>()
+        }
+    }
+
+    pub fn assets<T: Asset>(&self) -> &Assets<T> {
+        unsafe {
+            let world = self.world_mut();
+            world.resource::<Assets<T>>()
+        }
+    }
+}
+
+pub struct AssetAccessor<'w, T: Asset> {
+    assets: Rc<RefCell<WorldAcess<'w>>>,
+    _phantom: std::marker::PhantomData<T>,
+}
+
+impl<'w, T: Asset> AssetAccessor<'w, T> {
+    pub(crate) fn new(assets: Rc<RefCell<WorldAcess<'w>>>) -> Self {
+        Self {
+            assets,
+            _phantom: std::marker::PhantomData,
+        }
+    }
+}
+
+impl<'w, T: Asset> Deref for AssetAccessor<'w, T> {
+    type Target = Assets<T>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.assets.borrow().assets::<T>()
+    }
+}
+
+impl<'w, T: Asset> DerefMut for AssetAccessor<'w, T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.assets.borrow_mut().assets_mut::<T>().deref_mut()
+    }
+}
+
+pub struct AssetServerAccessor<'w> {
+    asset_server: Rc<RefCell<WorldAcess<'w>>>,
+}
+
+impl AssetServerAccessor<'_> {
+    pub(crate) fn new(asset_server: Rc<RefCell<WorldAcess>>) -> Self {
+        Self {
+            asset_server,
+        }
+    }
+}
+
+impl Deref for AssetServerAccessor<'_> {
+    type Target = AssetServer;
+
+    fn deref(&self) -> &Self::Target {
+        &self.asset_server.borrow().asset_server()
+    }
+}
+
+impl DerefMut for AssetServerAccessor<'_> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.asset_server.borrow_mut().asset_server().deref_mut()
+    }
+}
+
diff --git a/nannou/tests/geom_tests.rs b/nannou/tests/geom_tests.rs
index 99693bffc..2f6c8ba2f 100644
--- a/nannou/tests/geom_tests.rs
+++ b/nannou/tests/geom_tests.rs
@@ -3,13 +3,13 @@ use nannou::prelude::*;
 #[test]
 fn angle_test() {
     let vector = vec2(1.0, 1.0);
-    assert_eq!(vector.angle(), 0.7853981633974483);
+    assert_eq!(vector.angle(), 0.785_398_2);
     let vector = vec2(5.0, 2.0);
-    assert_eq!(vector.angle(), 0.3805063771123649);
+    assert_eq!(vector.angle(), 0.380_506_37);
     let vector = vec2(-3.0, 4.0);
-    assert_eq!(vector.angle(), 2.214297435588181);
+    assert_eq!(vector.angle(), 2.214_297_5);
     let vector = vec2(-2.1, -6.7);
     assert_eq!(vector.angle(), -1.874531);
     let vector = vec2(70.7, -60.8);
-    assert_eq!(vector.angle(), -0.7102547457375739);
+    assert_eq!(vector.angle(), -0.710_254_7);
 }
diff --git a/nannou_audio/.dropboxignore b/nannou_audio/.dropboxignore
new file mode 100644
index 000000000..833029195
--- /dev/null
+++ b/nannou_audio/.dropboxignore
@@ -0,0 +1,16 @@
+# ----
+# Automatically Generated .dropboxignore file at Tue Apr 23 13:35:38 PDT 2024
+# ----
+<<<<<<< HEAD
+capture_hi_res/
+simple_capture/
+target/
+**/*.rs.bk
+Cargo.lock
+.DS_Store
+=======
+/target
+**/*.rs.bk
+Cargo.lock
+>>>>>>> nannou_audio/master
+# ----
diff --git a/nannou_audio/src/device.rs b/nannou_audio/src/device.rs
index 19ab56600..9961bceda 100644
--- a/nannou_audio/src/device.rs
+++ b/nannou_audio/src/device.rs
@@ -1,8 +1,10 @@
+use std::ops::Deref;
+
+use cpal::traits::DeviceTrait;
+
 use crate::{
     DefaultStreamConfigError, DeviceNameError, SupportedStreamConfig, SupportedStreamConfigsError,
 };
-use cpal::traits::DeviceTrait;
-use std::ops::Deref;
 
 /// A device that can be used to spawn an audio stream.
 pub struct Device {
diff --git a/nannou_audio/src/lib.rs b/nannou_audio/src/lib.rs
index 266752392..a3fd21364 100644
--- a/nannou_audio/src/lib.rs
+++ b/nannou_audio/src/lib.rs
@@ -12,16 +12,11 @@
 //!   [**Requester**](./requester/struct.Requester.html) for buffering input and output streams that
 //!   may deliver buffers of inconsistent sizes into a stream of consistently sized buffers.
 
-use cpal::traits::HostTrait;
 use std::marker::PhantomData;
 use std::sync::Arc;
 
-pub use self::buffer::Buffer;
-pub use self::device::{Device, Devices};
-pub use self::receiver::Receiver;
-pub use self::requester::Requester;
-pub use self::stream::Stream;
 pub use cpal;
+use cpal::traits::HostTrait;
 #[doc(inline)]
 pub use cpal::{
     BackendSpecificError, BufferSize, BuildStreamError, DefaultStreamConfigError, DeviceNameError,
@@ -32,6 +27,12 @@ pub use cpal::{
 };
 pub use dasp_sample;
 
+pub use self::buffer::Buffer;
+pub use self::device::{Device, Devices};
+pub use self::receiver::Receiver;
+pub use self::requester::Requester;
+pub use self::stream::Stream;
+
 pub mod buffer;
 pub mod device;
 pub mod receiver;
diff --git a/nannou_audio/src/receiver.rs b/nannou_audio/src/receiver.rs
index 66a9dd084..dd3a40261 100644
--- a/nannou_audio/src/receiver.rs
+++ b/nannou_audio/src/receiver.rs
@@ -1,7 +1,9 @@
-use crate::{stream, Buffer};
-use dasp_sample::Sample;
 use std;
 
+use dasp_sample::Sample;
+
+use crate::{stream, Buffer};
+
 /// A `Receiver` for converting audio delivered by the backend at varying buffer sizes into buffers
 /// of a fixed size.
 ///
@@ -27,8 +29,8 @@ where
         let num_samples = num_frames + num_channels;
         Receiver {
             samples: Vec::with_capacity(num_samples),
-            num_frames: num_frames,
-            num_channels: num_channels,
+            num_frames,
+            num_channels,
         }
     }
 
@@ -86,7 +88,7 @@ where
             }
 
             // Capture the input data and update the model.
-            let interleaved_samples = std::mem::replace(samples, Vec::new()).into_boxed_slice();
+            let interleaved_samples = std::mem::take(samples).into_boxed_slice();
             let buffer = Buffer {
                 interleaved_samples,
                 channels,
diff --git a/nannou_audio/src/requester.rs b/nannou_audio/src/requester.rs
index 9533daa5e..dfbd65ab2 100644
--- a/nannou_audio/src/requester.rs
+++ b/nannou_audio/src/requester.rs
@@ -1,7 +1,9 @@
-use crate::{stream, Buffer};
-use dasp_sample::Sample;
 use std;
 
+use dasp_sample::Sample;
+
+use crate::{stream, Buffer};
+
 /// A `sound::Requester` for converting backend audio requests into requests for buffers of a fixed
 /// size called from a separate thread.
 ///
@@ -27,7 +29,7 @@ where
         let num_samples = num_frames + num_channels;
         Requester {
             samples: vec![S::EQUILIBRIUM; num_samples],
-            num_frames: num_frames,
+            num_frames,
             pending_range: None,
         }
     }
@@ -122,7 +124,7 @@ where
             silence(samples);
 
             // Render the state of the model to the samples buffer.
-            let interleaved_samples = std::mem::replace(samples, Vec::new()).into_boxed_slice();
+            let interleaved_samples = std::mem::take(samples).into_boxed_slice();
             let mut buffer = Buffer {
                 interleaved_samples,
                 channels,
diff --git a/nannou_audio/src/stream/input.rs b/nannou_audio/src/stream/input.rs
index f19415020..adce43f90 100644
--- a/nannou_audio/src/stream/input.rs
+++ b/nannou_audio/src/stream/input.rs
@@ -1,12 +1,14 @@
+use std::sync::atomic::AtomicBool;
+use std::sync::mpsc;
+use std::sync::{Arc, Mutex};
+
+use cpal::traits::{DeviceTrait, HostTrait};
+use dasp_sample::{FromSample, Sample, ToSample};
+
 use crate::{
     stream::{self, DefaultErrorFn, ErrorFn},
     Buffer, Device, Receiver, Stream,
 };
-use cpal::traits::{DeviceTrait, HostTrait};
-use dasp_sample::{FromSample, Sample, ToSample};
-use std::sync::atomic::AtomicBool;
-use std::sync::mpsc;
-use std::sync::{Arc, Mutex};
 
 /// The function that will be called when a captured `Buffer` is ready to be read.
 pub trait CaptureFn<M, S>: Fn(&mut M, &Buffer<S>) {}
@@ -140,7 +142,7 @@ impl<M, FC, FE, S> Builder<M, FC, FE, S> {
         let num_channels = matching.config.channels as usize;
         let sample_rate = matching.config.sample_rate.0;
         let sample_format = matching.sample_format;
-        let stream_config = matching.config.into();
+        let stream_config = matching.config;
 
         // A buffer for collecting model updates.
         let mut pending_updates: Vec<Box<dyn FnMut(&mut M) + 'static + Send>> = Vec::new();
@@ -196,15 +198,15 @@ impl<M, FC, FE, S> Builder<M, FC, FE, S> {
             match sample_format {
                 cpal::SampleFormat::U16 => {
                     let input = data.as_slice::<u16>().expect("expected u16 data");
-                    fill_input(&mut samples, &input);
+                    fill_input(&mut samples, input);
                 }
                 cpal::SampleFormat::I16 => {
                     let input = data.as_slice::<i16>().expect("expected i16 data");
-                    fill_input(&mut samples, &input);
+                    fill_input(&mut samples, input);
                 }
                 cpal::SampleFormat::F32 => {
                     let input = data.as_slice::<f32>().expect("expected f32 data");
-                    fill_input(&mut samples, &input);
+                    fill_input(&mut samples, input);
                 }
             }
 
diff --git a/nannou_audio/src/stream/mod.rs b/nannou_audio/src/stream/mod.rs
index 5a1be11d8..a9388994b 100644
--- a/nannou_audio/src/stream/mod.rs
+++ b/nannou_audio/src/stream/mod.rs
@@ -1,12 +1,14 @@
-use crate::Device;
-use cpal::traits::StreamTrait;
 use std;
 use std::any::{Any, TypeId};
 use std::marker::PhantomData;
 use std::sync::atomic::{self, AtomicBool};
 use std::sync::{mpsc, Arc, Mutex};
+
+use cpal::traits::StreamTrait;
 use thiserror::Error;
 
+use crate::Device;
+
 /// Items related to input audio streams.
 pub mod input;
 /// Items related to output audio streams.
diff --git a/nannou_audio/src/stream/output.rs b/nannou_audio/src/stream/output.rs
index 66cb46f6a..4fd8cb978 100644
--- a/nannou_audio/src/stream/output.rs
+++ b/nannou_audio/src/stream/output.rs
@@ -1,12 +1,14 @@
+use std::sync::atomic::AtomicBool;
+use std::sync::mpsc;
+use std::sync::{Arc, Mutex};
+
+use cpal::traits::{DeviceTrait, HostTrait};
+use dasp_sample::{Sample, ToSample};
+
 use crate::{
     stream::{self, DefaultErrorFn, ErrorFn},
     Buffer, Device, Requester, Stream,
 };
-use cpal::traits::{DeviceTrait, HostTrait};
-use dasp_sample::{Sample, ToSample};
-use std::sync::atomic::AtomicBool;
-use std::sync::mpsc;
-use std::sync::{Arc, Mutex};
 
 /// The function that will be called when a `Buffer` is ready to be rendered.
 pub trait RenderFn<M, S>: Fn(&mut M, &mut Buffer<S>) {}
@@ -139,7 +141,7 @@ impl<M, FR, FE, S> Builder<M, FR, FE, S> {
         let num_channels = matching.config.channels as usize;
         let sample_rate = matching.config.sample_rate.0;
         let sample_format = matching.sample_format;
-        let stream_config = matching.config.into();
+        let stream_config = matching.config;
 
         // A buffer for collecting model updates.
         let mut pending_updates: Vec<Box<dyn FnMut(&mut M) + 'static + Send>> = Vec::new();
diff --git a/nannou_core/Cargo.toml b/nannou_core/Cargo.toml
index 7c505066e..cdcf4ddf0 100644
--- a/nannou_core/Cargo.toml
+++ b/nannou_core/Cargo.toml
@@ -10,11 +10,10 @@ homepage = "https://nannou.cc"
 edition = "2018"
 
 [dependencies]
-glam = { version = "0.24.2", default-features = false, features = ["rand"] }
+glam = { version = "0.27.0", default-features = false, features = ["rand"] }
 # TODO: Awaiting `no-std` to be published.
 # noise = 0.6
 num-traits = { version = "0.2.14", default-features = false }
-palette = { version = "0.5", default-features = false, features = ["named"] }
 # TODO: Need to check support for no-std.
 # pennereq = "0.3"
 rand = { version = "0.8", default-features = false, features = ["small_rng"] }
@@ -23,9 +22,9 @@ rand = { version = "0.8", default-features = false, features = ["small_rng"] }
 
 [features]
 default = ["std"]
-libm = ["glam/libm", "num-traits/libm", "palette/libm" ]
-serde = ["glam/serde", "palette/serializing"]
-std = ["glam/std", "num-traits/std", "palette/std", "rand/std", "rand/std_rng"]
+libm = ["glam/libm", "num-traits/libm"]
+serde = ["glam/serde"]
+std = ["glam/std", "num-traits/std", "rand/std", "rand/std_rng"]
 
 [package.metadata.docs.rs]
 features = ["serde", "std"]
diff --git a/nannou_core/src/color/conv.rs b/nannou_core/src/color/conv.rs
deleted file mode 100644
index f9413f468..000000000
--- a/nannou_core/src/color/conv.rs
+++ /dev/null
@@ -1,143 +0,0 @@
-//! This module provides some more flexible conversions and aims to fill the gaps within the `From`
-//! and `Into` implementations provided by the `palette` library.
-//!
-//! If a desired conversion is missing, feel free to open an issue or pull request!
-
-use crate::color::white_point::D65;
-use crate::color::{self, encoding, Alpha, Component, IntoColor, LinSrgba};
-use crate::math::num_traits::Float;
-
-/// Types that may be converted directly into a linear sRGBA color representation.
-///
-/// This is more flexible than `Into<LinSrgba<S>>` as it also supports converting from different
-/// sRGBA encodings that also have different component types.
-///
-/// This trait is important for nannou as the `Draw` API works with the `LinSrgba` type as a target
-/// for its generic colour type API.
-pub trait IntoLinSrgba<S>
-where
-    S: Component,
-{
-    /// Convert self into RGBA.
-    fn into_lin_srgba(self) -> LinSrgba<S>;
-}
-
-impl<S> IntoLinSrgba<S> for color::Xyz<D65, S>
-where
-    S: Component + Float,
-{
-    fn into_lin_srgba(self) -> LinSrgba<S> {
-        into_lin_srgb_with_alpha(self)
-    }
-}
-
-impl<S> IntoLinSrgba<S> for color::Yxy<D65, S>
-where
-    S: Component + Float,
-{
-    fn into_lin_srgba(self) -> LinSrgba<S> {
-        into_lin_srgb_with_alpha(self)
-    }
-}
-
-impl<S> IntoLinSrgba<S> for color::Lab<D65, S>
-where
-    S: Component + Float,
-{
-    fn into_lin_srgba(self) -> LinSrgba<S> {
-        into_lin_srgb_with_alpha(self)
-    }
-}
-
-impl<S> IntoLinSrgba<S> for color::Lch<D65, S>
-where
-    S: Component + Float,
-{
-    fn into_lin_srgba(self) -> LinSrgba<S> {
-        into_lin_srgb_with_alpha(self)
-    }
-}
-
-impl<T, S> IntoLinSrgba<S> for color::LinSrgb<T>
-where
-    T: Component,
-    S: Component,
-{
-    fn into_lin_srgba(self) -> LinSrgba<S> {
-        let color = self.into_format();
-        let alpha = S::max_intensity();
-        Alpha { color, alpha }
-    }
-}
-
-impl<T, S> IntoLinSrgba<S> for color::Srgb<T>
-where
-    T: Component,
-    S: Component + Float,
-{
-    fn into_lin_srgba(self) -> LinSrgba<S> {
-        let color = self.into_format().into_linear();
-        let alpha = S::max_intensity();
-        Alpha { color, alpha }
-    }
-}
-
-impl<S> IntoLinSrgba<S> for color::Hsl<encoding::Srgb, S>
-where
-    S: Component + Float,
-{
-    fn into_lin_srgba(self) -> LinSrgba<S> {
-        into_lin_srgb_with_alpha(self)
-    }
-}
-
-impl<S> IntoLinSrgba<S> for color::Hsv<encoding::Srgb, S>
-where
-    S: Component + Float,
-{
-    fn into_lin_srgba(self) -> LinSrgba<S> {
-        into_lin_srgb_with_alpha(self)
-    }
-}
-
-impl<S> IntoLinSrgba<S> for color::Hwb<encoding::Srgb, S>
-where
-    S: Component + Float,
-{
-    fn into_lin_srgba(self) -> LinSrgba<S> {
-        into_lin_srgb_with_alpha(self)
-    }
-}
-
-impl<S> IntoLinSrgba<S> for color::SrgbLuma<S>
-where
-    S: Component + Float,
-{
-    fn into_lin_srgba(self) -> LinSrgba<S> {
-        into_lin_srgb_with_alpha(self)
-    }
-}
-
-impl<C, S, T> IntoLinSrgba<S> for Alpha<C, T>
-where
-    C: IntoLinSrgba<S>,
-    S: Component,
-    T: Component,
-{
-    fn into_lin_srgba(self) -> LinSrgba<S> {
-        let Alpha { color, alpha } = self;
-        let mut srgba = color.into_lin_srgba();
-        srgba.alpha = alpha.convert();
-        srgba
-    }
-}
-
-fn into_lin_srgb_with_alpha<C, S>(color: C) -> LinSrgba<S>
-where
-    C: IntoColor<D65, S>,
-    S: Component + Float,
-{
-    let color: color::LinSrgb<S> = color.into_rgb::<encoding::Srgb>();
-    let alpha = S::max_intensity();
-    Alpha { color, alpha }
-}
diff --git a/nannou_core/src/color/mod.rs b/nannou_core/src/color/mod.rs
deleted file mode 100644
index 5aa67c50a..000000000
--- a/nannou_core/src/color/mod.rs
+++ /dev/null
@@ -1,167 +0,0 @@
-//! Color items, including everything from rgb, hsb/l/v, lap, alpha, luma and more, provided by the
-//! [palette crate](https://docs.rs/palette).
-//!
-//! See the [**named**](./named/index.html) module for a set of provided color constants.
-
-pub mod conv;
-
-pub use self::conv::IntoLinSrgba;
-pub use self::named::*;
-#[doc(inline)]
-pub use palette::*;
-
-/// The default scalar value for working with color components, hues, etc.
-pub type DefaultScalar = f32;
-
-/// A color represented as red, green and blue intensities.
-///
-/// This type is an alias for the `Srgb` type, a type that represents the sRGB color space.
-///
-/// If you are looking for more advanced control over the RGB space and component type, please see
-/// the `palette` crate's generic `Rgb` type.
-pub type Rgb<S = DefaultScalar> = Srgb<S>;
-
-/// The same as `Rgb`, but with `u8`'s.
-pub type Rgb8 = Rgb<u8>;
-
-/// The same as `Rgb`, but with an alpha value representing opacity.
-///
-/// This type is an alias for the `Srgba` type, a type that represents the sRGB color space
-/// alongside an alpha value.
-///
-/// If you are looking for more advanced control over the RGB space and component type, please see
-/// the `palette` crate's generic `Rgb` type.
-pub type Rgba<S = DefaultScalar> = Srgba<S>;
-
-/// The same as `Rgba`, but with `u8`'s.
-pub type Rgba8 = Rgba<u8>;
-
-/// A color represented as gray intensity.
-///
-/// This type is an alias for the `Srgb` type, a type that represents the sRGB color space.
-///
-/// If you are looking for more advanced control over the RGB space and component type, please see
-/// the `palette` crate's generic `Rgb` type.
-pub type Gray<S = DefaultScalar> = Srgb<S>;
-
-/// A short-hand constructor for `Rgb::new`.
-pub fn rgb<T>(r: T, g: T, b: T) -> Rgb<T>
-where
-    T: Component,
-{
-    srgb(r, g, b)
-}
-
-/// A short-hand constructor for `Rgb::<u8>::new` .
-pub fn rgb8(r: u8, g: u8, b: u8) -> Rgb8 {
-    srgb(r, g, b)
-}
-
-/// A short-hand constructor for `Rgba::new`.
-pub fn rgba<T>(r: T, g: T, b: T, a: T) -> Rgba<T>
-where
-    T: Component,
-{
-    srgba(r, g, b, a)
-}
-
-/// A short-hand constructor for `Rgba<u8>::new`.
-pub fn rgba8(r: u8, g: u8, b: u8, a: u8) -> Rgba8 {
-    srgba8(r, g, b, a)
-}
-
-/// A short-hand constructor for `Srgb::new`.
-pub fn srgb<T>(r: T, g: T, b: T) -> Srgb<T>
-where
-    T: Component,
-{
-    Srgb::new(r, g, b)
-}
-
-/// A short-hand constructor for `Srgb<u8>::new`.
-pub fn srgb8(r: u8, g: u8, b: u8) -> Srgb<u8> {
-    Srgb::new(r, g, b)
-}
-
-/// A short-hand constructor for `Srgba::new`.
-pub fn srgba<T>(r: T, g: T, b: T, a: T) -> Srgba<T>
-where
-    T: Component,
-{
-    Srgba::new(r, g, b, a)
-}
-
-/// A short-hand constructor for `Srgba<u8>::new`.
-pub fn srgba8(r: u8, g: u8, b: u8, a: u8) -> Srgba<u8> {
-    Srgba::new(r, g, b, a)
-}
-
-/// A short-hand constructor for `LinSrgb::new`.
-pub fn lin_srgb<T>(r: T, g: T, b: T) -> LinSrgb<T>
-where
-    T: Component,
-{
-    LinSrgb::new(r, g, b)
-}
-
-/// A short-hand constructor for `LinSrgba::new`.
-pub fn lin_srgba<T>(r: T, g: T, b: T, a: T) -> LinSrgba<T>
-where
-    T: Component,
-{
-    LinSrgba::new(r, g, b, a)
-}
-
-/// Create a new color from a hexadecimal int literal
-#[inline]
-pub fn rgb_u32(c: u32) -> Rgb<u8> {
-    let blue: u8 = (c & 0xFF) as u8;
-    let green: u8 = ((c >> 8) & 0xFF) as u8;
-    let red: u8 = ((c >> 16) & 0xFF) as u8;
-    rgb8(red, green, blue)
-}
-
-/// A short-hand constructor for `Hsl::new(RgbHue::from_degrees(h * 360.0), s, l)`.
-///
-/// The given hue expects a value between `0.0` and `1.0` where `0.0` is 0 degress and `1.0` is
-/// 360 degrees (or 2 PI radians).
-pub fn hsl(h: f32, s: f32, l: f32) -> Hsl {
-    Hsl::new(RgbHue::from_degrees(h * 360.0), s, l)
-}
-
-/// A short-hand constructor for `Hsla::new(RgbHue::from_degrees(h * 360.0), s, l, a)`.
-///
-/// The given hue expects a value between `0.0` and `1.0` where `0.0` is 0 degress and `1.0` is
-/// 360 degrees (or 2 PI radians).
-pub fn hsla(h: f32, s: f32, l: f32, a: f32) -> Hsla {
-    Hsla::new(RgbHue::from_degrees(h * 360.0), s, l, a)
-}
-
-/// A short-hand constructor for `Hsv::new(RgbHue::from_degrees(h * 360.0), s, v)`.
-///
-/// The given hue expects a value between `0.0` and `1.0` where `0.0` is 0 degress and `1.0` is
-/// 360 degrees (or 2 PI radians).
-pub fn hsv(h: f32, s: f32, v: f32) -> Hsv {
-    Hsv::new(RgbHue::from_degrees(h * 360.0), s, v)
-}
-
-/// A short-hand constructor for `Hsva::new(RgbHue::from_degrees(h * 360.0), s, v, a)`.
-///
-/// The given hue expects a value between `0.0` and `1.0` where `0.0` is 0 degress and `1.0` is
-/// 360 degrees (or 2 PI radians).
-pub fn hsva(h: f32, s: f32, v: f32, a: f32) -> Hsva {
-    Hsva::new(RgbHue::from_degrees(h * 360.0), s, v, a)
-}
-
-/// A short-hand constructor for `Gray::new`.
-pub fn gray<T>(g: T) -> Gray<T>
-where
-    T: Component,
-{
-    srgb(g, g, g)
-}
-
-#[test]
-fn test_rgb_u32() {
-    assert_eq!(rgb_u32(0xFF8000), rgb8(255, 128, 0));
-}
diff --git a/nannou_core/src/geom/cuboid.rs b/nannou_core/src/geom/cuboid.rs
index 05aa95846..dd62748ce 100644
--- a/nannou_core/src/geom/cuboid.rs
+++ b/nannou_core/src/geom/cuboid.rs
@@ -467,14 +467,14 @@ where
     /// 0---1
     /// ```
     pub fn corners(&self) -> [[S; 3]; NUM_CORNERS as usize] {
-        let a = [self.x.start, self.y.start, self.z.start].into();
-        let b = [self.x.end, self.y.start, self.z.start].into();
-        let c = [self.x.start, self.y.end, self.z.start].into();
-        let d = [self.x.end, self.y.end, self.z.start].into();
-        let e = [self.x.start, self.y.start, self.z.end].into();
-        let f = [self.x.end, self.y.start, self.z.end].into();
-        let g = [self.x.start, self.y.end, self.z.end].into();
-        let h = [self.x.end, self.y.end, self.z.end].into();
+        let a = [self.x.start, self.y.start, self.z.start];
+        let b = [self.x.end, self.y.start, self.z.start];
+        let c = [self.x.start, self.y.end, self.z.start];
+        let d = [self.x.end, self.y.end, self.z.start];
+        let e = [self.x.start, self.y.start, self.z.end];
+        let f = [self.x.end, self.y.start, self.z.end];
+        let g = [self.x.start, self.y.end, self.z.end];
+        let h = [self.x.end, self.y.end, self.z.end];
         [a, b, c, d, e, f, g, h]
     }
 
@@ -753,7 +753,7 @@ where
         7 => corner_from_index!(7, c),
         _ => return None,
     };
-    Some(p.into())
+    Some(p)
 }
 
 impl<'a, S> Iterator for Corners<'a, S>
diff --git a/nannou_core/src/geom/ellipse.rs b/nannou_core/src/geom/ellipse.rs
index 58c55711c..0d409cbd0 100644
--- a/nannou_core/src/geom/ellipse.rs
+++ b/nannou_core/src/geom/ellipse.rs
@@ -155,11 +155,11 @@ where
         let two = math::two();
         Circumference {
             index: S::zero(),
-            num_points: num_points,
-            middle: [x, y].into(),
+            num_points,
+            middle: [x, y],
             half_w: w / two,
             half_h: h / two,
-            rad_step: rad_step,
+            rad_step,
             rad_offset: S::zero(),
         }
     }
@@ -258,7 +258,7 @@ where
         let x = mx + half_w * (rad_offset + rad_step * *index).cos();
         let y = my + half_h * (rad_offset + rad_step * *index).sin();
         *index += S::one();
-        Some([x, y].into())
+        Some([x, y])
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
diff --git a/nannou_core/src/geom/mod.rs b/nannou_core/src/geom/mod.rs
index a95c0f11f..6ad85ed33 100644
--- a/nannou_core/src/geom/mod.rs
+++ b/nannou_core/src/geom/mod.rs
@@ -9,17 +9,10 @@
 //! - Functions for determining the bounding rectangle or cuboid.
 //! - A function for finding the centroid.
 
-pub mod cuboid;
-pub mod ellipse;
-pub mod point;
-pub mod polygon;
-pub mod quad;
-pub mod range;
-pub mod rect;
-pub mod scalar;
-pub mod tri;
-pub mod vector;
-pub mod vertex;
+pub use glam::{
+    dvec2, dvec3, dvec4, ivec2, ivec3, ivec4, vec2, vec3, vec4, DVec2, DVec3, DVec4, IVec2, IVec3,
+    IVec4, Vec2, Vec3, Vec4,
+};
 
 pub use self::cuboid::Cuboid;
 pub use self::ellipse::Ellipse;
@@ -33,10 +26,18 @@ pub use self::tri::Tri;
 #[allow(deprecated)]
 pub use self::vector::{Vector2, Vector3, Vector4};
 pub use self::vertex::{Vertex, Vertex2d, Vertex3d};
-pub use glam::{
-    dvec2, dvec3, dvec4, ivec2, ivec3, ivec4, vec2, vec3, vec4, DVec2, DVec3, DVec4, IVec2, IVec3,
-    IVec4, Vec2, Vec3, Vec4,
-};
+
+pub mod cuboid;
+pub mod ellipse;
+pub mod point;
+pub mod polygon;
+pub mod quad;
+pub mod range;
+pub mod rect;
+pub mod scalar;
+pub mod tri;
+pub mod vector;
+pub mod vertex;
 
 // General geometry utility functions
 
diff --git a/nannou_core/src/geom/polygon.rs b/nannou_core/src/geom/polygon.rs
index 5f0b79527..3f9195038 100644
--- a/nannou_core/src/geom/polygon.rs
+++ b/nannou_core/src/geom/polygon.rs
@@ -96,9 +96,9 @@ where
         None => return None,
     };
     Some(Triangles {
-        first: first,
-        prev: prev,
-        points: points,
+        first,
+        prev,
+        points,
     })
 }
 
@@ -117,7 +117,7 @@ where
     I: IntoIterator,
     I::Item: Vertex2d,
 {
-    triangles(points).and_then(|ts| tri::iter_contains(ts, &point))
+    triangles(points).and_then(|ts| tri::iter_contains(ts, point))
 }
 
 impl<I> Iterator for Triangles<I>
diff --git a/nannou_core/src/geom/quad.rs b/nannou_core/src/geom/quad.rs
index 79221f1f2..d4255a1b4 100644
--- a/nannou_core/src/geom/quad.rs
+++ b/nannou_core/src/geom/quad.rs
@@ -1,6 +1,7 @@
-use crate::geom::{tri, vertex, Cuboid, Range, Rect, Tri, Vertex, Vertex2d, Vertex3d};
 use core::ops::{Deref, Index};
 
+use crate::geom::{tri, vertex, Cuboid, Range, Rect, Tri, Vertex, Vertex2d, Vertex3d};
+
 /// The number of vertices in a quad.
 pub const NUM_VERTICES: u8 = 4;
 
@@ -317,21 +318,21 @@ where
     }
 }
 
-impl<V> Into<[V; NUM_VERTICES as usize]> for Quad<V>
+impl<V> From<Quad<V>> for [V; NUM_VERTICES as usize]
 where
     V: Vertex,
 {
-    fn into(self) -> [V; NUM_VERTICES as usize] {
-        self.0
+    fn from(val: Quad<V>) -> Self {
+        val.0
     }
 }
 
-impl<V> Into<(V, V, V, V)> for Quad<V>
+impl<V> From<Quad<V>> for (V, V, V, V)
 where
     V: Vertex,
 {
-    fn into(self) -> (V, V, V, V) {
-        (self[0], self[1], self[2], self[3])
+    fn from(val: Quad<V>) -> Self {
+        (val[0], val[1], val[2], val[3])
     }
 }
 
diff --git a/nannou_core/src/geom/range.rs b/nannou_core/src/geom/range.rs
index f33ad44b0..18a62fcc6 100644
--- a/nannou_core/src/geom/range.rs
+++ b/nannou_core/src/geom/range.rs
@@ -1,9 +1,10 @@
 //! A type for working with one-dimensional ranges.
 
+use core::ops::{Add, Neg, Sub};
+
 use crate::geom::scalar;
 use crate::math::num_traits::{Float, NumCast, One, Zero};
 use crate::math::{self, two};
-use core::ops::{Add, Neg, Sub};
 
 /// Some start and end position along a single axis.
 ///
@@ -49,10 +50,7 @@ where
     /// assert_eq!(Range { start: 0.0, end: 10.0 }, Range::new(0.0, 10.0));
     /// ```
     pub fn new(start: S, end: S) -> Self {
-        Range {
-            start: start,
-            end: end,
-        }
+        Range { start, end }
     }
 
     /// Construct a new `Range` from a given length and its centered position.
@@ -564,32 +562,18 @@ where
         let Range { start, end } = self;
         if start <= end {
             if value < start {
-                Range {
-                    start: value,
-                    end: end,
-                }
+                Range { start: value, end }
             } else if value > end {
-                Range {
-                    start: start,
-                    end: value,
-                }
+                Range { start, end: value }
             } else {
                 self
             }
+        } else if value < end {
+            Range { start, end: value }
+        } else if value > start {
+            Range { start: value, end }
         } else {
-            if value < end {
-                Range {
-                    start: start,
-                    end: value,
-                }
-            } else if value > start {
-                Range {
-                    start: value,
-                    end: end,
-                }
-            } else {
-                self
-            }
+            self
         }
     }
 
diff --git a/nannou_core/src/geom/rect.rs b/nannou_core/src/geom/rect.rs
index 499309dd6..43a3e8a92 100644
--- a/nannou_core/src/geom/rect.rs
+++ b/nannou_core/src/geom/rect.rs
@@ -1,7 +1,8 @@
+use core::ops::Neg;
+
 use crate::geom::{quad, scalar, Align, Edge, Point2, Quad, Range, Scalar, Tri};
 use crate::glam::{DVec2, Vec2};
 use crate::math::{self, num_traits::Float};
-use core::ops::Neg;
 
 /// Defines a Rectangle's bounds across the x and y axes.
 #[derive(Copy, Clone, Debug, PartialEq, PartialOrd)]
@@ -289,7 +290,7 @@ where
     pub fn overlap(self, other: Self) -> Option<Self> {
         self.x
             .overlap(other.x)
-            .and_then(|x| self.y.overlap(other.y).map(|y| Rect { x: x, y: y }))
+            .and_then(|x| self.y.overlap(other.y).map(|y| Rect { x, y }))
     }
 
     /// The Rect that encompass the two given sets of Rect.
diff --git a/nannou_core/src/geom/scalar.rs b/nannou_core/src/geom/scalar.rs
index 91bca186a..153bf94b4 100644
--- a/nannou_core/src/geom/scalar.rs
+++ b/nannou_core/src/geom/scalar.rs
@@ -1,6 +1,7 @@
-use crate::math::num_traits::{Num, NumOps};
 use core::ops;
 
+use crate::math::num_traits::{Num, NumOps};
+
 /// Implemented for all numeric scalar types used within `geom`.
 ///
 /// A base set of traits that must be implemented by all types used to represent scalar values
diff --git a/nannou_core/src/geom/tri.rs b/nannou_core/src/geom/tri.rs
index 04929bb88..37fdfee3e 100644
--- a/nannou_core/src/geom/tri.rs
+++ b/nannou_core/src/geom/tri.rs
@@ -1,6 +1,7 @@
+use core::ops::Deref;
+
 use crate::geom::{vertex, Cuboid, Range, Rect, Scalar, Vertex, Vertex2d, Vertex3d};
 use crate::math::num_traits::Zero;
-use core::ops::Deref;
 
 /// The number of vertices in a triangle.
 pub const NUM_VERTICES: u8 = 3;
@@ -243,15 +244,15 @@ impl<V> From<(V, V, V)> for Tri<V> {
     }
 }
 
-impl<V> Into<[V; 3]> for Tri<V> {
-    fn into(self) -> [V; 3] {
-        self.0
+impl<V> From<Tri<V>> for [V; 3] {
+    fn from(val: Tri<V>) -> Self {
+        val.0
     }
 }
 
-impl<V> Into<(V, V, V)> for Tri<V> {
-    fn into(self) -> (V, V, V) {
-        let Tri([a, b, c]) = self;
+impl<V> From<Tri<V>> for (V, V, V) {
+    fn from(val: Tri<V>) -> Self {
+        let Tri([a, b, c]) = val;
         (a, b, c)
     }
 }
diff --git a/nannou_core/src/geom/vertex.rs b/nannou_core/src/geom/vertex.rs
index a433d7059..82ce38fdd 100644
--- a/nannou_core/src/geom/vertex.rs
+++ b/nannou_core/src/geom/vertex.rs
@@ -1,6 +1,7 @@
+use core::ops::{Add, Div};
+
 use crate::geom::{scalar::Scalar, Point3};
 use crate::math::num_traits::{cast, NumCast};
-use core::ops::{Add, Div};
 
 /// Types used as vertices that can be used to describe geometric points in space.
 pub trait Vertex: Clone + Copy + PartialEq {
@@ -61,7 +62,7 @@ where
     fn next(&mut self) -> Option<Self::Item> {
         let IterFromIndices {
             ref mut indices,
-            ref vertices,
+            vertices,
         } = *self;
         indices.next().map(|i| &vertices[i])
     }
@@ -78,7 +79,7 @@ where
     fn next_back(&mut self) -> Option<Self::Item> {
         let IterFromIndices {
             ref mut indices,
-            ref vertices,
+            vertices,
         } = *self;
         indices.next_back().map(|i| &vertices[i])
     }
diff --git a/nannou_core/src/lib.rs b/nannou_core/src/lib.rs
index 6689ae91e..362a7e935 100644
--- a/nannou_core/src/lib.rs
+++ b/nannou_core/src/lib.rs
@@ -32,11 +32,10 @@
 
 #![no_std]
 
-pub mod color;
+/// Re-export `glam` - linear algebra lib for graphics.
+pub use glam;
+
 pub mod geom;
 pub mod math;
 pub mod prelude;
 pub mod rand;
-
-/// Re-export `glam` - linear algebra lib for graphics.
-pub use glam;
diff --git a/nannou_core/src/math.rs b/nannou_core/src/math.rs
index a82a70a44..ddf5788e9 100644
--- a/nannou_core/src/math.rs
+++ b/nannou_core/src/math.rs
@@ -2,9 +2,9 @@
 //! helper/utility functions.
 
 use core::ops::Add;
-use num_traits::{Float, NumCast, One};
 
 pub use num_traits;
+use num_traits::{Float, NumCast, One};
 
 const ONE_TURN_DEGREES_F32: f32 = 360.0;
 const ONE_TURN_DEGREES_F64: f64 = 360.0;
@@ -184,14 +184,12 @@ where
         } else {
             n
         }
+    } else if n < end {
+        end
+    } else if n > start {
+        start
     } else {
-        if n < end {
-            end
-        } else if n > start {
-            start
-        } else {
-            n
-        }
+        n
     }
 }
 
diff --git a/nannou_core/src/prelude.rs b/nannou_core/src/prelude.rs
index 73971ed5c..325b82033 100644
--- a/nannou_core/src/prelude.rs
+++ b/nannou_core/src/prelude.rs
@@ -1,13 +1,8 @@
 //! A collection of commonly used items that are generally useful to have in scope.
 
-pub use crate::color::named::*;
-pub use crate::color::{
-    gray, hsl, hsla, hsv, hsva, lin_srgb, lin_srgba, rgb, rgb8, rgba, rgba8, srgb, srgb8, srgba,
-    srgba8,
-};
-pub use crate::color::{
-    Gray, Hsl, Hsla, Hsv, Hsva, LinSrgb, LinSrgba, Rgb, Rgb8, Rgba, Rgba8, Srgb, Srgba,
-};
+pub use core::f32::consts::{PI, TAU};
+pub use core::f64::consts::{PI as PI_F64, TAU as TAU_F64};
+
 pub use crate::geom::{self, pt2, pt3, Cuboid, Point2, Point3, Rect};
 #[allow(deprecated)]
 pub use crate::geom::{Vector2, Vector3, Vector4};
@@ -22,10 +17,6 @@ pub use crate::math::{
     clamp, deg_to_rad, fmod, map_range, partial_max, partial_min, rad_to_deg, rad_to_turns,
     turns_to_rad, Mat4LookTo, Vec2Angle, Vec2Rotate,
 };
-
 // NOTE: These helper functions rely on a thread-local RNG and are currently only available via std.
 #[cfg(feature = "std")]
 pub use crate::rand::{random, random_ascii, random_f32, random_f64, random_range};
-
-pub use core::f32::consts::{PI, TAU};
-pub use core::f64::consts::{PI as PI_F64, TAU as TAU_F64};
diff --git a/nannou_core/src/rand.rs b/nannou_core/src/rand.rs
index 379bbaef3..cc73b9cf9 100644
--- a/nannou_core/src/rand.rs
+++ b/nannou_core/src/rand.rs
@@ -5,9 +5,10 @@
 //! [**random_f64()**](./fn.random_f64.html) and [**random_range(min,
 //! max)**](./fn.random_range.html).
 
-pub use self::rand::*;
 pub use rand;
 
+pub use self::rand::*;
+
 /// A wrapper function around the `random` function that avoids the need for specifying a type in
 /// the case that it cannot be inferred. The primary purpose for this is to simplify the random API
 /// for new rust users.
diff --git a/nannou_egui/Cargo.toml b/nannou_egui/Cargo.toml
deleted file mode 100644
index 1c59a1931..000000000
--- a/nannou_egui/Cargo.toml
+++ /dev/null
@@ -1,21 +0,0 @@
-[package]
-name = "nannou_egui"
-version ="0.19.0"
-authors = [
-    "Alexandru Ene <alex.ene0x11@gmail.com>",
-    "mitchmindtree <mitchell.nordine@gmail.com>",
-]
-edition = "2018"
-license = "MIT OR Apache-2.0"
-description = "egui integration for nannou"
-repository = "https://github.com/AlexEne/nannou_egui"
-readme = "../README.md"
-
-[dependencies]
-egui-wgpu = "0.23"
-egui = "0.23"
-winit = "0.28"
-nannou = { version ="0.19.0", path = "../nannou" }
-
-[features]
-wayland = []
diff --git a/nannou_egui/README.md b/nannou_egui/README.md
deleted file mode 100644
index f5fcdef2a..000000000
--- a/nannou_egui/README.md
+++ /dev/null
@@ -1,22 +0,0 @@
-# nannou_egui [![Crates.io](https://img.shields.io/crates/v/nannou_egui.svg)](https://crates.io/crates/nannou_egui) [![docs.rs](https://docs.rs/nannou_egui/badge.svg)](https://docs.rs/nannou_egui/)
-
-[egui] integration for nannou. Useful for throwing together quick UIs for nannou
-apps, sketches and other experiments.
-
-For inspiration on how to expose UI widgets, please see the [egui] repo and its
-plethora of examples. There are sliders, color pickers, checkboxes,
-drop-down-lists and many more widgets to play with.
-
-For information on how to integrate it to your nannou creations, see the repo
-examples.
-
-To run the circle packing example: `cargo run --example circle_packing`:
-
-![](https://github.com/nannou-org/nannou/blob/main/nannou_egui/media/circle_packing.gif)
-
-
-To run the color tune example: `cargo run --example tune_color`:
-
-![](https://github.com/nannou-org/nannou/blob/main/nannou_egui/media/tune_egui.gif)
-
-[egui]: https://github.com/emilk/egui
diff --git a/nannou_egui/media/circle_packing.gif b/nannou_egui/media/circle_packing.gif
deleted file mode 100644
index e5dd7aeb3..000000000
Binary files a/nannou_egui/media/circle_packing.gif and /dev/null differ
diff --git a/nannou_egui/media/tune_egui.gif b/nannou_egui/media/tune_egui.gif
deleted file mode 100644
index ad4efe4ab..000000000
Binary files a/nannou_egui/media/tune_egui.gif and /dev/null differ
diff --git a/nannou_egui/src/lib.rs b/nannou_egui/src/lib.rs
deleted file mode 100644
index d0e39971c..000000000
--- a/nannou_egui/src/lib.rs
+++ /dev/null
@@ -1,504 +0,0 @@
-pub use egui;
-pub use egui::color_picker;
-pub use egui_wgpu;
-
-use egui::{pos2, ClippedPrimitive, PlatformOutput};
-use egui_wgpu::renderer::ScreenDescriptor;
-use nannou::wgpu::ToTextureView;
-use nannou::{wgpu, winit::event::VirtualKeyCode, winit::event::WindowEvent::*};
-use std::{cell::RefCell, ops::Deref, time::Duration};
-
-/// All `egui`-related state for a single window.
-///
-/// Includes the context, a renderer, and an input tracker.
-///
-/// For multi-window user interfaces, you will need to create an instance of this type per-window.
-pub struct Egui {
-    context: egui::Context,
-    renderer: RefCell<Renderer>,
-    input: Input,
-}
-
-/// A wrapper around all necessary state for rendering a `Egui` to a single texture (often a window
-/// texture).
-///
-/// For targeting more than one window, users should construct a `Egui` for each.
-pub struct Renderer {
-    renderer: egui_wgpu::Renderer,
-    paint_jobs: Vec<ClippedPrimitive>,
-    textures_delta: egui::TexturesDelta,
-}
-
-/// Tracking user and application event input.
-pub struct Input {
-    pub pointer_pos: egui::Pos2,
-    pub raw: egui::RawInput,
-    pub window_size_pixels: [u32; 2],
-    pub window_scale_factor: f32,
-}
-
-/// A wrapper around a `CtxRef` on which `begin_frame` was called.
-///
-/// Automatically calls `end_frame` on `drop` in the case that it wasn't already called by the
-/// usef.
-pub struct FrameCtx<'a> {
-    ui: &'a mut Egui,
-    ended: bool,
-}
-
-impl Egui {
-    /// Construct the `Egui` from its parts.
-    ///
-    /// The given `device` must be the same used to create the queue to which the Egui's render
-    /// commands will be submitted.
-    ///
-    /// The `target_format`, `target_msaa_samples`, `window_scale_factor` and `window_size_pixels`
-    /// must match the window to which the UI will be drawn.
-    ///
-    /// The `context` should have the desired initial styling and fonts already set.
-    pub fn new(
-        device: &wgpu::Device,
-        target_format: wgpu::TextureFormat,
-        target_msaa_samples: u32,
-        window_scale_factor: f32,
-        window_size_pixels: [u32; 2],
-    ) -> Self {
-        let renderer = RefCell::new(Renderer::new(device, target_format, target_msaa_samples));
-        let input = Input::new(window_scale_factor, window_size_pixels);
-        let context = Default::default();
-        Self {
-            renderer,
-            input,
-            context,
-        }
-    }
-
-    /// Construct a `Egui` associated with the given window.
-    pub fn from_window(window: &nannou::window::Window) -> Self {
-        let device = window.device();
-        let format = nannou::Frame::TEXTURE_FORMAT;
-        let msaa_samples = window.msaa_samples();
-        let scale_factor = window.scale_factor();
-        let (w_px, h_px) = window.inner_size_pixels();
-        Self::new(device, format, msaa_samples, scale_factor, [w_px, h_px])
-    }
-
-    /// Access to the inner `egui::CtxRef`.
-    pub fn ctx(&self) -> &egui::Context {
-        &self.context
-    }
-
-    /// Access to the currently tracked input state.
-    pub fn input(&self) -> &Input {
-        &self.input
-    }
-
-    /// Handles a raw window event, tracking all input and events relevant to the UI as necessary.
-    pub fn handle_raw_event(&mut self, event: &winit::event::WindowEvent) {
-        self.input.handle_raw_event(event);
-    }
-
-    /// Set the elapsed time since the `Egui` app started running.
-    pub fn set_elapsed_time(&mut self, elapsed: Duration) {
-        self.input.set_elapsed_time(elapsed);
-    }
-
-    /// Begin describing a UI frame.
-    pub fn begin_frame(&mut self) -> FrameCtx {
-        self.begin_frame_inner();
-        let ui = self;
-        let ended = false;
-        FrameCtx { ui, ended }
-    }
-
-    pub fn end_frame(&mut self) -> PlatformOutput {
-        self.end_frame_inner()
-    }
-
-    /// Registers a wgpu::Texture with a egui::TextureId.
-    pub fn texture_from_wgpu_texture(
-        &mut self,
-        device: &wgpu::Device,
-        texture: &wgpu::Texture,
-        texture_filter: wgpu::FilterMode,
-    ) -> egui::TextureId {
-        self.renderer.borrow_mut().renderer.register_native_texture(
-            device,
-            &texture.to_texture_view(),
-            texture_filter,
-        )
-    }
-
-    /// Registers a wgpu::Texture with an existing egui::TextureId.
-    pub fn update_texture_from_wgpu_texture(
-        &mut self,
-        device: &wgpu::Device,
-        texture: &wgpu::Texture,
-        texture_filter: wgpu::FilterMode,
-        id: egui::TextureId,
-    ) -> Result<(), egui_wgpu::WgpuError> {
-        self.renderer
-            .borrow_mut()
-            .renderer
-            .update_egui_texture_from_wgpu_texture(
-                device,
-                &texture.to_texture_view(),
-                texture_filter,
-                id,
-            );
-        Ok(())
-    }
-
-    /// Draws the contents of the inner `context` to the given frame.
-    pub fn draw_to_frame(&self, frame: &nannou::Frame) -> Result<(), egui_wgpu::WgpuError> {
-        let mut renderer = self.renderer.borrow_mut();
-        renderer.draw_to_frame(frame)
-    }
-
-    fn begin_frame_inner(&mut self) {
-        self.context.begin_frame(self.input.raw.take());
-    }
-
-    fn end_frame_inner(&mut self) -> egui::PlatformOutput {
-        let egui::FullOutput {
-            shapes,
-            platform_output,
-            textures_delta,
-            ..
-        } = self.context.end_frame();
-        self.renderer.borrow_mut().paint_jobs = self.context.tessellate(shapes);
-        self.renderer.borrow_mut().textures_delta = textures_delta;
-        platform_output
-    }
-}
-
-impl Input {
-    /// Initialise user input and window event tracking with the given target scale factor and size
-    /// in pixels.
-    pub fn new(window_scale_factor: f32, window_size_pixels: [u32; 2]) -> Self {
-        let raw = egui::RawInput {
-            pixels_per_point: Some(window_scale_factor),
-            ..Default::default()
-        };
-        let pointer_pos = Default::default();
-        let mut input = Self {
-            raw,
-            pointer_pos,
-            window_scale_factor,
-            window_size_pixels,
-        };
-        input.raw.screen_rect = Some(input.egui_window_rect());
-        input
-    }
-
-    /// Handles a raw window event, tracking all input and events relevant to the UI as necessary.
-    pub fn handle_raw_event(&mut self, event: &winit::event::WindowEvent) {
-        match event {
-            Resized(physical_size) => {
-                self.window_size_pixels = [physical_size.width, physical_size.height];
-                self.raw.screen_rect = Some(self.egui_window_rect());
-            }
-            ScaleFactorChanged {
-                scale_factor,
-                new_inner_size,
-            } => {
-                self.window_scale_factor = *scale_factor as f32;
-                self.window_size_pixels = [new_inner_size.width, new_inner_size.height];
-                self.raw.pixels_per_point = Some(self.window_scale_factor);
-                self.raw.screen_rect = Some(self.egui_window_rect());
-            }
-            MouseInput { state, button, .. } => {
-                if let winit::event::MouseButton::Other(..) = button {
-                } else {
-                    self.raw.events.push(egui::Event::PointerButton {
-                        pos: self.pointer_pos,
-                        button: match button {
-                            winit::event::MouseButton::Left => egui::PointerButton::Primary,
-                            winit::event::MouseButton::Right => egui::PointerButton::Secondary,
-                            winit::event::MouseButton::Middle => egui::PointerButton::Middle,
-                            winit::event::MouseButton::Other(_) => unreachable!(),
-                        },
-                        pressed: *state == winit::event::ElementState::Pressed,
-                        modifiers: self.raw.modifiers,
-                    });
-                }
-            }
-            MouseWheel { delta, .. } => {
-                match delta {
-                    winit::event::MouseScrollDelta::LineDelta(x, y) => {
-                        let line_height = 24.0;
-                        self.raw
-                            .events
-                            .push(egui::Event::Scroll(egui::vec2(*x, *y) * line_height));
-                    }
-                    winit::event::MouseScrollDelta::PixelDelta(delta) => {
-                        // Actually point delta
-                        self.raw.events.push(egui::Event::Scroll(egui::vec2(
-                            delta.x as f32,
-                            delta.y as f32,
-                        )));
-                    }
-                }
-            }
-            CursorMoved { position, .. } => {
-                self.pointer_pos = pos2(
-                    position.x as f32 / self.window_scale_factor as f32,
-                    position.y as f32 / self.window_scale_factor as f32,
-                );
-                self.raw
-                    .events
-                    .push(egui::Event::PointerMoved(self.pointer_pos));
-            }
-            CursorLeft { .. } => {
-                self.raw.events.push(egui::Event::PointerGone);
-            }
-            ModifiersChanged(input) => {
-                self.raw.modifiers = winit_to_egui_modifiers(*input);
-            }
-            KeyboardInput { input, .. } => {
-                if let Some(virtual_keycode) = input.virtual_keycode {
-                    if let Some(key) = winit_to_egui_key_code(virtual_keycode) {
-                        // TODO figure out why if I enable this the characters get ignored
-                        self.raw.events.push(egui::Event::Key {
-                            key,
-                            pressed: input.state == winit::event::ElementState::Pressed,
-                            repeat: false,
-                            modifiers: self.raw.modifiers,
-                        });
-                    }
-                }
-            }
-            ReceivedCharacter(ch) => {
-                if is_printable(*ch) && !self.raw.modifiers.ctrl && !self.raw.modifiers.command {
-                    self.raw.events.push(egui::Event::Text(ch.to_string()));
-                }
-            }
-            _ => {}
-        }
-    }
-
-    /// Set the elapsed time since the `Egui` app started running.
-    pub fn set_elapsed_time(&mut self, elapsed: Duration) {
-        self.raw.time = Some(elapsed.as_secs_f64());
-    }
-
-    /// Small helper for the common task of producing an `egui::Rect` describing the window.
-    fn egui_window_rect(&self) -> egui::Rect {
-        let [w, h] = self.window_size_pixels;
-        egui::Rect::from_min_size(
-            Default::default(),
-            egui::vec2(w as f32, h as f32) / self.window_scale_factor as f32,
-        )
-    }
-}
-
-impl Renderer {
-    /// Create a new `Renderer` from its parts.
-    ///
-    /// The `device` must be the same that was used to create the queue to which the `Renderer`s
-    /// render passes will be submitted.
-    ///
-    /// The `target_format` and `target_msaa_samples` should describe the target texture to which
-    /// the `Egui` will be rendered.
-    pub fn new(
-        device: &wgpu::Device,
-        target_format: wgpu::TextureFormat,
-        target_msaa_samples: u32,
-    ) -> Self {
-        Self {
-            renderer: egui_wgpu::Renderer::new(device, target_format, None, target_msaa_samples),
-            paint_jobs: Vec::new(),
-            textures_delta: Default::default(),
-        }
-    }
-
-    /// Construct a `Renderer` ready for drawing to the given window.
-    pub fn from_window(window: &nannou::window::Window) -> Self {
-        let device = window.device();
-        let format = nannou::Frame::TEXTURE_FORMAT;
-        let msaa_samples = window.msaa_samples();
-        Self::new(device, format, msaa_samples)
-    }
-
-    /// Encode a render pass for drawing the given context's texture to the given `dst_texture`.
-    pub fn encode_render_pass(
-        &mut self,
-        device: &wgpu::Device,
-        queue: &wgpu::Queue,
-        encoder: &mut wgpu::CommandEncoder,
-        dst_size_pixels: [u32; 2],
-        dst_scale_factor: f32,
-        dst_texture: &wgpu::TextureView,
-    ) -> Result<(), egui_wgpu::WgpuError> {
-        let renderer = &mut self.renderer;
-        let textures = &self.textures_delta;
-        let paint_jobs = &self.paint_jobs;
-        let screen_descriptor = ScreenDescriptor {
-            size_in_pixels: dst_size_pixels,
-            pixels_per_point: dst_scale_factor,
-        };
-        for (id, image_delta) in &textures.set {
-            renderer.update_texture(&device, &queue, *id, &image_delta);
-        }
-        renderer.update_buffers(device, queue, encoder, &paint_jobs, &screen_descriptor);
-        let mut render_pass = encoder.begin_render_pass(&egui_wgpu::wgpu::RenderPassDescriptor {
-            label: Some("nannou_egui_render_pass"),
-            color_attachments: &[Some(egui_wgpu::wgpu::RenderPassColorAttachment {
-                view: &dst_texture,
-                resolve_target: None,
-                ops: egui_wgpu::wgpu::Operations {
-                    load: egui_wgpu::wgpu::LoadOp::Load,
-                    store: true,
-                },
-            })],
-            depth_stencil_attachment: None,
-        });
-        renderer.render(&mut render_pass, &paint_jobs, &screen_descriptor);
-        Ok(())
-    }
-
-    /// Encodes a render pass for drawing the given context's texture to the given frame.
-    pub fn draw_to_frame(&mut self, frame: &nannou::Frame) -> Result<(), egui_wgpu::WgpuError> {
-        let device_queue_pair = frame.device_queue_pair();
-        let device = device_queue_pair.device();
-        let queue = device_queue_pair.queue();
-        let size_pixels = frame.texture_size();
-        let [width_px, _] = size_pixels;
-        let scale_factor = width_px as f32 / frame.rect().w();
-        let texture_view = frame.texture_view();
-        let mut encoder = frame.command_encoder();
-        self.encode_render_pass(
-            device,
-            queue,
-            &mut encoder,
-            size_pixels,
-            scale_factor,
-            texture_view,
-        )
-    }
-}
-
-impl<'a> FrameCtx<'a> {
-    /// Produces a `CtxRef` ready for describing the UI for this frame.
-    pub fn context(&self) -> egui::Context {
-        self.ui.context.clone()
-    }
-
-    /// End the current frame,
-    pub fn end(mut self) {
-        self.end_inner();
-    }
-
-    // The inner `end` implementation, shared between `end` and `drop`.
-    fn end_inner(&mut self) {
-        if !self.ended {
-            self.ui.end_frame_inner();
-            self.ended = true;
-        }
-    }
-}
-
-impl<'a> Drop for FrameCtx<'a> {
-    fn drop(&mut self) {
-        self.end_inner();
-    }
-}
-
-impl<'a> Deref for FrameCtx<'a> {
-    type Target = egui::Context;
-    fn deref(&self) -> &Self::Target {
-        &self.ui.context
-    }
-}
-
-/// Translates winit to egui keycodes.
-#[inline]
-fn winit_to_egui_key_code(key: VirtualKeyCode) -> Option<egui::Key> {
-    use egui::Key;
-
-    Some(match key {
-        VirtualKeyCode::Escape => Key::Escape,
-        VirtualKeyCode::Insert => Key::Insert,
-        VirtualKeyCode::Home => Key::Home,
-        VirtualKeyCode::Delete => Key::Delete,
-        VirtualKeyCode::End => Key::End,
-        VirtualKeyCode::PageDown => Key::PageDown,
-        VirtualKeyCode::PageUp => Key::PageUp,
-        VirtualKeyCode::Left => Key::ArrowLeft,
-        VirtualKeyCode::Up => Key::ArrowUp,
-        VirtualKeyCode::Right => Key::ArrowRight,
-        VirtualKeyCode::Down => Key::ArrowDown,
-        VirtualKeyCode::Back => Key::Backspace,
-        VirtualKeyCode::Return => Key::Enter,
-        VirtualKeyCode::Tab => Key::Tab,
-        VirtualKeyCode::Space => Key::Space,
-
-        VirtualKeyCode::A => Key::A,
-        VirtualKeyCode::B => Key::B,
-        VirtualKeyCode::C => Key::C,
-        VirtualKeyCode::D => Key::D,
-        VirtualKeyCode::E => Key::E,
-        VirtualKeyCode::F => Key::F,
-        VirtualKeyCode::G => Key::G,
-        VirtualKeyCode::H => Key::H,
-        VirtualKeyCode::I => Key::I,
-        VirtualKeyCode::J => Key::J,
-        VirtualKeyCode::K => Key::K,
-        VirtualKeyCode::L => Key::L,
-        VirtualKeyCode::M => Key::M,
-        VirtualKeyCode::N => Key::N,
-        VirtualKeyCode::O => Key::O,
-        VirtualKeyCode::P => Key::P,
-        VirtualKeyCode::Q => Key::Q,
-        VirtualKeyCode::R => Key::R,
-        VirtualKeyCode::S => Key::S,
-        VirtualKeyCode::T => Key::T,
-        VirtualKeyCode::U => Key::U,
-        VirtualKeyCode::V => Key::V,
-        VirtualKeyCode::W => Key::W,
-        VirtualKeyCode::X => Key::X,
-        VirtualKeyCode::Y => Key::Y,
-        VirtualKeyCode::Z => Key::Z,
-
-        VirtualKeyCode::Key0 => Key::Num0,
-        VirtualKeyCode::Key1 => Key::Num1,
-        VirtualKeyCode::Key2 => Key::Num2,
-        VirtualKeyCode::Key3 => Key::Num3,
-        VirtualKeyCode::Key4 => Key::Num4,
-        VirtualKeyCode::Key5 => Key::Num5,
-        VirtualKeyCode::Key6 => Key::Num6,
-        VirtualKeyCode::Key7 => Key::Num7,
-        VirtualKeyCode::Key8 => Key::Num8,
-        VirtualKeyCode::Key9 => Key::Num9,
-
-        _ => {
-            return None;
-        }
-    })
-}
-
-/// Translates winit to egui modifier keys.
-#[inline]
-fn winit_to_egui_modifiers(modifiers: winit::event::ModifiersState) -> egui::Modifiers {
-    egui::Modifiers {
-        alt: modifiers.alt(),
-        ctrl: modifiers.ctrl(),
-        shift: modifiers.shift(),
-        #[cfg(target_os = "macos")]
-        mac_cmd: modifiers.logo(),
-        #[cfg(target_os = "macos")]
-        command: modifiers.logo(),
-        #[cfg(not(target_os = "macos"))]
-        mac_cmd: false,
-        #[cfg(not(target_os = "macos"))]
-        command: modifiers.ctrl(),
-    }
-}
-
-/// We only want printable characters and ignore all special keys.
-fn is_printable(chr: char) -> bool {
-    let is_in_private_use_area = '\u{e000}' <= chr && chr <= '\u{f8ff}'
-        || '\u{f0000}' <= chr && chr <= '\u{ffffd}'
-        || '\u{100000}' <= chr && chr <= '\u{10fffd}';
-    !is_in_private_use_area && !chr.is_ascii_control()
-}
diff --git a/nannou_egui_demo_app/Cargo.toml b/nannou_egui_demo_app/Cargo.toml
deleted file mode 100644
index c1bac750e..000000000
--- a/nannou_egui_demo_app/Cargo.toml
+++ /dev/null
@@ -1,11 +0,0 @@
-[package]
-name = "nannou_egui_demo_app"
-version ="0.1.0"
-authors = ["mitchmindtree <mail@mitchellnordine.com>"]
-edition = "2018"
-publish = false
-
-[dependencies]
-nannou_egui = { version ="0.19.0", path = "../nannou_egui" }
-nannou = { version ="0.19.0", path = "../nannou" }
-egui_demo_lib = "0.23"
diff --git a/nannou_egui_demo_app/README.md b/nannou_egui_demo_app/README.md
deleted file mode 100644
index ea374e070..000000000
--- a/nannou_egui_demo_app/README.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# nannou_egui_demo_app
-
-An implementation of `egui`'s official demo app.
-
-The purpose of this app is *not* to demonstrate how to write a standard
-nannou+egui application, but rather to test and compare feature parity against
-egui's default backend.
diff --git a/nannou_egui_demo_app/src/main.rs b/nannou_egui_demo_app/src/main.rs
deleted file mode 100644
index 8d5a447eb..000000000
--- a/nannou_egui_demo_app/src/main.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-use nannou::prelude::*;
-use nannou_egui::Egui;
-use std::sync::{Arc, Mutex};
-
-fn main() {
-    nannou::app(model).update(update).run();
-}
-
-struct Model {
-    egui: Egui,
-    egui_demo_app: egui_demo_lib::DemoWindows,
-}
-
-fn model(app: &App) -> Model {
-    app.set_loop_mode(LoopMode::wait());
-    let w_id = app
-        .new_window()
-        .raw_event(raw_window_event)
-        .view(view)
-        .build()
-        .unwrap();
-    let window = app.window(w_id).unwrap();
-    let egui = Egui::from_window(&window);
-    let egui_demo_app = egui_demo_lib::DemoWindows::default();
-
-    let proxy = Arc::new(Mutex::new(app.create_proxy()));
-    egui.ctx().set_request_repaint_callback(move |_| {
-        proxy.lock().unwrap().wakeup().unwrap();
-    });
-    Model {
-        egui,
-        egui_demo_app,
-    }
-}
-
-fn raw_window_event(_app: &App, model: &mut Model, event: &nannou::winit::event::WindowEvent) {
-    model.egui.handle_raw_event(event);
-}
-
-fn update(_app: &App, model: &mut Model, update: Update) {
-    let Model {
-        ref mut egui,
-        ref mut egui_demo_app,
-        ..
-    } = *model;
-    egui.set_elapsed_time(update.since_start);
-    let ctx = egui.begin_frame();
-    egui_demo_app.ui(&ctx.context());
-    let _ = ctx.end();
-}
-
-fn view(_app: &App, model: &Model, frame: Frame) {
-    frame.clear(BLACK);
-    model.egui.draw_to_frame(&frame).unwrap();
-}
diff --git a/nannou_isf/.gitignore b/nannou_isf/.gitignore
deleted file mode 100644
index 96ef6c0b9..000000000
--- a/nannou_isf/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-/target
-Cargo.lock
diff --git a/nannou_isf/Cargo.toml b/nannou_isf/Cargo.toml
deleted file mode 100644
index bfd5255e9..000000000
--- a/nannou_isf/Cargo.toml
+++ /dev/null
@@ -1,13 +0,0 @@
-[package]
-name = "nannou_isf"
-version ="0.1.0"
-authors = ["mitchmindtree <mitchell.nordine@gmail.com>"]
-edition = "2018"
-
-[dependencies]
-hotglsl = "0.2"
-isf = { git = "https://github.com/nannou-org/isf", branch = "master" }
-nannou = { version ="0.19.0", path = "../nannou", features = ["spirv"] }
-thiserror = "1"
-threadpool = "1"
-walkdir = "2"
diff --git a/nannou_isf/README.md b/nannou_isf/README.md
deleted file mode 100644
index 5a5901146..000000000
--- a/nannou_isf/README.md
+++ /dev/null
@@ -1,9 +0,0 @@
-# nannou_isf
-
-## Currently WIP
-
-A suite of tools making it easy to build your own live ISF shader editing
-environment with nannou.
-
-Also provides a demo.rs with a basic environment demonstration.
-
diff --git a/nannou_isf/reference.fs b/nannou_isf/reference.fs
deleted file mode 100644
index 716aaebd8..000000000
--- a/nannou_isf/reference.fs
+++ /dev/null
@@ -1,87 +0,0 @@
-// A reference of what the ISF generated GLSL code should look like.
-
-#version 450
-
-//----- GENERATION BEGINS -----//
-
-// The normalized coordinates of the current fragment.
-// (0, 0) is bottom left. (1, 1) is top right.
-layout(location = 0) in vec2 isf_FragNormCoord;
-
-// Uniform data updated once per frame. These are accessible in all ISF shaders.
-layout(set = 0, binding = 0) uniform IsfData {
-    int PASSINDEX;
-    vec2 RENDERSIZE;
-    float TIME;
-    float TIMEDELTA;
-    vec4 DATE;
-    int FRAMEINDEX;
-};
-
-// Uniform data for a set of the ISF `INPUTS`.
-// Only generated in the case that one or more inputs exist.
-// Only generated for the types contained below.
-layout(set = 1, binding = 0) uniform IsfDataInputs {
-    bool my_event;
-    int my_long;
-    float my_float;
-    bool my_bool;
-    vec2 my_point2d;
-    vec4 my_color;
-};
-
-// TODO image, audio, audioFFT input uniforms?
-
-// The sampler shared between all images.
-layout(set = 2, binding = 0) uniform sampler img_sampler;
-
-// The following are not to be used directly, but rather via the generated macros.
-// All `INPUT`s of type image, audio or audioFFT (not necessarily in that order).
-layout(set = 2, binding = 1) uniform texture2D img_a;
-layout(set = 2, binding = 2) uniform texture2D img_b;
-layout(set = 2, binding = 3) uniform texture2D audio_a;
-layout(set = 2, binding = 4) uniform texture2D audio_b;
-layout(set = 2, binding = 5) uniform texture2D audio_fft_a;
-layout(set = 2, binding = 6) uniform texture2D audio_fft_b;
-
-// Textures for the `PASSES`. Names derived from `TARGET` field.
-layout(set = 2, binding = 7) uniform texture2D img_a;
-layout(set = 2, binding = 8) uniform texture2D img_b;
-
-// ISF provided short-hand for retrieving image size.
-ivec2 IMG_SIZE(texture2D img) {
-    return textureSize(sampler2D(img, img_sampler), 0);
-}
-
-// ISF provided short-hand for retrieving image color.
-vec4 IMG_NORM_PIXEL(texture2D img, vec2 norm_px_coord) {
-    return texture(sampler2D(img, img_sampler), norm_px_coord);
-}
-
-// ISF provided short-hand for retrieving image color.
-vec4 IMG_PIXEL(texture2D img, vec2 px_coord) {
-    ivec2 s = IMG_SIZE(img);
-    vec2 norm_px_coord = vec2(px_coord.x / float(s.x), px_coord.y / float(s.y));
-    return IMG_NORM_PIXEL(img, px_coord);
-}
-
-// The following two functions don't appear in the spec, but appear in a lot of the tests...
-
-// ISF provided short-hand for retrieving image color.
-vec4 IMG_THIS_NORM_PIXEL(texture2D img) {
-    return IMG_NORM_PIXEL(img, isf_FragNormCoord);
-}
-
-// ISF provided short-hand for retrieving image color.
-vec4 IMG_THIS_PIXEL(texture2D img) {
-    return IMG_THIS_NORM_PIXEL(img);
-}
-
-//----- GENERATION COMPLETE -----//
-
-void main() {
-    ivec2 s = IMG_SIZE(img_a);
-    vec4 a = IMG_NORM_PIXEL(img_b, vec2(0.25, 0.3));
-    vec4 b = IMG_PIXEL(img_a, vec2(float(s.x) * 0.5, float(s.y) * 0.5));
-    vec4 c = IMG_THIS_PIXEL(img_b);
-}
diff --git a/nannou_isf/src/pipeline.rs b/nannou_isf/src/pipeline.rs
deleted file mode 100644
index 9f046a127..000000000
--- a/nannou_isf/src/pipeline.rs
+++ /dev/null
@@ -1,1029 +0,0 @@
-use nannou::image;
-use nannou::prelude::*;
-use nannou::wgpu::BufferInitDescriptor;
-use std::collections::HashMap;
-use std::path::{Path, PathBuf};
-use std::sync::mpsc;
-use thiserror::Error;
-use threadpool::ThreadPool;
-
-/// A render pipeline designed for hotloading!
-pub struct IsfPipeline {
-    isf: Option<isf::Isf>,
-    pub isf_data: IsfData,
-    isf_err: Option<IsfError>,
-    image_loader: ImageLoader,
-    vs: Shader,
-    fs: Shader,
-    sampler: wgpu::Sampler,
-    sampler_filtering: bool,
-    isf_uniform_buffer: wgpu::Buffer,
-    isf_inputs_uniform_buffer: wgpu::Buffer,
-    isf_bind_group_layout: wgpu::BindGroupLayout,
-    isf_inputs_bind_group_layout: wgpu::BindGroupLayout,
-    isf_textures_bind_group_layout: wgpu::BindGroupLayout,
-    isf_bind_group: wgpu::BindGroup,
-    isf_inputs_bind_group: wgpu::BindGroup,
-    isf_textures_bind_group: wgpu::BindGroup,
-    layout: wgpu::PipelineLayout,
-    render_pipeline: Option<wgpu::RenderPipeline>,
-    vertex_buffer: wgpu::Buffer,
-    dst_format: wgpu::TextureFormat,
-    dst_texture_size: [u32; 2],
-    dst_sample_count: u32,
-}
-
-/// The first set of ISF uniforms that are available to every ISF shader.
-#[repr(C)]
-#[derive(Clone, Copy, Debug)]
-struct IsfUniforms {
-    pass_index: i32,
-    render_size: [f32; 2],
-    time: f32,
-    time_delta: f32,
-    date: [f32; 4],
-    frame_index: i32,
-}
-
-/// Timing information passed into the shader.
-#[derive(Copy, Clone, Debug, Default, PartialEq)]
-pub struct IsfTime {
-    /// The time since the start of the application.
-    pub time: f32,
-    /// The time since the last frame was rendered.
-    pub time_delta: f32,
-    /// The date as year, month, day and seconds.
-    pub date: [f32; 4],
-    /// The current frame that is to be rendered.
-    pub frame_index: i32,
-}
-
-/// Created directly after successfully parsing an `Isf`.
-///
-/// `imported` textures can be accessed by the user.
-#[derive(Debug, Default)]
-pub struct IsfData {
-    imported: HashMap<ImportName, ImageState>,
-    inputs: HashMap<InputName, IsfInputData>,
-    passes: Vec<wgpu::Texture>,
-}
-
-/// The state of the image.
-#[derive(Debug)]
-pub enum ImageState {
-    None,
-    Loading(mpsc::Receiver<Result<image::RgbaImage, ImageLoadError>>),
-    Ready(Result<ImageData, ImageLoadError>),
-}
-
-/// Handles to both the cpu and gpu representations of the image.
-#[derive(Debug)]
-pub struct ImageData {
-    pub image: image::RgbaImage,
-    pub texture: wgpu::Texture,
-}
-
-pub type ImportName = String;
-pub type InputName = String;
-
-#[derive(Debug)]
-pub enum IsfInputData {
-    Event {
-        happening: bool,
-    },
-    Bool(bool),
-    Long(i32),
-    Float(f32),
-    Point2d(Point2),
-    Color(LinSrgba),
-    Image(ImageState),
-    Audio {
-        samples: Vec<f32>,
-        texture: wgpu::Texture,
-    },
-    AudioFft {
-        columns: Vec<f32>,
-        texture: wgpu::Texture,
-    },
-}
-
-type IsfInputUniforms = [u32; 128];
-
-// #[derive(Clone, Debug)]
-// struct IsfInputUniforms {
-//     // Each supported uniform field type is 32-bit long, so store them as such.
-//     fields: Vec<u32>,
-// }
-
-/// A shader with some extra information relating to recent compilation success/failure.
-#[derive(Debug)]
-pub struct Shader {
-    source: ShaderSource,
-    module: Option<wgpu::ShaderModule>,
-    error: Option<ShaderError>,
-}
-
-#[derive(Debug)]
-enum ShaderSource {
-    Path(PathBuf),
-    HardCoded,
-}
-
-#[repr(C)]
-#[derive(Clone, Copy)]
-struct Vertex {
-    position: [f32; 2],
-}
-
-#[derive(Debug)]
-struct ImageLoader {
-    threadpool: ThreadPool,
-}
-
-/// Errors that can occur while trying to load and parse ISF from the fragment shader.
-#[derive(Debug, Error)]
-pub enum IsfError {
-    #[error("{err}")]
-    Parse {
-        #[from]
-        err: isf::ParseError,
-    },
-    #[error("failed to read fragment shader for ISF: {err}")]
-    Io {
-        #[from]
-        err: std::io::Error,
-    },
-}
-
-/// Errors that might occur while loading an image.
-#[derive(Debug, Error)]
-pub enum ImageLoadError {
-    #[error("an IO error: {err}")]
-    Io {
-        #[from]
-        err: std::io::Error,
-    },
-    #[error("{}", err)]
-    Image {
-        #[from]
-        err: image::ImageError,
-    },
-}
-
-/// Errors that might occur while loading a shader.
-#[derive(Debug, Error)]
-pub enum ShaderError {
-    #[error("{err}")]
-    Io {
-        #[from]
-        err: std::io::Error,
-    },
-    #[error("an error occurred while parsing ISF: {err}")]
-    IsfParse {
-        #[from]
-        err: isf::ParseError,
-    },
-    #[error("an error occurred while parsing ISF: {err}")]
-    Compile {
-        #[from]
-        err: hotglsl::CompileError,
-    },
-}
-
-const VERTICES: [Vertex; 4] = [
-    Vertex {
-        position: [-1.0, -1.0],
-    },
-    Vertex {
-        position: [-1.0, 1.0],
-    },
-    Vertex {
-        position: [1.0, -1.0],
-    },
-    Vertex {
-        position: [1.0, 1.0],
-    },
-];
-
-impl ImageState {
-    /// Whether or not the texture is currently loading.
-    pub fn is_loading(&self) -> bool {
-        match *self {
-            ImageState::Loading(_) => true,
-            _ => false,
-        }
-    }
-
-    /// If the image has been loaded, provides access to the result.
-    ///
-    /// Returns `None` if the image is still loading or has not started loading.
-    pub fn ready(&self) -> Option<Result<&ImageData, &ImageLoadError>> {
-        match *self {
-            ImageState::Ready(ref res) => Some(res.as_ref()),
-            _ => None,
-        }
-    }
-
-    /// Update the image state.
-    fn update(
-        &mut self,
-        device: &wgpu::Device,
-        encoder: &mut wgpu::CommandEncoder,
-        image_loader: &ImageLoader,
-        img_path: PathBuf,
-    ) {
-        *self = match *self {
-            ImageState::None => {
-                let (tx, rx) = mpsc::channel();
-                image_loader.threadpool.execute(move || {
-                    let img_res = image::open(img_path)
-                        .map(|img| img.to_rgba8())
-                        .map_err(|err| err.into());
-                    tx.send(img_res).ok();
-                });
-                ImageState::Loading(rx)
-            }
-            ImageState::Loading(ref rx) => match rx.try_recv() {
-                Ok(img_res) => {
-                    let usage =
-                        wgpu::TextureUsages::COPY_DST | wgpu::TextureUsages::TEXTURE_BINDING;
-                    let res = img_res.map(|image| {
-                        let texture = wgpu::Texture::encode_load_from_image_buffer(
-                            device, encoder, usage, &image,
-                        );
-                        ImageData { image, texture }
-                    });
-                    ImageState::Ready(res)
-                }
-                _ => return,
-            },
-            ImageState::Ready(_) => return,
-        };
-    }
-}
-
-impl IsfData {
-    /// The map of imported images.
-    pub fn imported(&self) -> &HashMap<ImportName, ImageState> {
-        &self.imported
-    }
-
-    /// The map of all declared inputs.
-    pub fn inputs(&self) -> &HashMap<InputName, IsfInputData> {
-        &self.inputs
-    }
-
-    /// The texture stored for each pass.
-    pub fn passes(&self) -> &[wgpu::Texture] {
-        &self.passes
-    }
-}
-
-impl IsfInputData {
-    /// Initialise a new `IsfInputData` instance.
-    fn new(
-        device: &wgpu::Device,
-        encoder: &mut wgpu::CommandEncoder,
-        image_loader: &ImageLoader,
-        images_path: &Path,
-        input: &isf::Input,
-    ) -> Self {
-        match &input.ty {
-            isf::InputType::Event => IsfInputData::Event { happening: false },
-            isf::InputType::Bool(b) => IsfInputData::Bool(b.default.unwrap_or_default()),
-            isf::InputType::Long(n) => {
-                let init = n
-                    .default
-                    .or(n.min)
-                    .or(n.values.first().cloned())
-                    .unwrap_or_default();
-                IsfInputData::Long(init)
-            }
-            isf::InputType::Float(f) => {
-                let init = f.default.or(f.min).unwrap_or_default();
-                IsfInputData::Float(init)
-            }
-            isf::InputType::Point2d(p) => {
-                let [x, y] = p.default.or(p.min).unwrap_or_default();
-                IsfInputData::Point2d(pt2(x, y))
-            }
-            isf::InputType::Color(c) => {
-                let v = c.default.clone().or(c.min.clone()).unwrap_or_default();
-                let r = v.get(0).cloned().unwrap_or_default();
-                let g = v.get(1).cloned().unwrap_or_default();
-                let b = v.get(2).cloned().unwrap_or_default();
-                let a = v.get(3).cloned().unwrap_or_default();
-                IsfInputData::Color(lin_srgba(r, g, b, a))
-            }
-            // For the input images, it's up to us how we want to source them. Perhaps
-            // `assets/images/`?  For now we'll black images.
-            isf::InputType::Image => {
-                let mut image_state = ImageState::None;
-                if let Some(img_path) = image_paths(images_path).next() {
-                    image_state.update(device, encoder, image_loader, img_path);
-                }
-                IsfInputData::Image(image_state)
-            }
-            isf::InputType::Audio(a) => {
-                let n_samples = a
-                    .num_samples
-                    .unwrap_or(IsfPipeline::DEFAULT_AUDIO_SAMPLE_COUNT);
-                let samples = vec![0.0; n_samples as usize];
-                let size = [n_samples, 1];
-                let format = IsfPipeline::DEFAULT_AUDIO_TEXTURE_FORMAT;
-                let texture = create_black_texture(device, encoder, size, format);
-                IsfInputData::Audio { samples, texture }
-            }
-            isf::InputType::AudioFft(a) => {
-                let n_columns = a
-                    .num_columns
-                    .unwrap_or(IsfPipeline::DEFAULT_AUDIO_FFT_COLUMNS);
-                let columns = vec![0.0; n_columns as usize];
-                let size = [n_columns, 1];
-                let format = IsfPipeline::DEFAULT_AUDIO_TEXTURE_FORMAT;
-                let texture = create_black_texture(device, encoder, size, format);
-                IsfInputData::AudioFft { columns, texture }
-            }
-        }
-    }
-
-    /// Short-hand for checking that the input type matches the data.
-    ///
-    /// This is useful for checking to see if the user has changed the type of data associated with
-    /// the name.
-    pub fn ty_matches(&self, ty: &isf::InputType) -> bool {
-        match (self, ty) {
-            (IsfInputData::Event { .. }, isf::InputType::Event)
-            | (IsfInputData::Bool(_), isf::InputType::Bool(_))
-            | (IsfInputData::Long(_), isf::InputType::Long(_))
-            | (IsfInputData::Float(_), isf::InputType::Float(_))
-            | (IsfInputData::Point2d(_), isf::InputType::Point2d(_))
-            | (IsfInputData::Color(_), isf::InputType::Color(_))
-            | (IsfInputData::Image(_), isf::InputType::Image)
-            | (IsfInputData::Audio { .. }, isf::InputType::Audio(_))
-            | (IsfInputData::AudioFft { .. }, isf::InputType::AudioFft(_)) => true,
-            _ => false,
-        }
-    }
-
-    /// Update an existing instance ISF input data instance with the given input.
-    fn update(
-        &mut self,
-        device: &wgpu::Device,
-        encoder: &mut wgpu::CommandEncoder,
-        image_loader: &ImageLoader,
-        images_path: &Path,
-        input: &isf::Input,
-    ) {
-        match (self, &input.ty) {
-            (IsfInputData::Event { .. }, isf::InputType::Event) => (),
-            (IsfInputData::Bool(_), isf::InputType::Bool(_)) => (),
-            (IsfInputData::Long(_), isf::InputType::Long(_)) => {}
-            (IsfInputData::Float(_), isf::InputType::Float(_)) => {}
-            (IsfInputData::Point2d(_), isf::InputType::Point2d(_)) => {}
-            (IsfInputData::Color(_), isf::InputType::Color(_)) => {}
-            (IsfInputData::Image(ref mut state), isf::InputType::Image) => {
-                if let Some(img_path) = image_paths(images_path).next() {
-                    state.update(device, encoder, image_loader, img_path);
-                }
-            }
-            (IsfInputData::Audio { .. }, isf::InputType::Audio(_)) => {}
-            (IsfInputData::AudioFft { .. }, isf::InputType::AudioFft(_)) => {}
-            (data, _) => *data = Self::new(device, encoder, image_loader, images_path, input),
-        }
-    }
-}
-
-impl ShaderSource {
-    fn as_path(&self) -> Option<&Path> {
-        match *self {
-            ShaderSource::Path(ref path) => Some(path),
-            ShaderSource::HardCoded => None,
-        }
-    }
-}
-
-/// Compile an ISF fragment shader.
-///
-/// This is used for compiling the ISF fragment shader.
-pub fn compile_isf_shader(
-    device: &wgpu::Device,
-    path: &Path,
-) -> (Option<wgpu::ShaderModule>, Option<ShaderError>) {
-    let res = std::fs::read_to_string(&path)
-        .map_err(ShaderError::from)
-        .and_then(|s| isf::parse(&s).map(|isf| (s, isf)).map_err(From::from))
-        .and_then(|(old_str, isf)| {
-            let isf_str = crate::glsl_string_from_isf(&isf);
-            let new_str = crate::prefix_isf_glsl_str(&isf_str, old_str);
-            let ty = hotglsl::ShaderStage::Fragment;
-            hotglsl::compile_str(&new_str, ty).map_err(From::from)
-        });
-    let (bytes, error) = split_result(res);
-    let module = bytes.map(|b| wgpu::shader_from_spirv_bytes(device, &b));
-    (module, error)
-}
-
-/// Compile a regular, non-ISF shader.
-///
-/// This is used for compiling the vertex shaders.
-pub fn compile_shader(
-    device: &wgpu::Device,
-    path: &Path,
-) -> (Option<wgpu::ShaderModule>, Option<ShaderError>) {
-    let res = hotglsl::compile(&path).map_err(ShaderError::from);
-    let (bytes, compile_err) = split_result(res);
-    let module = bytes.map(|b| wgpu::shader_from_spirv_bytes(device, &b));
-    (module, compile_err)
-}
-
-impl Shader {
-    pub fn fragment_from_path(device: &wgpu::Device, path: PathBuf) -> Self {
-        let (module, error) = compile_isf_shader(device, &path);
-        let source = ShaderSource::Path(path);
-        Shader {
-            source,
-            module,
-            error,
-        }
-    }
-
-    pub fn vertex_from_path(device: &wgpu::Device, path: PathBuf) -> Self {
-        let (module, error) = compile_shader(device, &path);
-        let source = ShaderSource::Path(path);
-        Shader {
-            source,
-            module,
-            error,
-        }
-    }
-
-    /// Create the default vertex shader for ISF fragment shaders.
-    pub fn vertex_default(device: &wgpu::Device) -> Self {
-        let vs = include_bytes!("shaders/vert.spv");
-        let module = Some(wgpu::shader_from_spirv_bytes(device, vs));
-        let error = None;
-        let source = ShaderSource::HardCoded;
-        Shader {
-            source,
-            module,
-            error,
-        }
-    }
-}
-
-impl IsfPipeline {
-    pub const DEFAULT_IMAGE_TEXTURE_FORMAT: wgpu::TextureFormat =
-        wgpu::TextureFormat::Rgba8UnormSrgb;
-    pub const DEFAULT_AUDIO_SAMPLE_COUNT: u32 = 64;
-    pub const DEFAULT_AUDIO_FFT_COLUMNS: u32 = 64;
-    pub const DEFAULT_AUDIO_TEXTURE_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::R32Float;
-
-    /// Construct a new **IsfPipeline**.
-    pub fn new(
-        device: &wgpu::Device,
-        encoder: &mut wgpu::CommandEncoder,
-        vs_path: Option<PathBuf>,
-        fs_path: PathBuf,
-        dst_format: wgpu::TextureFormat,
-        dst_texture_size: [u32; 2],
-        dst_sample_count: u32,
-        images_path: &Path,
-    ) -> Self {
-        // Retrieve the `Isf` instance.
-        let isf_res = read_isf_from_path(&fs_path);
-        let (isf, isf_err) = split_result(isf_res);
-
-        // Create the shaders.
-        let vs = match vs_path {
-            None => Shader::vertex_default(device),
-            Some(vs_path) => Shader::vertex_from_path(device, vs_path),
-        };
-        let fs = Shader::fragment_from_path(device, fs_path);
-
-        dbg!(&vs);
-        dbg!(&fs);
-
-        // Create a threadpool for loading images.
-        let threadpool = ThreadPool::default();
-        let image_loader = ImageLoader { threadpool };
-
-        // Initialise the ISF imported images, input data and passes.
-        let mut isf_data = IsfData::default();
-        if let Some(ref isf) = isf {
-            sync_isf_data(
-                device,
-                encoder,
-                isf,
-                dst_texture_size,
-                &image_loader,
-                &images_path,
-                &mut isf_data,
-            );
-        }
-
-        // Prepare the uniform buffers.
-        let [dst_tex_w, dst_tex_h] = dst_texture_size;
-        let isf_uniforms = IsfUniforms {
-            pass_index: 0,
-            render_size: [dst_tex_w as f32, dst_tex_h as f32],
-            time: 0.0,
-            time_delta: 0.0,
-            date: [0.0; 4],
-            frame_index: 0,
-        };
-        let isf_uniforms_bytes = isf_uniforms_as_bytes(&isf_uniforms);
-        let isf_input_uniforms: IsfInputUniforms = [0u32; 128];
-        let isf_input_uniforms_bytes = isf_input_uniforms_as_bytes(&isf_input_uniforms);
-        let uniforms_usage = wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST;
-        let isf_uniform_buffer = device.create_buffer_init(&BufferInitDescriptor {
-            label: None,
-            contents: &isf_uniforms_bytes,
-            usage: uniforms_usage,
-        });
-        let isf_inputs_uniform_buffer = device.create_buffer_init(&BufferInitDescriptor {
-            label: None,
-            contents: &isf_input_uniforms_bytes,
-            usage: uniforms_usage,
-        });
-
-        // Create the sampler.
-        let sampler_desc = wgpu::SamplerBuilder::new().into_descriptor();
-        let sampler_filtering = wgpu::sampler_filtering(&sampler_desc);
-        let sampler = device.create_sampler(&sampler_desc);
-
-        // Prepare the bind group layouts.
-        let isf_bind_group_layout = wgpu::BindGroupLayoutBuilder::new()
-            .uniform_buffer(wgpu::ShaderStages::FRAGMENT, false)
-            .build(device);
-        let isf_inputs_bind_group_layout = wgpu::BindGroupLayoutBuilder::new()
-            .uniform_buffer(wgpu::ShaderStages::FRAGMENT, false)
-            .build(device);
-        let isf_textures_bind_group_layout =
-            create_isf_textures_bind_group_layout(device, sampler_filtering, &isf_data);
-
-        // Create the bind groups
-        let isf_bind_group = wgpu::BindGroupBuilder::new()
-            .buffer::<IsfUniforms>(&isf_uniform_buffer, 0..1)
-            .build(device, &isf_bind_group_layout);
-        let isf_inputs_bind_group = wgpu::BindGroupBuilder::new()
-            .buffer::<IsfInputUniforms>(&isf_inputs_uniform_buffer, 0..1)
-            .build(device, &isf_inputs_bind_group_layout);
-        let isf_textures_bind_group = create_isf_textures_bind_group(
-            device,
-            &isf_textures_bind_group_layout,
-            &sampler,
-            &isf_data,
-        );
-
-        // Create the render pipeline.
-        let layout = create_pipeline_layout(
-            device,
-            &[
-                &isf_bind_group_layout,
-                &isf_inputs_bind_group_layout,
-                &isf_textures_bind_group_layout,
-            ],
-        );
-        let render_pipeline = match (vs.module.as_ref(), fs.module.as_ref()) {
-            (Some(vs_mod), Some(fs_mod)) => Some(create_render_pipeline(
-                device,
-                &layout,
-                vs_mod,
-                fs_mod,
-                dst_format,
-                dst_sample_count,
-            )),
-            _ => None,
-        };
-
-        // The quad vertex buffer.
-        let vertices_bytes = vertices_as_bytes(&VERTICES[..]);
-        let vertex_usage = wgpu::BufferUsages::VERTEX;
-        let vertex_buffer = device.create_buffer_init(&BufferInitDescriptor {
-            label: None,
-            contents: vertices_bytes,
-            usage: vertex_usage,
-        });
-
-        Self {
-            isf,
-            isf_data,
-            isf_err,
-            image_loader,
-            vs,
-            fs,
-            sampler,
-            sampler_filtering,
-            isf_uniform_buffer,
-            isf_inputs_uniform_buffer,
-            isf_bind_group_layout,
-            isf_inputs_bind_group_layout,
-            isf_textures_bind_group_layout,
-            isf_bind_group,
-            isf_inputs_bind_group,
-            isf_textures_bind_group,
-            layout,
-            render_pipeline,
-            vertex_buffer,
-            dst_format,
-            dst_texture_size,
-            dst_sample_count,
-        }
-    }
-
-    /// Update the ISF pipeline.
-    ///
-    /// Updating the ISF pipeline does the following:
-    ///
-    /// - First attempts to recompile the given sequence of touched shaders, both for ISF and GLSL.
-    /// - Synchronises the ISF data with the latest successfully parsed `Isf` instance. Any images
-    ///   that have completed loading will be uploaded to textures.
-    /// - If the number of textures has changed, recreates the texture bind group, layout and
-    ///   render pipeline layout.
-    /// - If any of the shaders successfully recompiled, or if the number of textures changed, the
-    ///   pipeline is recreated.
-    pub fn encode_update<I>(
-        &mut self,
-        device: &wgpu::Device,
-        encoder: &mut wgpu::CommandEncoder,
-        images_path: &Path,
-        touched_shaders: I,
-    ) where
-        I: IntoIterator,
-        I::Item: AsRef<Path>,
-    {
-        // UPDATE SHADERS
-        // --------------
-
-        // Attempt to recompile touched shaders.
-        let mut shader_recompiled = false;
-        for path in touched_shaders {
-            let path = path.as_ref();
-            if self.vs.source.as_path() == Some(&path) {
-                let (module, error) = compile_shader(device, &path);
-                self.vs.error = error;
-                if module.is_some() {
-                    shader_recompiled = true;
-                    self.vs.module = module;
-                }
-            } else if self.fs.source.as_path() == Some(&path) {
-                let (module, error) = compile_isf_shader(device, &path);
-                self.fs.error = error;
-                if module.is_some() {
-                    shader_recompiled = true;
-                    self.fs.module = module;
-                }
-                // Update the `Isf` instance.
-                let isf_res = read_isf_from_path(&path);
-                let (new_isf, new_isf_err) = split_result(isf_res);
-                self.isf_err = new_isf_err;
-                if self.isf.is_none() {
-                    self.isf = new_isf;
-                }
-            }
-        }
-
-        // UPDATE ISF DATA
-        // ---------------
-
-        // We can only update the isf data if we have an isf instance to work with.
-        let isf = match self.isf {
-            None => return,
-            Some(ref isf) => isf,
-        };
-
-        // Keep track of whether the number of textures change for our bind groups.
-        let texture_count = isf_data_textures(&self.isf_data).count();
-
-        // Synchronise the ISF data.
-        sync_isf_data(
-            device,
-            encoder,
-            isf,
-            self.dst_texture_size,
-            &self.image_loader,
-            images_path,
-            &mut self.isf_data,
-        );
-
-        // UPDATE TEXTURE BIND GROUP
-        // -------------------------
-
-        // If the number of textures have changed, update the bind group and pipeline layout.
-        let new_texture_count = isf_data_textures(&self.isf_data).count();
-        let texture_count_changed = texture_count != new_texture_count;
-        if texture_count_changed {
-            self.isf_textures_bind_group_layout = create_isf_textures_bind_group_layout(
-                device,
-                self.sampler_filtering,
-                &self.isf_data,
-            );
-            self.isf_textures_bind_group = create_isf_textures_bind_group(
-                device,
-                &self.isf_textures_bind_group_layout,
-                &self.sampler,
-                &self.isf_data,
-            );
-            self.layout = create_pipeline_layout(
-                device,
-                &[
-                    &self.isf_bind_group_layout,
-                    &self.isf_inputs_bind_group_layout,
-                    &self.isf_textures_bind_group_layout,
-                ],
-            );
-        }
-
-        // UPDATE RENDER PIPELINE
-        // ----------------------
-
-        if shader_recompiled || texture_count_changed {
-            if let (Some(vs_mod), Some(fs_mod)) = (self.vs.module.as_ref(), self.fs.module.as_ref())
-            {
-                self.render_pipeline = Some(create_render_pipeline(
-                    device,
-                    &self.layout,
-                    vs_mod,
-                    fs_mod,
-                    self.dst_format,
-                    self.dst_sample_count,
-                ));
-            }
-        }
-    }
-
-    /// Given an encoder, submits a render pass command for drawing the pipeline to the given
-    /// texture.
-    ///
-    /// If the pipeline has not yet been created because it has not yet compiled the necessary
-    /// shaders correctly, the render pass will not be encoded.
-    pub fn encode_render_pass(
-        &self,
-        device: &wgpu::Device,
-        encoder: &mut wgpu::CommandEncoder,
-        dst_texture: &wgpu::TextureViewHandle,
-        isf_time: IsfTime,
-    ) {
-        if let Some(ref pipeline) = self.render_pipeline {
-            // Encode an update for the ISF uniform buffer.
-            let [w, h] = self.dst_texture_size;
-            let isf_uniforms = IsfUniforms {
-                pass_index: 0,
-                render_size: [w as f32, h as f32],
-                time: isf_time.time,
-                time_delta: isf_time.time_delta,
-                date: isf_time.date,
-                frame_index: isf_time.frame_index,
-            };
-            let isf_uniforms_bytes = isf_uniforms_as_bytes(&isf_uniforms);
-            let usage = wgpu::BufferUsages::COPY_SRC;
-            let new_buffer = device.create_buffer_init(&BufferInitDescriptor {
-                label: None,
-                contents: &isf_uniforms_bytes,
-                usage,
-            });
-            let size = isf_uniforms_bytes.len() as wgpu::BufferAddress;
-            encoder.copy_buffer_to_buffer(&new_buffer, 0, &self.isf_uniform_buffer, 0, size);
-
-            // TODO: Update the inputs.
-            let _ = &self.isf_inputs_uniform_buffer;
-            //let size = std::mem::size_of::<IsfInputUniforms>() as wgpu::BufferAddress;
-            //encoder.copy_buffer_to_buffer(&new_buffer, 0, &self.isf_inputs_uniform_buffer, 0, size);
-
-            // Encode the render pass.
-            let mut render_pass = wgpu::RenderPassBuilder::new()
-                .color_attachment(dst_texture, |color| color)
-                .begin(encoder);
-            render_pass.set_pipeline(pipeline);
-            render_pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
-            render_pass.set_bind_group(0, &self.isf_bind_group, &[]);
-            render_pass.set_bind_group(1, &self.isf_inputs_bind_group, &[]);
-            render_pass.set_bind_group(2, &self.isf_textures_bind_group, &[]);
-            let vertex_range = 0..VERTICES.len() as u32;
-            let instance_range = 0..1;
-            render_pass.draw(vertex_range, instance_range);
-        }
-    }
-
-    /// Encode a render pass command for drawing the output of the pipeline to the given frame.
-    ///
-    /// Uses `encode_render_pass` internally.
-    pub fn encode_to_frame(&self, frame: &Frame, isf_time: IsfTime) {
-        let device = frame.device_queue_pair().device();
-        let mut encoder = frame.command_encoder();
-        self.encode_render_pass(device, &mut *encoder, frame.texture_view(), isf_time);
-    }
-
-    /// Returns the current compilation error for the vertex shader if there is one.
-    ///
-    /// Returns `Some` if the last call to `update_shaders` contained a compilation error for the
-    /// vertex shader.
-    pub fn vs_err(&self) -> Option<&ShaderError> {
-        self.vs.error.as_ref()
-    }
-
-    /// Returns the current compilation error for the vertex shader if there is one.
-    ///
-    /// Returns `Some` if the last call to `update_shaders` contained a compilation error for the
-    /// vertex shader.
-    pub fn fs_err(&self) -> Option<&ShaderError> {
-        self.fs.error.as_ref()
-    }
-}
-
-fn split_result<T, E>(res: Result<T, E>) -> (Option<T>, Option<E>) {
-    match res {
-        Ok(t) => (Some(t), None),
-        Err(e) => (None, Some(e)),
-    }
-}
-
-// Includes the sampler and then all textures for all images and passes.
-fn create_isf_textures_bind_group_layout(
-    device: &wgpu::Device,
-    sampler_filtering: bool,
-    isf_data: &IsfData,
-) -> wgpu::BindGroupLayout {
-    // Begin with the sampler.
-    let mut builder = wgpu::BindGroupLayoutBuilder::new()
-        .sampler(wgpu::ShaderStages::FRAGMENT, sampler_filtering);
-    for texture in isf_data_textures(isf_data) {
-        builder = builder.texture(
-            wgpu::ShaderStages::FRAGMENT,
-            false,
-            wgpu::TextureViewDimension::D2,
-            texture.sample_type(),
-        );
-    }
-    builder.build(device)
-}
-
-fn create_isf_textures_bind_group(
-    device: &wgpu::Device,
-    layout: &wgpu::BindGroupLayout,
-    sampler: &wgpu::Sampler,
-    isf_data: &IsfData,
-) -> wgpu::BindGroup {
-    let mut builder = wgpu::BindGroupBuilder::new().sampler(sampler);
-    let texture_views: Vec<_> = isf_data_textures(isf_data)
-        .map(|tex| tex.view().build())
-        .collect();
-    for texture_view in &texture_views {
-        builder = builder.texture_view(texture_view);
-    }
-    builder.build(device, layout)
-}
-
-fn create_pipeline_layout(
-    device: &wgpu::Device,
-    bind_group_layouts: &[&wgpu::BindGroupLayout],
-) -> wgpu::PipelineLayout {
-    let desc = wgpu::PipelineLayoutDescriptor {
-        label: None,
-        bind_group_layouts,
-        push_constant_ranges: &[],
-    };
-    device.create_pipeline_layout(&desc)
-}
-
-fn create_render_pipeline(
-    device: &wgpu::Device,
-    layout: &wgpu::PipelineLayout,
-    vs_mod: &wgpu::ShaderModule,
-    fs_mod: &wgpu::ShaderModule,
-    dst_format: wgpu::TextureFormat,
-    sample_count: u32,
-) -> wgpu::RenderPipeline {
-    wgpu::RenderPipelineBuilder::from_layout(layout, &vs_mod)
-        .fragment_shader(fs_mod)
-        .color_format(dst_format)
-        .add_vertex_buffer::<Vertex>(&wgpu::vertex_attr_array![0 => Float32x2])
-        .sample_count(sample_count)
-        .primitive_topology(wgpu::PrimitiveTopology::TriangleStrip)
-        .build(device)
-}
-
-// All textures stored within the `IsfData` instance in the order that they should be declared in
-// the order expected by the isf textures bind group.
-fn isf_data_textures(isf_data: &IsfData) -> impl Iterator<Item = &wgpu::Texture> {
-    let imported = isf_data.imported.values().filter_map(|state| match state {
-        ImageState::Ready(ref img_res) => match img_res {
-            Ok(ref img_data) => Some(&img_data.texture),
-            _ => None,
-        },
-        _ => None,
-    });
-    let inputs = isf_data
-        .inputs
-        .values()
-        .filter_map(|input_data| match input_data {
-            IsfInputData::Image(ref img_state) => match *img_state {
-                ImageState::Ready(Ok(ref data)) => Some(&data.texture),
-                _ => None,
-            },
-            IsfInputData::Audio { ref texture, .. }
-            | IsfInputData::AudioFft { ref texture, .. } => Some(texture),
-            _ => None,
-        });
-    let passes = isf_data.passes.iter();
-    imported.chain(inputs).chain(passes)
-}
-
-// Ensure the image state map is up to date.
-fn sync_isf_data(
-    device: &wgpu::Device,
-    encoder: &mut wgpu::CommandEncoder,
-    isf: &isf::Isf,
-    output_attachment_size: [u32; 2],
-    image_loader: &ImageLoader,
-    images_path: &Path,
-    isf_data: &mut IsfData,
-) {
-    // Update imported images. first.
-    isf_data
-        .imported
-        .retain(|name, _| isf.imported.contains_key(name));
-    for (key, img) in &isf.imported {
-        let state = isf_data
-            .imported
-            .entry(key.clone())
-            .or_insert(ImageState::None);
-        state.update(device, encoder, image_loader, img.path.clone());
-    }
-
-    // First, check all imported textures are loading.
-    isf_data
-        .inputs
-        .retain(|key, _| isf.inputs.iter().map(|i| &i.name).any(|n| n == key));
-    for input in &isf.inputs {
-        let input_data = isf_data
-            .inputs
-            .entry(input.name.clone())
-            .or_insert_with(|| {
-                IsfInputData::new(device, encoder, image_loader, images_path, input)
-            });
-        input_data.update(device, encoder, image_loader, images_path, input);
-    }
-
-    // Prepare the textures that will be written to for passes.
-    isf_data.passes.resize_with(isf.passes.len(), || {
-        let texture = wgpu::TextureBuilder::new()
-            .format(Frame::TEXTURE_FORMAT)
-            .size(output_attachment_size)
-            .usage(default_isf_texture_usage())
-            .build(device);
-        let data = vec![0u8; texture.size_bytes()];
-        texture.upload_data(device, encoder, &data);
-        texture
-    });
-}
-
-fn create_black_texture(
-    device: &wgpu::Device,
-    encoder: &mut wgpu::CommandEncoder,
-    size: [u32; 2],
-    format: wgpu::TextureFormat,
-) -> wgpu::Texture {
-    let texture = wgpu::TextureBuilder::new()
-        .usage(default_isf_texture_usage())
-        .size(size)
-        .format(format)
-        .build(device);
-    let data = vec![0u8; texture.size_bytes()];
-    texture.upload_data(device, encoder, &data);
-    texture
-}
-
-fn default_isf_texture_usage() -> wgpu::TextureUsages {
-    wgpu::TextureUsages::COPY_DST | wgpu::TextureUsages::TEXTURE_BINDING
-}
-
-fn read_isf_from_path(path: &Path) -> Result<isf::Isf, IsfError> {
-    std::fs::read_to_string(path)
-        .map_err(|err| IsfError::from(err))
-        .and_then(|s| isf::parse(&s).map_err(From::from))
-}
-
-/// Given a path to a directory, produces the paths of all images within it.
-fn image_paths(dir: &Path) -> impl Iterator<Item = PathBuf> {
-    walkdir::WalkDir::new(dir)
-        .into_iter()
-        .filter_map(|res| res.ok())
-        .map(|entry| entry.path().to_path_buf())
-        .filter(|path| image::image_dimensions(path).ok().is_some())
-}
-
-// Conversions to bytes for GPU buffer uploads.
-
-fn isf_uniforms_as_bytes(data: &IsfUniforms) -> &[u8] {
-    unsafe { wgpu::bytes::from(data) }
-}
-
-fn isf_input_uniforms_as_bytes(data: &[u32]) -> &[u8] {
-    unsafe { wgpu::bytes::from_slice(data) }
-}
-
-fn vertices_as_bytes(data: &[Vertex]) -> &[u8] {
-    unsafe { wgpu::bytes::from_slice(data) }
-}
diff --git a/nannou_isf/src/shaders/shader.vert b/nannou_isf/src/shaders/shader.vert
deleted file mode 100644
index 68e39fbff..000000000
--- a/nannou_isf/src/shaders/shader.vert
+++ /dev/null
@@ -1,15 +0,0 @@
-// NOTE: This shader requires being manually compiled to SPIR-V in order to
-// avoid having downstream users require building shaderc and compiling the
-// shader themselves. If you update this shader, be sure to also re-compile it
-// and update `vert.spv`. You can do so using `glslangValidator` with the
-// following command: `glslangValidator -V -o vert.spv shader.vert`
-
-#version 450
-
-layout(location = 0) in vec2 position;
-layout(location = 0) out vec2 isf_FragNormCoord;
-
-void main() {
-    gl_Position = vec4(position, 0.0, 1.0);
-    isf_FragNormCoord = vec2(position.x * 0.5 + 0.5, 1.0 - (position.y * 0.5 + 0.5));
-}
diff --git a/nannou_isf/src/shaders/vert.spv b/nannou_isf/src/shaders/vert.spv
deleted file mode 100644
index 36c7c2489..000000000
Binary files a/nannou_isf/src/shaders/vert.spv and /dev/null differ
diff --git a/nannou_isf/test_files/3d Rotate.fs b/nannou_isf/test_files/3d Rotate.fs
deleted file mode 100644
index ce1423085..000000000
--- a/nannou_isf/test_files/3d Rotate.fs	
+++ /dev/null
@@ -1,52 +0,0 @@
-/*{
-	"DESCRIPTION": "performs a 3d rotation",
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Geometry Adjustment", "Utility"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "xrot",
-			"LABEL": "X rotate",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 2.0,
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "yrot",
-			"LABEL": "Y rotate",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 2.0,
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "zrot",
-			"LABEL": "Z rotate",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 2.0,
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "zoom",
-			"LABEL": "Zoom Level",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 1.0
-		}
-	]
-}*/
-
-
-void main()
-{
-	gl_FragColor = IMG_THIS_PIXEL(inputImage);
-}
diff --git a/nannou_isf/test_files/3d Rotate.vs b/nannou_isf/test_files/3d Rotate.vs
deleted file mode 100644
index e05b13b05..000000000
--- a/nannou_isf/test_files/3d Rotate.vs	
+++ /dev/null
@@ -1,86 +0,0 @@
-float		PI_CONST = 3.14159265359;
-
-
-//	with help from http://duriansoftware.com/joe/An-intro-to-modern-OpenGL.-Chapter-3:-3D-transformation-and-projection.html
-//	and http://en.wikipedia.org/wiki/Rotation_matrix
-
-
-mat4 view_frustum(
-    float angle_of_view,
-    float aspect_ratio,
-    float z_near,
-    float z_far
-) {
-    return mat4(
-        vec4(1.0/tan(angle_of_view),           0.0, 0.0, 0.0),
-        vec4(0.0, aspect_ratio/tan(angle_of_view),  0.0, 0.0),
-        vec4(0.0, 0.0,    (z_far+z_near)/(z_far-z_near), 1.0),
-        vec4(0.0, 0.0, -2.0*z_far*z_near/(z_far-z_near), 0.0)
-    );
-}
-
-mat4 scale(float x, float y, float z)
-{
-    return mat4(
-        vec4(x,   0.0, 0.0, 0.0),
-        vec4(0.0, y,   0.0, 0.0),
-        vec4(0.0, 0.0, z,   0.0),
-        vec4(0.0, 0.0, 0.0, 1.0)
-    );
-}
-
-mat4 translate(float x, float y, float z)
-{
-    return mat4(
-        vec4(1.0, 0.0, 0.0, 0.0),
-        vec4(0.0, 1.0, 0.0, 0.0),
-        vec4(0.0, 0.0, 1.0, 0.0),
-        vec4(x,   y,   z,   1.0)
-    );
-}
-
-mat4 rotate_x(float theta)
-{
-    return mat4(
-        vec4(1.0, 0.0, 0.0, 0.0),
-        vec4(0.0, cos(theta*PI_CONST), sin(theta*PI_CONST), 0.0),
-        vec4(0.0, -sin(theta*PI_CONST), cos(theta*PI_CONST), 0.0),
-        vec4(0.0, 0.0, 0.0, 1.0)
-    );
-}
-
-mat4 rotate_y(float theta)
-{
-    return mat4(
-        vec4(cos(theta*PI_CONST), 0.0, sin(theta*PI_CONST), 0.0),
-        vec4(0.0, 1.0, 0.0, 0.0),
-        vec4(-sin(theta*PI_CONST), 0, cos(theta*PI_CONST), 0.0),
-        vec4(0.0, 0.0, 0.0, 1.0)
-    );
-}
-
-mat4 rotate_z(float theta)
-{
-    return mat4(
-        vec4(cos(theta*PI_CONST), -sin(theta*PI_CONST), 0.0, 0.0),
-        vec4(sin(theta*PI_CONST), cos(theta*PI_CONST), 0.0, 0.0),
-        vec4(0.0, 0.0, 1.0, 0.0),
-        vec4(0.0, 0.0, 0.0, 1.0)
-    );
-}
-
-void main()
-{
-	isf_vertShaderInit();
-	
-	vec4 position = gl_Position;
-
-    gl_Position = view_frustum(radians(45.0), RENDERSIZE.x/RENDERSIZE.y, 0.0, 2.0)
-        * translate(0.0, 0.0, RENDERSIZE.x/RENDERSIZE.y)
-        * rotate_x(-xrot)
-        * rotate_y(yrot)
-        * rotate_z(-zrot)
-        * scale(zoom*RENDERSIZE.x/RENDERSIZE.y, zoom, zoom)
-        * position;
-
-}
diff --git a/nannou_isf/test_files/ASCII Art.fs b/nannou_isf/test_files/ASCII Art.fs
deleted file mode 100644
index 6683278dd..000000000
--- a/nannou_isf/test_files/ASCII Art.fs	
+++ /dev/null
@@ -1,95 +0,0 @@
-/*{
-	"DESCRIPTION": "ASCII Art",
-	"CREDIT": "by VIDVOX (Ported from https://www.shadertoy.com/view/lssGDj)",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Stylize", "Retro"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "size",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.1
-		},
-		{
-			"NAME": "gamma",
-			"TYPE": "float",
-			"DEFAULT": 1.0,
-			"MIN": 0.5,
-			"MAX": 2.0
-		},
-		{
-			"NAME": "tint",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "tintColor",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.0,
-				1.0,
-				0.0,
-				1.0
-			]
-		},
-		{
-			"NAME": "alphaMode",
-			"TYPE": "bool",
-			"DEFAULT": 0.0
-		}
-	]
-	
-}*/
-
-
-
-float character(float n, vec2 p) // some compilers have the word "char" reserved
-{
-	p = floor(p*vec2(4.0, -4.0) + 2.5);
-	if (clamp(p.x, 0.0, 4.0) == p.x && clamp(p.y, 0.0, 4.0) == p.y)
-	{
-		if (int(mod(n/exp2(p.x + 5.0*p.y), 2.0)) == 1) return 1.0;
-	}	
-	return 0.0;
-}
-
-
-
-void main()	{
-	float _size = size*36.0+8.0;
-	vec2 uv = gl_FragCoord.xy;
-	vec4 inputColor = IMG_NORM_PIXEL(inputImage, (floor(uv/_size)*_size/RENDERSIZE.xy));
-	vec3 col = inputColor.rgb;
-	float gray = (col.r + col.g + col.b)/3.0;
-	gray = pow(gray, gamma);
-	col = mix(tintColor.rgb, col.rgb, 1.0-tint);
-	
-	float n =  65536.0;             // .
-	if (gray > 0.2) n = 65600.0;    // :
-	if (gray > 0.3) n = 332772.0;   // *
-	if (gray > 0.4) n = 15255086.0; // o 
-	if (gray > 0.5) n = 23385164.0; // &
-	if (gray > 0.6) n = 15252014.0; // 8
-	if (gray > 0.7) n = 13199452.0; // @
-	if (gray > 0.8) n = 11512810.0; // #
-		
-	vec2 p = mod(uv/(_size/2.0), 2.0) - vec2(1.0);
-	col = col*character(n, p);
-	float alpha = mix(tintColor.a * inputColor.a, inputColor.a, 1.0-tint);
-	if (alphaMode)	{
-		alpha = (col.r + col.g + col.b)/3.0;
-		alpha = (alpha > 0.01) ? tintColor.a : alpha;
-	}
-	
-	gl_FragColor = vec4(col,alpha);
-
-}
diff --git a/nannou_isf/test_files/Angular.fs b/nannou_isf/test_files/Angular.fs
deleted file mode 100644
index 982b2cbf8..000000000
--- a/nannou_isf/test_files/Angular.fs
+++ /dev/null
@@ -1,71 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Wipe"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/angular.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 90,
-            "MAX": 360,
-            "MIN": 0,
-            "NAME": "startingAngle",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: Fernando Kuteken
-// License: MIT
-
-#define PI 3.141592653589
-
-
-vec4 transition (vec2 uv) {
-  
-  float offset = startingAngle * PI / 180.0;
-  float angle = atan(uv.y - 0.5, uv.x - 0.5) + offset;
-  float normalizedAngle = (angle + PI) / (2.0 * PI);
-  
-  normalizedAngle = normalizedAngle - floor(normalizedAngle);
-
-  return mix(
-    getFromColor(uv),
-    getToColor(uv),
-    step(normalizedAngle, progress)
-    );
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Apply Alpha.fs b/nannou_isf/test_files/Apply Alpha.fs
deleted file mode 100644
index de826e35c..000000000
--- a/nannou_isf/test_files/Apply Alpha.fs	
+++ /dev/null
@@ -1,23 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Color Adjustment",
-        "Masking",
-        "Utility"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-void main() {
-	vec4		srcPixel = IMG_THIS_PIXEL(inputImage);
-	srcPixel.rgb = srcPixel.rgb * srcPixel.a;
-	srcPixel.a = 1.0;
-	gl_FragColor = srcPixel;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Auto Color Tone.fs b/nannou_isf/test_files/Auto Color Tone.fs
deleted file mode 100644
index 04d414cd2..000000000
--- a/nannou_isf/test_files/Auto Color Tone.fs	
+++ /dev/null
@@ -1,347 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Color Effect"
-    ],
-    "CREDIT": "by VIDVOX",
-    "DESCRIPTION": "Creates variations on a base color using a given algorithm.",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Sample Mode",
-            "LABELS": [
-                "Base Color",
-                "Pixel Follow",
-                "Color Average"
-            ],
-            "NAME": "sampleMode",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1,
-                2
-            ]
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Color Mode",
-            "LABELS": [
-                "Basic Complementary",
-                "Split Complementary",
-                "Compound Complementary",
-                "Spectrum",
-                "Shades",
-                "Analogous",
-                "Compound Analogous"
-            ],
-            "NAME": "colorModeOverride",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1,
-                2,
-                3,
-                4,
-                5,
-                6
-            ]
-        },
-        {
-            "DEFAULT": 7,
-            "LABEL": "Color Count",
-            "LABELS": [
-                "2",
-                "3",
-                "4",
-                "5",
-                "6",
-                "7",
-                "8",
-                "9",
-                "10",
-                "11",
-                "12",
-                "13",
-                "14",
-                "15",
-                "16"
-            ],
-            "NAME": "colorCount",
-            "TYPE": "long",
-            "VALUES": [
-                2,
-                3,
-                4,
-                5,
-                6,
-                7,
-                8,
-                9,
-                10,
-                11,
-                12,
-                13,
-                14,
-                15,
-                16
-            ]
-        },
-        {
-            "DEFAULT": [
-                0.25,
-                0.59,
-                0.9,
-                1
-            ],
-            "LABEL": "Base Color",
-            "NAME": "baseColor",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": [
-                0.5,
-                0.5
-            ],
-            "LABEL": "Pixel Point",
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "pixelFollowLocation",
-            "TYPE": "point2D"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "HEIGHT": "$HEIGHT / 100.0",
-            "TARGET": "bufferPassA",
-            "WIDTH": "$WIDTH / 100.0"
-        },
-        {
-            "HEIGHT": "1.0",
-            "TARGET": "autoColorBuffer",
-            "WIDTH": "1.0",
-            "persistent": true
-        },
-        {
-        }
-    ]
-}
-*/
-
-
-
-
-vec3 rgb2hsv(vec3 c)	{
-	vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-	//vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
-	//vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
-	vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
-	vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
-	
-	float d = q.x - min(q.w, q.y);
-	float e = 1.0e-10;
-	return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
-}
-
-vec3 hsv2rgb(vec3 c)	{
-	vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
-	vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
-	return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
-}
-
-float gray(vec4 c)	{
-	return (c.r + c.g + c.b) * c.a / 3.0;	
-}
-
-void main()
-{
-	if (PASSINDEX == 0)	{
-		vec4 		inputColor = IMG_NORM_PIXEL(inputImage, isf_FragNormCoord);
-		gl_FragColor = inputColor;
-	}
-	else if (PASSINDEX == 1)	{
-		vec4 		inputColor = IMG_NORM_PIXEL(bufferPassA, isf_FragNormCoord);
-		vec4 		oldColor = IMG_NORM_PIXEL(autoColorBuffer, vec2(0.5,0.5));
-		gl_FragColor = mix(inputColor, oldColor, 0.8);
-	}
-	else if (PASSINDEX == 2)	{
-		vec4 		inputColor = IMG_THIS_PIXEL(inputImage);
-		vec4		inColor = baseColor;
-		float		index = floor(gray(inputColor) * float(colorCount));	
-		//float		index = floor(isf_FragNormCoord.x * float(colorCount));
-		float		variation = 0.3236;	//	1/5 the golden ratio
-		int			colorMode = colorModeOverride;
-
-		if (sampleMode == 0)	{
-			inColor = baseColor;
-			inColor.rgb = rgb2hsv(inColor.rgb);
-		}
-		else if (sampleMode == 1)	{
-			inColor = IMG_NORM_PIXEL(inputImage, pixelFollowLocation);
-			inColor.rgb = rgb2hsv(inColor.rgb);
-		}
-		else if (sampleMode == 2)	{
-			inColor = IMG_NORM_PIXEL(autoColorBuffer, vec2(0.5,0.5));
-			inColor.rgb = rgb2hsv(inColor.rgb);
-			if (inColor.b < 0.1)	{
-				inColor = inColor * 1.5;	
-			}
-		}
-	
-		vec4		outColor = inColor;
-	
-		//	Basic complimentary  saturation and brightness variations on two fixed 180 degree opposite hues
-		if (colorMode == 0)	{
-			if (mod(index, 2.0) >= 1.0)	{
-				outColor.r = outColor.r + 0.5;
-				outColor.r = outColor.r - floor(outColor.r);
-			}
-		
-			outColor.g = outColor.g - variation * floor(index / 2.0);
-		
-			if (outColor.g < 0.1)	{
-				outColor.g = outColor.g + variation * floor(index / 2.0);
-				outColor.g = outColor.g - floor(outColor.g);
-			}
-		
-			outColor.b = outColor.b - variation * floor(index / 4.0);
-			if (outColor.b < 0.2)	{
-				outColor.b = outColor.b + variation * floor(index / 4.0);
-				outColor.b = outColor.b - floor(outColor.b);
-			}
-		}
-		//	Split complimentary  saturation and brightness variations on a 3 fixed 120 degree hues
-		else if (colorMode == 1)	{
-			float divisor = 3.0;
-			float ratio = 0.45;
-			if (mod(index, 3.0) >= 2.0)	{
-				outColor.r = outColor.r - ratio;
-			}
-			else if (mod(index, 3.0) >= 1.0)	{
-				outColor.r = outColor.r + ratio;
-			}
-		
-			//outColor.g = outColor.g + variation * floor(index / divisor);
-		
-			if (mod(index, 5.0) >= 3.0)	{
-				outColor.g = outColor.g - variation;
-				outColor.g = outColor.g - floor(outColor.g);
-			}
-			outColor.b = outColor.b - variation * floor(index / (divisor));
-			if (outColor.b < 0.1)	{
-				outColor.b = outColor.b + variation * floor(index / (divisor));
-				outColor.b = outColor.b - floor(outColor.b);
-			}
-		}
-		//	Compound complimentary  a combination of shades, complimentary and analogous colors with slight shifts
-		else if (colorMode == 2)	{
-			if (mod(index, 3.0) >= 2.0)	{
-				outColor.r = outColor.r + 0.5;
-				outColor.r = outColor.r + variation * index * 1.0 / float(colorCount - 1) / 4.0;
-			}
-			else	{
-				outColor.r = outColor.r + variation * index * 1.0 / float(colorCount - 1);
-			}
-			outColor.r = outColor.r - floor(outColor.r);
-		
-		
-			if (mod(index, 2.0) >= 1.0)	{
-				outColor.g = outColor.g + index * variation / 2.0;
-			}
-			else if (mod(index, 3.0) >= 2.0)	{
-				outColor.g = outColor.g - variation / 2.0;
-			}
-			else	{
-				outColor.g = outColor.g - index * variation / float(colorCount - 1);
-			}
-			if (outColor.g > 1.0)	{
-				outColor.g = outColor.g - floor(outColor.g);
-			}
-		}
-		//	Spectrum  hue shifts based on number of colors with minor saturation shifts
-		else if (colorMode == 3)	{
-			outColor.r = outColor.r + index * 1.0 / float(colorCount);
-			if (mod(index, 3.0) >= 2.0)	{
-				outColor.g = outColor.g - variation / 2.0;
-				outColor.g = outColor.g - floor(outColor.g);
-			}
-			else if (mod(index, 4.0) >= 3.0)	{
-				outColor.g = outColor.g + variation / 2.0;
-				//outColor.g = outColor.g - floor(outColor.g);
-			}
-		}
-		//	Shades  saturation and brightness variations on a single fixed hue
-		else if (colorMode == 4)	{
-			if (mod(index, 2.0) >= 1.0)	{
-				outColor.b = outColor.b - (index * variation) / float(colorCount-1);
-			}
-			else	{
-				outColor.b = outColor.b + (index * variation) / float(colorCount-1);
-				outColor.b = outColor.b - floor(outColor.b);
-			}
-			if (outColor.b < 0.075)	{
-				outColor.b = 1.0 - outColor.b * variation;
-			}
-		
-			if (mod(index, 3.0) >= 2.0)	{
-				outColor.g = outColor.g - (index * variation) / 2.0;
-			}
-			else if (mod(index, 4.0) >= 3.0)	{
-				outColor.g = outColor.g + (index * variation) / 2.0;
-			}
-		
-			if ((outColor.g > 1.0) || (outColor.g < 0.05))	{
-				outColor.g = outColor.g - floor(outColor.g);
-			}
-		}
-		//	Analogous  small hue and saturation shifts 
-		else if (colorMode == 5)	{
-
-			outColor.r = outColor.r + variation * index * 1.0 / float(colorCount - 1); 		
-
-			if (mod(index, 3.0) >= 1.0)	{
-				outColor.g = outColor.g - variation / 2.0;
-				if (outColor.g < 0.0)	{
-					outColor.g = outColor.g + variation / 2.0;
-				}
-				if (outColor.g > 1.0)	{
-					outColor.g = outColor.g - floor(outColor.g);
-				}
-			}
-		}
-		//	Compound Analogous  similar to analogous but with negative hue shifts
-		else if (colorMode == 6)	{
-			if (mod(index, 3.0) >= 1.0)	{
-				outColor.r = outColor.r + variation * index * 1.0 / float(colorCount - 1);
-			}
-			else	{
-				outColor.r = outColor.r - variation * index * 0.5 / float(colorCount - 1);	
-			}
-			if (mod(index, 3.0) >= 1.0)	{
-				outColor.g = outColor.g - variation / 2.0;
-				if (outColor.g < 0.0)	{
-					outColor.g = outColor.g + variation;
-				}
-				if (outColor.g > 1.0)	{
-					outColor.g = outColor.g - floor(outColor.g);
-				}
-			}
-			if (mod(index, 4.0) >= 2.0)	{
-				if (outColor.b < variation)	{
-					outColor.b = outColor.b + variation;
-				}				
-			}
-		}
-	
-		gl_FragColor = vec4(hsv2rgb(outColor.rgb), inColor.a);
-	}
-}
diff --git a/nannou_isf/test_files/Auto Colors Histogram.fs b/nannou_isf/test_files/Auto Colors Histogram.fs
deleted file mode 100644
index 208cdf377..000000000
--- a/nannou_isf/test_files/Auto Colors Histogram.fs	
+++ /dev/null
@@ -1,254 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Color Adjustment", "Histogram"
-  ],
-  "DESCRIPTION" : "",
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "NAME" : "inputImage",
-      "TYPE" : "image"
-    },
-    {
-      "NAME" : "sourceHistogram",
-      "TYPE" : "image"
-    },
-	{
-		"DEFAULT": 0,
-		"LABEL": "Normalization Mode",
-		"LABELS": [
-			"Average",
-			"Darker",
-			"Brighter",
-			"RGB"
-		],
-		"NAME": "colorMode",
-		"TYPE": "long",
-		"VALUES": [
-			0,
-			1,
-			2,
-			3
-		]
-	},
-	{
-		"DEFAULT": 1,
-		"LABEL": "Adjustment Type",
-		"LABELS": [
-			"Contrast",
-			"Gamma"
-		],
-		"NAME": "colorAdjustment",
-		"TYPE": "long",
-		"VALUES": [
-			0,
-			1
-		]
-	},
-    {
-      "NAME" : "maxGain",
-      "TYPE" : "float",
-      "MAX" : 8,
-      "DEFAULT" : 2,
-      "MIN" : 1
-    },
-    {
-      "NAME" : "threshold",
-      "TYPE" : "float",
-      "MAX" : 1.0,
-      "DEFAULT" : 0.02,
-      "MIN" : 0.0
-    },
-    {
-      "NAME" : "timeSmoothing",
-      "TYPE" : "float",
-      "MAX" : 1.0,
-      "DEFAULT" : 0.0,
-      "MIN" : 0.0
-    }
-  ],
-  "PASSES" : [
-    {
-      "WIDTH" : "2",
-      "TARGET" : "minmax",
-      "HEIGHT" : "1"
-    },
-    {
-      "WIDTH" : "2",
-      "TARGET" : "smoothedminmax",
-      "HEIGHT" : "1",
-      "PERSISTENT": true,
-      "FLOAT": true
-    },
-    {
-
-    }
-  ],
-  "CREDIT" : "VIDVOX"
-}
-*/
-
-float minChannel (vec3 c)	{
-	float	tmpVal = c.r;
-	if (c.g < tmpVal)
-		tmpVal = c.g;
-	if (c.b < tmpVal)
-		tmpVal = c.b;
-	return tmpVal;
-}
-
-float maxChannel (vec3 c)	{
-	float	tmpVal = c.r;
-	if (c.g > tmpVal)
-		tmpVal = c.g;
-	if (c.b > tmpVal)
-		tmpVal = c.b;
-	return tmpVal;
-}
-
-
-void main()	{
-	vec4		returnMe = vec4(0.0);
-	if (PASSINDEX==0)	{
-		//float		minOrMax = (isf_FragNormCoord.x < 0.5) ? 0.0 : 1.0;
-		vec4		accum = vec4(0.0);
-		//	go through each pixel of sourceHistogram
-		//		find the darkest and brightest for each color channel
-		if (isf_FragNormCoord.x < 0.5)	{
-			returnMe.a = 1.0;
-			for(int i=0;i<256;++i)	{
-				vec4	histo = IMG_PIXEL(sourceHistogram,vec2(float(i),0.5));
-				accum += histo;
-				if (returnMe.r == 0.0)	{
-					if (accum.r > threshold)	{
-						returnMe.r = float(i)/255.0;
-					}
-				}
-				if (returnMe.g == 0.0)	{
-					if (accum.g > threshold)	{
-						returnMe.g = float(i)/255.0;
-					}
-				}
-				if (returnMe.b == 0.0)	{
-					if (accum.b > threshold)	{
-						returnMe.b = float(i)/255.0;
-					}
-				}
-				if ((returnMe.r != 0.0)&&(returnMe.g != 0.0)&&(returnMe.b != 0.0))	{
-					break;
-				}
-			}
-		}
-		else	{
-			returnMe = vec4(1.0);
-			for(int i=255;i>=0;--i)	{
-				vec4	histo = IMG_PIXEL(sourceHistogram,vec2(float(i),0.5));
-				accum += histo;
-				if (returnMe.r == 1.0)	{
-					if (accum.r > threshold)	{
-						returnMe.r = float(i)/255.0;
-					}
-				}
-				if (returnMe.g == 1.0)	{
-					if (accum.g > threshold)	{
-						returnMe.g = float(i)/255.0;
-					}
-				}
-				if (returnMe.b == 1.0)	{
-					if (accum.b > threshold)	{
-						returnMe.b = float(i)/255.0;
-					}
-				}
-				if ((returnMe.r != 1.0)&&(returnMe.g != 1.0)&&(returnMe.b != 1.0))	{
-					break;
-				}
-			}
-		}
-	}
-	else if (PASSINDEX==1)	{
-		vec4		freshPixel = IMG_PIXEL(minmax,gl_FragCoord.xy);
-		vec4		stalePixel = IMG_PIXEL(smoothedminmax,gl_FragCoord.xy);
-		returnMe = mix(freshPixel,stalePixel,timeSmoothing);
-		
-		if (colorMode == 0)	{
-			//	Average
-			returnMe = vec4((returnMe.r + returnMe.g + returnMe.b) / 3.0);
-		}
-		else if (colorMode == 1)	{
-			//	we want to subtract the biggest and maximize the spread
-			//	find the brightest rgb channel
-			float	tmpVal = maxChannel(returnMe.rgb);
-			returnMe = vec4(tmpVal);
-		}
-		else if (colorMode == 2)	{
-			//	we want to subtract the smallest and minimize the spread
-			//	find the darkest rgb channel in min
-			float	tmpVal = minChannel(returnMe.rgb);
-			returnMe = vec4(tmpVal);
-		}
-	}
-	else if (PASSINDEX==2)	{
-		returnMe = IMG_THIS_PIXEL(inputImage);
-		vec4	minVal = IMG_PIXEL(smoothedminmax,vec2(0.5,0.5));
-		vec4	maxVal = IMG_PIXEL(smoothedminmax,vec2(1.5,0.5));
-		
-		if (colorAdjustment == 0)	{
-			vec4	contrastVal = (colorMode == 1) ? (maxVal - minVal) : 1.0 / (maxVal - minVal);
-		
-			if (colorMode == 1)	{
-				float	iMaxGain = 1.0 / maxGain;
-				if (contrastVal.r < iMaxGain)
-					contrastVal.r = iMaxGain;
-
-				if (contrastVal.g < iMaxGain)
-					contrastVal.g = iMaxGain;
-		
-				if (contrastVal.b < iMaxGain)
-					contrastVal.b = iMaxGain;
-			}
-			else	{
-				if (contrastVal.r > maxGain)
-					contrastVal.r = maxGain;
-
-				if (contrastVal.g > maxGain)
-					contrastVal.g = maxGain;
-		
-				if (contrastVal.b > maxGain)
-					contrastVal.b = maxGain;
-			}
-		
-			returnMe.r = (returnMe.r - minVal.r) * contrastVal.r;
-			returnMe.g = (returnMe.g - minVal.g) * contrastVal.g;
-			returnMe.b = (returnMe.b - minVal.b) * contrastVal.b;
-		}
-		else if (colorAdjustment == 1)	{
-			//	the input gamma range is 0.0-1.0 (normalized).  the actual gamma range i want to use is 0.0 - 5.0.
-			//	however, actual gamma 0.0-1.0 is just as interesting as actual gamma 1.0-5.0, so we scale the normalized input to match...
-			vec4	realGamma = (colorMode == 1) ? 1.0 / (maxVal - minVal) - 1.0 : 1.0 / (maxVal - minVal) - 0.5;
-			
-			if (realGamma.r > maxGain)
-				realGamma.r = maxGain;
-
-			if (realGamma.g > maxGain)
-				realGamma.g = maxGain;
-	
-			if (realGamma.b > maxGain)
-				realGamma.b = maxGain;
-			
-			float	iMaxGain = 1.0 / maxGain;
-			if (realGamma.r < iMaxGain)
-				realGamma.r = iMaxGain;
-
-			if (realGamma.g < iMaxGain)
-				realGamma.g = iMaxGain;
-	
-			if (realGamma.b < iMaxGain)
-				realGamma.b = iMaxGain;
-			
-			returnMe.rgb = pow(returnMe.rgb, vec3(1.0/realGamma));
-		}
-	}
-	
-	gl_FragColor = returnMe;
-}
diff --git a/nannou_isf/test_files/Auto Levels.fs b/nannou_isf/test_files/Auto Levels.fs
deleted file mode 100644
index 02ea12824..000000000
--- a/nannou_isf/test_files/Auto Levels.fs	
+++ /dev/null
@@ -1,322 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Color Effect"
-    ],
-    "CREDIT": "by Carter Rosenberg",
-    "DESCRIPTION": "Auto Levels",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "min_threshold",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "mid_point",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "max_threshold",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "adapt_rate",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "HEIGHT": "$HEIGHT / 2.0",
-            "TARGET": "bufferPassA",
-            "WIDTH": "$WIDTH / 2.0"
-        },
-        {
-            "HEIGHT": "max($HEIGHT / 27.0, 1.0)",
-            "TARGET": "bufferPassB",
-            "WIDTH": "max($WIDTH / 27.0, 1.0)"
-        },
-        {
-            "HEIGHT": "max($HEIGHT / 3.0, 1.0)",
-            "TARGET": "bufferPassC",
-            "WIDTH": "max($WIDTH / 3.0, 1.0)"
-        },
-        {
-            "HEIGHT": "max($HEIGHT / 243.0, 1.0)",
-            "TARGET": "bufferPassD",
-            "WIDTH": "max($WIDTH / 243.0, 1.0)"
-        },
-        {
-            "HEIGHT": "max($HEIGHT/486.0,1.0)",
-            "PERSISTENT": true,
-            "TARGET": "bufferVariableNameA",
-            "WIDTH": "max($WIDTH/486.0,1.0)"
-        },
-        {
-        }
-    ]
-}
-*/
-
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-in vec2 left_coord;
-in vec2 right_coord;
-in vec2 above_coord;
-in vec2 below_coord;
-
-in vec2 lefta_coord;
-in vec2 righta_coord;
-in vec2 leftb_coord;
-in vec2 rightb_coord;
-#endif
-
-float gray(vec4 n)
-{
-	return (n.r + n.g + n.b)/3.0;
-}
-
-//	packed as min, mid, max
-vec3 minmaxmean(vec4 n, vec3 old)
-{
-	float val = gray(n);
-	vec3 returnMe = old;
-	if (val < returnMe.x)	{
-		returnMe.x = val;
-	}
-	if (val > returnMe.z)	{
-		returnMe.z = val;
-	}
-	returnMe.y = returnMe.y + val / 9.0;
-	return returnMe;
-}
-
-vec3 minmaxcompare(vec4 n, vec3 old)	{
-	vec3 returnMe = old;
-	if (n.r < returnMe.x)	{
-		returnMe.x = n.r;
-	}
-	if (n.g > returnMe.z)	{
-		returnMe.z = n.g;
-	}
-	returnMe.y = returnMe.y + n.b / 9.0;
-	return returnMe;
-}
-
-
-void main()
-{
-	vec3 vals = vec3(1.0,0.0,0.0);
-	
-	//	on this first pass we find the local mins, mid, and max for each pixel
-	if (PASSINDEX == 0)	{
-		vec4 min_color = IMG_THIS_PIXEL(inputImage);
-		vec4 min_colorL = IMG_NORM_PIXEL(inputImage, left_coord);
-		vec4 min_colorR = IMG_NORM_PIXEL(inputImage, right_coord);
-		vec4 min_colorA = IMG_NORM_PIXEL(inputImage, above_coord);
-		vec4 min_colorB = IMG_NORM_PIXEL(inputImage, below_coord);
-	
-		vec4 min_colorLA = IMG_NORM_PIXEL(inputImage, lefta_coord);
-		vec4 min_colorRA = IMG_NORM_PIXEL(inputImage, righta_coord);
-		vec4 min_colorLB = IMG_NORM_PIXEL(inputImage, leftb_coord);
-		vec4 min_colorRB = IMG_NORM_PIXEL(inputImage, rightb_coord);
-	
-		vals = minmaxmean(min_color,vals);
-
-		vals = minmaxmean(min_colorL,vals);
-		vals = minmaxmean(min_colorR,vals);
-		vals = minmaxmean(min_colorA,vals);
-		vals = minmaxmean(min_colorB,vals);
-
-		vals = minmaxmean(min_colorLA,vals);
-		vals = minmaxmean(min_colorRA,vals);
-		vals = minmaxmean(min_colorLB,vals);
-		vals = minmaxmean(min_colorRB,vals);
-		gl_FragColor = vec4(vals.x,vals.y,vals.z,min_color.a);
-	}
-	//	second pass: read from "bufferPassA", write to "bufferPassB"
-	else if (PASSINDEX == 1)	{
-		vec4 min_color = IMG_THIS_PIXEL(bufferPassA);
-		vec4 min_colorL = IMG_NORM_PIXEL(bufferPassA, left_coord);
-		vec4 min_colorR = IMG_NORM_PIXEL(bufferPassA, right_coord);
-		vec4 min_colorA = IMG_NORM_PIXEL(bufferPassA, above_coord);
-		vec4 min_colorB = IMG_NORM_PIXEL(bufferPassA, below_coord);
-	
-		vec4 min_colorLA = IMG_NORM_PIXEL(bufferPassA, lefta_coord);
-		vec4 min_colorRA = IMG_NORM_PIXEL(bufferPassA, righta_coord);
-		vec4 min_colorLB = IMG_NORM_PIXEL(bufferPassA, leftb_coord);
-		vec4 min_colorRB = IMG_NORM_PIXEL(bufferPassA, rightb_coord);
-	
-		vals = minmaxcompare(min_color,vals);
-
-		vals = minmaxcompare(min_colorL,vals);
-		vals = minmaxcompare(min_colorR,vals);
-		vals = minmaxcompare(min_colorA,vals);
-		vals = minmaxcompare(min_colorB,vals);
-
-		vals = minmaxcompare(min_colorLA,vals);
-		vals = minmaxcompare(min_colorRA,vals);
-		vals = minmaxcompare(min_colorLB,vals);
-		vals = minmaxcompare(min_colorRB,vals);
-		gl_FragColor = vec4(vals.x,vals.y,vals.z,min_color.a);
-	}
-	//	read from "bufferPassB", write to "bufferPassC"
-	else if (PASSINDEX == 2)	{
-		vec4 min_color = IMG_THIS_PIXEL(bufferPassB);
-		vec4 min_colorL = IMG_NORM_PIXEL(bufferPassB, left_coord);
-		vec4 min_colorR = IMG_NORM_PIXEL(bufferPassB, right_coord);
-		vec4 min_colorA = IMG_NORM_PIXEL(bufferPassB, above_coord);
-		vec4 min_colorB = IMG_NORM_PIXEL(bufferPassB, below_coord);
-	
-		vec4 min_colorLA = IMG_NORM_PIXEL(bufferPassB, lefta_coord);
-		vec4 min_colorRA = IMG_NORM_PIXEL(bufferPassB, righta_coord);
-		vec4 min_colorLB = IMG_NORM_PIXEL(bufferPassB, leftb_coord);
-		vec4 min_colorRB = IMG_NORM_PIXEL(bufferPassB, rightb_coord);
-
-		vals = minmaxcompare(min_color,vals);
-
-		vals = minmaxcompare(min_colorL,vals);
-		vals = minmaxcompare(min_colorR,vals);
-		vals = minmaxcompare(min_colorA,vals);
-		vals = minmaxcompare(min_colorB,vals);
-
-		vals = minmaxcompare(min_colorLA,vals);
-		vals = minmaxcompare(min_colorRA,vals);
-		vals = minmaxcompare(min_colorLB,vals);
-		vals = minmaxcompare(min_colorRB,vals);
-		gl_FragColor = vec4(vals.x,vals.y,vals.z,min_color.a);
-	}
-	//	read from "bufferPassC", write to "bufferPassD"
-	else if (PASSINDEX == 3)	{
-		vec4 min_color = IMG_THIS_PIXEL(bufferPassC);
-		vec4 min_colorL = IMG_NORM_PIXEL(bufferPassC, left_coord);
-		vec4 min_colorR = IMG_NORM_PIXEL(bufferPassC, right_coord);
-		vec4 min_colorA = IMG_NORM_PIXEL(bufferPassC, above_coord);
-		vec4 min_colorB = IMG_NORM_PIXEL(bufferPassC, below_coord);
-	
-		vec4 min_colorLA = IMG_NORM_PIXEL(bufferPassC, lefta_coord);
-		vec4 min_colorRA = IMG_NORM_PIXEL(bufferPassC, righta_coord);
-		vec4 min_colorLB = IMG_NORM_PIXEL(bufferPassC, leftb_coord);
-		vec4 min_colorRB = IMG_NORM_PIXEL(bufferPassC, rightb_coord);
-	
-		vals = minmaxcompare(min_color,vals);
-
-		vals = minmaxcompare(min_colorL,vals);
-		vals = minmaxcompare(min_colorR,vals);
-		vals = minmaxcompare(min_colorA,vals);
-		vals = minmaxcompare(min_colorB,vals);
-
-		vals = minmaxcompare(min_colorLA,vals);
-		vals = minmaxcompare(min_colorRA,vals);
-		vals = minmaxcompare(min_colorLB,vals);
-		vals = minmaxcompare(min_colorRB,vals);
-		gl_FragColor = vec4(vals.x,vals.y,vals.z,min_color.a);
-	}
-	//	read from "bufferPassD", write to "bufferVariableNameA"
-	else if (PASSINDEX == 4)	{
-		vec4 min_color = IMG_THIS_PIXEL(bufferPassD);
-		vec4 stalePixel = IMG_THIS_PIXEL(bufferVariableNameA);
-		vec4 min_colorL = IMG_NORM_PIXEL(bufferPassD, left_coord);
-		vec4 min_colorR = IMG_NORM_PIXEL(bufferPassD, right_coord);
-		vec4 min_colorA = IMG_NORM_PIXEL(bufferPassD, above_coord);
-		vec4 min_colorB = IMG_NORM_PIXEL(bufferPassD, below_coord);
-	
-		vec4 min_colorLA = IMG_NORM_PIXEL(bufferPassD, lefta_coord);
-		vec4 min_colorRA = IMG_NORM_PIXEL(bufferPassD, righta_coord);
-		vec4 min_colorLB = IMG_NORM_PIXEL(bufferPassD, leftb_coord);
-		vec4 min_colorRB = IMG_NORM_PIXEL(bufferPassD, rightb_coord);
-	
-		vals = minmaxcompare(min_color,vals);
-
-		vals = minmaxcompare(min_colorL,vals);
-		vals = minmaxcompare(min_colorR,vals);
-		vals = minmaxcompare(min_colorA,vals);
-		vals = minmaxcompare(min_colorB,vals);
-
-		vals = minmaxcompare(min_colorLA,vals);
-		vals = minmaxcompare(min_colorRA,vals);
-		vals = minmaxcompare(min_colorLB,vals);
-		vals = minmaxcompare(min_colorRB,vals);
-		gl_FragColor = mix(vec4(vals.x,vals.y,vals.z,min_color.a),stalePixel,adapt_rate);;
-	}
-	//	read from "bufferVariableNameA", write to output
-	else if (PASSINDEX == 5)	{
-		vec4 min_color = IMG_THIS_PIXEL(bufferVariableNameA);
-		vec4 min_colorL = IMG_NORM_PIXEL(bufferVariableNameA, left_coord);
-		vec4 min_colorR = IMG_NORM_PIXEL(bufferVariableNameA, right_coord);
-		vec4 min_colorA = IMG_NORM_PIXEL(bufferVariableNameA, above_coord);
-		vec4 min_colorB = IMG_NORM_PIXEL(bufferVariableNameA, below_coord);
-	
-		vec4 min_colorLA = IMG_NORM_PIXEL(bufferVariableNameA, lefta_coord);
-		vec4 min_colorRA = IMG_NORM_PIXEL(bufferVariableNameA, righta_coord);
-		vec4 min_colorLB = IMG_NORM_PIXEL(bufferVariableNameA, leftb_coord);
-		vec4 min_colorRB = IMG_NORM_PIXEL(bufferVariableNameA, rightb_coord);
-	
-		vals = minmaxcompare(min_color,vals);
-
-		vals = minmaxcompare(min_colorL,vals);
-		vals = minmaxcompare(min_colorR,vals);
-		vals = minmaxcompare(min_colorA,vals);
-		vals = minmaxcompare(min_colorB,vals);
-
-		vals = minmaxcompare(min_colorLA,vals);
-		vals = minmaxcompare(min_colorRA,vals);
-		vals = minmaxcompare(min_colorLB,vals);
-		vals = minmaxcompare(min_colorRB,vals);
-		
-		vec4 final_pixel = IMG_THIS_PIXEL(inputImage);
-		
-		
-		float val = gray (final_pixel);
-		if (vals.x < min_threshold)	{
-			vals.x = min_threshold;
-		}
-		if (val < min_threshold)	{
-			val = min_threshold;
-		}
-		if (vals.z > max_threshold)	{
-			vals.z = max_threshold;
-		}
-		if (val > max_threshold)	{
-			val = max_threshold;
-		}
-		//final_pixel.rgb = (final_pixel.rgb - vals.x) / (vals.z - vals.x);
-		//	shift by the absdiff of the midpoint
-		//final_pixel.rgb = final_pixel.rgb + (mid_point - vals.y);
-		final_pixel.rgb = final_pixel.rgb - (0.5 - mid_point);
-		//	by contrast adjustments
-		float diff = vals.z-vals.x;
-		if (diff < 0.01)	{
-			diff = 0.01;
-		}
-		final_pixel.rgb = (final_pixel.rgb - vals.x) / diff;
-		//float contrast = 1.0/diff;		
-		//final_pixel.rgb = ((vec3(2.0) * (final_pixel.rgb - vec3(vals.x))) * vec3(contrast) / vec3(2.0)) + vec3(0.5);
-		
-		gl_FragColor = final_pixel;
-		//gl_FragColor = vec4(vec3(vals.z),1.0);
-	}
-}
diff --git a/nannou_isf/test_files/Auto Levels.vs b/nannou_isf/test_files/Auto Levels.vs
deleted file mode 100644
index 57a15704f..000000000
--- a/nannou_isf/test_files/Auto Levels.vs	
+++ /dev/null
@@ -1,39 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-out vec2 left_coord;
-out vec2 right_coord;
-out vec2 above_coord;
-out vec2 below_coord;
-
-out vec2 lefta_coord;
-out vec2 righta_coord;
-out vec2 leftb_coord;
-out vec2 rightb_coord;
-#endif
-
-void main()
-{
-	isf_vertShaderInit();
-	vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	vec2 d = 1.0/RENDERSIZE;
-	
-	left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
-	right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
-	above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
-	below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
-	
-	d = 1.0/RENDERSIZE;
-	lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
-	righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
-	leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
-	rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Bad TV.fs b/nannou_isf/test_files/Bad TV.fs
deleted file mode 100644
index 48ce081ed..000000000
--- a/nannou_isf/test_files/Bad TV.fs	
+++ /dev/null
@@ -1,185 +0,0 @@
-
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Glitch", "Retro"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "noiseLevel",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.5
-		},
-		{
-			"NAME": "distortion1",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 5.0,
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "distortion2",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 5.0,
-			"DEFAULT": 5.0
-		},
-		{
-			"NAME": "speed",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.3
-		},
-		{
-			"NAME": "scroll",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.0
-		},
-		{
-			"NAME": "scanLineThickness",
-			"TYPE": "float",
-			"MIN": 1.0,
-			"MAX": 50.0,
-			"DEFAULT": 25.0
-		},
-		{
-			"NAME": "scanLineIntensity",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.5
-		},
-		{
-			"NAME": "scanLineOffset",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.0
-		}		
-	]
-}*/
-
-//	Adapted from http://www.airtightinteractive.com/demos/js/badtvshader/js/BadTVShader.js
-//	Also uses adopted Ashima WebGl Noise: https://github.com/ashima/webgl-noise
-
-/*
- * The MIT License
- * 
- * Copyright (c) 2014 Felix Turner
- * 
- * 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.
- * 
-*/
-
-		
-// Start Ashima 2D Simplex Noise
-
-const vec4 C = vec4(0.211324865405187,0.366025403784439,-0.577350269189626,0.024390243902439);
-
-vec3 mod289(vec3 x) {
-	return x - floor(x * (1.0 / 289.0)) * 289.0;
-}
-
-vec2 mod289(vec2 x) {
-	return x - floor(x * (1.0 / 289.0)) * 289.0;
-}
-
-vec3 permute(vec3 x) {
-	return mod289(((x*34.0)+1.0)*x);
-}
-
-float snoise(vec2 v)	{
-	vec2 i  = floor(v + dot(v, C.yy) );
-	vec2 x0 = v -   i + dot(i, C.xx);
-
-	vec2 i1;
-	i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
-	vec4 x12 = x0.xyxy + C.xxzz;
-	x12.xy -= i1;
-
-	i = mod289(i); // Avoid truncation effects in permutation
-	vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 ))+ i.x + vec3(0.0, i1.x, 1.0 ));
-
-	vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);
-	m = m*m ;
-	m = m*m ;
-
-	vec3 x = 2.0 * fract(p * C.www) - 1.0;
-	vec3 h = abs(x) - 0.5;
-	vec3 ox = floor(x + 0.5);
-	vec3 a0 = x - ox;
-
-	m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h );
-
-	vec3 g;
-	g.x  = a0.x  * x0.x  + h.x  * x0.y;
-	g.yz = a0.yz * x12.xz + h.yz * x12.yw;
-	return 130.0 * dot(m, g);
-}
-
-// End Ashima 2D Simplex Noise
-
-const float tau = 6.28318530718;
-
-//	use this pattern for scan lines
-
-vec2 pattern(vec2 pt) {
-	float s = 0.0;
-	float c = 1.0;
-	vec2 tex = pt * RENDERSIZE;
-	vec2 point = vec2( c * tex.x - s * tex.y, s * tex.x + c * tex.y ) * (1.0/scanLineThickness);
-	float d = point.y;
-
-	return vec2(sin(d + scanLineOffset * tau + cos(pt.x * tau)), cos(d + scanLineOffset * tau + sin(pt.y * tau)));
-}
-
-float rand(vec2 co){
-    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-void main() {
-	vec2 p = isf_FragNormCoord;
-	float ty = TIME*speed;
-	float yt = p.y - ty;
-
-	//smooth distortion
-	float offset = snoise(vec2(yt*3.0,0.0))*0.2;
-	// boost distortion
-	offset = pow( offset*distortion1,3.0)/max(distortion1,0.001);
-	//add fine grain distortion
-	offset += snoise(vec2(yt*50.0,0.0))*distortion2*0.001;
-	//combine distortion on X with roll on Y
-	vec2 adjusted = vec2(fract(p.x + offset),fract(p.y-scroll) );
-	vec4 result = IMG_NORM_PIXEL(inputImage, adjusted);
-	vec2 pat = pattern(adjusted);
-	vec3 shift = scanLineIntensity * vec3(0.3 * pat.x, 0.59 * pat.y, 0.11) / 2.0;
-	result.rgb = (1.0 + scanLineIntensity / 2.0) * result.rgb + shift + (rand(adjusted * TIME) - 0.5) * noiseLevel;
-	gl_FragColor = result;
-
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Basic Shape.fs b/nannou_isf/test_files/Basic Shape.fs
deleted file mode 100644
index d8b196402..000000000
--- a/nannou_isf/test_files/Basic Shape.fs	
+++ /dev/null
@@ -1,286 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Geometry"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "DEFAULT": [
-                1,
-                1,
-                1,
-                1
-            ],
-            "NAME": "color",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Mask Shape Mode",
-            "LABELS": [
-                "Rectangle",
-                "Triangle",
-                "Circle",
-                "Diamond"
-            ],
-            "NAME": "maskShapeMode",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1,
-                2,
-                3
-            ]
-        },
-        {
-            "DEFAULT": 0.5,
-            "LABEL": "Shape Width",
-            "MAX": 2,
-            "MIN": 0,
-            "NAME": "shapeWidth",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "LABEL": "Shape Height",
-            "MAX": 2,
-            "MIN": 0,
-            "NAME": "shapeHeight",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0.5,
-                0.5
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "center",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": false,
-            "LABEL": "Invert Mask",
-            "NAME": "invertMask",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Horizontal Repeat",
-            "LABELS": [
-                "1",
-                "2",
-                "3",
-                "4",
-                "5",
-                "6",
-                "7",
-                "8",
-                "9"
-            ],
-            "NAME": "horizontalRepeat",
-            "TYPE": "long",
-            "VALUES": [
-                1,
-                2,
-                3,
-                4,
-                5,
-                6,
-                7,
-                8,
-                9
-            ]
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Vertical Repeat",
-            "LABELS": [
-                "1",
-                "2",
-                "3",
-                "4",
-                "5",
-                "6",
-                "7",
-                "8",
-                "9"
-            ],
-            "NAME": "verticalRepeat",
-            "TYPE": "long",
-            "VALUES": [
-                1,
-                2,
-                3,
-                4,
-                5,
-                6,
-                7,
-                8,
-                9
-            ]
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-const float pi = 3.14159265359;
-
-
-vec2 rotatePoint(vec2 pt, float angle, vec2 inCenter)
-{
-	vec2 returnMe;
-	float s = sin(angle * pi);
-	float c = cos(angle * pi);
-
-	returnMe = pt;
-
-	// translate point back to origin:
-	returnMe.x -= inCenter.x;
-	returnMe.y -= inCenter.y;
-
-	// rotate point
-	float xnew = returnMe.x * c - returnMe.y * s;
-	float ynew = returnMe.x * s + returnMe.y * c;
-
-	// translate point back:
-	returnMe.x = xnew + inCenter.x;
-	returnMe.y = ynew + inCenter.y;
-	return returnMe;
-}
-
-float sign(vec2 p1, vec2 p2, vec2 p3)
-{
-	return (p1.x - p3.x) * (p2.y - p3.y) - (p2.x - p3.x) * (p1.y - p3.y);
-}
-
-bool PointInTriangle(vec2 pt, vec2 v1, vec2 v2, vec2 v3)
-{
-	bool b1, b2, b3;
-
-	b1 = sign(pt, v1, v2) < 0.0;
-	b2 = sign(pt, v2, v3) < 0.0;
-	b3 = sign(pt, v3, v1) < 0.0;
-
-	return ((b1 == b2) && (b2 == b3));
-}
-
-bool RotatedPointInTriangle(vec2 pt, vec2 v1, vec2 v2, vec2 v3, vec2 inCenter)
-{
-	bool b1, b2, b3;
-	
-	vec2 v1r = v1;
-	vec2 v2r = v2;
-	vec2 v3r = v3;
-
-	b1 = sign(pt, v1r, v2r) < 0.0;
-	b2 = sign(pt, v2r, v3r) < 0.0;
-	b3 = sign(pt, v3r, v1r) < 0.0;
-
-	return ((b1 == b2) && (b2 == b3));
-}
-
-
-float isPointInShape(vec2 pt, int shape, vec4 shapeCoordinates)	{
-	float returnMe = 0.0;
-	
-	//	rectangle
-	if (shape == 0)	{
-		if (RotatedPointInTriangle(pt, shapeCoordinates.xy, shapeCoordinates.xy + vec2(0.0, shapeCoordinates.w), shapeCoordinates.xy + vec2(shapeCoordinates.z, 0.0), shapeCoordinates.xy + shapeCoordinates.zw / 2.0))	{
-			returnMe = 1.0;
-			// soft edge if needed
-			if ((pt.x > shapeCoordinates.x) && (pt.x < shapeCoordinates.x)) {
-				returnMe = clamp(((pt.x - shapeCoordinates.x) / RENDERSIZE.x), 0.0, 1.0);
-				returnMe = pow(returnMe, 0.5);
-			}
-			else if ((pt.x > shapeCoordinates.x + shapeCoordinates.z) && (pt.x < shapeCoordinates.x + shapeCoordinates.z)) {
-				returnMe = clamp(((shapeCoordinates.x + shapeCoordinates.z - pt.x) / RENDERSIZE.x), 0.0, 1.0);
-				returnMe = pow(returnMe, 0.5);
-			}
-		}
-		else if (RotatedPointInTriangle(pt, shapeCoordinates.xy + shapeCoordinates.zw, shapeCoordinates.xy + vec2(0.0, shapeCoordinates.w), shapeCoordinates.xy + vec2(shapeCoordinates.z, 0.0), shapeCoordinates.xy + shapeCoordinates.zw / 2.0))	{
-			returnMe = 1.0;
-			// soft edge if needed
-			if ((pt.x > shapeCoordinates.x) && (pt.x < shapeCoordinates.x)) {
-				returnMe = clamp(((pt.x - shapeCoordinates.x) / RENDERSIZE.x), 0.0, 1.0);
-				returnMe = pow(returnMe, 0.5);
-			}
-			else if ((pt.x > shapeCoordinates.x + shapeCoordinates.z) && (pt.x < shapeCoordinates.x + shapeCoordinates.z)) {
-				returnMe = clamp(((shapeCoordinates.x + shapeCoordinates.z - pt.x) / RENDERSIZE.x), 0.0, 1.0);
-				returnMe = pow(returnMe, 0.5);
-			}
-		}
-	}
-	//	triangle
-	else if (shape == 1)	{
-		if (RotatedPointInTriangle(pt, shapeCoordinates.xy, shapeCoordinates.xy + vec2(shapeCoordinates.z / 2.0, shapeCoordinates.w), shapeCoordinates.xy + vec2(shapeCoordinates.z, 0.0), shapeCoordinates.xy + shapeCoordinates.zw / 2.0))	{
-			returnMe = 1.0;
-		}
-	}
-	//	oval
-	else if (shape == 2)	{
-		returnMe = distance(pt, vec2(shapeCoordinates.xy + shapeCoordinates.zw / 2.0));
-		if (returnMe < min(shapeCoordinates.z,shapeCoordinates.w) / 2.0)	{
-			returnMe = 1.0;
-		}
-		else	{
-			returnMe = 0.0;
-		}
-	}
-	//	diamond
-	else if (shape == 3)	{
-		if (RotatedPointInTriangle(pt, shapeCoordinates.xy + vec2(0.0, shapeCoordinates.w / 2.0), shapeCoordinates.xy + vec2(shapeCoordinates.z / 2.0, shapeCoordinates.w), shapeCoordinates.xy + vec2(shapeCoordinates.z, shapeCoordinates.w / 2.0), shapeCoordinates.xy + shapeCoordinates.zw / 2.0))	{
-			returnMe = 1.0;
-		}
-		else if (RotatedPointInTriangle(pt, shapeCoordinates.xy + vec2(0.0, shapeCoordinates.w / 2.0), shapeCoordinates.xy + vec2(shapeCoordinates.z / 2.0, 0.0), shapeCoordinates.xy + vec2(shapeCoordinates.z, shapeCoordinates.w / 2.0), shapeCoordinates.xy + shapeCoordinates.zw / 2.0))	{
-			returnMe = 1.0;
-		}
-	}
-
-	return returnMe;	
-}
-
-
-
-void main() {
-	vec4		srcPixel = color;
-	vec2		centerPt = center * RENDERSIZE;
-	vec2		tmpVec = RENDERSIZE * vec2(shapeWidth,shapeHeight) / 2.0;
-	vec4		patternRect = vec4(vec2(centerPt - tmpVec),tmpVec * 2.0);
-	vec2		thisPoint = RENDERSIZE * isf_FragNormCoord;
-	
-	if ((thisPoint.x >= patternRect.x) && (thisPoint.x <= patternRect.x + abs(patternRect.z)))	{
-		patternRect.z = patternRect.z / float(horizontalRepeat);
-		patternRect.x = patternRect.x + abs(patternRect.z) * floor((thisPoint.x - patternRect.x) / abs(patternRect.z));
-	}
-	else	{
-		patternRect.z = patternRect.z / float(horizontalRepeat);	
-	}
-	
-	if ((thisPoint.y >= patternRect.y) && (thisPoint.y <= patternRect.y + abs(patternRect.w)))	{
-		patternRect.w = patternRect.w / float(verticalRepeat);
-		patternRect.y = patternRect.y + abs(patternRect.w) * floor((thisPoint.y - patternRect.y) / abs(patternRect.w));
-	}
-	else	{
-		patternRect.w = patternRect.w / float(verticalRepeat);	
-	}
-	
-	float		luminance = isPointInShape(thisPoint.xy, maskShapeMode, patternRect);
-	
-	if (invertMask)
-		luminance = 1.0 - luminance;
-	
-	srcPixel = color * luminance;
-	
-	gl_FragColor = srcPixel;
-}
-
diff --git a/nannou_isf/test_files/Bloom.fs b/nannou_isf/test_files/Bloom.fs
deleted file mode 100644
index 7b6a87104..000000000
--- a/nannou_isf/test_files/Bloom.fs
+++ /dev/null
@@ -1,134 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Blur",
-        "Film"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 12,
-            "MAX": 12,
-            "MIN": 0,
-            "NAME": "blurAmount",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "intensity",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "DESCRIPTION": "Pass 0",
-            "HEIGHT": "floor($HEIGHT/2.0)",
-            "TARGET": "halfSizeBaseRender",
-            "WIDTH": "floor($WIDTH/2.0)"
-        },
-        {
-            "DESCRIPTION": "Pass 1",
-            "HEIGHT": "floor($HEIGHT/4.0)",
-            "TARGET": "quarterSizeBaseRender",
-            "WIDTH": "floor($WIDTH/4.0)"
-        },
-        {
-            "DESCRIPTION": "Pass 2",
-            "HEIGHT": "floor($HEIGHT/8.0)",
-            "TARGET": "eighthSizeBaseRender",
-            "WIDTH": "floor($WIDTH/8.0)"
-        },
-        {
-            "DESCRIPTION": "Pass 3",
-            "HEIGHT": "floor($HEIGHT/4.0)",
-            "TARGET": "quarterGaussA",
-            "WIDTH": "floor($WIDTH/4.0)"
-        },
-        {
-            "DESCRIPTION": "Pass 4",
-            "HEIGHT": "floor($HEIGHT/4.0)",
-            "TARGET": "quarterGaussB",
-            "WIDTH": "floor($WIDTH/4.0)"
-        },
-        {
-            "DESCRIPTION": "Pass 5",
-            "TARGET": "fullGaussA"
-        },
-        {
-            "DESCRIPTION": "Pass 6",
-            "TARGET": "fullGaussB"
-        }
-    ]
-}
-*/
-
-#if __VERSION__ <= 120
-varying vec2		texOffsets[5];
-#else
-in vec2		texOffsets[5];
-#endif
-
-
-void main() {
-	int			blurLevel = int(floor(blurAmount/6.0));
-	float		blurLevelModulus = mod(blurAmount, 6.0);
-	//	first three passes are just copying the input image into the buffer at varying sizes
-	if (PASSINDEX==0)	{
-		gl_FragColor = IMG_NORM_PIXEL(inputImage, isf_FragNormCoord);
-	}
-	else if (PASSINDEX==1)	{
-		gl_FragColor = IMG_NORM_PIXEL(halfSizeBaseRender, isf_FragNormCoord);
-	}
-	else if (PASSINDEX==2)	{
-		gl_FragColor = IMG_NORM_PIXEL(quarterSizeBaseRender, isf_FragNormCoord);
-	}
-	//	start reading from the previous stage- each two passes completes a gaussian blur, then 
-	//	we increase the resolution & blur (the lower-res blurred image from the previous pass) again...
-	else if (PASSINDEX == 3)	{
-		vec4		sample0 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[2]);
-		vec4		sample3 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[3]);
-		vec4		sample4 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[4]);
-		//gl_FragColor = vec4((sample0 + sample1 + sample2).rgb / (3.0), 1.0);
-		//gl_FragColor = vec4((sample0 + sample1 + sample2 + sample3 + sample4).rgb / (5.0), 1.0);
-		gl_FragColor = vec4((sample0 + sample1 + sample2 + sample3 + sample4).rgba / (5.0));
-	}
-	else if (PASSINDEX == 4)	{
-		vec4		sample0 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[2]);
-		vec4		sample3 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[3]);
-		vec4		sample4 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[4]);
-		//gl_FragColor = vec4((sample0 + sample1 + sample2).rgb / (3.0), 1.0);
-		//gl_FragColor = vec4((sample0 + sample1 + sample2 + sample3 + sample4).rgb / (5.0), 1.0);
-		gl_FragColor = vec4((sample0 + sample1 + sample2 + sample3 + sample4).rgba / (5.0));
-	}
-	//	...writes into the full-size
-	else if (PASSINDEX == 5)	{
-		vec4		sample0 = IMG_NORM_PIXEL(quarterGaussB,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(quarterGaussB,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(quarterGaussB,texOffsets[2]);
-		//gl_FragColor =  vec4((sample0 + sample1 + sample2).rgb / (3.0), 1.0);
-		gl_FragColor =  vec4((sample0 + sample1 + sample2).rgba / (3.0));
-	}
-	else if (PASSINDEX == 6)	{
-		//	this is the last pass- calculate the blurred image as i have in previous passes, then mix it in with the full-size input image using the blur amount so i get a smooth transition into the blur at low blur levels
-		vec4		sample0 = IMG_NORM_PIXEL(fullGaussA,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(fullGaussA,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(fullGaussA,texOffsets[2]);
-		//vec4		blurredImg =  vec4((sample0 + sample1 + sample2).rgb / (3.0), 1.0);
-		vec4		blurredImg =  vec4((sample0 + sample1 + sample2).rgba / (4.0));
-		vec4		originalImg = IMG_NORM_PIXEL(inputImage,isf_FragNormCoord);
-		if (blurLevel == 0)
-			blurredImg = mix(originalImg, blurredImg, (blurLevelModulus/6.0));
-		
-		gl_FragColor = max(mix(originalImg,blurredImg*1.2,intensity), originalImg);
-	}
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Bloom.vs b/nannou_isf/test_files/Bloom.vs
deleted file mode 100644
index 3c9a24ee7..000000000
--- a/nannou_isf/test_files/Bloom.vs
+++ /dev/null
@@ -1,70 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2		texOffsets[5];
-#else
-out vec2		texOffsets[5];
-#endif
-
-void main(void)	{
-	//	load the main shader stuff
-	isf_vertShaderInit();
-	
-	
-	int			blurLevel = int(floor(blurAmount/6.0));
-	float		blurLevelModulus = mod(blurAmount, 6.0);
-	float		blurRadius = 0.0;
-	float		blurRadiusInPixels = 0.0;
-	//	first three passes are just drawing the texture- do nothing
-	
-	//	the next four passes do gaussion blurs on the various levels
-	if (PASSINDEX==3 || PASSINDEX==5)	{
-		float		pixelWidth = 1.0/RENDERSIZE.x;
-		//	pass 3 is sampling 1/12, but writing to 1/4
-		if (PASSINDEX==3)	{
-			if (blurLevel==1)
-				blurRadius = blurLevelModulus/1.5;
-			else if (blurLevel>1)
-				blurRadius = 4.0;
-		}
-		//	pass 5 is sampling 1/4 and writing to full-size
-		else if (PASSINDEX==5)	{
-			if (blurLevel==0)
-				blurRadius = blurLevelModulus;
-			else if (blurLevel>0)
-				blurRadius = 6.0;
-		}
-		blurRadiusInPixels = pixelWidth * blurRadius;
-		texOffsets[0] = isf_FragNormCoord;
-		texOffsets[1] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0]-blurRadiusInPixels, isf_FragNormCoord[1]),0.0,1.0);
-		texOffsets[2] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0]+blurRadiusInPixels, isf_FragNormCoord[1]),0.0,1.0);
-		if (PASSINDEX==3)	{
-			texOffsets[3] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0]-(2.0*blurRadiusInPixels), isf_FragNormCoord[1]),0.0,1.0);
-			texOffsets[4] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0]+(2.0*blurRadiusInPixels), isf_FragNormCoord[1]),0.0,1.0);
-		}
-	}
-	else if (PASSINDEX==4 || PASSINDEX==6)	{
-		float		pixelHeight = 1.0/RENDERSIZE.y;
-		//	pass 4 is sampling 1/12, but writing to 1/4
-		if (PASSINDEX==4)	{
-			if (blurLevel==1)
-				blurRadius = blurLevelModulus/1.5;
-			else if (blurLevel>1)
-				blurRadius = 4.0;
-		}
-		//	pass 6 is sampling 1/4 and writing to full-size
-		else if (PASSINDEX==6)	{
-			if (blurLevel==0)
-				blurRadius = blurLevelModulus;
-			else if (blurLevel>0)
-				blurRadius = 6.0;
-		}
-		blurRadiusInPixels = pixelHeight * blurRadius;
-		texOffsets[0] = isf_FragNormCoord;
-		texOffsets[1] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]-blurRadiusInPixels),0.0,1.0);
-		texOffsets[2] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]+blurRadiusInPixels),0.0,1.0);
-		if (PASSINDEX==4)	{
-			texOffsets[3] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]-(2.0*blurRadiusInPixels)),0.0,1.0);
-			texOffsets[4] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]+(2.0*blurRadiusInPixels)),0.0,1.0);
-		}
-	}
-	
-}
diff --git a/nannou_isf/test_files/Bounce.fs b/nannou_isf/test_files/Bounce.fs
deleted file mode 100644
index daafb805d..000000000
--- a/nannou_isf/test_files/Bounce.fs
+++ /dev/null
@@ -1,95 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Wipe"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/Bounce.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 2,
-            "MAX": 10,
-            "MIN": 0,
-            "NAME": "bounces",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.1,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "shadow_height",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0,
-                0,
-                1
-            ],
-            "NAME": "shadow_colour",
-            "TYPE": "color"
-        }
-    ],
-    "ISFVSN": "2",
-    "VSN": ""
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: Adrian Purser
-// License: MIT
-
-
-const float PI = 3.14159265358;
-
-vec4 transition (vec2 uv) {
-  float time = progress;
-  float stime = sin(time * PI / 2.);
-  float phase = time * PI * bounces;
-  float y = (abs(cos(phase))) * (1.0 - stime);
-  float d = uv.y - y;
-  return mix(
-    mix(
-      getToColor(uv),
-      shadow_colour,
-      step(d, shadow_height) * (1. - mix(
-        ((d / shadow_height) * shadow_colour.a) + (1.0 - shadow_colour.a),
-        1.0,
-        smoothstep(0.95, 1., progress) // fade-out the shadow at the end
-      ))
-    ),
-    getFromColor(vec2(uv.x, uv.y + (1.0 - y))),
-    step(d, 0.0)
-  );
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Bow Tie Horizontal.fs b/nannou_isf/test_files/Bow Tie Horizontal.fs
deleted file mode 100644
index d558837af..000000000
--- a/nannou_isf/test_files/Bow Tie Horizontal.fs	
+++ /dev/null
@@ -1,165 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Wipe"
-  ],
-  "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/BowTieHorizontal.glsl",
-  "DESCRIPTION" : "Automatically converted from https://gl-transitions.com/",
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "NAME" : "startImage",
-      "TYPE" : "image"
-    },
-    {
-      "NAME" : "endImage",
-      "TYPE" : "image"
-    },
-    {
-      "MIN" : 0,
-      "TYPE" : "float",
-      "NAME" : "progress",
-      "MAX" : 1,
-      "DEFAULT" : 0
-    }
-  ]
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: huynx
-// License: MIT
-
-vec2 bottom_left = vec2(0.0, 1.0);
-vec2 bottom_right = vec2(1.0, 1.0);
-vec2 top_left = vec2(0.0, 0.0);
-vec2 top_right = vec2(1.0, 0.0);
-vec2 center = vec2(0.5, 0.5);
-
-float check(vec2 p1, vec2 p2, vec2 p3)
-{
-  return (p1.x - p3.x) * (p2.y - p3.y) - (p2.x - p3.x) * (p1.y - p3.y);
-}
-
-bool PointInTriangle (vec2 pt, vec2 p1, vec2 p2, vec2 p3)
-{
-    bool b1, b2, b3;
-    b1 = check(pt, p1, p2) < 0.0;
-    b2 = check(pt, p2, p3) < 0.0;
-    b3 = check(pt, p3, p1) < 0.0;
-    return ((b1 == b2) && (b2 == b3));
-}
-
-bool in_left_triangle(vec2 p){
-  vec2 vertex1, vertex2, vertex3;
-  vertex1 = vec2(progress, 0.5);
-  vertex2 = vec2(0.0, 0.5-progress);
-  vertex3 = vec2(0.0, 0.5+progress);
-  if (PointInTriangle(p, vertex1, vertex2, vertex3))
-  {
-    return true;
-  }
-  return false;
-}
-
-bool in_right_triangle(vec2 p){
-  vec2 vertex1, vertex2, vertex3;
-  vertex1 = vec2(1.0-progress, 0.5);
-  vertex2 = vec2(1.0, 0.5-progress);
-  vertex3 = vec2(1.0, 0.5+progress);
-  if (PointInTriangle(p, vertex1, vertex2, vertex3))
-  {
-    return true;
-  }
-  return false;
-}
-
-float blur_edge(vec2 bot1, vec2 bot2, vec2 top, vec2 testPt)
-{
-  vec2 lineDir = bot1 - top;
-  vec2 perpDir = vec2(lineDir.y, -lineDir.x);
-  vec2 dirToPt1 = bot1 - testPt;
-  float dist1 = abs(dot(normalize(perpDir), dirToPt1));
-  
-  lineDir = bot2 - top;
-  perpDir = vec2(lineDir.y, -lineDir.x);
-  dirToPt1 = bot2 - testPt;
-  float min_dist = min(abs(dot(normalize(perpDir), dirToPt1)), dist1);
-  
-  if (min_dist < 0.005) {
-    return min_dist / 0.005;
-  }
-  else  {
-    return 1.0;
-  };
-}
-
-
-vec4 transition (vec2 uv) {
-  if (in_left_triangle(uv))
-  {
-    if (progress < 0.1)
-    {
-      return getFromColor(uv);
-    }
-    if (uv.x < 0.5)
-    {
-      vec2 vertex1 = vec2(progress, 0.5);
-      vec2 vertex2 = vec2(0.0, 0.5-progress);
-      vec2 vertex3 = vec2(0.0, 0.5+progress);
-      return mix(
-        getFromColor(uv),
-        getToColor(uv),
-        blur_edge(vertex2, vertex3, vertex1, uv)
-      );
-    }
-    else
-    {
-      if (progress > 0.0)
-      {
-        return getToColor(uv);
-      }
-      else
-      {
-        return getFromColor(uv);
-      }
-    }    
-  }
-  else if (in_right_triangle(uv))
-  {
-    if (uv.x >= 0.5)
-    {
-      vec2 vertex1 = vec2(1.0-progress, 0.5);
-      vec2 vertex2 = vec2(1.0, 0.5-progress);
-      vec2 vertex3 = vec2(1.0, 0.5+progress);
-      return mix(
-        getFromColor(uv),
-        getToColor(uv),
-        blur_edge(vertex2, vertex3, vertex1, uv)
-      );  
-    }
-    else
-    {
-      return getFromColor(uv);
-    }
-  }
-  else {
-    return getFromColor(uv);
-  }
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Bow Tie Vertical.fs b/nannou_isf/test_files/Bow Tie Vertical.fs
deleted file mode 100644
index fa96a4409..000000000
--- a/nannou_isf/test_files/Bow Tie Vertical.fs	
+++ /dev/null
@@ -1,158 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Wipe"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/BowTieVertical.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: huynx
-// License: MIT
-
-float check(vec2 p1, vec2 p2, vec2 p3)
-{
-  return (p1.x - p3.x) * (p2.y - p3.y) - (p2.x - p3.x) * (p1.y - p3.y);
-}
-
-bool PointInTriangle (vec2 pt, vec2 p1, vec2 p2, vec2 p3)
-{
-    bool b1, b2, b3;
-    b1 = check(pt, p1, p2) < 0.0;
-    b2 = check(pt, p2, p3) < 0.0;
-    b3 = check(pt, p3, p1) < 0.0;
-    return ((b1 == b2) && (b2 == b3));
-}
-
-bool in_top_triangle(vec2 p){
-  vec2 vertex1, vertex2, vertex3;
-  vertex1 = vec2(0.5, progress);
-  vertex2 = vec2(0.5-progress, 0.0);
-  vertex3 = vec2(0.5+progress, 0.0);
-  if (PointInTriangle(p, vertex1, vertex2, vertex3))
-  {
-    return true;
-  }
-  return false;
-}
-
-bool in_bottom_triangle(vec2 p){
-  vec2 vertex1, vertex2, vertex3;
-  vertex1 = vec2(0.5, 1.0 - progress);
-  vertex2 = vec2(0.5-progress, 1.0);
-  vertex3 = vec2(0.5+progress, 1.0);
-  if (PointInTriangle(p, vertex1, vertex2, vertex3))
-  {
-    return true;
-  }
-  return false;
-}
-
-float blur_edge(vec2 bot1, vec2 bot2, vec2 top, vec2 testPt)
-{
-  vec2 lineDir = bot1 - top;
-  vec2 perpDir = vec2(lineDir.y, -lineDir.x);
-  vec2 dirToPt1 = bot1 - testPt;
-  float dist1 = abs(dot(normalize(perpDir), dirToPt1));
-  
-  lineDir = bot2 - top;
-  perpDir = vec2(lineDir.y, -lineDir.x);
-  dirToPt1 = bot2 - testPt;
-  float min_dist = min(abs(dot(normalize(perpDir), dirToPt1)), dist1);
-  
-  if (min_dist < 0.005) {
-    return min_dist / 0.005;
-  }
-  else  {
-    return 1.0;
-  };
-}
-
-
-vec4 transition (vec2 uv) {
-  if (in_top_triangle(uv))
-  {
-    if (progress < 0.1)
-    {
-      return getFromColor(uv);
-    }
-    if (uv.y < 0.5)
-    {
-      vec2 vertex1 = vec2(0.5, progress);
-      vec2 vertex2 = vec2(0.5-progress, 0.0);
-      vec2 vertex3 = vec2(0.5+progress, 0.0);
-      return mix(
-        getFromColor(uv),
-        getToColor(uv),
-        blur_edge(vertex2, vertex3, vertex1, uv)
-      );
-    }
-    else
-    {
-      if (progress > 0.0)
-      {
-        return getToColor(uv);
-      }
-      else
-      {
-        return getFromColor(uv);
-      }
-    }    
-  }
-  else if (in_bottom_triangle(uv))
-  {
-    if (uv.y >= 0.5)
-    {
-      vec2 vertex1 = vec2(0.5, 1.0-progress);
-      vec2 vertex2 = vec2(0.5-progress, 1.0);
-      vec2 vertex3 = vec2(0.5+progress, 1.0);
-      return mix(
-        getFromColor(uv),
-        getToColor(uv),
-        blur_edge(vertex2, vertex3, vertex1, uv)
-      );  
-    }
-    else
-    {
-      return getFromColor(uv);
-    }
-  }
-  else {
-    return getFromColor(uv);
-  }
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Boxinator.fs b/nannou_isf/test_files/Boxinator.fs
deleted file mode 100644
index 32f9d0cdc..000000000
--- a/nannou_isf/test_files/Boxinator.fs
+++ /dev/null
@@ -1,146 +0,0 @@
-/*{
-	"CREDIT": "by mojovideotech",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Stylize"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "rate",
-			"TYPE": "float",
-			"DEFAULT": 2.5,
-			"MIN": 0.0,
-			"MAX": 10.0
-		},
-		{
-			"NAME": "edge",
-			"TYPE": "float",
-			"DEFAULT": 0.001,
-			"MIN": 0.0,
-			"MAX": 0.01
-		},
-		{
-			"NAME": "blend",
-			"TYPE": "float",
-			"DEFAULT": 0.95,
-			"MIN": -1.0,
-			"MAX": 1.0
-		},
-		{
-			"NAME": "randomize",
-			"TYPE": "float",
-			"DEFAULT": 0.5,
-			"MIN": 0.0,
-			"MAX": 1.0
-		},
-		{
-			"NAME": "gamma",
-			"TYPE": "float",
-			"DEFAULT": -0.3,
-			"MIN": -0.5,
-			"MAX": 0.2
-		},
-		{
-			"NAME": "grid",
-			"TYPE": "point2D",
-			"DEFAULT": [ 64.0, 36.0 ],
-			"MIN": [ 1.5, 1.5 ],
-			"MAX": [ 900.0, 600.0 ]
-		}
-	]
-}*/
-
-////////////////////////////////////////////////////////////////////
-// Boxinator  by mojovideotech
-//
-// License Creative Commons Attribution-NonCommercial-ShareAlike 3.0
-////////////////////////////////////////////////////////////////////
-
-
-#ifdef GL_ES
-precision mediump float;
-#endif
-
-
-//------------------------------------------------------------------
-// simplex noise function
-// by : Ian McEwan, Ashima Arts
-// © 2011 Ashima Arts,  MIT License
-
-vec4 permute(vec4 x) { return mod(((x*34.0)+1.0)*x, 289.0); }
-
-vec4 taylorInvSqrt(vec4 r) { return 1.79284291400159 - 0.85373472095314 * r; }
-
-float snoise(vec3 v) { 
-  const vec2  C = vec2(1.0/6.0, 1.0/3.0) ;
-  const vec4  D = vec4(0.0, 0.5, 1.0, 2.0);
-  vec3 i  = floor(v + dot(v, C.yyy) );
-  vec3 x0 =   v - i + dot(i, C.xxx) ;
-  vec3 g = step(x0.yzx, x0.xyz);
-  vec3 l = 1.0 - g;
-  vec3 i1 = min( g.xyz, l.zxy );
-  vec3 i2 = max( g.xyz, l.zxy );
-  vec3 x1 = x0 - i1 + 1.0 * C.xxx;
-  vec3 x2 = x0 - i2 + 2.0 * C.xxx;
-  vec3 x3 = x0 - 1. + 3.0 * C.xxx;
-  i = mod(i, 289.0 ); 
-  vec4 p = permute( permute( permute( 
-             i.z + vec4(0.0, i1.z, i2.z, 1.0 ))
-           + i.y + vec4(0.0, i1.y, i2.y, 1.0 )) 
-           + i.x + vec4(0.0, i1.x, i2.x, 1.0 ));
-  float n_ = 1.0/7.0; // N=7
-  vec3  ns = n_ * D.wyz - D.xzx;
-  vec4 j = p - 49.0 * floor(p * ns.z *ns.z);  //  mod(p,N*N)
-  vec4 x_ = floor(j * ns.z);
-  vec4 y_ = floor(j - 7.0 * x_ );    // mod(j,N)
-  vec4 x = x_ *ns.x + ns.yyyy;
-  vec4 y = y_ *ns.x + ns.yyyy;
-  vec4 h = 1.0 - abs(x) - abs(y);
-  vec4 b0 = vec4( x.xy, y.xy );
-  vec4 b1 = vec4( x.zw, y.zw );
-  vec4 s0 = floor(b0)*2.0 + 1.0;
-  vec4 s1 = floor(b1)*2.0 + 1.0;
-  vec4 sh = -step(h, vec4(0.0));
-  vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ;
-  vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ;
-  vec3 p0 = vec3(a0.xy,h.x);
-  vec3 p1 = vec3(a0.zw,h.y);
-  vec3 p2 = vec3(a1.xy,h.z);
-  vec3 p3 = vec3(a1.zw,h.w);
-  vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
-  p0 *= norm.x;
-  p1 *= norm.y;
-  p2 *= norm.z;
-  p3 *= norm.w;
-  vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);
-  m = m * m;
-  return 42.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1), 
-                                dot(p2,x2), dot(p3,x3) ) );
-}
-//------------------------------------------------------------------
-
-float hash(float h) { return fract(sin(h) * 43758.5453123); }
-
-vec2 tile(vec2 cell, vec2 size) { return fract(cell*size); }
-
-float box(vec2 a, vec2 b){ vec2 o = step(b,a); return o.x*o.y; }
-
-void main(void){
-	float T = TIME*rate;
-    vec2 uv = gl_FragCoord.xy/RENDERSIZE.xy;
-    vec2 g = floor(grid.xy);
-    float C = g.x*g.y ;                                                                                                                                          
-    float I = 1.0 + floor(uv.x * g.x) + g.y * floor(uv.y * g.y) + g.x;
-	vec2 st = tile(uv, g);
-    float S = I / C * box(st, vec2(edge*g.xy));
-    S = mix(S,hash(S),randomize);
-    vec3 color = vec3(S*T);
-	float n = snoise(color+IMG_NORM_PIXEL(inputImage, uv.xy).xyz*blend);  
-
-    gl_FragColor = sqrt(max(vec4(vec3(n, n, n ),1.0)+IMG_NORM_PIXEL(inputImage, uv.xy),0.0)+gamma);
-}
-
diff --git a/nannou_isf/test_files/Brick Pattern.fs b/nannou_isf/test_files/Brick Pattern.fs
deleted file mode 100644
index 118264990..000000000
--- a/nannou_isf/test_files/Brick Pattern.fs	
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Pattern", "Color"
-  ],
-  "DESCRIPTION" : "Generates a basic brick pattern",
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "NAME" : "brickSize",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0.2,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "fillSize",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0.9,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "brickOffset",
-      "TYPE" : "point2D",
-      "MAX" : [
-        1,
-        1
-      ],
-      "DEFAULT" : [
-        0,
-        0
-      ],
-      "MIN" : [
-        0,
-        0
-      ]
-    },
-    {
-      "NAME" : "fillColor",
-      "TYPE" : "color",
-      "DEFAULT" : [
-        0,
-        0,
-        0,
-        0
-      ]
-    },
-    {
-      "NAME" : "brickColor",
-      "TYPE" : "color",
-      "DEFAULT" : [
-        1,
-        1,
-        1,
-        1
-      ]
-    }
-  ],
-  "CREDIT" : "patriciogv"
-}
-*/
-
-// Based on Brick example from https://thebookofshaders.com/09/
-// Author @patriciogv ( patriciogonzalezvivo.com ) - 2015
-
-
-
-vec2 brickTile(vec2 _st, float _zoom){
-    _st *= _zoom;
-
-    // Here is where the offset is happening
-    _st.x += step(1., mod(_st.y,2.0)) * 0.5;
-
-    return fract(_st);
-}
-
-float box(vec2 _st, vec2 _size){
-    _size = vec2(0.5)-_size*0.5;
-    vec2 uv = smoothstep(_size,_size+vec2(1e-4),_st);
-    uv *= smoothstep(_size,_size+vec2(1e-4),vec2(1.0)-_st);
-    return uv.x*uv.y;
-}
-
-void main(void){
-    vec2 st = isf_FragNormCoord;
-    vec4 color = fillColor;
-    float brickCount = (brickSize == 0.0) ? max(RENDERSIZE.x,RENDERSIZE.y) : 1.0 / brickSize;
-    //	Apply the offset
-    st += brickOffset;
-    // Apply the brick tiling
-    st = brickTile(st,brickCount);
-
-	float val = box(st,vec2(fillSize));
-    color = mix(fillColor,brickColor,val);
-
-    // Uncomment to see the space coordinates
-    //color.rgb = vec3(st,0.0);
-
-    gl_FragColor = color;
-}
-
diff --git a/nannou_isf/test_files/Bright.fs b/nannou_isf/test_files/Bright.fs
deleted file mode 100644
index c9d3e0317..000000000
--- a/nannou_isf/test_files/Bright.fs
+++ /dev/null
@@ -1,24 +0,0 @@
-/*{
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Color Adjustment"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "bright",
-			"TYPE": "float",
-			"MIN": -1.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.0
-		}
-	]
-}*/
-
-void main() {
-	gl_FragColor = clamp(IMG_THIS_PIXEL(inputImage) + vec4(bright,bright,bright,0.0), 0.0, 1.0);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Broken LCD.fs b/nannou_isf/test_files/Broken LCD.fs
deleted file mode 100644
index ead59312f..000000000
--- a/nannou_isf/test_files/Broken LCD.fs	
+++ /dev/null
@@ -1,660 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Glitch",
-    "Stylize"
-  ],
-  "DESCRIPTION" : "Broken LCD using value noise",
-  "INPUTS" : [
-    {
-      "NAME" : "inputImage",
-      "TYPE" : "image"
-    },
-    {
-      "NAME" : "flickerLevel",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0,
-      "MIN" : 0
-    },
-    {
-      "VALUES" : [
-        0,
-        1,
-        2,
-        3,
-        4,
-        5,
-        6,
-        7,
-        8,
-        9
-      ],
-      "LABELS" : [
-        "Random1",
-        "Random2",
-        "Random3",
-        "Nothing",
-        "Noise",
-        "Lines",
-        "Vertical",
-        "Horizontal",
-        "Stripes",
-        "Checkerboard"
-      ],
-      "IDENTITY" : 0,
-      "DEFAULT" : 0,
-      "LABEL" : "Pattern Style",
-      "TYPE" : "long",
-      "NAME" : "patternStyle"
-    },
-    {
-      "NAME" : "glitchBrightness",
-      "TYPE" : "float",
-      "MAX" : 4,
-      "DEFAULT" : 3,
-      "MIN" : 0,
-      "LABEL" : "Glitch Thickness"
-    },
-    {
-      "NAME" : "glitchBrightnessCurve",
-      "TYPE" : "float",
-      "MAX" : 4,
-      "DEFAULT" : 2,
-      "LABEL" : "Glitch Shape",
-      "MIN" : 1
-    },
-    {
-      "NAME" : "glitchRadius",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0.5,
-      "LABEL" : "Glitch Spread",
-      "MIN" : 0
-    },
-    {
-      "NAME" : "glitchSmoothness",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0.5,
-      "MIN" : 0,
-      "LABEL" : "Glitch Edge Smoothness"
-    },
-    {
-      "NAME" : "glitchScale",
-      "TYPE" : "float",
-      "MAX" : 100,
-      "DEFAULT" : 4.1013007164001465,
-      "MIN" : 0,
-      "LABEL" : "Glitch Size"
-    },
-    {
-      "NAME" : "noiseSeed",
-      "TYPE" : "float",
-      "MAX" : 10,
-      "DEFAULT" : 5.0863485336303711,
-      "MIN" : 0,
-      "LABEL" : "Glitch Seed"
-    },
-    {
-      "NAME" : "patternSeed",
-      "TYPE" : "float",
-      "MAX" : 10,
-      "DEFAULT" : 2.3372085094451904,
-      "LABEL" : "Pattern Seed",
-      "MIN" : 0
-    },
-    {
-      "NAME" : "tintBrightness",
-      "TYPE" : "float",
-      "MAX" : 4,
-      "DEFAULT" : 4,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "tintRadius",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0.22620739042758942,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "tintBrightnessCurve",
-      "TYPE" : "float",
-      "MAX" : 4,
-      "DEFAULT" : 1.2606533765792847,
-      "MIN" : 1
-    },
-    {
-      "NAME" : "tintSeed",
-      "TYPE" : "float",
-      "MAX" : 20,
-      "DEFAULT" : 0,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "tintColor1",
-      "TYPE" : "color",
-      "DEFAULT" : [
-        0.90196079015731812,
-        0.25098040699958801,
-        0.25098040699958801,
-        1
-      ]
-    },
-    {
-      "NAME" : "tintColor2",
-      "TYPE" : "color",
-      "DEFAULT" : [
-        0.25098040699958801,
-        0.50196081399917603,
-        0.90196079015731812,
-        1
-      ]
-    },
-    {
-      "NAME" : "tintScale",
-      "TYPE" : "float",
-      "MAX" : 100,
-      "DEFAULT" : 4,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "rowGlitchLevel",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0.0099999997764825821,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "rowFlickerLevel",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "rowGlitchSeed",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0.34099999070167542,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "hardEdge",
-      "TYPE" : "bool",
-      "DEFAULT" : true,
-      "LABEL" : "Hard Edge"
-    },
-    {
-      "VALUES" : [
-        0,
-        1,
-        2
-      ],
-      "LABELS" : [
-        "Original",
-        "Multiply",
-        "Replace"
-      ],
-      "IDENTITY" : 0,
-      "DEFAULT" : 0,
-      "LABEL" : "Alpha Mode",
-      "TYPE" : "long",
-      "NAME" : "alphaMode"
-    }
-  ],
-  "ISFVSN" : "2",
-  "CREDIT" : "VIDVOX"
-}
-*/
-
-
-const float pi = 3.1415926535897932384626433832795;
-
-
-vec2 rotatePoint(vec2 pt, float angle, vec2 center)
-{
-	vec2 returnMe;
-	float s = sin(angle * pi);
-	float c = cos(angle * pi);
-
-	returnMe = pt;
-
-	// translate point back to origin:
-	returnMe.x -= center.x;
-	returnMe.y -= center.y;
-
-	// rotate point
-	float xnew = returnMe.x * c - returnMe.y * s;
-	float ynew = returnMe.x * s + returnMe.y * c;
-
-	// translate point back:
-	returnMe.x = xnew + center.x;
-	returnMe.y = ynew + center.y;
-	return returnMe;
-}
-
-float sign(vec2 p1, vec2 p2, vec2 p3)
-{
-	return (p1.x - p3.x) * (p2.y - p3.y) - (p2.x - p3.x) * (p1.y - p3.y);
-}
-
-bool PointInTriangle(vec2 pt, vec2 v1, vec2 v2, vec2 v3)
-{
-	bool b1, b2, b3;
-
-	b1 = sign(pt, v1, v2) < 0.0;
-	b2 = sign(pt, v2, v3) < 0.0;
-	b3 = sign(pt, v3, v1) < 0.0;
-
-	return ((b1 == b2) && (b2 == b3));
-}
-
-bool RotatedPointInTriangle(vec2 pt, vec2 v1, vec2 v2, vec2 v3, vec2 center)
-{
-	bool b1, b2, b3;
-	
-	vec2 v1r = v1;
-	vec2 v2r = v2;
-	vec2 v3r = v3;
-
-	b1 = sign(pt, v1r, v2r) < 0.0;
-	b2 = sign(pt, v2r, v3r) < 0.0;
-	b3 = sign(pt, v3r, v1r) < 0.0;
-
-	return ((b1 == b2) && (b2 == b3));
-}
-
-
-float isPointInShape(vec2 pt, int shape, vec4 shapeCoordinates)	{
-	float returnMe = 0.0;
-	
-	//	rectangle
-	if (shape == 0)	{
-		if (RotatedPointInTriangle(pt, shapeCoordinates.xy, shapeCoordinates.xy + vec2(0.0, shapeCoordinates.w), shapeCoordinates.xy + vec2(shapeCoordinates.z, 0.0), shapeCoordinates.xy + shapeCoordinates.zw / 2.0))	{
-			returnMe = 1.0;
-			// soft edge if needed
-			if ((pt.x > shapeCoordinates.x) && (pt.x < shapeCoordinates.x)) {
-				returnMe = clamp(((pt.x - shapeCoordinates.x) / RENDERSIZE.x), 0.0, 1.0);
-				returnMe = pow(returnMe, 0.5);
-			}
-			else if ((pt.x > shapeCoordinates.x + shapeCoordinates.z) && (pt.x < shapeCoordinates.x + shapeCoordinates.z)) {
-				returnMe = clamp(((shapeCoordinates.x + shapeCoordinates.z - pt.x) / RENDERSIZE.x), 0.0, 1.0);
-				returnMe = pow(returnMe, 0.5);
-			}
-		}
-		else if (RotatedPointInTriangle(pt, shapeCoordinates.xy + shapeCoordinates.zw, shapeCoordinates.xy + vec2(0.0, shapeCoordinates.w), shapeCoordinates.xy + vec2(shapeCoordinates.z, 0.0), shapeCoordinates.xy + shapeCoordinates.zw / 2.0))	{
-			returnMe = 1.0;
-			// soft edge if needed
-			if ((pt.x > shapeCoordinates.x) && (pt.x < shapeCoordinates.x)) {
-				returnMe = clamp(((pt.x - shapeCoordinates.x) / RENDERSIZE.x), 0.0, 1.0);
-				returnMe = pow(returnMe, 0.5);
-			}
-			else if ((pt.x > shapeCoordinates.x + shapeCoordinates.z) && (pt.x < shapeCoordinates.x + shapeCoordinates.z)) {
-				returnMe = clamp(((shapeCoordinates.x + shapeCoordinates.z - pt.x) / RENDERSIZE.x), 0.0, 1.0);
-				returnMe = pow(returnMe, 0.5);
-			}
-		}
-	}
-	//	triangle
-	else if (shape == 1)	{
-		if (RotatedPointInTriangle(pt, shapeCoordinates.xy, shapeCoordinates.xy + vec2(shapeCoordinates.z / 2.0, shapeCoordinates.w), shapeCoordinates.xy + vec2(shapeCoordinates.z, 0.0), shapeCoordinates.xy + shapeCoordinates.zw / 2.0))	{
-			returnMe = 1.0;
-		}
-	}
-	//	oval
-	else if (shape == 2)	{
-		returnMe = distance(pt, vec2(shapeCoordinates.xy + shapeCoordinates.zw / 2.0));
-		if (returnMe < min(shapeCoordinates.z,shapeCoordinates.w) / 2.0)	{
-			returnMe = 1.0;
-		}
-		else	{
-			returnMe = 0.0;
-		}
-	}
-	//	diamond
-	else if (shape == 3)	{
-		if (RotatedPointInTriangle(pt, shapeCoordinates.xy + vec2(0.0, shapeCoordinates.w / 2.0), shapeCoordinates.xy + vec2(shapeCoordinates.z / 2.0, shapeCoordinates.w), shapeCoordinates.xy + vec2(shapeCoordinates.z, shapeCoordinates.w / 2.0), shapeCoordinates.xy + shapeCoordinates.zw / 2.0))	{
-			returnMe = 1.0;
-		}
-		else if (RotatedPointInTriangle(pt, shapeCoordinates.xy + vec2(0.0, shapeCoordinates.w / 2.0), shapeCoordinates.xy + vec2(shapeCoordinates.z / 2.0, 0.0), shapeCoordinates.xy + vec2(shapeCoordinates.z, shapeCoordinates.w / 2.0), shapeCoordinates.xy + shapeCoordinates.zw / 2.0))	{
-			returnMe = 1.0;
-		}
-	}
-
-	return returnMe;	
-}
-
-// Value Noise code by Inigo Quilez ported by @colin_movecraft
-
-// Value Noise (http://en.wikipedia.org/wiki/Value_noise), not to be confused with Perlin's
-// Noise, is probably the simplest way to generate noise (a random smooth signal with 
-// mostly all its energy in the low frequencies) suitable for procedural texturing/shading,
-// modeling and animation.
-//
-// It produces lowe quality noise than Gradient Noise (https://www.shadertoy.com/view/XdXGW8)
-// but it is slightly faster to compute. When used in a fractal construction, the blockyness
-// of Value Noise gets qcuikly hidden, making it a very popular alternative to Gradient Noise.
-//
-// The princpiple is to create a virtual grid/latice all over the plane, and assign one
-// random value to every vertex in the grid. When querying/requesting a noise value at
-// an arbitrary point in the plane, the grid cell in which the query is performed is
-// determined (line 30), the four vertices of the grid are determined and their random
-// value fetched (lines 35 to 38) and then bilinearly interpolated (lines 35 to 38 again)
-// with a smooth interpolant (line 31 and 33).
-
-
-// Value    Noise 2D, Derivatives: https://www.shadertoy.com/view/4dXBRH
-// Gradient Noise 2D, Derivatives: https://www.shadertoy.com/view/XdXBRH
-// Value    Noise 3D, Derivatives: https://www.shadertoy.com/view/XsXfRH
-// Gradient Noise 3D, Derivatives: https://www.shadertoy.com/view/4dffRH
-// Value    Noise 2D             : https://www.shadertoy.com/view/lsf3WH
-// Value    Noise 3D             : https://www.shadertoy.com/view/4sfGzS
-// Gradient Noise 2D             : https://www.shadertoy.com/view/XdXGW8
-// Gradient Noise 3D             : https://www.shadertoy.com/view/Xsl3Dl
-// Simplex  Noise 2D             : https://www.shadertoy.com/view/Msf3WH
-
-
-float hash(vec2 p, float seed)  // replace this by something better
-{
-    p  = 50.0*fract(seed*1.17921+p*0.3183099 + vec2(0.71,0.113));
-    return -1.0+2.0*fract( p.x*p.y*(p.x+p.y) );
-}
-
-float noise( in vec2 p , in float seed)
-{
-    vec2 i = floor( p );
-    vec2 f = fract( p );
-	
-	vec2 u = f*f*(3.0-2.0*f);
-
-    float v1 = mix( mix( hash( i + vec2(0.0,0.0) , floor(seed) ), 
-                     hash( i + vec2(1.0,0.0) , floor(seed) ), u.x),
-                mix( hash( i + vec2(0.0,1.0) , floor(seed) ), 
-                     hash( i + vec2(1.0,1.0) , floor(seed) ), u.x), u.y);
-    float v2 = mix( mix( hash( i + vec2(0.0,0.0) , ceil(seed) ), 
-                     hash( i + vec2(1.0,0.0) , ceil(seed) ), u.x),
-                mix( hash( i + vec2(0.0,1.0) , ceil(seed) ), 
-                     hash( i + vec2(1.0,1.0) , ceil(seed) ), u.x), u.y);
-    return mix(v1,v2,fract(seed));
-}
-
-float map(float n, float i1, float i2, float o1, float o2){
-	return o1 + (o2-o1) * (n-i1)/(i2-i1);
-	
-}
-
-float rand(vec2 co){
-    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-vec4 rand4(vec4 co)	{
-	vec4	returnMe = vec4(0.0);
-	returnMe.r = rand(co.rg);
-	returnMe.g = rand(co.gb);
-	returnMe.b = rand(co.ba);
-	returnMe.a = rand(co.rb);
-	return returnMe;
-}
-
-vec4 patternForType(vec2 coord, int pType, vec2 seed)	{
-	vec4	returnMe = vec4(0.0);
-	int		pt = pType;
-	if (pt <= 2)	{
-    	vec2 p = gl_FragCoord.xy / RENDERSIZE;
-		vec2 uv = p*vec2(RENDERSIZE.x/RENDERSIZE.y,1.0);
-		float f = 0.0;
-
-		if (glitchSmoothness < 1.0)	{
-			float blockness = rand(noiseSeed*(floor(uv*(1.0+glitchScale*50.0))/(1.0+glitchScale*50.0)));
-			if (blockness > glitchSmoothness)
-				uv = floor(uv*(1.0+glitchScale*20.0))/(1.0+glitchScale*20.0);
-		}
-
-		//fbm - fractal noise (4 octaves)	
-		{
-			uv *= glitchScale;
-       	 	mat2 m = mat2( 1.6,  1.2, -1.2,  1.6 );
-			f  = 0.5000*noise( uv , patternSeed ); uv = m*uv;
-			f += 0.2500*noise( uv , patternSeed ); uv = m*uv;
-			f += 0.1250*noise( uv , patternSeed ); uv = m*uv;
-			f += 0.0625*noise( uv , patternSeed ); uv = m*uv;
-		}
-	
-		f = pow(f,0.5);
-	
-		float d = distance(isf_FragNormCoord,vec2(0.5));
-		if (d > glitchRadius)	{
-			f = f + (d-glitchRadius);
-		}
-		if (pt == 0)	{
-			pt = 5 + int(min(f,1.0) * 3.99);	
-		}
-		else if (pt == 1)	{
-			pt = 3 + int(min(f,1.0) * 3.99);	
-		}
-		else if (pt == 2)	{
-			pt = 4 + int(f * 5.99);
-		}
-		/*
-		if (patternSeed < 0.25)
-			pt = 2 + int(4.999 * rand(seed));
-		else if (patternSeed < 0.5)
-			pt = 2 + int(4.999 * rand(vec2(seed.x*floor(coord.x/(RENDERSIZE.x/4.0)),seed.x*floor(coord.y/(RENDERSIZE.y/4.0)))));
-		else if (patternSeed < 0.75)
-			pt = 2 + int(4.999 * rand(vec2(seed.x*floor(coord.x/(RENDERSIZE.x/10.0)),seed.x*floor(coord.y/(RENDERSIZE.y/10.0)))));
-		else
-			pt = 2 + int(4.999 * rand(vec2(seed.x*floor(coord.x/(RENDERSIZE.x/100.0)),seed.x*floor(coord.y/(RENDERSIZE.y/100.0)))));
-		*/
-	}
-	
-	vec2	flickCoord = coord;
-	if (pt == 5)	{
-		flickCoord = vec2(coord.x,floor(coord.y/(1.0+patternSeed))*(1.0+patternSeed));
-	}
-	else if (pt == 6)	{
-		flickCoord = vec2(floor(coord.x/(1.0+patternSeed))*(1.0+patternSeed),coord.y);
-	}
-	else if (pt > 6) {
-		flickCoord = floor(coord/(1.0+patternSeed))*(1.0+patternSeed);
-	}
-	float	flickRand = (flickerLevel > 0.0) ? rand(TIME * flickCoord + patternSeed) : 0.0;
-	bool	doFlick = false;
-	if (flickRand < flickerLevel)	{
-		doFlick = true;
-	}
-	//nothing
-	if (pt == 3)	{
-		returnMe = vec4(0.0);
-	}
-	//noise
-	else if (pt == 4)	{
-		if (doFlick)	{
-			returnMe = IMG_THIS_PIXEL(inputImage);
-		}
-		else	{
-			vec2	modCoord = RENDERSIZE*vec2(rand(patternSeed * coord),rand(patternSeed * coord.yx));
-			modCoord *= max(1.0+patternSeed,1.00001);
-			returnMe.r = (mod(modCoord.x+modCoord.y,4.0)<2.0) ? 1.0 : 0.0;
-			returnMe.g = (mod(modCoord.x+modCoord.y,5.0)<2.0) ? 1.0 : 0.0;
-			returnMe.b = (mod(modCoord.x+modCoord.y,7.0)<2.0) ? 1.0 : 0.0;
-			returnMe.a = 1.0;
-		}
-	}
-	//lines
-	else if (pt == 5)	{
-		vec2	modCoord = (rand(vec2(patternSeed,coord.y)) < 0.25) ? coord : coord.yx;
-		modCoord *= (1.0+patternSeed);
-		if (doFlick)	{
-			returnMe = mix(IMG_PIXEL(inputImage,vec2(modCoord.x,0.0)),IMG_PIXEL(inputImage,vec2(modCoord.x,RENDERSIZE.y)),modCoord.y/RENDERSIZE.y);
-		}
-		else	{
-			returnMe.r = (mod(modCoord.x,4.0)<1.0) ? 1.0 : 0.0;
-			returnMe.g = (mod(modCoord.x,5.0)<1.0) ? 1.0 : 0.0;
-			returnMe.b = (mod(modCoord.x,7.0)<1.0) ? 1.0 : 0.0;
-			returnMe.a = 1.0;
-		}
-	}
-	//vertical lines
-	else if (pt == 6)	{
-		vec2	modCoord = coord;
-		//modCoord.x += rand(vec2(patternSeed,modCoord.x));
-		modCoord.x *= (1.0+patternSeed);
-		modCoord *= (1.0+patternSeed);
-		modCoord = mod(modCoord,RENDERSIZE);
-		if (doFlick)	{
-			returnMe = mix(IMG_PIXEL(inputImage,vec2(modCoord.x,0.0)),IMG_PIXEL(inputImage,vec2(modCoord.x,RENDERSIZE.y)),modCoord.y/RENDERSIZE.y);
-		}
-		else	{
-			returnMe.r = (mod(modCoord.x,4.0)<1.0) ? 1.0 : 0.0;
-			returnMe.g = (mod(modCoord.x,5.0)<1.0) ? 1.0 : 0.0;
-			returnMe.b = (mod(modCoord.x,7.0)<1.0) ? 1.0 : 0.0;
-			returnMe.a = 1.0;
-		}
-	}
-	//horizontal lines
-	else if (pt == 7)	{
-		vec2	modCoord = coord;
-		//modCoord.y += rand(vec2(patternSeed,modCoord.y));
-		modCoord.y *= (1.0+patternSeed);
-		modCoord = mod(modCoord,RENDERSIZE);
-		if (doFlick)	{
-			returnMe = mix(IMG_PIXEL(inputImage,vec2(0.0,modCoord.y)),IMG_PIXEL(inputImage,vec2(RENDERSIZE.x,modCoord.y)),modCoord.x/RENDERSIZE.x);
-		}
-		else	{
-			returnMe.r = (mod(modCoord.y,4.0)<1.0) ? 1.0 : 0.0;
-			returnMe.g = (mod(modCoord.y,5.0)<1.0) ? 1.0 : 0.0;
-			returnMe.b = (mod(modCoord.y,7.0)<1.0) ? 1.0 : 0.0;
-			returnMe.a = 1.0;
-		}
-	}
-	//stripes
-	else if (pt == 8)	{
-		vec2	modCoord = mod(coord*(1.0+patternSeed),10.0);
-		if (doFlick)	{
-			returnMe = (modCoord.x<5.0) ? IMG_PIXEL(inputImage,vec2(modCoord.x,0.0)) : IMG_PIXEL(inputImage,vec2(modCoord.x,RENDERSIZE.y));
-		}
-		else	{
-			returnMe = ((modCoord.x<5.0)) ? vec4(1.0) : vec4(0.0,0.0,0.0,1.0);
-		}
-	}
-	//checkerboard
-	else 	{
-		vec2	modCoord = mod(coord*(1.0+patternSeed),80.0);
-		returnMe = vec4(0.9,0.9,0.9,1.0);
-		if (doFlick)
-			returnMe = IMG_PIXEL(inputImage,floor(coord/(1.0+patternSeed))*(1.0+patternSeed));
-		else if ((modCoord.x<40.0)&&(modCoord.y<40.0))
-			returnMe = vec4(0.5,0.5,0.5,1.0);
-		else if ((modCoord.x>40.0)&&(modCoord.y>40.0))
-			returnMe = vec4(0.5,0.5,0.5,1.0);
-		
-	}
-	return returnMe;
-}
-
-void main(){
-    vec2 p = gl_FragCoord.xy / RENDERSIZE;
-    vec4 returnMe = IMG_THIS_PIXEL(inputImage);
-    float f = 1.0;
-    bool didRowGlitch = false;
-
-	if (rowGlitchLevel > 0.0)	{
-		float rowGlitch = rand(vec2(p.y+patternSeed+0.239,noiseSeed+0.821));
-		if (rowGlitch < rowGlitchLevel)	{
-			rowGlitch = rand(vec2(p.y+1.287*patternSeed+2.239,6.12*noiseSeed+3.477));
-			if (p.x < rowGlitch)	{
-				returnMe = IMG_NORM_PIXEL(inputImage,vec2(rowGlitch,p.y));
-				vec4	bgColor = rand4(vec4(rowGlitch, 1.28*rowGlitchSeed+p.y, rowGlitchSeed+floor(10.0*p.x/rowGlitch), rowGlitchSeed));
-				//patternForType(vec2(rowGlitch,p.y)*RENDERSIZE,patternStyle,vec2(noiseSeed,rowGlitchSeed));
-				returnMe = mix(returnMe,bgColor,1.0-rowFlickerLevel*rand(vec2(TIME+p.y,rowGlitch+rowGlitchSeed)));
-				didRowGlitch = true;
-			}
-		}
-	}
-	{
-		vec2 uv = p*vec2(RENDERSIZE.x/RENDERSIZE.y,1.0);
-		f = 0.0;
-		if (glitchSmoothness < 1.0)	{
-			float blockness = rand(noiseSeed*(floor(uv*(1.0+glitchScale*100.0))/(1.0+glitchScale*100.0)));
-			if (blockness > glitchSmoothness)
-				uv = floor(uv*(1.0+glitchScale*25.0))/(1.0+glitchScale*25.0);
-		}
-		//fbm - fractal noise (4 octaves)	
-		{
-			uv *= glitchScale;
-       		mat2 m = mat2( 1.6,  1.2, -1.2,  1.6 );
-			f  = 0.5000*noise( uv , noiseSeed ); uv = m*uv;
-			f += 0.2500*noise( uv , noiseSeed ); uv = m*uv;
-			f += 0.1250*noise( uv , noiseSeed ); uv = m*uv;
-			f += 0.0625*noise( uv , noiseSeed ); uv = m*uv;
-		}
-	
-		f = 1.0-pow(f,(5.0-glitchBrightnessCurve))*glitchBrightness;
-	
-		float d = distance(isf_FragNormCoord,vec2(0.5));
-		if (d > glitchRadius)	{
-			f = f + (d-glitchRadius);
-		}
-	
-		f = (f > 1.0) ? 1.0 : f;
-	
-		
-		//vec4 returnMe = vec4(f,f,f,1.0);
-		if (hardEdge)	{
-			f = (f > 0.9) ? 1.0 : 0.0;	
-		}
-		if (f < 1.0)	{
-			vec4	bgColor = patternForType(gl_FragCoord.xy,patternStyle,vec2(patternSeed,0.2941));
-			returnMe = mix(returnMe,bgColor,1.0-f);
-		}
-	}
-	
-	{
-		vec2 uv = p*vec2(RENDERSIZE.x/RENDERSIZE.y,1.0);
-		f = 0.0;
-		//fbm - fractal noise (4 octaves)	
-		{
-			uv *= tintScale;
-       		mat2 m = mat2( 1.6,  1.2, -1.2,  1.6 );
-			f  = 0.5000*noise( uv , tintSeed ); uv = m*uv;
-			f += 0.2500*noise( uv , tintSeed ); uv = m*uv;
-			f += 0.1250*noise( uv , tintSeed ); uv = m*uv;
-			f += 0.0625*noise( uv , tintSeed ); uv = m*uv;
-		}
-	
-		f = 1.0-pow(f,(5.0-tintBrightnessCurve))*tintBrightness;
-	
-		float d = distance(isf_FragNormCoord,vec2(0.5));
-		if (d > tintRadius)	{
-			f = f + (d-tintRadius);
-		}
-	
-		f = (f > 1.0) ? 1.0 : f;
-	
-		
-		//vec4 returnMe = vec4(f,f,f,1.0);
-		if (f < 1.0)	{
-			vec4	bgColor = mix(tintColor1,tintColor2,f+rand(vec2(tintSeed,0.231)));
-			if (hardEdge)	{
-				f = (f > 0.9) ? 1.0 : 0.0;	
-			}
-			returnMe = mix(returnMe,bgColor*returnMe,1.0-f);
-		}
-	}
-	
-	if (alphaMode == 1)
-		returnMe.a *= f;
-	else if (alphaMode == 2)
-		returnMe.a = f;
-	
-	gl_FragColor = returnMe;
-}
-
-
-
-
-// The MIT License
-// Copyright © 2013 Inigo Quilez
-// 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/nannou_isf/test_files/Bump Distortion.fs b/nannou_isf/test_files/Bump Distortion.fs
deleted file mode 100644
index 88a381501..000000000
--- a/nannou_isf/test_files/Bump Distortion.fs	
+++ /dev/null
@@ -1,90 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion Effect"
-    ],
-    "CREDIT": "by carter rosenberg",
-    "DESCRIPTION": "Bends and distorts the image",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": -1,
-            "NAME": "level",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.25,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "radius",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0.5,
-                0.5
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "center",
-            "TYPE": "point2D"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-const float pi = 3.14159265359;
-
-#ifndef GL_ES
-float distance (vec2 inCenter, vec2 pt)
-{
-	float tmp = pow(inCenter.x-pt.x,2.0)+pow(inCenter.y-pt.y,2.0);
-	return pow(tmp,0.5);
-}
-#endif
-
-void main() {
-	vec2		uv = isf_FragNormCoord.xy;
-	vec2		texSize = RENDERSIZE.xy;
-	vec2		tc = uv * texSize;
-	vec2		modifiedCenter = center * texSize;
-	float		r = distance(modifiedCenter, tc);
-	float		a = atan ((tc.y-modifiedCenter.y),(tc.x-modifiedCenter.x));
-	float		radius_sized = radius * length(RENDERSIZE);
-	
-	tc -= modifiedCenter;
-
-	if (r < radius_sized) 	{
-		float percent = 1.0-(radius_sized - r) / radius_sized;
-		if (level>=0.0)	{
-			percent = percent * percent;
-			tc.x = r*pow(percent,level) * cos(a);
-			tc.y = r*pow(percent,level) * sin(a);
-		}
-		else	{
-			float adjustedLevel = level/2.0;
-			tc.x = r*pow(percent,adjustedLevel) * cos(a);
-			tc.y = r*pow(percent,adjustedLevel) * sin(a);		
-		}
-	}
-	tc += modifiedCenter;
-	vec2 loc = tc / texSize;
-
-	if ((loc.x < 0.0)||(loc.y < 0.0)||(loc.x > 1.0)||(loc.y > 1.0))	{
-		gl_FragColor = vec4(0.0);
-	}
-	else	{
-		gl_FragColor = IMG_NORM_PIXEL(inputImage, loc);
-	}
-}
diff --git a/nannou_isf/test_files/Burn.fs b/nannou_isf/test_files/Burn.fs
deleted file mode 100644
index af6b88c8b..000000000
--- a/nannou_isf/test_files/Burn.fs
+++ /dev/null
@@ -1,63 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Dissolve"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/burn.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                1,
-                1,
-                1,
-                1
-            ],
-            "NAME": "color",
-            "TYPE": "color"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// author: gre
-// License: MIT
-vec4 transition (vec2 uv) {
-  return mix(
-    getFromColor(uv) + progress*color,
-    getToColor(uv) + (1.0-progress)*color,
-    progress
-  );
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Butterfly Wave Scrawler.fs b/nannou_isf/test_files/Butterfly Wave Scrawler.fs
deleted file mode 100644
index 766196a1d..000000000
--- a/nannou_isf/test_files/Butterfly Wave Scrawler.fs	
+++ /dev/null
@@ -1,90 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/ButterflyWaveScrawler.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 5,
-            "MIN": 0,
-            "NAME": "amplitude",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 30,
-            "MAX": 50,
-            "MIN": 0,
-            "NAME": "waves",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.3,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "colorSeparation",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: mandubian
-// License: MIT
-float PI = 3.14159265358979323846264;
-float compute(vec2 p, float progress, vec2 center) {
-vec2 o = p*sin(progress * amplitude)-center;
-// horizontal vector
-vec2 h = vec2(1., 0.);
-// butterfly polar function (don't ask me why this one :))
-float theta = acos(dot(o, h)) * waves;
-return (exp(cos(theta)) - 2.*cos(4.*theta) + pow(sin((2.*theta - PI) / 24.), 5.)) / 10.;
-}
-vec4 transition(vec2 uv) {
-  vec2 p = uv.xy / vec2(1.0).xy;
-  float inv = 1. - progress;
-  vec2 dir = p - vec2(.5);
-  float dist = length(dir);
-  float disp = compute(p, progress, vec2(0.5, 0.5)) ;
-  vec4 texTo = getToColor(p + inv*disp);
-  vec4 texFrom = vec4(
-  getFromColor(p + progress*disp*(1.0 - colorSeparation)).r,
-  getFromColor(p + progress*disp).g,
-  getFromColor(p + progress*disp*(1.0 + colorSeparation)).b,
-  1.0);
-  return texTo*progress + texFrom*inv;
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/CMYK Halftone-Lookaround.fs b/nannou_isf/test_files/CMYK Halftone-Lookaround.fs
deleted file mode 100644
index 8dfe49b7a..000000000
--- a/nannou_isf/test_files/CMYK Halftone-Lookaround.fs	
+++ /dev/null
@@ -1,138 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Halftone Effect",
-        "Retro"
-    ],
-    "CREDIT": "by zoidberg",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 45,
-            "MAX": 256,
-            "MIN": 1,
-            "NAME": "gridSize",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.15,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "smoothing",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-vec4		gridRot = vec4(15.0, 45.0, 0.0, 75.0);
-//vec4		gridRot = vec4(15.0, 75.0, 0.0, 45.0);
-//vec4		gridRot = vec4(0.0, 0.0, 0.0, 0.0);
-
-
-
-//	during calculation we find the closest dot to a frag, determine its size, and then determine the size of the four dots above/below/right/left of it. this array of offsets move "one left", "one up", "one right", and "one down"...
-vec2		originOffsets[4];
-
-
-
-vec4 RGBAtoCMYK(vec4 inColor)
-{
-	/*
-	vec4	cmyk;
-	cmyk.xyz = 1.0 - inColor.xyz;
-	cmyk.w = min(cmyk.x, min(cmyk.y, cmyk.z)); // Create K
-	cmyk.xyz -= cmyk.w; // Subtract K equivalent from CMY
-	return cmyk;
-	*/
-	vec4		ret;
-	ret.w = 1.0 - max(max(inColor.x, inColor.y), inColor.z);
-	ret.x = (1.0-inColor.x-ret.w)/(1.0-ret.w);
-	ret.y = (1.0-inColor.y-ret.w)/(1.0-ret.w);
-	ret.z = (1.0-inColor.z-ret.w)/(1.0-ret.w);
-	//ret.w = min(min(ret.x, ret.y), min(ret.z, ret.w));
-	return ret;
-	
-}
-vec4 CMYKtoRGBA(vec4 inColor)
-{
-	vec4		ret;
-	ret.xyz = (1.0-inColor.xyz)*(1.0-inColor.w);
-	ret.w = 1.0;
-	return ret;
-}
-
-void main() {
-	//	a halftone is an overlapping series of grids of dots
-	//	each grid of dots is rotated by a different amount
-	//	the size of the dots determines the colors. the shape of the dot should never change (always be a dot with regular edges)
-	originOffsets[0] = vec2(-1.0, 0.0);
-	originOffsets[1] = vec2(0.0, 1.0);
-	originOffsets[2] = vec2(1.0, 0.0);
-	originOffsets[3] = vec2(0.0, -1.0);
-	
-	vec4		cmykAmounts = vec4(0.0);
-	int i;
-	int j;
-	//	for each of the channels (i) of CMYK...
-	for (i=0; i<4; ++i)	{
-		//	figure out the rotation of the grid in radians
-		float		rotRad = radians(gridRot[i]);
-		//	the grids are rotated counter-clockwise- to find the nearest dot, take the fragment pixel loc, 
-		//	rotate it clockwise, and split by the grid to find the center of the dot. then rotate this 
-		//	coord counter-clockwise to yield the location of the center of the dot in pixel coords local to the render space
-		mat2		ccTrans = mat2(vec2(cos(rotRad), sin(rotRad)), vec2(-1.0*sin(rotRad), cos(rotRad)));
-		mat2		cTrans = mat2(vec2(cos(rotRad), -1.0*sin(rotRad)), vec2(sin(rotRad), cos(rotRad)));
-		
-		//	find the location of the frag in the grid (prior to rotating it)
-		vec2		gridFragLoc = cTrans * gl_FragCoord.xy;
-		//	find the center of the dot closest to the frag- there's no "round" in GLSL 1.2, so do a "floor" to find the dot to the bottom-left of the frag, then figure out if the frag would be in the top and right halves of that square to find the closest dot to the frag
-		vec2		gridOriginLoc = vec2(floor(gridFragLoc.x/gridSize), floor(gridFragLoc.y/gridSize));
-		
-		vec2		tmpGridCoords = gridFragLoc/vec2(gridSize);
-		bool		fragAtTopOfGrid = ((tmpGridCoords.y-floor(tmpGridCoords.y)) > (gridSize/2.0)) ? true : false;
-		bool		fragAtRightOfGrid = ((tmpGridCoords.x-floor(tmpGridCoords.x)) > (gridSize/2.0)) ? true : false;
-		if (fragAtTopOfGrid)
-			gridOriginLoc.y = gridOriginLoc.y + 1.0;
-		if (fragAtRightOfGrid)
-			gridOriginLoc.x = gridOriginLoc.x + 1.0;
-		//	...at this point, "gridOriginLoc" contains the grid coords of the nearest dot to the fragment being rendered
-		//	convert the location of the center of the dot from grid coords to pixel coords
-		vec2		gridDotLoc = vec2(gridOriginLoc.x*gridSize, gridOriginLoc.y*gridSize) + vec2(gridSize/2.0);
-		//	rotate the pixel coords of the center of the dot so they become relative to the rendering space
-		vec2		renderDotLoc = ccTrans * gridDotLoc;
-		//	get the color of the pixel of the input image under this dot (the color will ultimately determine the size of the dot)
-		vec4		renderDotImageColorRGB = IMG_PIXEL(inputImage, renderDotLoc);
-		//	convert the color from RGB to CMYK
-		vec4		renderDotImageColorCMYK = RGBAtoCMYK(renderDotImageColorRGB);
-		
-		//	the amount of this channel is taken from the same channel of the color of the pixel of the input image under this halftone dot
-		float		imageChannelAmount = renderDotImageColorCMYK[i];
-		//	the size of the dot is determined by the value of the channel
-		float		dotRadius = imageChannelAmount * (gridSize*1.50/2.0);
-		float		fragDistanceToDotCenter = distance(gl_FragCoord.xy, renderDotLoc);
-		if (fragDistanceToDotCenter < dotRadius)	{
-			cmykAmounts[i] += smoothstep(dotRadius, dotRadius-(dotRadius*smoothing), fragDistanceToDotCenter);
-		}
-		
-		//	calcluate the size of the dots abov/below/to the left/right to see if they're overlapping
-		for (j=0; j<4; ++j)	{
-			gridDotLoc = vec2((gridOriginLoc.x+originOffsets[j].x)*gridSize, (gridOriginLoc.y+originOffsets[j].y)*gridSize) + vec2(gridSize/2.0);
-			renderDotLoc = ccTrans * gridDotLoc;
-			renderDotImageColorRGB = IMG_PIXEL(inputImage, renderDotLoc);
-			renderDotImageColorCMYK = RGBAtoCMYK(renderDotImageColorRGB);
-			
-			imageChannelAmount = renderDotImageColorCMYK[i];
-			dotRadius = imageChannelAmount * (gridSize*1.50/2.0);
-			fragDistanceToDotCenter = distance(gl_FragCoord.xy, renderDotLoc);
-			if (fragDistanceToDotCenter < dotRadius)	{
-				cmykAmounts[i] += smoothstep(dotRadius, dotRadius-(dotRadius*smoothing), fragDistanceToDotCenter);
-			}
-		}
-	}
-	
-	gl_FragColor = CMYKtoRGBA(cmykAmounts);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/CMYK Halftone.fs b/nannou_isf/test_files/CMYK Halftone.fs
deleted file mode 100644
index 16d9200e5..000000000
--- a/nannou_isf/test_files/CMYK Halftone.fs	
+++ /dev/null
@@ -1,87 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Halftone Effect",
-        "Retro"
-    ],
-    "CREDIT": "by zoidberg",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 45,
-            "MAX": 256,
-            "MIN": 1,
-            "NAME": "gridSize",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.15,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "smoothing",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-const vec4		gridRot = vec4(15.0, 45.0, 0.0, 75.0);
-
-
-
-
-vec4 RGBAtoCMYK(vec4 inColor)
-{
-	vec4		ret;
-	ret.w = 1.0 - max(max(inColor.x, inColor.y), inColor.z);
-	ret.x = (1.0-inColor.x-ret.w)/(1.0-ret.w);
-	ret.y = (1.0-inColor.y-ret.w)/(1.0-ret.w);
-	ret.z = (1.0-inColor.z-ret.w)/(1.0-ret.w);
-	return ret;
-}
-vec4 CMYKtoRGBA(vec4 inColor)
-{
-	vec4		ret;
-	ret.xyz = (1.0-inColor.xyz)*(1.0-inColor.w);
-	ret.w = 1.0;
-	return ret;
-}
-
-void main() {
-	//	a halftone is an overlapping series of grids of dots
-	//	each grid of dots is rotated by a different amount
-	//	the size of the dots determines the colors. the shape of the dot should never change (always be a dot with regular edges)
-	
-	vec4		cmykAmounts = vec4(0.0);
-	
-	//	for each of the channels (i) of CMYK...
-	for (int i=0; i<4; ++i)	{
-		//	figure out the rotation of the grid in radians
-		float		rotRad = radians(gridRot[i]);
-		//	the grids are rotated counter-clockwise- to find the nearest dot, take the fragment pixel loc, 
-		//	rotate it clockwise, and split by the grid to find the center of the dot. then rotate this 
-		//	coord counter-clockwise to yield the location of the center of the dot in pixel coords local to the render space
-		mat2		ccTrans = mat2(vec2(cos(rotRad), sin(rotRad)), vec2(-1.0*sin(rotRad), cos(rotRad)));
-		mat2		cTrans = mat2(vec2(cos(rotRad), -1.0*sin(rotRad)), vec2(sin(rotRad), cos(rotRad)));
-		
-		//	render loc -> grid loc -> grid dot loc -> grid dot loc in render coords -> pixel color under grid dot loc
-		vec2		gridFragLoc = cTrans * gl_FragCoord.xy;
-		vec2		gridDotLoc = vec2(floor(gridFragLoc.x/gridSize)*gridSize, floor(gridFragLoc.y/gridSize)*gridSize);
-		gridDotLoc = gridDotLoc + vec2(gridSize/2.0);
-		vec2		renderDotLoc = ccTrans * gridDotLoc;
-		vec4		renderDotImageColorRGB = IMG_PIXEL(inputImage, renderDotLoc);
-		vec4		renderDotImageColorCMYK = RGBAtoCMYK(renderDotImageColorRGB);
-		
-		float		channelAmount = renderDotImageColorCMYK[i];
-		float		dotRadius = channelAmount * (gridSize/2.0);
-		float		fragDistanceToGridCenter = distance(gl_FragCoord.xy, renderDotLoc);
-		//	the amount of the channel depends on the distance to the center of the grid, the size of the dot, and smoothing
-		float		smoothDist = smoothing * (gridSize/6.0);
-		cmykAmounts[i] += smoothstep(dotRadius, dotRadius-(dotRadius*smoothing), fragDistanceToGridCenter);
-	}
-	
-	gl_FragColor = CMYKtoRGBA(cmykAmounts);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Channel Slide.fs b/nannou_isf/test_files/Channel Slide.fs
deleted file mode 100644
index a26fac725..000000000
--- a/nannou_isf/test_files/Channel Slide.fs	
+++ /dev/null
@@ -1,50 +0,0 @@
-/*{
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Color Effect"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "slideAmt",
-			"LABEL": "slide amount",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.0,
-				0.0,
-				0.0,
-				0.0
-			]
-		},
-		{
-			"NAME": "reflection",
-			"TYPE": "bool",
-			"DEFAULT": 0.0
-		}
-	]
-}*/
-
-void main() {
-	vec4		srcPixel = IMG_THIS_PIXEL(inputImage);
-	if (reflection == true)	{
-		vec4		outPixel;
-		outPixel.rgb = srcPixel.rgb - slideAmt.rgb;
-		outPixel.a = srcPixel.a + slideAmt.a;	//	alpha behaves the same in both modes (just easier to work with)
-		gl_FragColor.x = (outPixel.x<0.0) ? outPixel.x+1.0 : outPixel.x;
-		gl_FragColor.y = (outPixel.y<0.0) ? outPixel.y+1.0 : outPixel.y;
-		gl_FragColor.z = (outPixel.z<0.0) ? outPixel.z+1.0 : outPixel.z;
-		//gl_FragColor.a = (outPixel.a<0.0) ? outPixel.a+1.0 : outPixel.a;
-		gl_FragColor.a = (outPixel.a>1.0) ? outPixel.a-1.0 : outPixel.a;
-	}
-	else	{
-		vec4		outPixel = srcPixel+slideAmt;
-		gl_FragColor.x = (outPixel.x>1.0) ? outPixel.x-1.0 : outPixel.x;
-		gl_FragColor.y = (outPixel.y>1.0) ? outPixel.y-1.0 : outPixel.y;
-		gl_FragColor.z = (outPixel.z>1.0) ? outPixel.z-1.0 : outPixel.z;
-		gl_FragColor.a = (outPixel.a>1.0) ? outPixel.a-1.0 : outPixel.a;
-	}
-}
diff --git a/nannou_isf/test_files/Checkerboard.fs b/nannou_isf/test_files/Checkerboard.fs
deleted file mode 100644
index f4b7f99d1..000000000
--- a/nannou_isf/test_files/Checkerboard.fs
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Pattern", "Color"
-  ],
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "NAME" : "width",
-      "TYPE" : "float",
-      "DEFAULT" : 0.25
-    },
-    {
-      "NAME" : "offset",
-      "TYPE" : "point2D",
-      "DEFAULT" : [
-        0,
-        0
-      ],
-      "MIN" : [
-      	0,
-      	0
-      ],
-      "MAX" : [
-      	1,
-      	1
-      ]
-    },
-    {
-      "NAME" : "color1",
-      "TYPE" : "color",
-      "DEFAULT" : [
-        1,
-        1,
-        1,
-        1
-      ]
-    },
-    {
-      "NAME" : "color2",
-      "TYPE" : "color",
-      "DEFAULT" : [
-        0,
-        0,
-        0,
-        1
-      ]
-    },
-    {
-      "NAME" : "splitPos",
-      "TYPE" : "point2D",
-      "MAX" : [
-        1,
-        1
-      ],
-      "DEFAULT" : [
-        0.5,
-        0.5
-      ],
-      "MIN" : [
-        0,
-        0
-      ]
-    }
-  ],
-  "CREDIT" : "by VIDVOX"
-}
-*/
-
-
-
-void main() {
-	//	determine if we are on an even or odd line
-	//	math goes like..
-	//	mod(((coord+offset) / width),2)
-	
-	
-	vec4		out_color = color2;
-	float		size = width * RENDERSIZE.x;
-
-	if (size == 0.0)	{
-		out_color = color1;
-	}
-	else if ((mod(((gl_FragCoord.x+(offset.x*RENDERSIZE.x)) / size),2.0) < 2.0 * splitPos.x)&&(mod(((gl_FragCoord.y+(offset.y*RENDERSIZE.y)) / size),2.0) > 2.0 * splitPos.y))	{
-		out_color = color1;
-	}
-	else if ((mod(((gl_FragCoord.x+(offset.x*RENDERSIZE.x)) / size),2.0) > 2.0 * splitPos.x)&&(mod(((gl_FragCoord.y+(offset.y*RENDERSIZE.y)) / size),2.0) < 2.0 * splitPos.y))	{
-		out_color = color1;
-	}
-	
-	gl_FragColor = out_color;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Chroma Desaturation Mask.fs b/nannou_isf/test_files/Chroma Desaturation Mask.fs
deleted file mode 100755
index 2ccd820c4..000000000
--- a/nannou_isf/test_files/Chroma Desaturation Mask.fs	
+++ /dev/null
@@ -1,352 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Masking",
-        "Color Effect"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.5,
-            "LABEL": "Master Threshold",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "threshold",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0.24,
-                0.77,
-                0.38,
-                1
-            ],
-            "LABEL": "Key Color",
-            "NAME": "mask_color",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "HUE- Tol.",
-            "MAX": 0.25,
-            "MIN": 0,
-            "NAME": "hueTol",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.25,
-            "LABEL": "HUE- Min. Bracket",
-            "MAX": 0.5,
-            "MIN": 0,
-            "NAME": "hueMinBracket",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.25,
-            "LABEL": "HUE- Max Bracket",
-            "MAX": 0.5,
-            "MIN": 0,
-            "NAME": "hueMaxBracket",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "SAT- Tol.",
-            "MAX": 0.5,
-            "MIN": 0,
-            "NAME": "satTol",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "LABEL": "SAT- Min. Bracket",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "satMinBracket",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "LABEL": "SAT- Max Bracket",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "satMaxBracket",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "VAL- Tol.",
-            "MAX": 0.5,
-            "MIN": 0,
-            "NAME": "valTol",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "LABEL": "VAL- Min. Bracket",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "valMinBracket",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "LABEL": "VAL- Max Bracket",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "valMaxBracket",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Dilate",
-            "MAX": 6,
-            "MIN": 0,
-            "NAME": "dilate",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Blur",
-            "MAX": 6,
-            "MIN": 0,
-            "NAME": "blur",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "TARGET": "alphaPass"
-        },
-        {
-            "TARGET": "horizDilate"
-        },
-        {
-            "TARGET": "vertDilate"
-        },
-        {
-            "TARGET": "horizBlur"
-        },
-        {
-            "TARGET": "vertBlur"
-        }
-    ]
-}
-*/
-
-
-
-vec3 rgb2hsv(vec3 c);
-vec3 hsv2rgb(vec3 c);
-
-void main() {
-	//	generally speaking, sample a bunch of pixels, for each sample convert color val to HSV, if luma is greater than max luma, that's the new color
-	vec2		tmpCoord;
-	float		maxAlpha;
-	vec4		sampleColorRGB;
-	vec4		src_rgb;
-	
-	if (PASSINDEX==0)	{
-		//	the goal is to calculate a new float value for the alpha channel, and/or desaturate the color, if this pixel is "close" to the mask color
-		//	get the src pixel's color (as RGB), convert to HSV values
-		src_rgb = IMG_PIXEL(inputImage, gl_FragCoord.xy);
-		vec3			src_hsl = rgb2hsv(src_rgb.rgb);
-		//	convert the passed color (which is RGB) to HSV values
-		vec3			color_hsl = rgb2hsv(mask_color.rgb);
-		
-		
-/*			-minBracket	-tolerance	color_hsl	+tolerance	+maxBracket
-				|			|			|			|			|			val being examined
-		----------------------------------------------------------------
-				|						|						|			alpha
-				1.0						0.0						1.0									*/
-		
-		
-		float			hueAlpha;
-		float			satAlpha;
-		float			valAlpha;
-		//	use a 'for' loop to generate the hue/sat/val alpha values
-		int			i = 0;
-		float		source;
-		float		color;
-		float		tolerance;
-		vec2		bracket;
-		float		alpha;
-		float		minVal;
-		float		maxVal;
-		for (i=0; i<3; ++i)	{
-			source = src_hsl[i];
-			color = color_hsl[i];
-			if (i==0)	{
-				tolerance = hueTol;
-				bracket = vec2(hueMinBracket, hueMaxBracket);
-			}
-			else if (i==1)	{
-				tolerance = satTol;
-				bracket = vec2(satMinBracket, satMaxBracket);
-			}
-			else if (i==2)	{
-				tolerance = valTol;
-				bracket = vec2(valMinBracket, valMaxBracket);
-			}
-			
-			//	if the source sat is < the mask color sat
-			if (source < color)	{
-				//	the minVal is the bracket and tolerance, the maxVal is the mask color
-				minVal = color - tolerance - bracket.x;
-				maxVal = color;
-				//	as i go from minVal to maxVal, the alpha goes from 1 to 0
-				alpha = 1.0 - smoothstep(minVal, maxVal, source);
-			}
-			//	else if the source sat is > the mask color sat
-			else if (source > color)	{
-				//	the minVal is the mask color, the maxVal is the tolerance and bracket
-				minVal = color;
-				maxVal = color + tolerance + bracket.y;
-				//	as i go from minVal to maxVal, the alpha goes from 0 to 1
-				alpha = smoothstep(minVal, maxVal, source);
-			}
-			//	else the source sat == the mask color sat, the alpha should be 0
-			else
-				alpha = 0.0;
-			
-			if (i==0)	{
-				hueAlpha = alpha;
-			}
-			else if (i==1)	{
-				satAlpha = alpha;
-			}
-			else if (i==2)	{
-				valAlpha = alpha;
-			}
-		}
-		
-		
-		//	calculate the alpha i'll be applying
-		src_rgb.a = sqrt(max(hueAlpha,max(satAlpha, valAlpha)));
-		
-		//	desaturate the color if appropriate, use the desaturated color
-		if (hueAlpha < 1.0)	{
-			//src_hsl.y = 0.0;
-			src_hsl.y = mix(0.0, src_hsl.y, hueAlpha);
-			src_rgb.rgb = hsv2rgb(src_hsl.xyz);
-		}
-		
-		
-		gl_FragColor = src_rgb;
-		//gl_FragColor = vec4(src_rgb.a, src_rgb.a, src_rgb.a, 1.0);
-	}
-	
-	else if (PASSINDEX==1)	{
-		//	'dilate' samples on either side + the source pixel = 2*dilate+1 total samples
-		for (float i=0.; i<=float(int(dilate)); ++i)	{
-			tmpCoord = vec2(clamp(gl_FragCoord.x+i,0.,RENDERSIZE.x), gl_FragCoord.y);
-			sampleColorRGB = IMG_PIXEL(alphaPass, tmpCoord);
-			//	if this is the first sample for this fragment, don't bother comparing- just set the max luma stuff
-			if (i == 0.)	{
-				maxAlpha = sampleColorRGB.a;
-				src_rgb = sampleColorRGB;
-			}
-			//	else this isn't the first sample...
-			else	{
-				//	compare, determine if it's the max luma
-				if (sampleColorRGB.a < maxAlpha)	{
-					maxAlpha = sampleColorRGB.a;
-				}
-				//	do another sample for the negative coordinate
-				tmpCoord = vec2(clamp(gl_FragCoord.x-i,0.,RENDERSIZE.x), gl_FragCoord.y);
-				sampleColorRGB = IMG_PIXEL(alphaPass, tmpCoord);
-				if (sampleColorRGB.a < maxAlpha)	{
-					maxAlpha = sampleColorRGB.a;
-				}
-			}
-		}
-		gl_FragColor = vec4(src_rgb.rgb, maxAlpha);
-	}
-	else if (PASSINDEX==2)	{
-		//	'dilate' samples up and down + the source pixel = 2*dilate+1 total samples
-		for (float i=0.; i<=float(int(dilate)); ++i)	{
-			tmpCoord = vec2(gl_FragCoord.x, clamp(gl_FragCoord.y+i,0.,RENDERSIZE.y));
-			sampleColorRGB = IMG_PIXEL(horizDilate, tmpCoord);
-			//	if this is the first sample for this fragment, don't bother comparing- just set the max luma stuff
-			if (i == 0.)	{
-				maxAlpha = sampleColorRGB.a;
-				src_rgb = sampleColorRGB;
-			}
-			//	else this isn't the first sample...
-			else	{
-				//	compare, determine if it's the max luma
-				if (sampleColorRGB.a < maxAlpha)	{
-					maxAlpha = sampleColorRGB.a;
-				}
-				//	do another sample for the negative coordinate
-				tmpCoord = vec2(gl_FragCoord.x, clamp(gl_FragCoord.y-i,0.,RENDERSIZE.y));
-				sampleColorRGB = IMG_PIXEL(horizDilate, tmpCoord);
-				if (sampleColorRGB.a < maxAlpha)	{
-					maxAlpha = sampleColorRGB.a;
-				}
-			}
-		}
-		gl_FragColor = vec4(src_rgb.rgb, maxAlpha);
-	}
-	else if (PASSINDEX==3)	{
-		float		tmpRadius = float(int(blur));
-		vec4		tmpColor;
-		vec4		srcColor;
-		float		totalAlpha = 0.0;
-		for (float i=-1.*tmpRadius; i<=tmpRadius; ++i)	{
-			tmpColor = IMG_PIXEL(vertDilate, gl_FragCoord.xy+vec2(i,0.0));
-			totalAlpha += tmpColor.a;
-			if (i==0.0)
-				srcColor = tmpColor;
-		}
-		totalAlpha /= ((tmpRadius*2.)+1.);
-		gl_FragColor = vec4(srcColor.r, srcColor.g, srcColor.b, totalAlpha);
-	}
-	else if (PASSINDEX==4)	{
-		float		tmpRadius = float(int(blur));
-		vec4		tmpColor;
-		vec4		srcColor;
-		float		totalAlpha = 0.0;
-		for (float i=-1.*tmpRadius; i<=tmpRadius; ++i)	{
-			tmpColor = IMG_PIXEL(horizBlur, gl_FragCoord.xy+vec2(0.0,i));
-			totalAlpha += tmpColor.a;
-			if (i==0.0)
-				srcColor = tmpColor;
-		}
-		totalAlpha /= ((tmpRadius*2.)+1.);
-		
-		if (totalAlpha > threshold)	{
-			srcColor = IMG_PIXEL(inputImage,gl_FragCoord.xy);
-			float gray = (srcColor.r + srcColor.g + srcColor.b) / 3.0;
-			gl_FragColor = vec4(gray, gray, gray, srcColor.a);
-		}
-		else	
-			gl_FragColor = IMG_PIXEL(inputImage,gl_FragCoord.xy);
-	}
-}
-
-
-
-
-vec3 rgb2hsv(vec3 c)	{
-	vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-	//vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
-	//vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
-	vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
-	vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
-	
-	float d = q.x - min(q.w, q.y);
-	float e = 1.0e-10;
-	return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
-}
-
-vec3 hsv2rgb(vec3 c)	{
-	vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
-	vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
-	return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Chroma Mask.fs b/nannou_isf/test_files/Chroma Mask.fs
deleted file mode 100755
index 8b2520759..000000000
--- a/nannou_isf/test_files/Chroma Mask.fs	
+++ /dev/null
@@ -1,401 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Masking",
-        "Color Effect"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": [
-                0.24,
-                0.77,
-                0.38,
-                1
-            ],
-            "LABEL": "Key Color",
-            "NAME": "mask_color",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": false,
-            "LABEL": "Show Alpha",
-            "NAME": "showAlpha",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 0,
-            "NAME": "applyAlpha",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": false,
-            "LABEL": "Hard Cutoff",
-            "NAME": "applyCutOff",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Alpha Mode",
-            "LABELS": [
-                "Additive",
-                "Multiply",
-                "Replace"
-            ],
-            "NAME": "alphaMode",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1,
-                2
-            ]
-        },
-        {
-            "DEFAULT": 0.5,
-            "LABEL": "Cutoff Thresh",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "cutoffThresh",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "HUE- Tol.",
-            "MAX": 0.25,
-            "MIN": 0,
-            "NAME": "hueTol",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.25,
-            "LABEL": "HUE- Min. Bracket",
-            "MAX": 0.5,
-            "MIN": 0,
-            "NAME": "hueMinBracket",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.25,
-            "LABEL": "HUE- Max Bracket",
-            "MAX": 0.5,
-            "MIN": 0,
-            "NAME": "hueMaxBracket",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "SAT- Tol.",
-            "MAX": 0.5,
-            "MIN": 0,
-            "NAME": "satTol",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "LABEL": "SAT- Min. Bracket",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "satMinBracket",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "LABEL": "SAT- Max Bracket",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "satMaxBracket",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "VAL- Tol.",
-            "MAX": 0.5,
-            "MIN": 0,
-            "NAME": "valTol",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "LABEL": "VAL- Min. Bracket",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "valMinBracket",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "LABEL": "VAL- Max Bracket",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "valMaxBracket",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Dilate",
-            "MAX": 6,
-            "MIN": 0,
-            "NAME": "dilate",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Blur",
-            "MAX": 6,
-            "MIN": 0,
-            "NAME": "blur",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "TARGET": "alphaPass"
-        },
-        {
-            "TARGET": "horizDilate"
-        },
-        {
-            "TARGET": "vertDilate"
-        },
-        {
-            "TARGET": "horizBlur"
-        },
-        {
-            "TARGET": "vertBlur"
-        }
-    ]
-}
-*/
-
-
-
-vec3 rgb2hsv(vec3 c);
-vec3 hsv2rgb(vec3 c);
-
-void main() {
-	//	generally speaking, sample a bunch of pixels, for each sample convert color val to HSV, if luma is greater than max luma, that's the new color
-	vec2		tmpCoord;
-	float		maxAlpha;
-	vec4		sampleColorRGB;
-	vec4		src_rgb;
-	
-	if (PASSINDEX==0)	{
-		//	the goal is to calculate a new float value for the alpha channel, and/or desaturate the color, if this pixel is "close" to the mask color
-		//	get the src pixel's color (as RGB), convert to HSV values
-		src_rgb = IMG_PIXEL(inputImage, gl_FragCoord.xy);
-		vec3			src_hsl = rgb2hsv(src_rgb.rgb);
-		//	convert the passed color (which is RGB) to HSV values
-		vec3			color_hsl = rgb2hsv(mask_color.rgb);
-		
-		
-/*			-minBracket	-tolerance	color_hsl	+tolerance	+maxBracket
-				|			|			|			|			|			val being examined
-		----------------------------------------------------------------
-				|						|						|			alpha
-				1.0						0.0						1.0									*/
-		
-		
-		float			hueAlpha;
-		float			satAlpha;
-		float			valAlpha;
-		//	use a 'for' loop to generate the hue/sat/val alpha values
-		int			i = 0;
-		float		source;
-		float		color;
-		float		tolerance;
-		vec2		bracket;
-		float		alpha;
-		float		minVal;
-		float		maxVal;
-		for (i=0; i<3; ++i)	{
-			source = src_hsl[i];
-			color = color_hsl[i];
-			if (i==0)	{
-				tolerance = hueTol;
-				bracket = vec2(hueMinBracket, hueMaxBracket);
-			}
-			else if (i==1)	{
-				tolerance = satTol;
-				bracket = vec2(satMinBracket, satMaxBracket);
-			}
-			else if (i==2)	{
-				tolerance = valTol;
-				bracket = vec2(valMinBracket, valMaxBracket);
-			}
-			
-			//	if the source sat is < the mask color sat
-			if (source < color)	{
-				//	the minVal is the bracket and tolerance, the maxVal is the mask color
-				minVal = color - tolerance - bracket.x;
-				maxVal = color;
-				//	as i go from minVal to maxVal, the alpha goes from 1 to 0
-				alpha = 1.0 - smoothstep(minVal, maxVal, source);
-			}
-			//	else if the source sat is > the mask color sat
-			else if (source > color)	{
-				//	the minVal is the mask color, the maxVal is the tolerance and bracket
-				minVal = color;
-				maxVal = color + tolerance + bracket.y;
-				//	as i go from minVal to maxVal, the alpha goes from 0 to 1
-				alpha = smoothstep(minVal, maxVal, source);
-			}
-			//	else the source sat == the mask color sat, the alpha should be 0
-			else
-				alpha = 0.0;
-			
-			if (i==0)	{
-				hueAlpha = alpha;
-			}
-			else if (i==1)	{
-				satAlpha = alpha;
-			}
-			else if (i==2)	{
-				valAlpha = alpha;
-			}
-		}
-		
-		
-		//	calculate the alpha i'll be applying
-		src_rgb.a = sqrt(max(hueAlpha,max(satAlpha, valAlpha)));
-		
-		//	if we're doing a hard cutoff on the alpha, set it to 0.0 if below it
-		if ((applyCutOff) && (src_rgb.a < cutoffThresh))	{
-			src_rgb.a = 0.0;
-		}
-		//	otherwise, desaturate the color if appropriate, use the desaturated color
-		else if (hueAlpha < 1.0)	{
-			//src_hsl.y = 0.0;
-			src_hsl.y = mix(0.0, src_hsl.y, hueAlpha);
-			src_rgb.rgb = hsv2rgb(src_hsl.xyz);
-		}
-		
-		
-		gl_FragColor = src_rgb;
-		//gl_FragColor = vec4(src_rgb.a, src_rgb.a, src_rgb.a, 1.0);
-	}
-	
-	else if (PASSINDEX==1)	{
-		//	'dilate' samples on either side + the source pixel = 2*dilate+1 total samples
-		for (float i=0.; i<=float(int(dilate)); ++i)	{
-			tmpCoord = vec2(clamp(gl_FragCoord.x+i,0.,RENDERSIZE.x), gl_FragCoord.y);
-			sampleColorRGB = IMG_PIXEL(alphaPass, tmpCoord);
-			//	if this is the first sample for this fragment, don't bother comparing- just set the max luma stuff
-			if (i == 0.)	{
-				maxAlpha = sampleColorRGB.a;
-				src_rgb = sampleColorRGB;
-			}
-			//	else this isn't the first sample...
-			else	{
-				//	compare, determine if it's the max luma
-				if (sampleColorRGB.a < maxAlpha)	{
-					maxAlpha = sampleColorRGB.a;
-				}
-				//	do another sample for the negative coordinate
-				tmpCoord = vec2(clamp(gl_FragCoord.x-i,0.,RENDERSIZE.x), gl_FragCoord.y);
-				sampleColorRGB = IMG_PIXEL(alphaPass, tmpCoord);
-				if (sampleColorRGB.a < maxAlpha)	{
-					maxAlpha = sampleColorRGB.a;
-				}
-			}
-		}
-		gl_FragColor = vec4(src_rgb.rgb, maxAlpha);
-	}
-	else if (PASSINDEX==2)	{
-		//	'dilate' samples up and down + the source pixel = 2*dilate+1 total samples
-		for (float i=0.; i<=float(int(dilate)); ++i)	{
-			tmpCoord = vec2(gl_FragCoord.x, clamp(gl_FragCoord.y+i,0.,RENDERSIZE.y));
-			sampleColorRGB = IMG_PIXEL(horizDilate, tmpCoord);
-			//	if this is the first sample for this fragment, don't bother comparing- just set the max luma stuff
-			if (i == 0.)	{
-				maxAlpha = sampleColorRGB.a;
-				src_rgb = sampleColorRGB;
-			}
-			//	else this isn't the first sample...
-			else	{
-				//	compare, determine if it's the max luma
-				if (sampleColorRGB.a < maxAlpha)	{
-					maxAlpha = sampleColorRGB.a;
-				}
-				//	do another sample for the negative coordinate
-				tmpCoord = vec2(gl_FragCoord.x, clamp(gl_FragCoord.y-i,0.,RENDERSIZE.y));
-				sampleColorRGB = IMG_PIXEL(horizDilate, tmpCoord);
-				if (sampleColorRGB.a < maxAlpha)	{
-					maxAlpha = sampleColorRGB.a;
-				}
-			}
-		}
-		gl_FragColor = vec4(src_rgb.rgb, maxAlpha);
-	}
-	else if (PASSINDEX==3)	{
-		float		tmpRadius = float(int(blur));
-		vec4		tmpColor;
-		vec4		srcColor;
-		float		totalAlpha = 0.0;
-		for (float i=-1.*tmpRadius; i<=tmpRadius; ++i)	{
-			tmpColor = IMG_PIXEL(vertDilate, gl_FragCoord.xy+vec2(i,0.0));
-			totalAlpha += tmpColor.a;
-			if (i==0.0)
-				srcColor = tmpColor;
-		}
-		totalAlpha /= ((tmpRadius*2.)+1.);
-		gl_FragColor = vec4(srcColor.r, srcColor.g, srcColor.b, totalAlpha);
-	}
-	else if (PASSINDEX==4)	{
-		float		tmpRadius = float(int(blur));
-		vec4		tmpColor;
-		vec4		srcColor;
-		float		totalAlpha = 0.0;
-		for (float i=-1.*tmpRadius; i<=tmpRadius; ++i)	{
-			tmpColor = IMG_PIXEL(horizBlur, gl_FragCoord.xy+vec2(0.0,i));
-			totalAlpha += tmpColor.a;
-			if (i==0.0)
-				srcColor = tmpColor;
-		}
-		totalAlpha /= ((tmpRadius*2.)+1.);
-		
-		//	if multiplying the alpha (eg this is being used with multiple chroma mask fx)
-		if (alphaMode == 0)	{
-			vec4		originalColor = IMG_PIXEL(inputImage, gl_FragCoord.xy);
-			totalAlpha = originalColor.a + totalAlpha;	
-		}
-		else if (alphaMode == 1)	{
-			vec4		originalColor = IMG_PIXEL(inputImage, gl_FragCoord.xy);
-			totalAlpha = originalColor.a * totalAlpha;
-		}
-		
-		if (showAlpha)	{
-			gl_FragColor = vec4(totalAlpha, totalAlpha, totalAlpha, 1.0);
-		}
-		else	{
-			if (applyAlpha)
-				gl_FragColor = vec4(srcColor.r*totalAlpha, srcColor.g*totalAlpha, srcColor.b*totalAlpha, 1.0);
-			else
-				gl_FragColor = vec4(srcColor.r, srcColor.g, srcColor.b, totalAlpha);
-		}
-	}
-}
-
-
-
-
-vec3 rgb2hsv(vec3 c)	{
-	vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-	//vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
-	//vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
-	vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
-	vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
-	
-	float d = q.x - min(q.w, q.y);
-	float e = 1.0e-10;
-	return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
-}
-
-vec3 hsv2rgb(vec3 c)	{
-	vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
-	vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
-	return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Chroma Zoom.fs b/nannou_isf/test_files/Chroma Zoom.fs
deleted file mode 100644
index 0f846db9b..000000000
--- a/nannou_isf/test_files/Chroma Zoom.fs	
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Color Effect",
-    "Stylize"
-  ],
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "NAME" : "inputImage",
-      "TYPE" : "image"
-    },
-    {
-      "NAME" : "master_zoom",
-      "TYPE" : "float",
-      "MAX" : 2,
-      "DEFAULT" : 1,
-      "MIN" : 0.1
-    },
-    {
-      "NAME" : "red_zoom",
-      "TYPE" : "float",
-      "MAX" : 1.5,
-      "DEFAULT" : 1,
-      "MIN" : 1
-    },
-    {
-      "NAME" : "green_zoom",
-      "TYPE" : "float",
-      "MAX" : 1.5,
-      "DEFAULT" : 1,
-      "MIN" : 1
-    },
-    {
-      "NAME" : "blue_zoom",
-      "TYPE" : "float",
-      "MAX" : 1.5,
-      "DEFAULT" : 1,
-      "MIN" : 1
-    },
-    {
-      "NAME" : "center",
-      "TYPE" : "point2D",
-      "MAX" : [
-        1,
-        1
-      ],
-      "DEFAULT" : [
-        0.5,
-        0.5
-      ],
-      "MIN" : [
-        0,
-        0
-      ]
-    }
-  ],
-  "CREDIT" : "by toneburst"
-}
-*/
-
-void main() {
-	vec2		loc;
-	vec2		modifiedCenter;
-	
-	loc = isf_FragNormCoord;
-	modifiedCenter = center;
-	
-	vec2 locR = (loc - modifiedCenter)*(1.0/(red_zoom*master_zoom)) + modifiedCenter;
-	vec2 locG = (loc - modifiedCenter)*(1.0/(green_zoom*master_zoom)) + modifiedCenter;
-	vec2 locB = (loc - modifiedCenter)*(1.0/(blue_zoom*master_zoom)) + modifiedCenter;
-	
-	vec4 outPix;
-	outPix.r = IMG_NORM_PIXEL(inputImage,locR).r;
-	outPix.g = IMG_NORM_PIXEL(inputImage,locG).g;
-	outPix.b = IMG_NORM_PIXEL(inputImage,locB).b;
-
-	loc.x = (loc.x - modifiedCenter.x)*(1.0/master_zoom) + modifiedCenter.x;
-	loc.y = (loc.y - modifiedCenter.y)*(1.0/master_zoom) + modifiedCenter.y;
-	
-	outPix.a = IMG_NORM_PIXEL(inputImage,loc).a;
-	gl_FragColor = outPix;
-}
diff --git a/nannou_isf/test_files/Circle Crop.fs b/nannou_isf/test_files/Circle Crop.fs
deleted file mode 100644
index e0f5fec32..000000000
--- a/nannou_isf/test_files/Circle Crop.fs	
+++ /dev/null
@@ -1,70 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Wipe"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/CircleCrop.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0,
-                0,
-                1
-            ],
-            "NAME": "bgcolor",
-            "TYPE": "color"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// License: MIT
-// Author: fkuteken
-// ported by gre from https://gist.github.com/fkuteken/f63e3009c1143950dee9063c3b83fb88
-
-float ratio = RENDERSIZE.x/RENDERSIZE.y;
-vec2 ratio2 = vec2(1.0, 1.0 / ratio);
-float s = pow(2.0 * abs(progress - 0.5), 3.0);
-
-vec4 transition(vec2 p) {
-  float dist = length((vec2(p) - 0.5) * ratio2);
-  return mix(
-    progress < 0.5 ? getFromColor(p) : getToColor(p), // branching is ok here as we statically depend on progress uniform (branching won't change over pixels)
-    bgcolor,
-    step(s, dist)
-  );
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Circle Open.fs b/nannou_isf/test_files/Circle Open.fs
deleted file mode 100644
index 6c9145074..000000000
--- a/nannou_isf/test_files/Circle Open.fs	
+++ /dev/null
@@ -1,67 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Wipe"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/circleopen.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.3,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "smoothness",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": true,
-            "NAME": "opening",
-            "TYPE": "bool"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// author: gre
-// License: MIT
-
-const vec2 center = vec2(0.5, 0.5);
-const float SQRT_2 = 1.414213562373;
-
-vec4 transition (vec2 uv) {
-  float x = opening ? progress : 1.-progress;
-  float m = smoothstep(-smoothness, 0.0, SQRT_2*distance(center, uv) - x*(1.+smoothness));
-  return mix(getFromColor(uv), getToColor(uv), opening ? 1.-m : m);
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Circle Splash Distortion.fs b/nannou_isf/test_files/Circle Splash Distortion.fs
deleted file mode 100644
index beb4366f2..000000000
--- a/nannou_isf/test_files/Circle Splash Distortion.fs	
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Distortion Effect"
-  ],
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "NAME" : "inputImage",
-      "TYPE" : "image"
-    },
-    {
-      "NAME" : "radius",
-      "TYPE" : "float",
-      "MAX" : 0.75,
-      "DEFAULT" : 0.125,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "streaks",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "center",
-      "TYPE" : "point2D",
-      "MAX" : [
-        1,
-        1
-      ],
-      "DEFAULT" : [
-        0.5,
-        0.5
-      ],
-      "MIN" : [
-        0,
-        0
-      ]
-    }
-  ],
-  "CREDIT" : "by VIDVOX"
-}
-*/
-
-
-
-
-//	Pretty simple – if we're inside the radius, draw as normal
-//	If we're outside the circle grab the last color along the angle
-
-#ifndef GL_ES
-float distance (vec2 inCenter, vec2 pt)
-{
-	float tmp = pow(inCenter.x-pt.x,2.0)+pow(inCenter.y-pt.y,2.0);
-	return pow(tmp,0.5);
-}
-#endif
-
-void main() {
-	vec2 uv = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	vec2 texSize = RENDERSIZE;
-	vec2 tc = uv * texSize;
-	vec2 tc2 = uv * texSize;
-	vec2 modifiedCenter = center * texSize;
-	float r = distance(modifiedCenter, tc);
-	float render_length = length(RENDERSIZE);
-	float a = atan ((tc.y-modifiedCenter.y),(tc.x-modifiedCenter.x));
-	float radius_sized = clamp(radius * render_length, 1.0, render_length);
-	
-	tc -= modifiedCenter;
-	tc2 -= modifiedCenter;
-
-	if (r < radius_sized) 	{
-		tc.x = r * cos(a);
-		tc.y = r * sin(a);
-		tc2 = tc;
-	}
-	else	{
-		tc.x = radius_sized * cos(a);
-		tc.y = radius_sized * sin(a);
-		tc2.x = (radius_sized + streaks * render_length) * cos(a);
-		tc2.y = (radius_sized + streaks * render_length) * sin(a); 
-	}
-	tc += modifiedCenter;
-	tc2 += modifiedCenter;
-	vec2 loc = tc / texSize;
-
-	if ((loc.x < 0.0)||(loc.y < 0.0)||(loc.x > 1.0)||(loc.y > 1.0))	{
-		gl_FragColor = vec4(0.0);
-	}
-	else	{
-		vec4 result = IMG_NORM_PIXEL(inputImage, loc);
-		if (streaks > 0.0)	{
-			vec2 loc2 = tc2 / texSize;
-			vec4 mixColor = IMG_NORM_PIXEL(inputImage, loc2);
-			result = mix(result, mixColor, clamp(2.0*((r - radius_sized)/(render_length))*streaks,0.0,1.0));
-		}
-		gl_FragColor = result;
-	}
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Circle Trails.fs b/nannou_isf/test_files/Circle Trails.fs
deleted file mode 100644
index 3d70ad2de..000000000
--- a/nannou_isf/test_files/Circle Trails.fs	
+++ /dev/null
@@ -1,160 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Drawing"
-    ],
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "DEFAULT": [
-                0,
-                0
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "pointInput",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": [
-                0.9596965909004211,
-                0.5817266273340564,
-                0.17662368847084817,
-                1
-            ],
-            "NAME": "startColor",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": [
-                0.9623754620552063,
-                0.9023552320837249,
-                0.28796788144265206,
-                1
-            ],
-            "NAME": "endColor",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": 0.1,
-            "MAX": 0.5,
-            "MIN": 0,
-            "NAME": "startSize",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 0.5,
-            "MIN": 0,
-            "NAME": "endSize",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 16,
-            "MAX": 32,
-            "MIN": 1,
-            "NAME": "trailCount",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 0.1,
-            "MIN": 0,
-            "NAME": "strokeSize",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0,
-                0,
-                1
-            ],
-            "NAME": "strokeColor",
-            "TYPE": "color"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "HEIGHT": "1",
-            "PERSISTENT": true,
-            "TARGET": "pointsBuffer",
-            "WIDTH": "$trailCount"
-        },
-        {
-            "DESCRIPTION": "this empty pass is rendered at the same rez as whatever you are running the ISF filter at- the previous step rendered an image at one-sixteenth the res, so this step ensures that the output is full-size"
-        }
-    ],
-    "VSN": ""
-}
-*/
-
-float drawCircle(vec2 pt, vec2 circlePosition, float circleSize){
-    if (distance(pt, circlePosition)<circleSize){
-        return distance(pt, circlePosition) / circleSize;
-    }
-    return 0.0;
-}
-
-void main()	{
-	vec4		returnMe = vec4(0.0);
-	
-	if (PASSINDEX == 0)	{
-		vec2	loc = isf_FragNormCoord.xy;
-		float	val = 1.0 / floor(trailCount);
-		if (loc.x < val)	{
-			returnMe = vec4(pointInput.x,pointInput.y,1.0,1.0);
-		}
-		else	{
-			loc.x = loc.x - val;
-			returnMe = IMG_NORM_PIXEL(pointsBuffer,loc);
-		}
-	}
-	else if (PASSINDEX == 1)	{
-		float	inCircle = 0.0;
-		float	aspectRatio = RENDERSIZE.x / RENDERSIZE.y;
-		vec2	loc = isf_FragNormCoord * aspectRatio;
-		float	trailFloor = floor(trailCount);
-		int 	j = 0;
-		float	val = 1.0 / (trailFloor-1.0);
-		
-		for (int i = 0;i < 32;++i)	{
-			
-			float	cSize = mix(startSize,endSize,float(i)/trailFloor);
-			vec2	pos = vec2(float(i)*val,0.5);
-			vec4	ptInfo = IMG_NORM_PIXEL(pointsBuffer,pos);
-			if (ptInfo.g > 0.0)
-				inCircle += drawCircle(loc,ptInfo.xy*aspectRatio,cSize);
-			
-			if (inCircle > 0.0)	{
-				//inCircle = 1.0;
-				j = i;
-				break;
-			}
-			
-			if (i == int(trailCount))	{
-				j = i;
-				break;
-			}
-			
-		}
-		
-		if (inCircle > 0.0)	{
-			returnMe = mix(startColor,endColor,float(j)/floor(trailCount));
-			
-			if ((strokeSize > 0.0)&&(inCircle > 1.0 - strokeSize))	{
-				returnMe = strokeColor;
-			}
-			
-		}
-		
-	}
-
-	gl_FragColor = returnMe;
-}
diff --git a/nannou_isf/test_files/Circle Warp.fs b/nannou_isf/test_files/Circle Warp.fs
deleted file mode 100644
index 9462fa5b8..000000000
--- a/nannou_isf/test_files/Circle Warp.fs	
+++ /dev/null
@@ -1,78 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion Effect"
-    ],
-    "CREDIT": "VIDVOX",
-    "DESCRIPTION": "Warps an image to fit in a circle by fitting the height of the image to the height of a circle",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 0.5,
-            "MIN": 0,
-            "NAME": "radius",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 2,
-            "MIN": 0,
-            "NAME": "width",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "resultRotation",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-const float pi = 3.1415926535897932384626433832795;
-
-vec2 rotatePointNorm(vec2 pt, float rot)	{
-	vec2 returnMe = pt;
-
-	float r = distance(vec2(0.50), returnMe);
-	float a = atan((returnMe.y-0.5),(returnMe.x-0.5));
-
-	returnMe.x = r * cos(a + 2.0 * pi * rot - pi) + 0.5;
-	returnMe.y = r * sin(a + 2.0 * pi * rot - pi) + 0.5;
-	
-	returnMe = returnMe;
-	
-	return returnMe;
-}
-
-void main()	{
-	vec4		inputPixelColor;
-	vec2		pt = isf_FragNormCoord;
-	vec2		ct = vec2(0.5,0.5);
-	
-	pt -= ct;
-	pt.x /= width;
-	pt += ct;
-	
-	pt = mix(vec2((pt.x*RENDERSIZE.x/RENDERSIZE.y)-(RENDERSIZE.x*.5-RENDERSIZE.y*.5)/RENDERSIZE.y,pt.y), 
-				vec2(pt.x,pt.y*(RENDERSIZE.y/RENDERSIZE.x)-(RENDERSIZE.y*.5-RENDERSIZE.x*.5)/RENDERSIZE.x), 
-				step(RENDERSIZE.x,RENDERSIZE.y));
-	pt = rotatePointNorm(pt,resultRotation+0.5);
-	if (distance(pt,ct) < radius)	{
-		float		a = (atan(ct.y-pt.y,ct.x-pt.x) + pi) / (2.0*pi);
-		//inputPixelColor = IMG_NORM_PIXEL(inputImage,pt);
-		pt.y -= 0.5;
-		pt.y /= 2.0*sqrt(pow(radius,2.0)-pow((pt.x-0.5),2.0));
-		pt.y += 0.5;
-		inputPixelColor = IMG_NORM_PIXEL(inputImage,pt);
-	}
-	
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/Circle Wrap Distortion.fs b/nannou_isf/test_files/Circle Wrap Distortion.fs
deleted file mode 100644
index 56b750783..000000000
--- a/nannou_isf/test_files/Circle Wrap Distortion.fs	
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Distortion Effect"
-  ],
-  "DESCRIPTION" : "Wraps the video into a circular shape",
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "NAME" : "inputImage",
-      "TYPE" : "image"
-    },
-    {
-      "NAME" : "inputAngle",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0.5,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "inputRadius",
-      "TYPE" : "float",
-      "MAX" : 2,
-      "DEFAULT" : 1,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "inputCenter",
-      "TYPE" : "point2D",
-      "MAX" : [
-        1,
-        1
-      ],
-      "DEFAULT" : [
-        0.5,
-        0.5
-      ],
-      "MIN" : [
-        0,
-        0
-      ]
-    },
-    {
-      "NAME" : "mirror",
-      "TYPE" : "bool",
-      "DEFAULT" : false
-    },
-    {
-      "NAME" : "correctAspect",
-      "TYPE" : "bool",
-      "DEFAULT" : true
-    }
-  ],
-  "CREDIT" : "VIDVOX"
-}
-*/
-
-
-const float tau = 6.28318530718;
-const float pi = 3.14159265359;
-const float halfpi = 1.57079632679;
-
-
-void main()	{
-	vec4		inputPixelColor;
-	if (inputRadius > 0.0)	{
-	
-		vec2		loc = isf_FragNormCoord.xy;
-		vec2		center = inputCenter;
-	
-		//	account for aspect ratio so we stay circle
-		if (correctAspect)	{
-			loc.x = loc.x * RENDERSIZE.x/RENDERSIZE.y;
-			center.x = center.x * RENDERSIZE.x/RENDERSIZE.y;
-		}
-		//	translate from polar coords back to cart for this point
-		//		the effect translates (x,y) to (r,theta)
-		float		r = distance(loc,center);
-		float		theta = (inputAngle * tau + pi + atan(loc.x-center.x,loc.y-center.y))/tau;
-		
-		theta = mod(theta, 1.0);
-	
-		//loc = vec2((r * 2.0)/inputRadius, theta / pi);
-		loc = vec2(theta, (r * 2.0)/inputRadius);
-		
-		if ((loc.x < 0.0)||(loc.x > 1.0)||(loc.y < 0.0)||(loc.y > 1.0))
-			inputPixelColor = vec4(0.0);
-		else	{
-			loc.y = 1.0 - loc.y;
-			if (mirror)	{
-				loc.x = (loc.x < 0.5) ? loc.x * 2.0 : 2.0 - loc.x * 2.0;
-			}
-			inputPixelColor = IMG_NORM_PIXEL(inputImage, loc);
-		}
-	}
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/Circle.fs b/nannou_isf/test_files/Circle.fs
deleted file mode 100644
index 33928f39d..000000000
--- a/nannou_isf/test_files/Circle.fs
+++ /dev/null
@@ -1,87 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Wipe"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/circle.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0,
-                0,
-                1
-            ],
-            "NAME": "backColor",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": [
-                0.5,
-                0.5
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "center",
-            "TYPE": "point2D"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: Fernando Kuteken
-// License: MIT
-
-
-vec4 transition (vec2 uv) {
-  
-  float distance = length(uv - center);
-  float radius = sqrt(8.0) * abs(progress - 0.5);
-  
-  if (distance > radius) {
-    return backColor;
-  }
-  else {
-    if (progress < 0.5) return getFromColor(uv);
-    else return getToColor(uv);
-  }
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Circular Feedback Mask.fs b/nannou_isf/test_files/Circular Feedback Mask.fs
deleted file mode 100644
index baab2494e..000000000
--- a/nannou_isf/test_files/Circular Feedback Mask.fs	
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Feedback"
-  ],
-  "DESCRIPTION" : "",
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "NAME" : "inputImage",
-      "TYPE" : "image"
-    },
-    {
-      "NAME" : "maskRadius",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0.25,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "feedbackRate",
-      "TYPE" : "float",
-      "MAX" : 16,
-      "DEFAULT" : 1,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "twirlAmount",
-      "TYPE" : "float",
-      "MAX" : 0.25,
-      "DEFAULT" : 0,
-      "MIN" : -0.25
-    },
-    {
-      "NAME" : "fadeRate",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "centerFeedback",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "feedbackCenter",
-      "TYPE" : "point2D",
-      "MAX" : [
-        1,
-        1
-      ],
-      "DEFAULT" : [
-        0.5,
-        0.5
-      ],
-      "MIN" : [
-        0,
-        0
-      ]
-    },
-    {
-      "LABELS" : [
-        "Mask",
-        "CenteredMask",
-        "Scaled",
-        "Wrap",
-        "MirrorWrap",
-        "InvertedMask"
-      ],
-      "NAME" : "styleMode",
-      "TYPE" : "long",
-      "DEFAULT" : 2,
-      "VALUES" : [
-        0,
-        1,
-        2,
-        3,
-        4,
-        5
-      ]
-    },
-    {
-      "NAME" : "clearBuffer",
-      "TYPE" : "event"
-    }
-  ],
-  "PASSES" : [
-    {
-      "TARGET" : "feedbackBuffer",
-      "PERSISTENT" : true
-    }
-  ],
-  "CREDIT" : "VIDVOX"
-}
-*/
-
-const float pi = 3.1415926535897932384626433832795;
-const float tau =  6.2831853071795864769252867665590;
-
-
-void main()	{
-	vec4		inputPixelColor = vec4(0.0);
-	vec2		loc = gl_FragCoord.xy;
-	vec2		locCenter = feedbackCenter * RENDERSIZE;
-	float		scaledRadius = maskRadius * min(RENDERSIZE.x,RENDERSIZE.y);
-	float		dist = distance(locCenter,loc);
-	bool		invertMask = (styleMode == 5);
-	//	if within the shape, just do the shape
-	if (((dist>scaledRadius)&&(invertMask))||((dist<scaledRadius)&&(invertMask==false)))	{
-		if (styleMode == 1)	{
-			loc -= (locCenter-RENDERSIZE/2.0);
-		}
-		else if (styleMode == 2)	{
-			loc -= (locCenter-RENDERSIZE/2.0);
-			loc -= RENDERSIZE/2.0;
-			loc /= (2.0 * maskRadius);
-			loc += RENDERSIZE/2.0;
-		}
-		else if (styleMode == 3)	{
-			float	r = distance(locCenter,loc);
-			float 	a = atan((loc.y-locCenter.y),(loc.x-locCenter.x));	
-			a = (a + pi)/(tau);
-			a = mod(a+0.75,1.0);
-			r /= scaledRadius;
-			loc = RENDERSIZE * vec2(a,r);
-		}
-		else if (styleMode == 4)	{
-			float	r = distance(locCenter,loc);
-			float 	a = atan((loc.y-locCenter.y),(loc.x-locCenter.x));	
-			a = (a + pi)/(tau);
-			a = mod(a+0.75,1.0);
-			a = (a < 0.5) ? a * 2.0 : 2.0 - a * 2.0;
-			r /= scaledRadius;
-			loc = RENDERSIZE * vec2(a,r);
-		}
-		inputPixelColor = IMG_PIXEL(inputImage,loc);
-		if ((centerFeedback > 0.0)&&(clearBuffer == false))	{
-			inputPixelColor = mix(inputPixelColor,IMG_THIS_PIXEL(feedbackBuffer),centerFeedback);	
-		}
-		//inputPixelColor = vec4(loc.x,loc.y,0.0,1.0);
-	}
-	else if (clearBuffer == false)	{
-		//float	r = distance(RENDERSIZE/2.0,loc);
-		float 	a = atan((loc.y-locCenter.y),(loc.x-locCenter.x));
-		float	shiftAmount = -1.0 * feedbackRate;
-		vec2	shift = shiftAmount * vec2(cos(a + twirlAmount * tau), sin(a + twirlAmount * tau));
-		loc = (invertMask) ? loc - shift : loc + shift;
-		inputPixelColor = IMG_PIXEL(feedbackBuffer,loc);
-		inputPixelColor.a -= fadeRate / 50.0;
-		//inputPixelColor = vec4((a+pi)/(2.0*pi),2.0*r/RENDERSIZE.x,0.0,1.0);
-		//inputPixelColor = vec4(shift.x*2.0-1.0,shift.y*2.0-1.0,0.0,1.0);
-	}
-	
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/Circular Screen.fs b/nannou_isf/test_files/Circular Screen.fs
deleted file mode 100644
index f295b3459..000000000
--- a/nannou_isf/test_files/Circular Screen.fs	
+++ /dev/null
@@ -1,111 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Halftone Effect"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 10,
-            "MIN": 0,
-            "NAME": "sharpness",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "offset",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 2,
-            "MIN": 0,
-            "NAME": "scale",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "colorize",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0.5,
-                0.5
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "center",
-            "TYPE": "point2D"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-in vec2 left_coord;
-in vec2 right_coord;
-in vec2 above_coord;
-in vec2 below_coord;
-
-in vec2 lefta_coord;
-in vec2 righta_coord;
-in vec2 leftb_coord;
-in vec2 rightb_coord;
-#endif
-
-const float tau = 6.28318530718;
-
-float pattern() {
-	float s = 0.0;
-	float c = 1.0;
-	vec2 tex = isf_FragNormCoord * RENDERSIZE;
-	vec2 point = vec2( c * tex.x - s * tex.y, s * tex.x + c * tex.y );
-	float d = distance(point, center*RENDERSIZE) * max(scale,0.001);
-	return ( sin(d + offset * tau) ) * 4.0;
-}
-
-void main() {
-	vec4 color = IMG_THIS_PIXEL(inputImage);
-	vec4 colorL = IMG_NORM_PIXEL(inputImage, left_coord);
-	vec4 colorR = IMG_NORM_PIXEL(inputImage, right_coord);
-	vec4 colorA = IMG_NORM_PIXEL(inputImage, above_coord);
-	vec4 colorB = IMG_NORM_PIXEL(inputImage, below_coord);
-
-	vec4 colorLA = IMG_NORM_PIXEL(inputImage, lefta_coord);
-	vec4 colorRA = IMG_NORM_PIXEL(inputImage, righta_coord);
-	vec4 colorLB = IMG_NORM_PIXEL(inputImage, leftb_coord);
-	vec4 colorRB = IMG_NORM_PIXEL(inputImage, rightb_coord);
-
-	vec4 final = color + sharpness * (8.0*color - colorL - colorR - colorA - colorB - colorLA - colorRA - colorLB - colorRB);
-	
-	float average = ( final.r + final.g + final.b ) / 3.0;
-	final = vec4( vec3( average * 10.0 - 5.0 + pattern() ), color.a );
-	final = mix (color * final, final, 1.0-colorize);
-	gl_FragColor = final;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Circular Screen.vs b/nannou_isf/test_files/Circular Screen.vs
deleted file mode 100644
index 8f2188f5d..000000000
--- a/nannou_isf/test_files/Circular Screen.vs	
+++ /dev/null
@@ -1,39 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-out vec2 left_coord;
-out vec2 right_coord;
-out vec2 above_coord;
-out vec2 below_coord;
-
-out vec2 lefta_coord;
-out vec2 righta_coord;
-out vec2 leftb_coord;
-out vec2 rightb_coord;
-#endif
-
-
-void main()
-{
-	isf_vertShaderInit();
-	vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	vec2 d = 1.0/RENDERSIZE;
-	
-	left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
-	right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
-	above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
-	below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
-
-	lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
-	righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
-	leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
-	rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/City Lights.fs b/nannou_isf/test_files/City Lights.fs
deleted file mode 100644
index 462d79ad6..000000000
--- a/nannou_isf/test_files/City Lights.fs	
+++ /dev/null
@@ -1,297 +0,0 @@
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Stylize"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "blurAmount",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 12.0,
-			"DEFAULT": 4.0
-		},
-		{
-			"NAME": "intensity",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.5
-		},
-		{
-			"NAME": "edgeIntensity",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 100.0,
-			"DEFAULT": 15.0
-		},
-		{
-			"NAME": "edgeThreshold",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.0
-		},
-		{
-			"NAME": "erodeIntensity",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.25
-		},
-		{
-			"NAME": "erodeRadius",
-			"TYPE": "float",
-			"MIN": 1.0,
-			"MAX": 15.0,
-			"DEFAULT": 1.0
-		}
-	],
-	"PASSES": [
-		{
-			"TARGET": "edges",
-			"DESCRIPTION": "PASSINDEX is 0",
-			"DESCRIPTION": "Pass 0"
-		},
-		{
-			"TARGET": "halfSize",
-			"WIDTH": "floor($WIDTH/2.0)",
-			"HEIGHT": "floor($HEIGHT/2.0)",
-			"DESCRIPTION": "pass 1, 1x horiz sampling (3 wide total) to prevent data loss"
-		},
-		{
-			"TARGET": "quarterSizePassA",
-			"WIDTH": "floor($WIDTH/4.0)",
-			"HEIGHT": "floor($HEIGHT/4.0)",
-			"DESCRIPTION": "pass 2, vert sampling, use erodeRadius (size is being reduced, halve coords deltas when sampling)"
-		},
-		{
-			"TARGET": "quarterSizePassB",
-			"WIDTH": "floor($WIDTH/4.0)",
-			"HEIGHT": "floor($HEIGHT/4.0)",
-			"DESCRIPTION": "pass 3, horiz sampling, use erodeRadius"
-		},
-		{
-			"TARGET": "quarterGaussA",
-			"WIDTH": "floor($WIDTH/4.0)",
-			"HEIGHT": "floor($HEIGHT/4.0)",
-			"DESCRIPTION": "Pass 4"
-		},
-		{
-			"TARGET": "quarterGaussB",
-			"WIDTH": "floor($WIDTH/4.0)",
-			"HEIGHT": "floor($HEIGHT/4.0)",
-			"DESCRIPTION": "Pass 5"
-		},
-		{
-			"TARGET": "fullGaussA",
-			"DESCRIPTION": "Pass 6"
-		},
-		{
-			"TARGET": "fullGaussB",
-			"DESCRIPTION": "Pass 7"
-		}
-	]
-}*/
-
-#if __VERSION__ <= 120
-varying vec2		left_coord;
-varying vec2		right_coord;
-varying vec2		above_coord;
-varying vec2		below_coord;
-
-varying vec2		lefta_coord;
-varying vec2		righta_coord;
-varying vec2		leftb_coord;
-varying vec2		rightb_coord;
-
-varying vec2		texOffsets[5];
-#else
-in vec2		left_coord;
-in vec2		right_coord;
-in vec2		above_coord;
-in vec2		below_coord;
-
-in vec2		lefta_coord;
-in vec2		righta_coord;
-in vec2		leftb_coord;
-in vec2		rightb_coord;
-
-in vec2		texOffsets[5];
-#endif
-
-vec3 rgb2hsv(vec3 c);
-float gray(vec4 n);
-
-
-
-void main() {
-	int			blurLevel = int(floor(blurAmount/6.0));
-	float		blurLevelModulus = mod(blurAmount, 6.0);
-	//	first pass draws edges
-	if (PASSINDEX==0)	{
-		vec4 color = IMG_THIS_PIXEL(inputImage);
-		vec4 colorL = IMG_NORM_PIXEL(inputImage, left_coord);
-		vec4 colorR = IMG_NORM_PIXEL(inputImage, right_coord);
-		vec4 colorA = IMG_NORM_PIXEL(inputImage, above_coord);
-		vec4 colorB = IMG_NORM_PIXEL(inputImage, below_coord);
-	
-		vec4 colorLA = IMG_NORM_PIXEL(inputImage, lefta_coord);
-		vec4 colorRA = IMG_NORM_PIXEL(inputImage, righta_coord);
-		vec4 colorLB = IMG_NORM_PIXEL(inputImage, leftb_coord);
-		vec4 colorRB = IMG_NORM_PIXEL(inputImage, rightb_coord);
-	
-		float gx = (-1.0 * gray(colorLA)) + (-2.0 * gray(colorL)) + (-1.0 * gray(colorLB)) + (1.0 * gray(colorRA)) + (2.0 * gray(colorR)) + (1.0 * gray(colorRB));
-		float gy = (1.0 * gray(colorLA)) + (2.0 * gray(colorA)) + (1.0 * gray(colorRA)) + (-1.0 * gray(colorRB)) + (-2.0 * gray(colorB)) + (-1.0 * gray(colorLB));
-		
-		float bright = pow(gx*gx + gy*gy,0.5);
-		vec4 final = color * bright;
-		
-		//	if the brightness is below the threshold draw black
-		if (bright < edgeThreshold)	{
-			final = vec4(0.0, 0.0, 0.0, 1.0);
-		}
-		else	{
-			final = final * edgeIntensity;
-			final.a = 1.0;
-		}
-		
-		gl_FragColor = final;
-	}
-	//	next three passes are doing an erode.  the first and third are doing horizontal sampling, the second is doing vert sampling
-	else if (PASSINDEX==1 || PASSINDEX==2 || PASSINDEX==3)	{
-		//	generally speaking, sample a bunch of pixels, for each sample convert color val to HSV, if luma is greater than max luma, that's the new color
-		vec2		tmpCoord;
-		float		maxLuma;
-		vec4		maxLumaRGBColor = vec4(0.0);
-		vec4		sampleColorRGB;
-		vec4		sampleColorHSV;
-		vec2		pixelWidth = 1.0/RENDERSIZE.xy;
-		float		localBlurRadius;
-		bool		vertFlag = false;
-		
-		//	pass 0 and 2 are doing horizontal erosion
-		if (PASSINDEX==2)
-			vertFlag = true;
-		//	the first pass should have a blur radius of 1.0 simply to prevent the loss of information while reducing resolution
-		if (PASSINDEX==1)
-			localBlurRadius = 1.0;
-		//	other passes go by the blur radius!
-		else
-			localBlurRadius = float(int(erodeRadius));
-		//	sample pixels as per the blur radius...
-		for (float i=0.; i<=localBlurRadius; ++i)	{
-			if (PASSINDEX==1)	{
-				tmpCoord = vec2(clamp(isf_FragNormCoord.x+(i*pixelWidth.x), 0., 1.), isf_FragNormCoord.y);
-				sampleColorRGB = IMG_NORM_PIXEL(edges, tmpCoord);
-			}
-			else if (PASSINDEX==2)	{
-				tmpCoord = vec2(isf_FragNormCoord.x, clamp(isf_FragNormCoord.y+(i*pixelWidth.y), 0., 1.));
-				sampleColorRGB = IMG_NORM_PIXEL(halfSize, tmpCoord);
-			}
-			else if (PASSINDEX==3)	{
-				tmpCoord = vec2(clamp(isf_FragNormCoord.x+(i*pixelWidth.x), 0., 1.), isf_FragNormCoord.y);
-				sampleColorRGB = IMG_NORM_PIXEL(quarterSizePassA, tmpCoord);
-			}
-			//	if this is the first sample for this fragment, don't bother comparing- just set the max luma stuff
-			if (i == 0.)	{
-				maxLuma = rgb2hsv(sampleColorRGB.rgb).b;
-				maxLumaRGBColor = sampleColorRGB;
-			}
-			//	else this isn't the first sample...
-			else	{
-				//	compare, determine if it's the max luma
-				sampleColorRGB = mix(maxLumaRGBColor, sampleColorRGB, 1.*erodeIntensity/i);
-				sampleColorHSV.rgb = rgb2hsv(sampleColorRGB.rgb);
-				if (sampleColorHSV.b > maxLuma)	{
-					maxLuma = sampleColorHSV.b;
-					maxLumaRGBColor = sampleColorRGB;
-				}
-				//	do another sample for the negative coordinate
-				if (PASSINDEX==1)	{
-					tmpCoord = vec2(clamp(isf_FragNormCoord.x-(i*pixelWidth.x), 0., 1.), isf_FragNormCoord.y);
-					sampleColorRGB = IMG_NORM_PIXEL(edges, tmpCoord);
-				}
-				else if (PASSINDEX==2)	{
-					tmpCoord = vec2(isf_FragNormCoord.x, clamp(isf_FragNormCoord.y-(i*pixelWidth.y), 0., 1.));
-					sampleColorRGB = IMG_NORM_PIXEL(halfSize, tmpCoord);
-				}
-				else if (PASSINDEX==3)	{
-					tmpCoord = vec2(clamp(isf_FragNormCoord.x-(i*pixelWidth.x), 0., 1.), isf_FragNormCoord.y);
-					sampleColorRGB = IMG_NORM_PIXEL(quarterSizePassA, tmpCoord);
-				}
-				sampleColorRGB = mix(maxLumaRGBColor, sampleColorRGB, 1.*erodeIntensity/i);
-				sampleColorHSV.rgb = rgb2hsv(sampleColorRGB.rgb);
-				if (sampleColorHSV.b > maxLuma)	{
-					maxLuma = sampleColorHSV.b;
-					maxLumaRGBColor = sampleColorRGB;
-				}
-			}
-		}
-		gl_FragColor = maxLumaRGBColor;
-		
-	}
-	//	start reading from the previous stage- each two passes completes a gaussian blur, then 
-	//	we increase the resolution & blur (the lower-res blurred image from the previous pass) again...
-	else if (PASSINDEX == 4)	{
-		vec4		sample0 = IMG_NORM_PIXEL(quarterSizePassB,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(quarterSizePassB,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(quarterSizePassB,texOffsets[2]);
-		vec4		sample3 = IMG_NORM_PIXEL(quarterSizePassB,texOffsets[3]);
-		vec4		sample4 = IMG_NORM_PIXEL(quarterSizePassB,texOffsets[4]);
-		//gl_FragColor = vec4((sample0 + sample1 + sample2).rgb / (3.0), 1.0);
-		gl_FragColor = vec4((sample0 + sample1 + sample2 + sample3 + sample4).rgb / (5.0), 1.0);
-	}
-	else if (PASSINDEX == 5)	{
-		vec4		sample0 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[2]);
-		vec4		sample3 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[3]);
-		vec4		sample4 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[4]);
-		//gl_FragColor = vec4((sample0 + sample1 + sample2).rgb / (3.0), 1.0);
-		gl_FragColor = vec4((sample0 + sample1 + sample2 + sample3 + sample4).rgb / (5.0), 1.0);
-	}
-	//	...writes into the full-size
-	else if (PASSINDEX == 6)	{
-		vec4		sample0 = IMG_NORM_PIXEL(quarterGaussB,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(quarterGaussB,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(quarterGaussB,texOffsets[2]);
-		gl_FragColor =  vec4((sample0 + sample1 + sample2).rgb / (3.0), 1.0);
-	}
-	else if (PASSINDEX == 7)	{
-		//	this is the last pass- calculate the blurred image as i have in previous passes, then mix it in with the full-size input image using the blur amount so i get a smooth transition into the blur at low blur levels
-		vec4		sample0 = IMG_NORM_PIXEL(fullGaussA,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(fullGaussA,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(fullGaussA,texOffsets[2]);
-		vec4		blurredImg =  vec4((sample0 + sample1 + sample2).rgb / (3.0), 1.0);
-		vec4		originalImg = IMG_NORM_PIXEL(edges,isf_FragNormCoord);
-		if (blurLevel == 0)
-			blurredImg = mix(originalImg, blurredImg, (blurLevelModulus/6.0));
-		
-		gl_FragColor = max(mix(originalImg,blurredImg*1.9,intensity), originalImg);
-	}
-	
-}
-
-
-
-vec3 rgb2hsv(vec3 c)	{
-	vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-	//vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
-	//vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
-	vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
-	vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
-	
-	float d = q.x - min(q.w, q.y);
-	float e = 1.0e-10;
-	return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
-}
-float gray(vec4 n)
-{
-	return (n.r + n.g + n.b)/3.0;
-}
diff --git a/nannou_isf/test_files/City Lights.vs b/nannou_isf/test_files/City Lights.vs
deleted file mode 100644
index 29a749be5..000000000
--- a/nannou_isf/test_files/City Lights.vs	
+++ /dev/null
@@ -1,105 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2		left_coord;
-varying vec2		right_coord;
-varying vec2		above_coord;
-varying vec2		below_coord;
-
-varying vec2		lefta_coord;
-varying vec2		righta_coord;
-varying vec2		leftb_coord;
-varying vec2		rightb_coord;
-
-varying vec2		texOffsets[5];
-#else
-out vec2		left_coord;
-out vec2		right_coord;
-out vec2		above_coord;
-out vec2		below_coord;
-
-out vec2		lefta_coord;
-out vec2		righta_coord;
-out vec2		leftb_coord;
-out vec2		rightb_coord;
-
-out vec2		texOffsets[5];
-#endif
-
-void main(void)	{
-	//	load the main shader stuff
-	isf_vertShaderInit();
-	
-	
-	int			blurLevel = int(floor(blurAmount/6.0));
-	float		blurLevelModulus = mod(blurAmount, 6.0);
-	float		blurRadius = 0.0;
-	float		blurRadiusInPixels = 0.0;
-	//	first pass draws edges
-	if (PASSINDEX==0)	{
-		vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-		vec2 d = 1.0/RENDERSIZE;
-		
-		left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
-		right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
-		above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
-		below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
-	
-		lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
-		righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
-		leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
-		rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
-	}
-	//	next three passes are just drawing the texture- do nothing
-	
-	//	the next four passes do gaussion blurs on the various levels
-	else if (PASSINDEX==4 || PASSINDEX==6)	{
-		float		pixelWidth = 1.0/RENDERSIZE.x;
-		//	pass 4 is sampling 1/8, but writing to 1/4
-		if (PASSINDEX==4)	{
-			if (blurLevel==1)
-				blurRadius = blurLevelModulus/1.5;
-			else if (blurLevel>1)
-				blurRadius = 4.0;
-		}
-		//	pass 6 is sampling 1/4 and writing to full-size
-		else if (PASSINDEX==6)	{
-			if (blurLevel==0)
-				blurRadius = blurLevelModulus;
-			else if (blurLevel>0)
-				blurRadius = 6.0;
-		}
-		blurRadiusInPixels = pixelWidth * blurRadius;
-		texOffsets[0] = isf_FragNormCoord;
-		texOffsets[1] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0]-blurRadiusInPixels, isf_FragNormCoord[1]),0.0,1.0);
-		texOffsets[2] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0]+blurRadiusInPixels, isf_FragNormCoord[1]),0.0,1.0);
-		if (PASSINDEX==4)	{
-			texOffsets[3] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0]-(2.0*blurRadiusInPixels), isf_FragNormCoord[1]),0.0,1.0);
-			texOffsets[4] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0]+(2.0*blurRadiusInPixels), isf_FragNormCoord[1]),0.0,1.0);
-		}
-	}
-	else if (PASSINDEX==5 || PASSINDEX==7)	{
-		float		pixelHeight = 1.0/RENDERSIZE.y;
-		//	pass 5 is sampling 1/14, but writing to 1/4
-		if (PASSINDEX==5)	{
-			if (blurLevel==1)
-				blurRadius = blurLevelModulus/1.5;
-			else if (blurLevel>1)
-				blurRadius = 4.0;
-		}
-		//	pass 7 is sampling 1/4 and writing to full-size
-		else if (PASSINDEX==7)	{
-			if (blurLevel==0)
-				blurRadius = blurLevelModulus;
-			else if (blurLevel>0)
-				blurRadius = 6.0;
-		}
-		blurRadiusInPixels = pixelHeight * blurRadius;
-		texOffsets[0] = isf_FragNormCoord;
-		texOffsets[1] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]-blurRadiusInPixels),0.0,1.0);
-		texOffsets[2] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]+blurRadiusInPixels),0.0,1.0);
-		if (PASSINDEX==5)	{
-			texOffsets[3] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]-(2.0*blurRadiusInPixels)),0.0,1.0);
-			texOffsets[4] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]+(2.0*blurRadiusInPixels)),0.0,1.0);
-		}
-	}
-	
-}
diff --git a/nannou_isf/test_files/Collage.fs b/nannou_isf/test_files/Collage.fs
deleted file mode 100644
index 1d8ef1210..000000000
--- a/nannou_isf/test_files/Collage.fs
+++ /dev/null
@@ -1,112 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Geometry Adjustment"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0.01,
-            "NAME": "seed",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.125,
-            "MAX": 1,
-            "MIN": 0.01,
-            "NAME": "cell_size",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "NAME": "allow_flips_h",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 0,
-            "NAME": "allow_flips_v",
-            "TYPE": "bool"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-float rand(vec2 co){
-    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-void main()
-{
-// CALCULATE EDGES OF CURRENT CELL
-	//	At 0.0 just do a pass-thru
-	if (cell_size == 0.0)	{
-		gl_FragColor = IMG_THIS_PIXEL(inputImage);
-	}
-		else	{
-		// Position of current pixel
-		vec2 xy; 
-		xy.x = isf_FragNormCoord[0];
-		xy.y = isf_FragNormCoord[1];
-
-
-		// Left and right of tile
-		float CellWidth = cell_size;
-		float CellHeight = cell_size;
-		
-		/*
-		float x1 = floor(xy.x / CellWidth)*CellWidth;
-		float x2 = clamp((ceil(xy.x / CellWidth)*CellWidth), 0.0, 1.0);
-		// Top and bottom of tile
-		float y1 = floor(xy.y / CellHeight)*CellHeight;
-		float y2 = clamp((ceil(xy.y / CellHeight)*CellHeight), 0.0, 1.0);
-		*/
-		
-		//	divide 1 by the cell width and cell height to determine the count
-		float rows = floor(1.0/CellHeight);
-		float cols = floor(1.0/CellWidth);
-		float count = floor(rows * cols);
-		
-		//	figure out the ID # of the region
-		float region = cols*floor(xy.x / CellWidth) + floor(xy.y / CellHeight);
-
-		//	use this to draw the gradient of the regions as gray colors..
-		//gl_FragColor = vec4(vec3(region/count),1.0);
-		
-		//	now translate this region to another random region using our seed and region
-		float translated = clamp(rand(vec2(region/count, seed)),0.0,1.0);
-		//translated = region/count;
-		//gl_FragColor = vec4(vec3(translated),1.0);
-		
-		//	quantize the translated!
-		translated = floor(count * translated);
-		//gl_FragColor = vec4(vec3(translated),1.0);
-		//	now convert the translated region back to an xy location
-		//	get the relative position within the original block and then add on the translated amount
-		xy.x = (xy.x - floor(xy.x / CellWidth)*CellWidth) + CellWidth * floor(translated / rows);
-		//xy.x = (xy.x - floor(xy.x / CellWidth)*CellWidth);
-		xy.y = xy.y - floor(xy.y / CellHeight)*CellHeight + CellHeight * floor(mod(translated , cols));
-		
-		//	lastly if flips are allowed, randomly flip h
-		if (allow_flips_h)	{
-			float flipx = rand(vec2(translated, seed));
-			if (flipx > 0.5)	{
-				xy.x = 1.0-xy.x;
-			}
-		}
-		if (allow_flips_v)	{
-			float flipy = rand(vec2(translated, seed));
-			if (flipy > 0.5)	{
-				xy.y = 1.0-xy.y;
-			}
-		}
-		
-		gl_FragColor = IMG_NORM_PIXEL(inputImage, xy);
-		
-	}
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Color Bars.fs b/nannou_isf/test_files/Color Bars.fs
deleted file mode 100644
index c527d3b7b..000000000
--- a/nannou_isf/test_files/Color Bars.fs	
+++ /dev/null
@@ -1,74 +0,0 @@
-/*{
-	"DESCRIPTION": "",
-	"CREDIT": "VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Utility"
-	],
-	"INPUTS": [
-		{
-			"NAME": "colorShift",
-			"LABEL": "Color Shift",
-			"TYPE": "float",
-			"DEFAULT": 0.0,
-			"MIN": 0.0,
-			"MAX": 1.0
-		}
-	]
-	
-}*/
-
-
-
-
-vec4 colorsArray[9];
-
-
-
-
-void main()	{	
-	vec4		outputPixelColor = vec4(0.0);
-	vec2		loc = isf_FragNormCoord.xy;
-	
-	//	figure out if we are in the top, middle or bottom sections
-	//	these are broken into the ratios 3/4, 1/8, 1/8
-	
-	//	if we are in the top section figure out which of the 9 colors to use
-	if (loc.y > 0.25)	{
-		colorsArray[0] = vec4(0.412, 0.412, 0.412, 1.0);
-		colorsArray[1] = vec4(0.757, 0.757, 0.757, 1.0);
-		colorsArray[2] = vec4(0.757, 0.757, 0.000, 1.0);
-		colorsArray[3] = vec4(0.000, 0.757, 0.757, 1.0);
-		colorsArray[4] = vec4(0.000, 0.757, 0.000, 1.0);
-		colorsArray[5] = vec4(0.757, 0.000, 0.757, 1.0);
-		colorsArray[6] = vec4(0.757, 0.000, 0.000, 1.0);
-		colorsArray[7] = vec4(0.000, 0.000, 0.757, 1.0);
-		colorsArray[8] = vec4(0.412, 0.412, 0.412, 1.0);
-		
-		int		colorIndex = int((9.0 * mod(loc.x + colorShift, 1.0)));
-		
-		outputPixelColor = colorsArray[colorIndex];
-	}
-	//	in the 'middle section we draw the black to white image
-	else if (loc.y > 0.125)	{
-		outputPixelColor.rgb = vec3(loc.x);
-		outputPixelColor.a = 1.0;
-	}
-	else	{
-		colorsArray[0] = vec4(0.169, 0.169, 0.169, 1.0);
-		colorsArray[1] = vec4(0.019, 0.019, 0.019, 1.0);
-		colorsArray[2] = vec4(1.000, 1.000, 1.000, 1.0);
-		colorsArray[3] = vec4(1.000, 1.000, 1.000, 1.0);
-		colorsArray[4] = vec4(0.019, 0.019, 0.019, 1.0);
-		colorsArray[5] = vec4(0.000, 0.000, 0.000, 1.0);
-		colorsArray[6] = vec4(0.019, 0.019, 0.019, 1.0);
-		colorsArray[7] = vec4(0.038, 0.038, 0.038, 1.0);
-		colorsArray[8] = vec4(0.169, 0.169, 0.169, 1.0);
-		
-		int		colorIndex = int((9.0 * loc.x));
-		
-		outputPixelColor = colorsArray[colorIndex];		
-	}
-	
-	gl_FragColor = outputPixelColor;
-}
diff --git a/nannou_isf/test_files/Color Blowout.fs b/nannou_isf/test_files/Color Blowout.fs
deleted file mode 100644
index c279bf355..000000000
--- a/nannou_isf/test_files/Color Blowout.fs	
+++ /dev/null
@@ -1,114 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Color Effect"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": -1,
-            "NAME": "intensity",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "TARGET": "pass1"
-        },
-        {
-            "TARGET": "pass2"
-        },
-        {
-            "TARGET": "pass3"
-        }
-    ]
-}
-*/
-
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-in vec2 left_coord;
-in vec2 right_coord;
-in vec2 above_coord;
-in vec2 below_coord;
-
-in vec2 lefta_coord;
-in vec2 righta_coord;
-in vec2 leftb_coord;
-in vec2 rightb_coord;
-#endif
-
-float gray(vec4 n)
-{
-	return (n.r + n.g + n.b)/3.0;
-}
-
-void main()
-{
-	vec4 final = vec4(0.0);
-	
-	if (PASSINDEX == 0)	{
-		vec4 color = IMG_THIS_PIXEL(inputImage);
-		vec4 colorL = (IMG_NORM_PIXEL(inputImage, left_coord));
-		vec4 colorR = (IMG_NORM_PIXEL(inputImage, right_coord));
-		vec4 colorA = (IMG_NORM_PIXEL(inputImage, above_coord));
-		vec4 colorB = (IMG_NORM_PIXEL(inputImage, below_coord));
-
-		vec4 colorLA = (IMG_NORM_PIXEL(inputImage, lefta_coord));
-		vec4 colorRA = (IMG_NORM_PIXEL(inputImage, righta_coord));
-		vec4 colorLB = (IMG_NORM_PIXEL(inputImage, leftb_coord));
-		vec4 colorRB = (IMG_NORM_PIXEL(inputImage, rightb_coord));
-		
-		final = color - color * intensity * (8.0*gray(color) - colorL - colorR - colorA - colorB - colorLA - colorRA - colorLB - colorRB);
-		final.a = color.a;
-	}
-	else if (PASSINDEX == 1)	{
-		vec4 color = IMG_THIS_PIXEL(pass1);
-		vec4 colorL = (IMG_NORM_PIXEL(pass1, left_coord));
-		vec4 colorR = (IMG_NORM_PIXEL(pass1, right_coord));
-		vec4 colorA = (IMG_NORM_PIXEL(pass1, above_coord));
-		vec4 colorB = (IMG_NORM_PIXEL(pass1, below_coord));
-
-		vec4 colorLA = (IMG_NORM_PIXEL(pass1, lefta_coord));
-		vec4 colorRA = (IMG_NORM_PIXEL(pass1, righta_coord));
-		vec4 colorLB = (IMG_NORM_PIXEL(pass1, leftb_coord));
-		vec4 colorRB = (IMG_NORM_PIXEL(pass1, rightb_coord));
-		
-		final = (1.0 - abs(intensity)) * color + abs(intensity) * (colorL + colorR + colorA + colorB + colorLA + colorRA + colorLB + colorRB) / 8.0;
-		final.a = color.a;
-	}
-	else if (PASSINDEX == 2)	{
-		vec4 color = IMG_THIS_PIXEL(pass2);
-		vec4 colorL = (IMG_NORM_PIXEL(pass2, left_coord));
-		vec4 colorR = (IMG_NORM_PIXEL(pass2, right_coord));
-		vec4 colorA = (IMG_NORM_PIXEL(pass2, above_coord));
-		vec4 colorB = (IMG_NORM_PIXEL(pass2, below_coord));
-
-		vec4 colorLA = (IMG_NORM_PIXEL(pass2, lefta_coord));
-		vec4 colorRA = (IMG_NORM_PIXEL(pass2, righta_coord));
-		vec4 colorLB = (IMG_NORM_PIXEL(pass2, leftb_coord));
-		vec4 colorRB = (IMG_NORM_PIXEL(pass2, rightb_coord));
-		
-		final = color - color * intensity * (8.0*gray(color) - colorL - colorR - colorA - colorB - colorLA - colorRA - colorLB - colorRB);
-		final.a = color.a;
-	}
-	
-	
-	
-	gl_FragColor = final;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Color Blowout.vs b/nannou_isf/test_files/Color Blowout.vs
deleted file mode 100644
index 8f2188f5d..000000000
--- a/nannou_isf/test_files/Color Blowout.vs	
+++ /dev/null
@@ -1,39 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-out vec2 left_coord;
-out vec2 right_coord;
-out vec2 above_coord;
-out vec2 below_coord;
-
-out vec2 lefta_coord;
-out vec2 righta_coord;
-out vec2 leftb_coord;
-out vec2 rightb_coord;
-#endif
-
-
-void main()
-{
-	isf_vertShaderInit();
-	vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	vec2 d = 1.0/RENDERSIZE;
-	
-	left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
-	right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
-	above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
-	below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
-
-	lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
-	righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
-	leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
-	rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Color Controls.fs b/nannou_isf/test_files/Color Controls.fs
deleted file mode 100644
index dd2945df9..000000000
--- a/nannou_isf/test_files/Color Controls.fs	
+++ /dev/null
@@ -1,92 +0,0 @@
-/*{
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Color Adjustment", "Utility"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "bright",
-			"TYPE": "float",
-			"MIN": -1.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.0
-		},
-		{
-			"NAME": "contrast",
-			"TYPE": "float",
-			"MIN": -4.0,
-			"MAX": 4.0,
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "hue",
-			"TYPE": "float",
-			"MIN": -1.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.0
-		},
-		{
-			"NAME": "saturation",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 4.0,
-			"DEFAULT": 1.0
-		}
-	]
-}*/
-
-
-vec3 rgb2hsv(vec3 c);
-vec3 hsv2rgb(vec3 c);
-
-void main() {
-	vec4		tmpColorA = IMG_THIS_PIXEL(inputImage);
-	vec4		tmpColorB;
-	//	bright
-	tmpColorB = tmpColorA + vec4(bright, bright, bright, 0.0);
-	//	contrast
-	tmpColorA.rgb = ((vec3(2.0) * (tmpColorB.rgb - vec3(0.5))) * vec3(contrast) / vec3(2.0)) + vec3(0.5);
-	tmpColorA.a = ((2.0 * (tmpColorB.a - 0.5)) * abs(contrast) / 2.0) + 0.5;
-	
-	//	convert RGB to HSV
-	tmpColorB.xyz = rgb2hsv(clamp(tmpColorA.rgb, 0.0, 1.0));
-	tmpColorB.a = tmpColorA.a;
-	
-	
-	//	hue
-	tmpColorB.x = mod((tmpColorB.x + hue), 1.0);
-	//	saturation
-	tmpColorB.y = tmpColorB.y * saturation;
-	
-	
-	//	convert HSV back to RGB
-	tmpColorA.rgb = hsv2rgb(clamp(tmpColorB.xyz, 0.0, 1.0));
-	tmpColorA.a = tmpColorB.a;
-	
-	
-	gl_FragColor = clamp(tmpColorA, 0.0, 1.0);
-}
-
-
-vec3 rgb2hsv(vec3 c)	{
-	vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-	//vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
-	//vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
-	vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
-	vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
-	
-	float d = q.x - min(q.w, q.y);
-	float e = 1.0e-10;
-	return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
-}
-
-vec3 hsv2rgb(vec3 c)	{
-	vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
-	vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
-	return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
-}
diff --git a/nannou_isf/test_files/Color History.fs b/nannou_isf/test_files/Color History.fs
deleted file mode 100644
index 7d24210f0..000000000
--- a/nannou_isf/test_files/Color History.fs	
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Color"
-  ],
-  "DESCRIPTION" : "Displays Data Over Time",
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "LABELS" : [
-        "Color",
-        "Lines"
-      ],
-      "NAME" : "displayMode",
-      "TYPE" : "long",
-      "DEFAULT" : 0,
-      "VALUES" : [
-        0,
-        1
-      ]
-    },
-    {
-      "NAME" : "data",
-      "TYPE" : "color",
-      "DEFAULT" : [
-        0.95,
-        0.25,
-        0,
-        1
-      ]
-    }
-  ],
-  "PASSES" : [
-    {
-      "PERSISTENT" : true,
-      "WIDTH" : "$WIDTH",
-      "HEIGHT" : "1",
-      "TARGET" : "dataHistory",
-      "FLOAT" : true
-    },
-    {
-
-    }
-  ],
-  "CREDIT" : "VIDVOX"
-}
-*/
-
-void main()	{
-	vec4		inputPixelColor = vec4(0.0);
-	if (PASSINDEX == 0)	{
-		vec2	loc = gl_FragCoord.xy;
-		if (floor(loc.x) == 0.0)	{
-			inputPixelColor = data;
-		}
-		else	{
-			loc.x = loc.x - 1.0;
-			inputPixelColor = IMG_PIXEL(dataHistory,loc);
-		}
-	}
-	else	{
-		vec2	loc = gl_FragCoord.xy;
-		vec4	val = IMG_PIXEL(dataHistory,loc);
-		if (displayMode == 0)	{
-			inputPixelColor = val;
-		}
-		else if (displayMode == 1)	{
-			float	tmp = floor(val.r * RENDERSIZE.y);
-			inputPixelColor.a = val.a;
-			if (floor(loc.y) == tmp)	{
-				inputPixelColor.r = 1.0;
-				inputPixelColor.a = 1.0;
-			}
-			tmp = floor(val.g * RENDERSIZE.y);
-			if (floor(loc.y) == tmp)	{
-				inputPixelColor.g = 1.0;
-				inputPixelColor.a = 1.0;
-			}
-			tmp = floor(val.b * RENDERSIZE.y);
-			if (floor(loc.y) == tmp)	{
-				inputPixelColor.b = 1.0;
-				inputPixelColor.a = 1.0;
-			}
-		}
-		
-	}
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/Color Invert.fs b/nannou_isf/test_files/Color Invert.fs
deleted file mode 100644
index bb6025d35..000000000
--- a/nannou_isf/test_files/Color Invert.fs	
+++ /dev/null
@@ -1,19 +0,0 @@
-/*{
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2",
-	"DESCRIPTION": "Inverts the RGB channels of the input",
-	"CATEGORIES": [
-		"Color Effect", "Utility"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		}
-	]
-}*/
-
-void main() {
-	vec4		srcPixel = IMG_THIS_PIXEL(inputImage);
-	gl_FragColor = vec4(1.0-srcPixel.r, 1.0-srcPixel.g, 1.0-srcPixel.b, srcPixel.a);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Color Levels.fs b/nannou_isf/test_files/Color Levels.fs
deleted file mode 100644
index 928cbc979..000000000
--- a/nannou_isf/test_files/Color Levels.fs	
+++ /dev/null
@@ -1,156 +0,0 @@
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Color Adjustment"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "minLevel",
-			"LABEL": "Minimum Point",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.2
-		},
-		{
-			"NAME": "midLevel",
-			"LABEL": "Mid Point",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.5
-		},
-		{
-			"NAME": "maxLevel",
-			"LABEL": "Maximum Point",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.8
-		},
-		{
-			"NAME": "offset1",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.5,
-				0.5,
-				0.5,
-				0.5
-			]
-		},
-		{
-			"NAME": "offset2",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.5,
-				0.5,
-				0.5,
-				0.5
-			]
-		},
-		{
-			"NAME": "offset3",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.5,
-				0.5,
-				0.5,
-				0.5
-			]
-		},
-		{
-			"NAME": "offset4",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.5,
-				0.5,
-				0.5,
-				0.5
-			]
-		},
-		{
-			"NAME": "offset5",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.5,
-				0.5,
-				0.5,
-				0.5
-			]
-		},
-		{
-			"NAME": "offset6",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.5,
-				0.5,
-				0.5,
-				0.5
-			]
-		},
-		{
-			"NAME": "levelsMode",
-			"LABEL": "Levels Mode",
-			"TYPE": "bool",
-			"DEFAULT": 0.0
-		}
-	]
-}*/
-
-
-
-void main() {
-	vec4		tmpColor = IMG_THIS_PIXEL(inputImage);
-	float brightness = (tmpColor.r + tmpColor.g + tmpColor.b) * tmpColor.a / 3.0;
-	
-	//	all adjustments
-	if (brightness <= minLevel)	{
-		tmpColor = tmpColor + offset1 - 0.5;
-	}
-	else if (brightness <= (minLevel + midLevel)/2.0)	{
-		tmpColor = tmpColor + offset2 - 0.5;
-	}
-	else if (brightness <= midLevel)	{
-		tmpColor = tmpColor + offset3 - 0.5;
-	}
-	else if (brightness <= (maxLevel + midLevel)/2.0)	{
-		tmpColor = tmpColor + offset4 - 0.5;
-	}
-	else if (brightness <= maxLevel)	{
-		tmpColor = tmpColor + offset5 - 0.5;
-	}
-	else	{
-		tmpColor = tmpColor + offset6 - 0.5;
-	}	
-	
-	if (levelsMode)	{
-		//	all adjustments
-		tmpColor.rgb = vec3(1.0);
-		
-		if (brightness <= minLevel)	{
-			tmpColor.a = 0.0;
-		}
-		else if (brightness <= (minLevel + midLevel)/2.0)	{
-			tmpColor.a = 1.0/5.0;
-		}
-		else if (brightness <= midLevel)	{
-			tmpColor.a = 2.0/5.0;
-		}
-		else if (brightness <= (maxLevel + midLevel)/2.0)	{
-			tmpColor.a = 3.0/5.0;
-		}
-		else if (brightness <= maxLevel)	{
-			tmpColor.a = 4.0/5.0;
-		}
-		else	{
-			tmpColor.a = 1.0;
-		}
-	}
-	gl_FragColor = clamp(tmpColor, 0.0, 1.0);
-}
-
diff --git a/nannou_isf/test_files/Color Monochrome.fs b/nannou_isf/test_files/Color Monochrome.fs
deleted file mode 100644
index 0ec0b10e1..000000000
--- a/nannou_isf/test_files/Color Monochrome.fs	
+++ /dev/null
@@ -1,46 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Color Effect",
-        "Retro"
-    ],
-    "CREDIT": "by zoidberg",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "intensity",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0.6,
-                0.45,
-                0.3,
-                1
-            ],
-            "NAME": "color",
-            "TYPE": "color"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-//const vec4		lumcoeff = vec4(0.299, 0.587, 0.114, 0.0);
-const vec4 	lumcoeff = vec4(0.2126, 0.7152, 0.0722, 0.0);
-
-void main() {
-	vec4		srcPixel = IMG_THIS_PIXEL(inputImage);
-	float		luminance = dot(srcPixel,lumcoeff);
-	//float		luminance = (srcPixel.r + srcPixel.g + srcPixel.b)/3.0;
-	vec4		dstPixel = (luminance >= 0.50)
-		? mix(color, vec4(1,1,1,srcPixel.a), (luminance-0.5)*2.0)
-		: mix(vec4(0,0,0,srcPixel.a), color, luminance*2.0);
-	gl_FragColor = mix(srcPixel, dstPixel, intensity);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Color Organ Polyphonic.fs b/nannou_isf/test_files/Color Organ Polyphonic.fs
deleted file mode 100644
index 18730bf17..000000000
--- a/nannou_isf/test_files/Color Organ Polyphonic.fs	
+++ /dev/null
@@ -1,796 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Color"
-  ],
-  "DESCRIPTION" : "",
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "LABELS" : [
-      	"Custom Input",
-        "Newton",
-        "Castel",
-        "Field",
-        "Jameson",
-        "Seemann",
-        "Rimington",
-        "Bishop",
-        "Helmholtz",
-        "Scriabin",
-        "Klein",
-        "Aeppli",
-        "Belmont",
-        "Zieverink"
-      ],
-      "NAME" : "iAuthor",
-      "TYPE" : "long",
-      "LABEL" : "Author",
-      "VALUES" : [
-        0,
-        1,
-        2,
-        3,
-        4,
-        5,
-        6,
-        7,
-        8,
-        9,
-        10,
-        11,
-        12,
-        13
-      ]
-    },
-	{
-		"NAME": "iBaseCustomColor",
-		"TYPE": "color",
-		"DEFAULT": [
-			0.25,
-			0.59,
-			0.9,
-			1.0
-		]
-	},
-	{
-		"NAME": "iColorMode",
-		"TYPE": "long",
-		"VALUES": [
-			0,
-			1,
-			2,
-			3,
-			4,
-			5,
-			6
-		],
-		"LABELS": [
-			"Basic Complementary",
-			"Split Complementary",
-			"Compound Complementary",
-			"Spectrum",
-			"Shades",
-			"Analogous",
-			"Compound Analogous"
-		],
-		"DEFAULT": 0
-	},
-    {
-      "NAME" : "note0",
-      "TYPE" : "bool",
-      "DEFAULT" : 0
-    },
-    {
-      "NAME" : "note1",
-      "TYPE" : "bool",
-      "DEFAULT" : 0
-    },
-    {
-      "NAME" : "note2",
-      "TYPE" : "bool",
-      "DEFAULT" : 0
-    },
-    {
-      "NAME" : "note3",
-      "TYPE" : "bool",
-      "DEFAULT" : 0
-    },
-    {
-      "NAME" : "note4",
-      "TYPE" : "bool",
-      "DEFAULT" : 0
-    },
-    {
-      "NAME" : "note5",
-      "TYPE" : "bool",
-      "DEFAULT" : 0
-    },
-    {
-      "NAME" : "note6",
-      "TYPE" : "bool",
-      "DEFAULT" : 0
-    },
-    {
-      "NAME" : "note7",
-      "TYPE" : "bool",
-      "DEFAULT" : 0
-    },
-    {
-      "NAME" : "note8",
-      "TYPE" : "bool",
-      "DEFAULT" : 0
-    },
-    {
-      "NAME" : "note9",
-      "TYPE" : "bool",
-      "DEFAULT" : 0
-    },
-    {
-      "NAME" : "note10",
-      "TYPE" : "bool",
-      "DEFAULT" : 0
-    },
-    {
-      "NAME" : "note11",
-      "TYPE" : "bool",
-      "DEFAULT" : 0
-    }
-  ],
-  "CREDIT" : "VIDVOX"
-}
-*/
-
-
-/*
-//	Color Scales via http://rhythmiclight.com/archives/ideas/colorscales.html
-C C# D D# E F F# G G# A A# B 
-Newton • red • orange • yellow • green • blue • indigo • violet (Gerstner, p.167)
-Castel • blue • blue-green • green • olive green • yellow • yellow-orange • orange • red • crimson • violet • agate • indigo (Peacock, p.400)
-Field • blue • purple • red • orange • yellow • yellow green • green (Klein, p.69)
-Jameson • red • red-orange • orange • orange-yellow • yellow • green • green-blue • blue • blue-purple • purple • purple-violet • violet (Jameson, p.12)
-Seemann • carmine • scarlet • orange • yellow-orange • yellow • green • green blue • blue • indigo • violet • brown • black (Klein, p.86)
-Rimington • deep red • crimson • orange-crimson • orange • yellow • yellow-green • green • blueish green • blue-green • indigo • deep blue • violet (Peacock, p.402)
-Bishop • red • orange-red or scarlet • orange • gold or yellow-orange • yellow or green-gold • yellow-green • green • greenish-blue or aquamarine • blue • indigo or violet-blue • violet • violet-red • red (Bishop, p.11)
-Helmholtz • yellow • green • greenish blue • cayan-blue • indigo blue • violet • end of red • red • red • red • red orange • orange (Helmholtz, p.22)
-Scriabin • red • violet • yellow • steely with the glint of metal • pearly blue the shimmer of moonshine • dark red • bright blue • rosy orange • purple • green • steely with a glint of metal • pearly blue the shimmer of moonshine (Jones, p.104)
-Klein • dark red • red • red orange • orange • yellow • yellow green • green • blue-green • blue • blue violet • violet • dark violet (Klein, p.209)
-Aeppli • red • orange • yellow • green • blue-green • ultramarine blue • violet • purple (Gerstner, p.169)
-Belmont • red • red-orange • orange • yellow-orange • yellow • yellow-green • green • blue-green • blue • blue-violet • violet • red-violet (Belmont, p.226)
-Zieverink • yellow/green • green • blue/green • blue • indigo • violet • ultra violet • infra red • red • orange • yellow/white • yellow (Cincinnati Contemporary Art Center)
-*/
-
-const vec3 red = vec3(231.0/255.0,52.0/255.0,39.0/255.0);
-const vec3 orange = vec3(234.0/255.0,134.0/255.0,54.0/255.0);
-const vec3 yellow = vec3(245.0/255.0,243.0/255.0,98.0/255.0);
-const vec3 green = vec3(64.0/255.0,141.0/255.0,64.0/255.0);
-const vec3 blue = vec3(25.0/255.0,19.0/255.0,125.0/255.0);
-
-const vec3 indigo = vec3(117.0/255.0,28.0/255.0,120.0/255.0);
-const vec3 violet = vec3(199.0/255.0,49.0/255.0,132.0/255.0);
-
-const vec3 bluegreen = vec3(66.0/255.0,142.0/255.0,129.0/255.0);
-const vec3 olivegreen = vec3(119.0/255.0,144.0/255.0,57.0/255.0);
-const vec3 yelloworange = vec3(240.0/255.0,210.0/255.0,90.0/255.0);
-const vec3 crimson = vec3(148.0/255.0,33.0/255.0,23.0/255.0);
-const vec3 agate = vec3(69.0/255.0,23.0/255.0,120.0/255.0);
-
-const vec3 purple = vec3(117.0/255.0,28.0/255.0,120.0/255.0);
-const vec3 yellowgreen = vec3(119.0/255.0,144.0/255.0,57.0/255.0);
-const vec3 redorange = vec3(227.0/255.0,85.0/255.0,44.0/255.0);
-const vec3 orangeyellow = vec3(240.0/255.0,210.0/255.0,90.0/255.0);
-const vec3 greenblue = vec3(66.0/255.0,142.0/255.0,129.0/255.0);
-const vec3 bluepurple = vec3(69.0/255.0,23.0/255.0,120.0/255.0);
-const vec3 purpleviolet = vec3(153.0/255.0,41.0/255.0,130.0/255.0);
-const vec3 carmine = vec3(98.0/255.0,34.0/255.0,31.0/255.0);
-const vec3 scarlet = vec3(231.0/255.0,52.0/255.0,39.0/255.0);
-const vec3 brown = vec3(98.0/255.0,34.0/255.0,31.0/255.0);
-const vec3 black = vec3(7.0/255.0);
-const vec3 deepred = vec3(231.0/255.0,52.0/255.0,39.0/255.0);
-const vec3 orangecrimson = vec3(227.0/255.0,85.0/255.0,44.0/255.0);
-const vec3 blueishgreen = vec3(79.0/255.0,161.0/255.0,131.0/255.0);
-const vec3 deepblue = vec3(25.0/255.0,19.0/255.0,125.0/255.0);
-
-const vec3 greenishblue = vec3(66.0/255.0,142.0/255.0,129.0/255.0);
-const vec3 violetred = vec3(201.0/255.0,51.0/255.0,83.0/255.0);
-const vec3 darkviolet = vec3(117.0/255.0,28.0/255.0,120.0/255.0);
-const vec3 cayanblue = vec3(45.0/255.0,91.0/255.0,155.0/255.0);
-const vec3 indigoblue = purple;
-
-const vec3 endofred = vec3(145.0/255.0,34.0/255.0,84.0/255.0);
-const vec3 steely = vec3(89.0/255.0,87.0/255.0,130.0/255.0);
-const vec3 pearlyblue = vec3(45.0/255.0,91.0/255.0,155.0/255.0);
-const vec3 darkred = vec3(148.0/255.0,33.0/255.0,23.0/255.0);
-
-const vec3 brightblue = vec3(25.0/255.0,19.0/255.0,125.0/255.0);
-const vec3 rosyorange = vec3(234.0,134.0,54.0);
-const vec3 ultramarineblue = vec3(45.0/255.0,91.0/255.0,155.0/255.0);
-const vec3 blueviolet = vec3(69.0/255.0,23.0/255.0,120.0/255.0);
-
-const vec3 ultraviolet = vec3(102.0/255.0,25.0/255.0,68.0/255.0);
-const vec3 infrared = vec3(148.0/255.0,33.0/255.0,23.0/255.0);
-const vec3 yellowwhite = vec3(238.0/255.0,239.0/255.0,149.0/255.0);
-
-
-vec4 colorForAuthorAndNote(int author, int note)	{
-	vec4	inputPixelColor = vec4(0.0);
-	inputPixelColor.a = 1.0;
-	//	newton
-	if (author == 0)	{
-		if (note == 0)
-			inputPixelColor.rgb = red;
-		else if (note == 1)
-			inputPixelColor.rgb = red;
-		else if (note == 2)
-			inputPixelColor.rgb = orange;
-		else if (note == 3)
-			inputPixelColor.rgb = orange;
-		else if (note == 4)
-			inputPixelColor.rgb = yellow;
-		else if (note == 5)
-			inputPixelColor.rgb = green;
-		else if (note == 6)
-			inputPixelColor.rgb = green;
-		else if (note == 7)
-			inputPixelColor.rgb = blue;
-		else if (note == 8)
-			inputPixelColor.rgb = blue;
-		else if (note == 9)
-			inputPixelColor.rgb = indigo;
-		else if (note == 10)
-			inputPixelColor.rgb = indigo;
-		else if (note == 11)
-			inputPixelColor.rgb = violet;
-	}
-	//	castel
-	else if (author == 1)	{
-		if (note == 0)
-			inputPixelColor.rgb = blue;
-		else if (note == 1)
-			inputPixelColor.rgb = bluegreen;
-		else if (note == 2)
-			inputPixelColor.rgb = green;
-		else if (note == 3)
-			inputPixelColor.rgb = olivegreen;
-		else if (note == 4)
-			inputPixelColor.rgb = yellow;
-		else if (note == 5)
-			inputPixelColor.rgb = yelloworange;
-		else if (note == 6)
-			inputPixelColor.rgb = orange;
-		else if (note == 7)
-			inputPixelColor.rgb = red;
-		else if (note == 8)
-			inputPixelColor.rgb = crimson;
-		else if (note == 9)
-			inputPixelColor.rgb = violet;
-		else if (note == 10)
-			inputPixelColor.rgb = agate;
-		else if (note == 11)
-			inputPixelColor.rgb = indigo;
-	}
-	//	field
-	else if (author == 2)	{
-		if (note == 0)
-			inputPixelColor.rgb = blue;
-		else if (note == 1)
-			inputPixelColor.rgb = blue;
-		else if (note == 2)
-			inputPixelColor.rgb = purple;
-		else if (note == 3)
-			inputPixelColor.rgb = purple;
-		else if (note == 4)
-			inputPixelColor.rgb = red;
-		else if (note == 5)
-			inputPixelColor.rgb = orange;
-		else if (note == 6)
-			inputPixelColor.rgb = orange;
-		else if (note == 7)
-			inputPixelColor.rgb = yellow;
-		else if (note == 8)
-			inputPixelColor.rgb = yellow;
-		else if (note == 9)
-			inputPixelColor.rgb = yellowgreen;
-		else if (note == 10)
-			inputPixelColor.rgb = yellowgreen;
-		else if (note == 11)
-			inputPixelColor.rgb = green;
-	}
-	//	jameson
-	else if (author == 3)	{
-		if (note == 0)
-			inputPixelColor.rgb = red;
-		else if (note == 1)
-			inputPixelColor.rgb = redorange;
-		else if (note == 2)
-			inputPixelColor.rgb = orange;
-		else if (note == 3)
-			inputPixelColor.rgb = orangeyellow;
-		else if (note == 4)
-			inputPixelColor.rgb = yellow;
-		else if (note == 5)
-			inputPixelColor.rgb = green;
-		else if (note == 6)
-			inputPixelColor.rgb = greenblue;
-		else if (note == 7)
-			inputPixelColor.rgb = blue;
-		else if (note == 8)
-			inputPixelColor.rgb = bluepurple;
-		else if (note == 9)
-			inputPixelColor.rgb = purple;
-		else if (note == 10)
-			inputPixelColor.rgb = purpleviolet;
-		else if (note == 11)
-			inputPixelColor.rgb = violet;
-	}
-	//	seemann
-	else if (author == 4)	{
-		if (note == 0)
-			inputPixelColor.rgb = carmine;
-		else if (note == 1)
-			inputPixelColor.rgb = scarlet;
-		else if (note == 2)
-			inputPixelColor.rgb = orange;
-		else if (note == 3)
-			inputPixelColor.rgb = yelloworange;
-		else if (note == 4)
-			inputPixelColor.rgb = yellow;
-		else if (note == 5)
-			inputPixelColor.rgb = green;
-		else if (note == 6)
-			inputPixelColor.rgb = greenblue;
-		else if (note == 7)
-			inputPixelColor.rgb = blue;
-		else if (note == 8)
-			inputPixelColor.rgb = indigo;
-		else if (note == 9)
-			inputPixelColor.rgb = violet;
-		else if (note == 10)
-			inputPixelColor.rgb = brown;
-		else if (note == 11)
-			inputPixelColor.rgb = black;
-	}
-	//	rimington
-	else if (author == 5)	{
-		if (note == 0)
-			inputPixelColor.rgb = deepred;
-		else if (note == 1)
-			inputPixelColor.rgb = crimson;
-		else if (note == 2)
-			inputPixelColor.rgb = orangecrimson;
-		else if (note == 3)
-			inputPixelColor.rgb = orange;
-		else if (note == 4)
-			inputPixelColor.rgb = yellow;
-		else if (note == 5)
-			inputPixelColor.rgb = yellowgreen;
-		else if (note == 6)
-			inputPixelColor.rgb = green;
-		else if (note == 7)
-			inputPixelColor.rgb = blueishgreen;
-		else if (note == 8)
-			inputPixelColor.rgb = bluegreen;
-		else if (note == 9)
-			inputPixelColor.rgb = indigo;
-		else if (note == 10)
-			inputPixelColor.rgb = deepblue;
-		else if (note == 11)
-			inputPixelColor.rgb = violet;
-	}
-	//	bishop
-	else if (author == 6)	{
-		if (note == 0)
-			inputPixelColor.rgb = red;
-		else if (note == 1)
-			inputPixelColor.rgb = scarlet;
-		else if (note == 2)
-			inputPixelColor.rgb = orange;
-		else if (note == 3)
-			inputPixelColor.rgb = yelloworange;
-		else if (note == 4)
-			inputPixelColor.rgb = yellow;
-		else if (note == 5)
-			inputPixelColor.rgb = yellowgreen;
-		else if (note == 6)
-			inputPixelColor.rgb = green;
-		else if (note == 7)
-			inputPixelColor.rgb = greenishblue;
-		else if (note == 8)
-			inputPixelColor.rgb = blue;
-		else if (note == 9)
-			inputPixelColor.rgb = indigo;
-		else if (note == 10)
-			inputPixelColor.rgb = violet;
-		else if (note == 11)
-			inputPixelColor.rgb = violetred;
-	}
-	//	helmholtz
-	else if (author == 7)	{
-		if (note == 0)
-			inputPixelColor.rgb = yellow;
-		else if (note == 1)
-			inputPixelColor.rgb = green;
-		else if (note == 2)
-			inputPixelColor.rgb = greenishblue;
-		else if (note == 3)
-			inputPixelColor.rgb = cayanblue;
-		else if (note == 4)
-			inputPixelColor.rgb = indigoblue;
-		else if (note == 5)
-			inputPixelColor.rgb = violet;
-		else if (note == 6)
-			inputPixelColor.rgb = endofred;
-		else if (note == 7)
-			inputPixelColor.rgb = red;
-		else if (note == 8)
-			inputPixelColor.rgb = red;
-		else if (note == 9)
-			inputPixelColor.rgb = red;
-		else if (note == 10)
-			inputPixelColor.rgb = redorange;
-		else if (note == 11)
-			inputPixelColor.rgb = orange;
-	}
-	//	scriabin
-	else if (author == 8)	{
-		if (note == 0)
-			inputPixelColor.rgb = red;
-		else if (note == 1)
-			inputPixelColor.rgb = violet;
-		else if (note == 2)
-			inputPixelColor.rgb = yellow;
-		else if (note == 3)
-			inputPixelColor.rgb = steely;
-		else if (note == 4)
-			inputPixelColor.rgb = pearlyblue;
-		else if (note == 5)
-			inputPixelColor.rgb = darkred;
-		else if (note == 6)
-			inputPixelColor.rgb = brightblue;
-		else if (note == 7)
-			inputPixelColor.rgb = rosyorange;
-		else if (note == 8)
-			inputPixelColor.rgb = purple;
-		else if (note == 9)
-			inputPixelColor.rgb = green;
-		else if (note == 10)
-			inputPixelColor.rgb = steely;
-		else if (note == 11)
-			inputPixelColor.rgb = pearlyblue;
-	}
-	//	klein
-	else if (author == 9)	{
-		if (note == 0)
-			inputPixelColor.rgb = darkred;
-		else if (note == 1)
-			inputPixelColor.rgb = red;
-		else if (note == 2)
-			inputPixelColor.rgb = redorange;
-		else if (note == 3)
-			inputPixelColor.rgb = orange;
-		else if (note == 4)
-			inputPixelColor.rgb = yellow;
-		else if (note == 5)
-			inputPixelColor.rgb = yellowgreen;
-		else if (note == 6)
-			inputPixelColor.rgb = green;
-		else if (note == 7)
-			inputPixelColor.rgb = bluegreen;
-		else if (note == 8)
-			inputPixelColor.rgb = blue;
-		else if (note == 9)
-			inputPixelColor.rgb = blueviolet;
-		else if (note == 10)
-			inputPixelColor.rgb = violet;
-		else if (note == 11)
-			inputPixelColor.rgb = darkviolet;
-	}
-	//	aeppli
-	else if (author == 10)	{
-		if (note == 0)
-			inputPixelColor.rgb = red;
-		else if (note == 1)
-			inputPixelColor.rgb = red;
-		else if (note == 2)
-			inputPixelColor.rgb = orange;
-		else if (note == 3)
-			inputPixelColor.rgb = orange;
-		else if (note == 4)
-			inputPixelColor.rgb = yellow;
-		else if (note == 5)
-			inputPixelColor.rgb = yellow;
-		else if (note == 6)
-			inputPixelColor.rgb = green;
-		else if (note == 7)
-			inputPixelColor.rgb = bluegreen;
-		else if (note == 8)
-			inputPixelColor.rgb = bluegreen;
-		else if (note == 9)
-			inputPixelColor.rgb = ultramarineblue;
-		else if (note == 10)
-			inputPixelColor.rgb = violet;
-		else if (note == 11)
-			inputPixelColor.rgb = purple;
-	}
-	//	belmont
-	else if (author == 11)	{
-		if (note == 0)
-			inputPixelColor.rgb = red;
-		else if (note == 1)
-			inputPixelColor.rgb = redorange;
-		else if (note == 2)
-			inputPixelColor.rgb = orange;
-		else if (note == 3)
-			inputPixelColor.rgb = yelloworange;
-		else if (note == 4)
-			inputPixelColor.rgb = yellow;
-		else if (note == 5)
-			inputPixelColor.rgb = yellowgreen;
-		else if (note == 6)
-			inputPixelColor.rgb = green;
-		else if (note == 7)
-			inputPixelColor.rgb = bluegreen;
-		else if (note == 8)
-			inputPixelColor.rgb = blue;
-		else if (note == 9)
-			inputPixelColor.rgb = blueviolet;
-		else if (note == 10)
-			inputPixelColor.rgb = violet;
-		else if (note == 11)
-			inputPixelColor.rgb = violetred;
-	}
-	//	zieverink
-	else if (author == 12)	{
-		if (note == 0)
-			inputPixelColor.rgb = yellowgreen;
-		else if (note == 1)
-			inputPixelColor.rgb = green;
-		else if (note == 2)
-			inputPixelColor.rgb = bluegreen;
-		else if (note == 3)
-			inputPixelColor.rgb = blue;
-		else if (note == 4)
-			inputPixelColor.rgb = indigo;
-		else if (note == 5)
-			inputPixelColor.rgb = violet;
-		else if (note == 6)
-			inputPixelColor.rgb = ultraviolet;
-		else if (note == 7)
-			inputPixelColor.rgb = infrared;
-		else if (note == 8)
-			inputPixelColor.rgb = red;
-		else if (note == 9)
-			inputPixelColor.rgb = orange;
-		else if (note == 10)
-			inputPixelColor.rgb = yellowwhite;
-		else if (note == 11)
-			inputPixelColor.rgb = yellow;
-	}
-	return inputPixelColor;
-}
-
-vec3 rgb2hsv(vec3 c)	{
-	vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-	//vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
-	//vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
-	vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
-	vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
-	
-	float d = q.x - min(q.w, q.y);
-	float e = 1.0e-10;
-	return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
-}
-
-vec3 hsv2rgb(vec3 c)	{
-	vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
-	vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
-	return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
-}
-
-vec4 relatedColorForMode(vec4 inColor, int colorMode, float index, int colorCount)	{
-	vec3		outColor = rgb2hsv(inColor.rgb);
-	float		variation = 0.3236;	//	1/5 the golden ratio
-	
-	//	Basic complimentary – saturation and brightness variations on two fixed 180 degree opposite hues
-	if (colorMode == 0)	{
-		if (mod(index, 2.0) >= 1.0)	{
-			outColor.r = outColor.r + 0.5;
-			outColor.r = outColor.r - floor(outColor.r);
-		}
-		
-		outColor.g = outColor.g - variation * floor(index / 2.0);
-		
-		if (outColor.g < 0.1)	{
-			outColor.g = outColor.g + variation * floor(index / 2.0);
-			outColor.g = outColor.g - floor(outColor.g);
-		}
-		
-		outColor.b = outColor.b - variation * floor(index / 4.0);
-		if (outColor.b < 0.2)	{
-			outColor.b = outColor.b + variation * floor(index / 4.0);
-			outColor.b = outColor.b - floor(outColor.b);
-		}
-	}
-	//	Split complimentary – saturation and brightness variations on a 3 fixed 120 degree hues
-	else if (colorMode == 1)	{
-		float divisor = 3.0;
-		float ratio = 0.45;
-		if (mod(index, 3.0) >= 2.0)	{
-			outColor.r = outColor.r - ratio;
-		}
-		else if (mod(index, 3.0) >= 1.0)	{
-			outColor.r = outColor.r + ratio;
-		}
-		
-		//outColor.g = outColor.g + variation * floor(index / divisor);
-		
-		if (mod(index, 5.0) >= 3.0)	{
-			outColor.g = outColor.g - variation;
-			outColor.g = outColor.g - floor(outColor.g);
-		}
-		outColor.b = outColor.b - variation * floor(index / (divisor));
-		if (outColor.b < 0.1)	{
-			outColor.b = outColor.b + variation * floor(index / (divisor));
-			outColor.b = outColor.b - floor(outColor.b);
-		}
-	}
-	//	Compound complimentary – a combination of shades, complimentary and analogous colors with slight shifts
-	else if (colorMode == 2)	{
-		if (mod(index, 3.0) >= 2.0)	{
-			outColor.r = outColor.r + 0.5;
-			outColor.r = outColor.r + variation * index * 1.0 / float(colorCount - 1) / 4.0;
-		}
-		else	{
-			outColor.r = outColor.r + variation * index * 1.0 / float(colorCount - 1);
-		}
-		outColor.r = outColor.r - floor(outColor.r);
-		
-		
-		if (mod(index, 2.0) >= 1.0)	{
-			outColor.g = outColor.g + index * variation / 2.0;
-		}
-		else if (mod(index, 3.0) >= 2.0)	{
-			outColor.g = outColor.g - variation / 2.0;
-		}
-		else	{
-			outColor.g = outColor.g - index * variation / float(colorCount - 1);
-		}
-		if (outColor.g > 1.0)	{
-			outColor.g = outColor.g - floor(outColor.g);
-		}
-	}
-	//	Spectrum – hue shifts based on number of colors with minor saturation shifts
-	else if (colorMode == 3)	{
-		outColor.r = outColor.r + index * 1.0 / float(colorCount);
-		if (mod(index, 3.0) >= 2.0)	{
-			outColor.g = outColor.g - variation / 2.0;
-			outColor.g = outColor.g - floor(outColor.g);
-		}
-		else if (mod(index, 4.0) >= 3.0)	{
-			outColor.g = outColor.g + variation / 2.0;
-			//outColor.g = outColor.g - floor(outColor.g);
-		}
-	}
-	//	Shades – saturation and brightness variations on a single fixed hue
-	else if (colorMode == 4)	{
-		if (mod(index, 2.0) >= 1.0)	{
-			outColor.b = outColor.b - (index * variation) / float(colorCount-1);
-		}
-		else	{
-			outColor.b = outColor.b + (index * variation) / float(colorCount-1);
-			outColor.b = outColor.b - floor(outColor.b);
-		}
-		if (outColor.b < 0.075)	{
-			outColor.b = 1.0 - outColor.b * variation;
-		}
-		
-		if (mod(index, 3.0) >= 2.0)	{
-			outColor.g = outColor.g - (index * variation) / 2.0;
-		}
-		else if (mod(index, 4.0) >= 3.0)	{
-			outColor.g = outColor.g + (index * variation) / 2.0;
-		}
-		
-		if ((outColor.g > 1.0) || (outColor.g < 0.05))	{
-			outColor.g = outColor.g - floor(outColor.g);
-		}
-	}
-	//	Analogous – small hue and saturation shifts 
-	else if (colorMode == 5)	{
-
-		outColor.r = outColor.r + variation * index * 1.0 / float(colorCount - 1); 		
-
-		if (mod(index, 3.0) >= 1.0)	{
-			outColor.g = outColor.g - variation / 2.0;
-			if (outColor.g < 0.0)	{
-				outColor.g = outColor.g + variation / 2.0;
-			}
-			if (outColor.g > 1.0)	{
-				outColor.g = outColor.g - floor(outColor.g);
-			}
-		}
-	}
-	//	Compound Analogous – similar to analogous but with negative hue shifts
-	else if (colorMode == 6)	{
-		if (mod(index, 3.0) >= 1.0)	{
-			outColor.r = outColor.r + variation * index * 1.0 / float(colorCount - 1); 
-		}
-		else	{
-			outColor.r = outColor.r - variation * index * 0.5 / float(colorCount - 1);	
-		}
-		if (mod(index, 3.0) >= 1.0)	{
-			outColor.g = outColor.g - variation / 2.0;
-			if (outColor.g < 0.0)	{
-				outColor.g = outColor.g + variation / 2.0;
-			}
-			if (outColor.g > 1.0)	{
-				outColor.g = outColor.g - floor(outColor.g);
-			}
-		}	
-	}
-	
-	return vec4(hsv2rgb(outColor.rgb),inColor.a);
-}
-
-void main()	{
-	vec4		inputPixelColor = vec4(0.0);
-	vec4		colorsArray[12];
-	int			colorsCount = 0;
-	
-	//	how many colors are active?
-	if (note0)	{
-		colorsArray[colorsCount] = (iAuthor == 0) ? relatedColorForMode(iBaseCustomColor,iColorMode,0.0,12) : colorForAuthorAndNote(iAuthor-1,0);
-		++colorsCount;
-	}
-	if (note1)	{
-		colorsArray[colorsCount] = (iAuthor == 0) ? relatedColorForMode(iBaseCustomColor,iColorMode,1.0,12) : colorForAuthorAndNote(iAuthor-1,1);
-		++colorsCount;
-	}
-	if (note2)	{
-		colorsArray[colorsCount] = (iAuthor == 0) ? relatedColorForMode(iBaseCustomColor,iColorMode,2.0,12) :  colorForAuthorAndNote(iAuthor-1,2);
-		++colorsCount;
-	}
-	if (note3)	{
-		colorsArray[colorsCount] = (iAuthor == 0) ? relatedColorForMode(iBaseCustomColor,iColorMode,3.0,12) :  colorForAuthorAndNote(iAuthor-1,3);
-		++colorsCount;
-	}
-	if (note4)	{
-		colorsArray[colorsCount] = (iAuthor == 0) ? relatedColorForMode(iBaseCustomColor,iColorMode,4.0,12) :  colorForAuthorAndNote(iAuthor-1,4);
-		++colorsCount;
-	}
-	if (note5)	{
-		colorsArray[colorsCount] = (iAuthor == 0) ? relatedColorForMode(iBaseCustomColor,iColorMode,5.0,12) :  colorForAuthorAndNote(iAuthor-1,5);
-		++colorsCount;
-	}
-	if (note6)	{
-		colorsArray[colorsCount] = (iAuthor == 0) ? relatedColorForMode(iBaseCustomColor,iColorMode,6.0,12) :  colorForAuthorAndNote(iAuthor-1,6);
-		++colorsCount;
-	}
-	if (note7)	{
-		colorsArray[colorsCount] = (iAuthor == 0) ? relatedColorForMode(iBaseCustomColor,iColorMode,7.0,12) :  colorForAuthorAndNote(iAuthor-1,7);
-		++colorsCount;
-	}
-	if (note8)	{
-		colorsArray[colorsCount] = (iAuthor == 0) ? relatedColorForMode(iBaseCustomColor,iColorMode,8.0,12) :  colorForAuthorAndNote(iAuthor-1,8);
-		++colorsCount;
-	}
-	if (note9)	{
-		colorsArray[colorsCount] = (iAuthor == 0) ? relatedColorForMode(iBaseCustomColor,iColorMode,9.0,12) :  colorForAuthorAndNote(iAuthor-1,9);
-		++colorsCount;
-	}
-	if (note10)	{
-		colorsArray[colorsCount] = (iAuthor == 0) ? relatedColorForMode(iBaseCustomColor,iColorMode,10.0,12) :  colorForAuthorAndNote(iAuthor-1,10);
-		++colorsCount;
-	}
-	if (note11)	{
-		colorsArray[colorsCount] = (iAuthor == 0) ? relatedColorForMode(iBaseCustomColor,iColorMode,11.0,12) :  colorForAuthorAndNote(iAuthor-1,11);
-		++colorsCount;
-	}
-	
-	if (colorsCount > 0)	{
-		int		thisIndex = int(isf_FragNormCoord.x * float(colorsCount));
-		inputPixelColor = colorsArray[thisIndex];
-	}
-	
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/Color Phase.fs b/nannou_isf/test_files/Color Phase.fs
deleted file mode 100644
index 61dabc9ed..000000000
--- a/nannou_isf/test_files/Color Phase.fs	
+++ /dev/null
@@ -1,76 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Dissolve"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/colorphase.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0.19607843137254902,
-                0.39215686274509803,
-                0
-            ],
-            "NAME": "fromStep",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": [
-                0.6,
-                0.8,
-                1,
-                1
-            ],
-            "NAME": "toStep",
-            "TYPE": "color"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: gre
-// License: MIT
-
-// Usage: fromStep and toStep must be in [0.0, 1.0] range 
-// and all(fromStep) must be < all(toStep)
-
-
-vec4 transition (vec2 uv) {
-  vec4 a = getFromColor(uv);
-  vec4 b = getToColor(uv);
-  return mix(a, b, smoothstep(fromStep, toStep, vec4(progress)));
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Color Posterize.fs b/nannou_isf/test_files/Color Posterize.fs
deleted file mode 100644
index a76a0925e..000000000
--- a/nannou_isf/test_files/Color Posterize.fs	
+++ /dev/null
@@ -1,32 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Color Effect",
-        "Retro"
-    ],
-    "CREDIT": "by zoidberg",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 30,
-            "MAX": 30,
-            "MIN": 2,
-            "NAME": "levels",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-void main() {
-	//	get the src pixel, convert to HSL, posterize the 'L', convert back to RGB
-	vec4		srcPixel = IMG_THIS_PIXEL(inputImage);
-	vec4		amountPerLevel = vec4(1.0/levels);
-	vec4		numOfLevels = floor(srcPixel/amountPerLevel);
-	vec4		outColor = numOfLevels * (vec4(1.0) / (vec4(levels) - vec4(1.0)));
-	outColor.a = srcPixel.a;
-	gl_FragColor = outColor;
-}
diff --git a/nannou_isf/test_files/Color Relookup.fs b/nannou_isf/test_files/Color Relookup.fs
deleted file mode 100644
index f6d4bb3dc..000000000
--- a/nannou_isf/test_files/Color Relookup.fs	
+++ /dev/null
@@ -1,38 +0,0 @@
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Glitch"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "lookupImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "mix_amount",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.5
-		}
-	]
-}*/
-
-void main() {
-	vec4 thisColor = IMG_THIS_PIXEL(inputImage);
-	vec2 lookupCoord;
-	lookupCoord.x = mix (thisColor.r, thisColor.g, mix_amount);
-	lookupCoord.x = mix (lookupCoord.x, thisColor.b, mix_amount);
-	lookupCoord.x = RENDERSIZE.x * lookupCoord.x / 255.0;
-	
-	lookupCoord.y = mix (thisColor.r, thisColor.g, mix_amount);
-	lookupCoord.y = mix (lookupCoord.y, thisColor.b, mix_amount);
-	lookupCoord.y = RENDERSIZE.y * lookupCoord.y / 255.0;
-	
-	gl_FragColor = IMG_NORM_PIXEL(lookupImage, lookupCoord);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Color Replacement.fs b/nannou_isf/test_files/Color Replacement.fs
deleted file mode 100755
index 6cc1a79e2..000000000
--- a/nannou_isf/test_files/Color Replacement.fs	
+++ /dev/null
@@ -1,364 +0,0 @@
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Color Effect"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"LABEL": "Master Threshold",
-			"NAME": "threshold",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.5
-		},
-		{
-			"LABEL": "Key Color",
-			"NAME": "mask_color",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.24,
-				0.77,
-				0.38,
-				1.0
-			]
-		},
-		{
-			"LABEL": "Target Color",
-			"NAME": "target_color",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.77,
-				0.38,
-				0.24,
-				1.0
-			]
-		},
-		{
-			"LABEL": "HUE- Tol.",
-			"NAME": "hueTol",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 0.25,
-			"DEFAULT": 0.0
-		},
-		{
-			"LABEL": "HUE- Min. Bracket",
-			"NAME": "hueMinBracket",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 0.5,
-			"DEFAULT": 0.25
-		},
-		{
-			"LABEL": "HUE- Max Bracket",
-			"NAME": "hueMaxBracket",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 0.5,
-			"DEFAULT": 0.25
-		},
-		{
-			"LABEL": "SAT- Tol.",
-			"NAME": "satTol",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 0.5,
-			"DEFAULT": 0.0
-		},
-		{
-			"LABEL": "SAT- Min. Bracket",
-			"NAME": "satMinBracket",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.5
-		},
-		{
-			"LABEL": "SAT- Max Bracket",
-			"NAME": "satMaxBracket",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.5
-		},
-		{
-			"LABEL": "VAL- Tol.",
-			"NAME": "valTol",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 0.5,
-			"DEFAULT": 0.0
-		},
-		{
-			"LABEL": "VAL- Min. Bracket",
-			"NAME": "valMinBracket",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.5
-		},
-		{
-			"LABEL": "VAL- Max Bracket",
-			"NAME": "valMaxBracket",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.5
-		},
-		{
-			"LABEL": "Dilate",
-			"NAME": "dilate",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 6.0,
-			"DEFAULT": 0.0
-		},
-		{
-			"LABEL": "Blur",
-			"NAME": "blur",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 6.0,
-			"DEFAULT": 0.0
-		}
-	],
-	"PASSES": [
-		{
-			"TARGET": "alphaPass"
-		},
-		{
-			"TARGET": "horizDilate"
-		},
-		{
-			"TARGET": "vertDilate"
-		},
-		{
-			"TARGET": "horizBlur"
-		},
-		{
-			"TARGET": "vertBlur"
-		}
-	]
-}*/
-
-
-
-vec3 rgb2hsv(vec3 c);
-vec3 hsv2rgb(vec3 c);
-
-void main() {
-	//	generally speaking, sample a bunch of pixels, for each sample convert color val to HSV, if luma is greater than max luma, that's the new color
-	vec2		tmpCoord;
-	float		maxAlpha;
-	vec4		sampleColorRGB;
-	vec4		src_rgb;
-	
-	if (PASSINDEX==0)	{
-		//	the goal is to calculate a new float value for the alpha channel, and/or desaturate the color, if this pixel is "close" to the mask color
-		//	get the src pixel's color (as RGB), convert to HSV values
-		src_rgb = IMG_PIXEL(inputImage, gl_FragCoord.xy);
-		vec3			src_hsl = rgb2hsv(src_rgb.rgb);
-		//	convert the passed color (which is RGB) to HSV values
-		vec3			color_hsl = rgb2hsv(mask_color.rgb);
-		
-		
-/*			-minBracket	-tolerance	color_hsl	+tolerance	+maxBracket
-				|			|			|			|			|			val being examined
-		----------------------------------------------------------------
-				|						|						|			alpha
-				1.0						0.0						1.0									*/
-		
-		
-		float			hueAlpha;
-		float			satAlpha;
-		float			valAlpha;
-		//	use a 'for' loop to generate the hue/sat/val alpha values
-		int			i = 0;
-		float		source;
-		float		color;
-		float		tolerance;
-		vec2		bracket;
-		float		alpha;
-		float		minVal;
-		float		maxVal;
-		for (i=0; i<3; ++i)	{
-			source = src_hsl[i];
-			color = color_hsl[i];
-			if (i==0)	{
-				tolerance = hueTol;
-				bracket = vec2(hueMinBracket, hueMaxBracket);
-			}
-			else if (i==1)	{
-				tolerance = satTol;
-				bracket = vec2(satMinBracket, satMaxBracket);
-			}
-			else if (i==2)	{
-				tolerance = valTol;
-				bracket = vec2(valMinBracket, valMaxBracket);
-			}
-			
-			//	if the source sat is < the mask color sat
-			if (source < color)	{
-				//	the minVal is the bracket and tolerance, the maxVal is the mask color
-				minVal = color - tolerance - bracket.x;
-				maxVal = color;
-				//	as i go from minVal to maxVal, the alpha goes from 1 to 0
-				alpha = 1.0 - smoothstep(minVal, maxVal, source);
-			}
-			//	else if the source sat is > the mask color sat
-			else if (source > color)	{
-				//	the minVal is the mask color, the maxVal is the tolerance and bracket
-				minVal = color;
-				maxVal = color + tolerance + bracket.y;
-				//	as i go from minVal to maxVal, the alpha goes from 0 to 1
-				alpha = smoothstep(minVal, maxVal, source);
-			}
-			//	else the source sat == the mask color sat, the alpha should be 0
-			else
-				alpha = 0.0;
-			
-			if (i==0)	{
-				hueAlpha = alpha;
-			}
-			else if (i==1)	{
-				satAlpha = alpha;
-			}
-			else if (i==2)	{
-				valAlpha = alpha;
-			}
-		}
-		
-		
-		//	calculate the alpha i'll be applying
-		src_rgb.a = sqrt(max(hueAlpha,max(satAlpha, valAlpha)));
-		
-		//	desaturate the color if appropriate, use the desaturated color
-		if (hueAlpha < 1.0)	{
-			//src_hsl.y = 0.0;
-			src_hsl.y = mix(0.0, src_hsl.y, hueAlpha);
-			src_rgb.rgb = hsv2rgb(src_hsl.xyz);
-		}
-		
-		
-		gl_FragColor = src_rgb;
-		//gl_FragColor = vec4(src_rgb.a, src_rgb.a, src_rgb.a, 1.0);
-	}
-	
-	else if (PASSINDEX==1)	{
-		//	'dilate' samples on either side + the source pixel = 2*dilate+1 total samples
-		for (float i=0.; i<=float(int(dilate)); ++i)	{
-			tmpCoord = vec2(clamp(gl_FragCoord.x+i,0.,RENDERSIZE.x), gl_FragCoord.y);
-			sampleColorRGB = IMG_PIXEL(alphaPass, tmpCoord);
-			//	if this is the first sample for this fragment, don't bother comparing- just set the max luma stuff
-			if (i == 0.)	{
-				maxAlpha = sampleColorRGB.a;
-				src_rgb = sampleColorRGB;
-			}
-			//	else this isn't the first sample...
-			else	{
-				//	compare, determine if it's the max luma
-				if (sampleColorRGB.a < maxAlpha)	{
-					maxAlpha = sampleColorRGB.a;
-				}
-				//	do another sample for the negative coordinate
-				tmpCoord = vec2(clamp(gl_FragCoord.x-i,0.,RENDERSIZE.x), gl_FragCoord.y);
-				sampleColorRGB = IMG_PIXEL(alphaPass, tmpCoord);
-				if (sampleColorRGB.a < maxAlpha)	{
-					maxAlpha = sampleColorRGB.a;
-				}
-			}
-		}
-		gl_FragColor = vec4(src_rgb.rgb, maxAlpha);
-	}
-	else if (PASSINDEX==2)	{
-		//	'dilate' samples up and down + the source pixel = 2*dilate+1 total samples
-		for (float i=0.; i<=float(int(dilate)); ++i)	{
-			tmpCoord = vec2(gl_FragCoord.x, clamp(gl_FragCoord.y+i,0.,RENDERSIZE.y));
-			sampleColorRGB = IMG_PIXEL(horizDilate, tmpCoord);
-			//	if this is the first sample for this fragment, don't bother comparing- just set the max luma stuff
-			if (i == 0.)	{
-				maxAlpha = sampleColorRGB.a;
-				src_rgb = sampleColorRGB;
-			}
-			//	else this isn't the first sample...
-			else	{
-				//	compare, determine if it's the max luma
-				if (sampleColorRGB.a < maxAlpha)	{
-					maxAlpha = sampleColorRGB.a;
-				}
-				//	do another sample for the negative coordinate
-				tmpCoord = vec2(gl_FragCoord.x, clamp(gl_FragCoord.y-i,0.,RENDERSIZE.y));
-				sampleColorRGB = IMG_PIXEL(horizDilate, tmpCoord);
-				if (sampleColorRGB.a < maxAlpha)	{
-					maxAlpha = sampleColorRGB.a;
-				}
-			}
-		}
-		gl_FragColor = vec4(src_rgb.rgb, maxAlpha);
-	}
-	else if (PASSINDEX==3)	{
-		float		tmpRadius = float(int(blur));
-		vec4		tmpColor;
-		vec4		srcColor;
-		float		totalAlpha = 0.0;
-		for (float i=-1.*tmpRadius; i<=tmpRadius; ++i)	{
-			tmpColor = IMG_PIXEL(vertDilate, gl_FragCoord.xy+vec2(i,0.0));
-			totalAlpha += tmpColor.a;
-			if (i==0.0)
-				srcColor = tmpColor;
-		}
-		totalAlpha /= ((tmpRadius*2.)+1.);
-		gl_FragColor = vec4(srcColor.r, srcColor.g, srcColor.b, totalAlpha);
-	}
-	else if (PASSINDEX==4)	{
-		float		tmpRadius = float(int(blur));
-		vec4		tmpColor;
-		vec4		srcColor;
-		float		totalAlpha = 0.0;
-		for (float i=-1.*tmpRadius; i<=tmpRadius; ++i)	{
-			tmpColor = IMG_PIXEL(horizBlur, gl_FragCoord.xy+vec2(0.0,i));
-			totalAlpha += tmpColor.a;
-			if (i==0.0)
-				srcColor = tmpColor;
-		}
-		totalAlpha /= ((tmpRadius*2.)+1.);
-		//	if it's above the threshold draw the original
-		if (totalAlpha > threshold)	{
-			gl_FragColor = IMG_PIXEL(inputImage,gl_FragCoord.xy);
-		}
-		//	otherwise replace with a shade of the target_color
-		else	{
-			srcColor = IMG_PIXEL(inputImage,gl_FragCoord.xy);
-			//float gray = (srcColor.r + srcColor.g + srcColor.b) / 3.0;
-			float gray = 1.0 - totalAlpha;
-			gl_FragColor = target_color * vec4(gray, gray, gray, srcColor.a);
-		}
-	}
-}
-
-
-
-
-vec3 rgb2hsv(vec3 c)	{
-	vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-	//vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
-	//vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
-	vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
-	vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
-	
-	float d = q.x - min(q.w, q.y);
-	float e = 1.0e-10;
-	return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
-}
-
-vec3 hsv2rgb(vec3 c)	{
-	vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
-	vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
-	return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Color Scales.fs b/nannou_isf/test_files/Color Scales.fs
deleted file mode 100644
index 5f387fbd9..000000000
--- a/nannou_isf/test_files/Color Scales.fs	
+++ /dev/null
@@ -1,505 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Color"
-  ],
-  "DESCRIPTION" : "",
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "LABELS" : [
-        "Comparison Mode",
-        "Newton",
-        "Castel",
-        "Field",
-        "Jameson",
-        "Seemann",
-        "Rimington",
-        "Bishop",
-        "Helmholtz",
-        "Scriabin",
-        "Klein",
-        "Aeppli",
-        "Belmont",
-        "Zieverink"
-      ],
-      "NAME" : "iAuthor",
-      "TYPE" : "long",
-      "DEFAULT" : 0,
-      "LABEL" : "Author",
-      "VALUES" : [
-        0,
-        1,
-        2,
-        3,
-        4,
-        5,
-        6,
-        7,
-        8,
-        9,
-        10,
-        11,
-        12,
-        13
-      ]
-    },
-    {
-      "NAME" : "iNote",
-      "TYPE" : "float",
-      "MAX" : 11,
-      "DEFAULT" : 0,
-      "MIN" : 0,
-      "LABEL" : "Note"
-    },
-    {
-      "NAME" : "iPreviewMode",
-      "TYPE" : "bool",
-      "DEFAULT" : 0
-    }
-  ],
-  "CREDIT" : "VIDVOX"
-}
-*/
-
-
-/*
-//	Color Scales via http://rhythmiclight.com/archives/ideas/colorscales.html
-C C# D D# E F F# G G# A A# B 
-Newton • red • orange • yellow • green • blue • indigo • violet (Gerstner, p.167)
-Castel • blue • blue-green • green • olive green • yellow • yellow-orange • orange • red • crimson • violet • agate • indigo (Peacock, p.400)
-Field • blue • purple • red • orange • yellow • yellow green • green (Klein, p.69)
-Jameson • red • red-orange • orange • orange-yellow • yellow • green • green-blue • blue • blue-purple • purple • purple-violet • violet (Jameson, p.12)
-Seemann • carmine • scarlet • orange • yellow-orange • yellow • green • green blue • blue • indigo • violet • brown • black (Klein, p.86)
-Rimington • deep red • crimson • orange-crimson • orange • yellow • yellow-green • green • blueish green • blue-green • indigo • deep blue • violet (Peacock, p.402)
-Bishop • red • orange-red or scarlet • orange • gold or yellow-orange • yellow or green-gold • yellow-green • green • greenish-blue or aquamarine • blue • indigo or violet-blue • violet • violet-red • red (Bishop, p.11)
-Helmholtz • yellow • green • greenish blue • cayan-blue • indigo blue • violet • end of red • red • red • red • red orange • orange (Helmholtz, p.22)
-Scriabin • red • violet • yellow • steely with the glint of metal • pearly blue the shimmer of moonshine • dark red • bright blue • rosy orange • purple • green • steely with a glint of metal • pearly blue the shimmer of moonshine (Jones, p.104)
-Klein • dark red • red • red orange • orange • yellow • yellow green • green • blue-green • blue • blue violet • violet • dark violet (Klein, p.209)
-Aeppli • red • orange • yellow • green • blue-green • ultramarine blue • violet • purple (Gerstner, p.169)
-Belmont • red • red-orange • orange • yellow-orange • yellow • yellow-green • green • blue-green • blue • blue-violet • violet • red-violet (Belmont, p.226)
-Zieverink • yellow/green • green • blue/green • blue • indigo • violet • ultra violet • infra red • red • orange • yellow/white • yellow (Cincinnati Contemporary Art Center)
-*/
-
-const vec3 red = vec3(231.0/255.0,52.0/255.0,39.0/255.0);
-const vec3 orange = vec3(234.0/255.0,134.0/255.0,54.0/255.0);
-const vec3 yellow = vec3(245.0/255.0,243.0/255.0,98.0/255.0);
-const vec3 green = vec3(64.0/255.0,141.0/255.0,64.0/255.0);
-const vec3 blue = vec3(25.0/255.0,19.0/255.0,125.0/255.0);
-
-const vec3 indigo = vec3(117.0/255.0,28.0/255.0,120.0/255.0);
-const vec3 violet = vec3(199.0/255.0,49.0/255.0,132.0/255.0);
-
-const vec3 bluegreen = vec3(66.0/255.0,142.0/255.0,129.0/255.0);
-const vec3 olivegreen = vec3(119.0/255.0,144.0/255.0,57.0/255.0);
-const vec3 yelloworange = vec3(240.0/255.0,210.0/255.0,90.0/255.0);
-const vec3 crimson = vec3(148.0/255.0,33.0/255.0,23.0/255.0);
-const vec3 agate = vec3(69.0/255.0,23.0/255.0,120.0/255.0);
-
-const vec3 purple = vec3(117.0/255.0,28.0/255.0,120.0/255.0);
-const vec3 yellowgreen = vec3(119.0/255.0,144.0/255.0,57.0/255.0);
-const vec3 redorange = vec3(227.0/255.0,85.0/255.0,44.0/255.0);
-const vec3 orangeyellow = vec3(240.0/255.0,210.0/255.0,90.0/255.0);
-const vec3 greenblue = vec3(66.0/255.0,142.0/255.0,129.0/255.0);
-const vec3 bluepurple = vec3(69.0/255.0,23.0/255.0,120.0/255.0);
-const vec3 purpleviolet = vec3(153.0/255.0,41.0/255.0,130.0/255.0);
-const vec3 carmine = vec3(98.0/255.0,34.0/255.0,31.0/255.0);
-const vec3 scarlet = vec3(231.0/255.0,52.0/255.0,39.0/255.0);
-const vec3 brown = vec3(98.0/255.0,34.0/255.0,31.0/255.0);
-const vec3 black = vec3(7.0/255.0);
-const vec3 deepred = vec3(231.0/255.0,52.0/255.0,39.0/255.0);
-const vec3 orangecrimson = vec3(227.0/255.0,85.0/255.0,44.0/255.0);
-const vec3 blueishgreen = vec3(79.0/255.0,161.0/255.0,131.0/255.0);
-const vec3 deepblue = vec3(25.0/255.0,19.0/255.0,125.0/255.0);
-
-const vec3 greenishblue = vec3(66.0/255.0,142.0/255.0,129.0/255.0);
-const vec3 violetred = vec3(201.0/255.0,51.0/255.0,83.0/255.0);
-const vec3 darkviolet = vec3(117.0/255.0,28.0/255.0,120.0/255.0);
-const vec3 cayanblue = vec3(45.0/255.0,91.0/255.0,155.0/255.0);
-const vec3 indigoblue = purple;
-
-const vec3 endofred = vec3(145.0/255.0,34.0/255.0,84.0/255.0);
-const vec3 steely = vec3(89.0/255.0,87.0/255.0,130.0/255.0);
-const vec3 pearlyblue = vec3(45.0/255.0,91.0/255.0,155.0/255.0);
-const vec3 darkred = vec3(148.0/255.0,33.0/255.0,23.0/255.0);
-
-const vec3 brightblue = vec3(25.0/255.0,19.0/255.0,125.0/255.0);
-const vec3 rosyorange = vec3(234.0,134.0,54.0);
-const vec3 ultramarineblue = vec3(45.0/255.0,91.0/255.0,155.0/255.0);
-const vec3 blueviolet = vec3(69.0/255.0,23.0/255.0,120.0/255.0);
-
-const vec3 ultraviolet = vec3(102.0/255.0,25.0/255.0,68.0/255.0);
-const vec3 infrared = vec3(148.0/255.0,33.0/255.0,23.0/255.0);
-const vec3 yellowwhite = vec3(238.0/255.0,239.0/255.0,149.0/255.0);
-
-
-vec3 colorForAuthorAndNote(int author, int note)	{
-	vec3	inputPixelColor = vec3(0.0);
-	//	newton
-	if (author == 0)	{
-		if (note == 0)
-			inputPixelColor.rgb = red;
-		else if (note == 1)
-			inputPixelColor.rgb = red;
-		else if (note == 2)
-			inputPixelColor.rgb = orange;
-		else if (note == 3)
-			inputPixelColor.rgb = orange;
-		else if (note == 4)
-			inputPixelColor.rgb = yellow;
-		else if (note == 5)
-			inputPixelColor.rgb = green;
-		else if (note == 6)
-			inputPixelColor.rgb = green;
-		else if (note == 7)
-			inputPixelColor.rgb = blue;
-		else if (note == 8)
-			inputPixelColor.rgb = blue;
-		else if (note == 9)
-			inputPixelColor.rgb = indigo;
-		else if (note == 10)
-			inputPixelColor.rgb = indigo;
-		else if (note == 11)
-			inputPixelColor.rgb = violet;
-	}
-	//	castel
-	else if (author == 1)	{
-		if (note == 0)
-			inputPixelColor.rgb = blue;
-		else if (note == 1)
-			inputPixelColor.rgb = bluegreen;
-		else if (note == 2)
-			inputPixelColor.rgb = green;
-		else if (note == 3)
-			inputPixelColor.rgb = olivegreen;
-		else if (note == 4)
-			inputPixelColor.rgb = yellow;
-		else if (note == 5)
-			inputPixelColor.rgb = yelloworange;
-		else if (note == 6)
-			inputPixelColor.rgb = orange;
-		else if (note == 7)
-			inputPixelColor.rgb = red;
-		else if (note == 8)
-			inputPixelColor.rgb = crimson;
-		else if (note == 9)
-			inputPixelColor.rgb = violet;
-		else if (note == 10)
-			inputPixelColor.rgb = agate;
-		else if (note == 11)
-			inputPixelColor.rgb = indigo;
-	}
-	//	field
-	else if (author == 2)	{
-		if (note == 0)
-			inputPixelColor.rgb = blue;
-		else if (note == 1)
-			inputPixelColor.rgb = blue;
-		else if (note == 2)
-			inputPixelColor.rgb = purple;
-		else if (note == 3)
-			inputPixelColor.rgb = purple;
-		else if (note == 4)
-			inputPixelColor.rgb = red;
-		else if (note == 5)
-			inputPixelColor.rgb = orange;
-		else if (note == 6)
-			inputPixelColor.rgb = orange;
-		else if (note == 7)
-			inputPixelColor.rgb = yellow;
-		else if (note == 8)
-			inputPixelColor.rgb = yellow;
-		else if (note == 9)
-			inputPixelColor.rgb = yellowgreen;
-		else if (note == 10)
-			inputPixelColor.rgb = yellowgreen;
-		else if (note == 11)
-			inputPixelColor.rgb = green;
-	}
-	//	jameson
-	else if (author == 3)	{
-		if (note == 0)
-			inputPixelColor.rgb = red;
-		else if (note == 1)
-			inputPixelColor.rgb = redorange;
-		else if (note == 2)
-			inputPixelColor.rgb = orange;
-		else if (note == 3)
-			inputPixelColor.rgb = orangeyellow;
-		else if (note == 4)
-			inputPixelColor.rgb = yellow;
-		else if (note == 5)
-			inputPixelColor.rgb = green;
-		else if (note == 6)
-			inputPixelColor.rgb = greenblue;
-		else if (note == 7)
-			inputPixelColor.rgb = blue;
-		else if (note == 8)
-			inputPixelColor.rgb = bluepurple;
-		else if (note == 9)
-			inputPixelColor.rgb = purple;
-		else if (note == 10)
-			inputPixelColor.rgb = purpleviolet;
-		else if (note == 11)
-			inputPixelColor.rgb = violet;
-	}
-	//	seemann
-	else if (author == 4)	{
-		if (note == 0)
-			inputPixelColor.rgb = carmine;
-		else if (note == 1)
-			inputPixelColor.rgb = scarlet;
-		else if (note == 2)
-			inputPixelColor.rgb = orange;
-		else if (note == 3)
-			inputPixelColor.rgb = yelloworange;
-		else if (note == 4)
-			inputPixelColor.rgb = yellow;
-		else if (note == 5)
-			inputPixelColor.rgb = green;
-		else if (note == 6)
-			inputPixelColor.rgb = greenblue;
-		else if (note == 7)
-			inputPixelColor.rgb = blue;
-		else if (note == 8)
-			inputPixelColor.rgb = indigo;
-		else if (note == 9)
-			inputPixelColor.rgb = violet;
-		else if (note == 10)
-			inputPixelColor.rgb = brown;
-		else if (note == 11)
-			inputPixelColor.rgb = black;
-	}
-	//	rimington
-	else if (author == 5)	{
-		if (note == 0)
-			inputPixelColor.rgb = deepred;
-		else if (note == 1)
-			inputPixelColor.rgb = crimson;
-		else if (note == 2)
-			inputPixelColor.rgb = orangecrimson;
-		else if (note == 3)
-			inputPixelColor.rgb = orange;
-		else if (note == 4)
-			inputPixelColor.rgb = yellow;
-		else if (note == 5)
-			inputPixelColor.rgb = yellowgreen;
-		else if (note == 6)
-			inputPixelColor.rgb = green;
-		else if (note == 7)
-			inputPixelColor.rgb = blueishgreen;
-		else if (note == 8)
-			inputPixelColor.rgb = bluegreen;
-		else if (note == 9)
-			inputPixelColor.rgb = indigo;
-		else if (note == 10)
-			inputPixelColor.rgb = deepblue;
-		else if (note == 11)
-			inputPixelColor.rgb = violet;
-	}
-	//	bishop
-	else if (author == 6)	{
-		if (note == 0)
-			inputPixelColor.rgb = red;
-		else if (note == 1)
-			inputPixelColor.rgb = scarlet;
-		else if (note == 2)
-			inputPixelColor.rgb = orange;
-		else if (note == 3)
-			inputPixelColor.rgb = yelloworange;
-		else if (note == 4)
-			inputPixelColor.rgb = yellow;
-		else if (note == 5)
-			inputPixelColor.rgb = yellowgreen;
-		else if (note == 6)
-			inputPixelColor.rgb = green;
-		else if (note == 7)
-			inputPixelColor.rgb = greenishblue;
-		else if (note == 8)
-			inputPixelColor.rgb = blue;
-		else if (note == 9)
-			inputPixelColor.rgb = indigo;
-		else if (note == 10)
-			inputPixelColor.rgb = violet;
-		else if (note == 11)
-			inputPixelColor.rgb = violetred;
-	}
-	//	helmholtz
-	else if (author == 7)	{
-		if (note == 0)
-			inputPixelColor.rgb = yellow;
-		else if (note == 1)
-			inputPixelColor.rgb = green;
-		else if (note == 2)
-			inputPixelColor.rgb = greenishblue;
-		else if (note == 3)
-			inputPixelColor.rgb = cayanblue;
-		else if (note == 4)
-			inputPixelColor.rgb = indigoblue;
-		else if (note == 5)
-			inputPixelColor.rgb = violet;
-		else if (note == 6)
-			inputPixelColor.rgb = endofred;
-		else if (note == 7)
-			inputPixelColor.rgb = red;
-		else if (note == 8)
-			inputPixelColor.rgb = red;
-		else if (note == 9)
-			inputPixelColor.rgb = red;
-		else if (note == 10)
-			inputPixelColor.rgb = redorange;
-		else if (note == 11)
-			inputPixelColor.rgb = orange;
-	}
-	//	scriabin
-	else if (author == 8)	{
-		if (note == 0)
-			inputPixelColor.rgb = red;
-		else if (note == 1)
-			inputPixelColor.rgb = violet;
-		else if (note == 2)
-			inputPixelColor.rgb = yellow;
-		else if (note == 3)
-			inputPixelColor.rgb = steely;
-		else if (note == 4)
-			inputPixelColor.rgb = pearlyblue;
-		else if (note == 5)
-			inputPixelColor.rgb = darkred;
-		else if (note == 6)
-			inputPixelColor.rgb = brightblue;
-		else if (note == 7)
-			inputPixelColor.rgb = rosyorange;
-		else if (note == 8)
-			inputPixelColor.rgb = purple;
-		else if (note == 9)
-			inputPixelColor.rgb = green;
-		else if (note == 10)
-			inputPixelColor.rgb = steely;
-		else if (note == 11)
-			inputPixelColor.rgb = pearlyblue;
-	}
-	//	klein
-	else if (author == 9)	{
-		if (note == 0)
-			inputPixelColor.rgb = darkred;
-		else if (note == 1)
-			inputPixelColor.rgb = red;
-		else if (note == 2)
-			inputPixelColor.rgb = redorange;
-		else if (note == 3)
-			inputPixelColor.rgb = orange;
-		else if (note == 4)
-			inputPixelColor.rgb = yellow;
-		else if (note == 5)
-			inputPixelColor.rgb = yellowgreen;
-		else if (note == 6)
-			inputPixelColor.rgb = green;
-		else if (note == 7)
-			inputPixelColor.rgb = bluegreen;
-		else if (note == 8)
-			inputPixelColor.rgb = blue;
-		else if (note == 9)
-			inputPixelColor.rgb = blueviolet;
-		else if (note == 10)
-			inputPixelColor.rgb = violet;
-		else if (note == 11)
-			inputPixelColor.rgb = darkviolet;
-	}
-	//	aeppli
-	else if (author == 10)	{
-		if (note == 0)
-			inputPixelColor.rgb = red;
-		else if (note == 1)
-			inputPixelColor.rgb = red;
-		else if (note == 2)
-			inputPixelColor.rgb = orange;
-		else if (note == 3)
-			inputPixelColor.rgb = orange;
-		else if (note == 4)
-			inputPixelColor.rgb = yellow;
-		else if (note == 5)
-			inputPixelColor.rgb = yellow;
-		else if (note == 6)
-			inputPixelColor.rgb = green;
-		else if (note == 7)
-			inputPixelColor.rgb = bluegreen;
-		else if (note == 8)
-			inputPixelColor.rgb = bluegreen;
-		else if (note == 9)
-			inputPixelColor.rgb = ultramarineblue;
-		else if (note == 10)
-			inputPixelColor.rgb = violet;
-		else if (note == 11)
-			inputPixelColor.rgb = purple;
-	}
-	//	belmont
-	else if (author == 11)	{
-		if (note == 0)
-			inputPixelColor.rgb = red;
-		else if (note == 1)
-			inputPixelColor.rgb = redorange;
-		else if (note == 2)
-			inputPixelColor.rgb = orange;
-		else if (note == 3)
-			inputPixelColor.rgb = yelloworange;
-		else if (note == 4)
-			inputPixelColor.rgb = yellow;
-		else if (note == 5)
-			inputPixelColor.rgb = yellowgreen;
-		else if (note == 6)
-			inputPixelColor.rgb = green;
-		else if (note == 7)
-			inputPixelColor.rgb = bluegreen;
-		else if (note == 8)
-			inputPixelColor.rgb = blue;
-		else if (note == 9)
-			inputPixelColor.rgb = blueviolet;
-		else if (note == 10)
-			inputPixelColor.rgb = violet;
-		else if (note == 11)
-			inputPixelColor.rgb = violetred;
-	}
-	//	zieverink
-	else if (author == 12)	{
-		if (note == 0)
-			inputPixelColor.rgb = yellowgreen;
-		else if (note == 1)
-			inputPixelColor.rgb = green;
-		else if (note == 2)
-			inputPixelColor.rgb = bluegreen;
-		else if (note == 3)
-			inputPixelColor.rgb = blue;
-		else if (note == 4)
-			inputPixelColor.rgb = indigo;
-		else if (note == 5)
-			inputPixelColor.rgb = violet;
-		else if (note == 6)
-			inputPixelColor.rgb = ultraviolet;
-		else if (note == 7)
-			inputPixelColor.rgb = infrared;
-		else if (note == 8)
-			inputPixelColor.rgb = red;
-		else if (note == 9)
-			inputPixelColor.rgb = orange;
-		else if (note == 10)
-			inputPixelColor.rgb = yellowwhite;
-		else if (note == 11)
-			inputPixelColor.rgb = yellow;
-	}
-	return inputPixelColor;
-}
-
-void main()	{
-	vec4		inputPixelColor = vec4(1.0);
-	float		mixPoint = (iPreviewMode) ? 0.0 : fract(iNote);
-	int			note1 = (iPreviewMode) ? int(floor((12.0*isf_FragNormCoord.x))) : int(iNote);
-	int			note2 = (mixPoint == 0.0) ? note1 : note1 + 1;
-	int			author = (iAuthor == 0) ? int(floor((13.0*(1.0-isf_FragNormCoord.y)))) : iAuthor - 1;
-	
-	vec3		c1 = colorForAuthorAndNote(author,note1);
-	vec3		c2 = colorForAuthorAndNote(author,note2);
-	
-	inputPixelColor.rgb = mix(c1,c2,mixPoint);
-	
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/Color Schemes.fs b/nannou_isf/test_files/Color Schemes.fs
deleted file mode 100644
index 5cc8f3881..000000000
--- a/nannou_isf/test_files/Color Schemes.fs	
+++ /dev/null
@@ -1,267 +0,0 @@
-/*{
-	"DESCRIPTION": "Creates variations on a base color using a given algorithm.",
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Color"
-	],
-	"INPUTS": [
-		{
-			"LABEL": "Base Color",
-			"NAME": "baseColor",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.25,
-				0.59,
-				0.9,
-				1.0
-			]
-		},
-		{
-			"LABEL": "Color Mode",
-			"NAME": "colorModeOverride",
-			"TYPE": "long",
-			"VALUES": [
-				0,
-				1,
-				2,
-				3,
-				4,
-				5,
-				6,
-				7
-			],
-			"LABELS": [
-				"Overview",
-				"Basic Complementary",
-				"Split Complementary",
-				"Compound Complementary",
-				"Spectrum",
-				"Shades",
-				"Analogous",
-				"Compound Analogous"
-			],
-			"DEFAULT": 1
-		},
-		{
-			"LABEL": "Color Count",
-			"NAME": "colorCount",
-			"TYPE": "long",
-			"VALUES": [
-				2,
-				3,
-				4,
-				5,
-				6,
-				7,
-				8,
-				9,
-				10,
-				11,
-				12,
-				13,
-				14,
-				15
-			],
-			"LABELS": [
-				"2",
-				"3",
-				"4",
-				"5",
-				"6",
-				"7",
-				"8",
-				"9",
-				"10",
-				"11",
-				"12",
-				"13",
-				"14",
-				"15"
-			],
-			"DEFAULT": 5
-		}
-	]
-}*/
-
-
-
-
-vec3 rgb2hsv(vec3 c)	{
-	vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-	//vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
-	//vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
-	vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
-	vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
-	
-	float d = q.x - min(q.w, q.y);
-	float e = 1.0e-10;
-	return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
-}
-
-vec3 hsv2rgb(vec3 c)	{
-	vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
-	vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
-	return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
-}
-
-
-
-
-void main()
-{
-	vec4		inColor = baseColor;
-	float		index = floor(isf_FragNormCoord.x * float(colorCount));
-	float		variation = 0.3236;	//	1/5 the golden ratio
-	int		colorMode = 0;
-	if (colorModeOverride == 0)	{
-		colorMode = int(floor((1.0-isf_FragNormCoord.y) * 6.99));
-	}
-	else	{
-		colorMode = colorModeOverride - 1;	
-	}
-	
-	inColor.rgb = rgb2hsv(inColor.rgb);
-	
-	vec4		outColor = inColor;
-	
-	//	Basic complimentary – saturation and brightness variations on two fixed 180 degree opposite hues
-	if (colorMode == 0)	{
-		if (mod(index, 2.0) >= 1.0)	{
-			outColor.r = outColor.r + 0.5;
-			outColor.r = outColor.r - floor(outColor.r);
-		}
-		
-		outColor.g = outColor.g - variation * floor(index / 2.0);
-		
-		if (outColor.g < 0.1)	{
-			outColor.g = outColor.g + variation * floor(index / 2.0);
-			outColor.g = outColor.g - floor(outColor.g);
-		}
-		
-		outColor.b = outColor.b - variation * floor(index / 4.0);
-		if (outColor.b < 0.2)	{
-			outColor.b = outColor.b + variation * floor(index / 4.0);
-			outColor.b = outColor.b - floor(outColor.b);
-		}
-	}
-	//	Split complimentary – saturation and brightness variations on a 3 fixed 120 degree hues
-	else if (colorMode == 1)	{
-		float divisor = 3.0;
-		float ratio = 0.45;
-		if (mod(index, 3.0) >= 2.0)	{
-			outColor.r = outColor.r - ratio;
-		}
-		else if (mod(index, 3.0) >= 1.0)	{
-			outColor.r = outColor.r + ratio;
-		}
-		
-		//outColor.g = outColor.g + variation * floor(index / divisor);
-		
-		if (mod(index, 5.0) >= 3.0)	{
-			outColor.g = outColor.g - variation;
-			outColor.g = outColor.g - floor(outColor.g);
-		}
-		outColor.b = outColor.b - variation * floor(index / (divisor));
-		if (outColor.b < 0.1)	{
-			outColor.b = outColor.b + variation * floor(index / (divisor));
-			outColor.b = outColor.b - floor(outColor.b);
-		}
-	}
-	//	Compound complimentary – a combination of shades, complimentary and analogous colors with slight shifts
-	else if (colorMode == 2)	{
-		if (mod(index, 3.0) >= 2.0)	{
-			outColor.r = outColor.r + 0.5;
-			outColor.r = outColor.r + variation * index * 1.0 / float(colorCount - 1) / 4.0;
-		}
-		else	{
-			outColor.r = outColor.r + variation * index * 1.0 / float(colorCount - 1);
-		}
-		outColor.r = outColor.r - floor(outColor.r);
-		
-		
-		if (mod(index, 2.0) >= 1.0)	{
-			outColor.g = outColor.g + index * variation / 2.0;
-		}
-		else if (mod(index, 3.0) >= 2.0)	{
-			outColor.g = outColor.g - variation / 2.0;
-		}
-		else	{
-			outColor.g = outColor.g - index * variation / float(colorCount - 1);
-		}
-		if (outColor.g > 1.0)	{
-			outColor.g = outColor.g - floor(outColor.g);
-		}
-	}
-	//	Spectrum – hue shifts based on number of colors with minor saturation shifts
-	else if (colorMode == 3)	{
-		outColor.r = outColor.r + index * 1.0 / float(colorCount);
-		if (mod(index, 3.0) >= 2.0)	{
-			outColor.g = outColor.g - variation / 2.0;
-			outColor.g = outColor.g - floor(outColor.g);
-		}
-		else if (mod(index, 4.0) >= 3.0)	{
-			outColor.g = outColor.g + variation / 2.0;
-			//outColor.g = outColor.g - floor(outColor.g);
-		}
-	}
-	//	Shades – saturation and brightness variations on a single fixed hue
-	else if (colorMode == 4)	{
-		if (mod(index, 2.0) >= 1.0)	{
-			outColor.b = outColor.b - (index * variation) / float(colorCount-1);
-		}
-		else	{
-			outColor.b = outColor.b + (index * variation) / float(colorCount-1);
-			outColor.b = outColor.b - floor(outColor.b);
-		}
-		if (outColor.b < 0.075)	{
-			outColor.b = 1.0 - outColor.b * variation;
-		}
-		
-		if (mod(index, 3.0) >= 2.0)	{
-			outColor.g = outColor.g - (index * variation) / 2.0;
-		}
-		else if (mod(index, 4.0) >= 3.0)	{
-			outColor.g = outColor.g + (index * variation) / 2.0;
-		}
-		
-		if ((outColor.g > 1.0) || (outColor.g < 0.05))	{
-			outColor.g = outColor.g - floor(outColor.g);
-		}
-	}
-	//	Analogous – small hue and saturation shifts 
-	else if (colorMode == 5)	{
-
-		outColor.r = outColor.r + variation * index * 1.0 / float(colorCount - 1); 		
-
-		if (mod(index, 3.0) >= 1.0)	{
-			outColor.g = outColor.g - variation / 2.0;
-			if (outColor.g < 0.0)	{
-				outColor.g = outColor.g + variation / 2.0;
-			}
-			if (outColor.g > 1.0)	{
-				outColor.g = outColor.g - floor(outColor.g);
-			}
-		}
-	}
-	//	Compound Analogous – similar to analogous but with negative hue shifts
-	else if (colorMode == 6)	{
-		if (mod(index, 3.0) >= 1.0)	{
-			outColor.r = outColor.r + variation * index * 1.0 / float(colorCount - 1); 
-		}
-		else	{
-			outColor.r = outColor.r - variation * index * 0.5 / float(colorCount - 1);	
-		}
-		if (mod(index, 3.0) >= 1.0)	{
-			outColor.g = outColor.g - variation / 2.0;
-			if (outColor.g < 0.0)	{
-				outColor.g = outColor.g + variation / 2.0;
-			}
-			if (outColor.g > 1.0)	{
-				outColor.g = outColor.g - floor(outColor.g);
-			}
-		}	
-	}
-	
-	gl_FragColor = vec4(hsv2rgb(outColor.rgb), inColor.a);
-}
diff --git a/nannou_isf/test_files/Color Test Grid.fs b/nannou_isf/test_files/Color Test Grid.fs
deleted file mode 100644
index 1e24f2066..000000000
--- a/nannou_isf/test_files/Color Test Grid.fs	
+++ /dev/null
@@ -1,88 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Color",
-        "Utility"
-    ],
-    "CREDIT": "VIDVOX",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "DEFAULT": 16,
-            "LABEL": "Grid Columns",
-            "MAX": 32,
-            "MIN": 1,
-            "NAME": "gridCols",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 9,
-            "LABEL": "Grid Rows",
-            "MAX": 32,
-            "MIN": 1,
-            "NAME": "gridRows",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Color Shift",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "colorShift",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Color Range",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "colorRange",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-
-vec3 rgb2hsv(vec3 c)	{
-	vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-	//vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
-	//vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
-	vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
-	vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
-	
-	float d = q.x - min(q.w, q.y);
-	float e = 1.0e-10;
-	return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
-}
-
-vec3 hsv2rgb(vec3 c)	{
-	vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
-	vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
-	return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
-}
-
-
-
-
-void main()	{	
-	vec4		outputPixelColor = vec4(1.0);
-	vec2		loc = isf_FragNormCoord.xy;
-	vec2		gridLoc = loc * vec2(gridCols, gridRows);
-		
-	//	figure out which grid square we are in, normalized, and use it for the hue
-	outputPixelColor.r = (floor(gridLoc.x) + gridCols * floor(mod(gridLoc.y, gridRows))) / (gridCols * gridRows - 1.0);
-	
-	//	scale to the hue range
-	outputPixelColor.r = outputPixelColor.r * colorRange;
-	
-	//	apply the hue shift
-	outputPixelColor.r = mod(outputPixelColor.r + colorShift, 1.0);
-	
-	//	finally convert to RGB
-	outputPixelColor.rgb = hsv2rgb(outputPixelColor.rgb);
-	
-	gl_FragColor = outputPixelColor;
-}
diff --git a/nannou_isf/test_files/Colour Distance.fs b/nannou_isf/test_files/Colour Distance.fs
deleted file mode 100644
index 6b9784684..000000000
--- a/nannou_isf/test_files/Colour Distance.fs	
+++ /dev/null
@@ -1,67 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Dissolve",
-        "Wipe"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/ColourDistance.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 5,
-            "MAX": 10,
-            "MIN": 0,
-            "NAME": "power",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// License: MIT
-// Author: P-Seebauer
-// ported by gre from https://gist.github.com/P-Seebauer/2a5fa2f77c883dd661f9
-
-
-vec4 transition(vec2 p) {
-  vec4 fTex = getFromColor(p);
-  vec4 tTex = getToColor(p);
-  float m = step(distance(fTex, tTex), progress);
-  return mix(
-    mix(fTex, tTex, m),
-    tTex,
-    pow(progress, power)
-  );
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Comet Tails.fs b/nannou_isf/test_files/Comet Tails.fs
deleted file mode 100644
index 26f5990a0..000000000
--- a/nannou_isf/test_files/Comet Tails.fs	
+++ /dev/null
@@ -1,99 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Feedback",
-        "Glitch"
-    ],
-    "CREDIT": "VIDVOX",
-    "DESCRIPTION": "This does a feedback motion blur based on the brightness of pixels to create an analog recording comet trails effect",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "absorptionRate",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.02,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "dischargeRate",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "FLOAT": true,
-            "PERSISTENT": true,
-            "TARGET": "feedbackBuffer"
-        }
-    ]
-}
-*/
-
-
-
-//	Comet Tails is a specific type of Image Lag
-//	From https://bavc.github.io/avaa/artifacts/image_lag.html
-/*
-Image lag occurs in video recorded or displayed using certain types of pick-up devices and cameras, including the Vidicon picture tube, among others.
-This type of camera tube captures light radiating from a scene through a lens and projects it onto a photoconductive target, creating a charge-density pattern which is scanned using low-velocity electrons.
-The resulting image can be amplified and recorded to tape or output to a video monitor.
-The electrical charge remains present on the target until it is re-scanned or the charge dissipates.
-*/
-
-
-
-const vec4  kRGBToYPrime = vec4 (0.299, 0.587, 0.114, 0.0);
-const vec4  kRGBToI     = vec4 (0.596, -0.275, -0.321, 0.0);
-const vec4  kRGBToQ     = vec4 (0.212, -0.523, 0.311, 0.0);
-
-const vec4  kYIQToR   = vec4 (1.0, 0.956, 0.621, 0.0);
-const vec4  kYIQToG   = vec4 (1.0, -0.272, -0.647, 0.0);
-const vec4  kYIQToB   = vec4 (1.0, -1.107, 1.704, 0.0);
-
-
-vec3 rgb2yiq(vec3 c)	{
-    float   YPrime = dot (c, kRGBToYPrime.rgb);
-    float   I = dot (c, kRGBToI.rgb);
-    float   Q = dot (c, kRGBToQ.rgb);
-    return vec3(YPrime,I,Q);
-}
-
-vec3 yiq2rgb(vec3 c)	{
-    vec3    yIQ   = vec3 (c.r, c.g, c.b);
-    return vec3(dot (yIQ, kYIQToR.rgb),dot (yIQ, kYIQToG.rgb),dot (yIQ, kYIQToB.rgb));
-}
-
-
-
-
-void main()
-{
-	vec4		freshPixel = IMG_PIXEL(inputImage,gl_FragCoord.xy);
-	vec4		stalePixel = IMG_PIXEL(feedbackBuffer,gl_FragCoord.xy);
-	//	the input gamma range is 0.0-1.0 (normalized).  the actual gamma range i want to use is 0.0 - 5.0.
-	//	however, actual gamma 0.0-1.0 is just as interesting as actual gamma 1.0-5.0, so we scale the normalized input to match...
-	float		realGamma = (absorptionRate<=0.5) ? (absorptionRate * 2.0) : (((absorptionRate-0.5) * 2.0 * 4.0) + 1.0);
-	vec4		tmpColorA = stalePixel;
-	vec4		tmpColorB;
-	tmpColorB.rgb = pow(tmpColorA.rgb, vec3(1.0/realGamma));
-	tmpColorB.a = tmpColorA.a;
-	
-	float		feedbackLevel = rgb2yiq(tmpColorB.rgb).r;
-	//	if the new pixel is brighter, it immediately fills up the buffer to its level
-	if (rgb2yiq(freshPixel.rgb).r > feedbackLevel)	{
-		feedbackLevel = 0.0;
-	}
-	//	otherwise, discharge
-	else	{
-		feedbackLevel *= (1.0 - dischargeRate);
-	}
-	
-	gl_FragColor = mix(freshPixel,stalePixel,feedbackLevel);
-}
diff --git a/nannou_isf/test_files/Convergence.fs b/nannou_isf/test_files/Convergence.fs
deleted file mode 100644
index b7a4bb144..000000000
--- a/nannou_isf/test_files/Convergence.fs
+++ /dev/null
@@ -1,108 +0,0 @@
-/*{
-	"DESCRIPTION": "",
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Glitch", "Color Effect"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "horizontal_magnitude",
-			"TYPE": "float",
-			"MIN": 0.00,
-			"MAX": 1.0,
-			"DEFAULT": 0.125
-		},
-		{
-			"NAME": "vertical_magnitude",
-			"TYPE": "float",
-			"MIN": 0.00,
-			"MAX": 1.0,
-			"DEFAULT": 0.125
-		},
-		{
-			"NAME": "color_magnitude",
-			"TYPE": "float",
-			"MIN": 0.00,
-			"MAX": 2.0,
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "mode",
-			"VALUES": [
-				0,
-				1,
-				2,
-				3
-			],
-			"LABELS": [
-				"add",
-				"add mod",
-				"multiply",
-				"difference"
-			],
-			"DEFAULT": 0,
-			"TYPE": "long"
-		}
-	]
-	
-}*/
-
-
-
-//	adapted from maxilla inc's https://github.com/maxillacult/ofxPostGlitch/
-
-
-
-float rand(vec2 co){
-    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-
-
-void main()
-{
-	
-	vec2 texCoord = isf_FragNormCoord;
-
-	vec4 col = IMG_NORM_PIXEL(inputImage,texCoord);
-
-	vec4 col_r = vec4(0.0);
-	vec4 col_l = vec4(0.0);
-	vec4 col_g = vec4(0.0);
-
-	vec2 rand_offset = texCoord + vec2((horizontal_magnitude * rand(vec2(TIME,0.213))-horizontal_magnitude/2.0), (vertical_magnitude * rand(vec2(TIME,0.463467))) - vertical_magnitude / 2.0);
-	col_r = IMG_NORM_PIXEL(inputImage,rand_offset);
-	rand_offset = texCoord + vec2((horizontal_magnitude * rand(vec2(TIME,0.5345))-horizontal_magnitude/2.0), (vertical_magnitude * rand(vec2(TIME,0.7875))) - vertical_magnitude / 2.0);
-	col_l = IMG_NORM_PIXEL(inputImage,rand_offset);
-	rand_offset = texCoord + vec2((horizontal_magnitude * rand(vec2(TIME,0.456345))-horizontal_magnitude/2.0), (vertical_magnitude * rand(vec2(TIME,0.9432))) - vertical_magnitude / 2.0);
-	col_g = IMG_NORM_PIXEL(inputImage,rand_offset);
-
-	vec4 color_shift;
-	color_shift.b = color_magnitude*col_r.b*max(1.0,sin(texCoord.y*1.2)*2.5)*rand(vec2(TIME,0.0342));
-	color_shift.r = color_magnitude*col_l.r*max(1.0,sin(texCoord.y*1.2)*2.5)*rand(vec2(TIME,0.5253));
-	color_shift.g = color_magnitude*col_g.g*max(1.0,sin(texCoord.y*1.2)*2.5)*rand(vec2(TIME,0.1943));
-
-	//	if doing add maths
-	if (mode == 0)	{
-		col = col + color_shift;
-	}
-	//	add mod
-	else if (mode == 1)	{
-		col = mod(col + color_shift,1.001);
-	}
-	//	multiply
-	else if (mode == 2)	{
-		col = mix(col, col * (color_magnitude + color_shift),0.9);
-	}
-	// difference
-	else if (mode == 3)	{
-		col = abs(color_shift - col);
-	}
-
-	gl_FragColor = col;
-}
diff --git a/nannou_isf/test_files/Corner Color Tint.fs b/nannou_isf/test_files/Corner Color Tint.fs
deleted file mode 100644
index 550f26a5b..000000000
--- a/nannou_isf/test_files/Corner Color Tint.fs	
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Color Effect"
-  ],
-  "DESCRIPTION" : "Tints the corners of the image in different colors.",
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "NAME" : "inputImage",
-      "TYPE" : "image"
-    },
-    {
-      "NAME" : "color1",
-      "TYPE" : "color",
-      "DEFAULT" : [
-        1,
-        0,
-        0,
-        1
-      ]
-    },
-    {
-      "NAME" : "color2",
-      "TYPE" : "color",
-      "DEFAULT" : [
-        0,
-        1,
-        0,
-        1
-      ]
-    },
-    {
-      "NAME" : "color3",
-      "TYPE" : "color",
-      "DEFAULT" : [
-        0,
-        0,
-        1,
-        1
-      ]
-    },
-    {
-      "NAME" : "color4",
-      "TYPE" : "color",
-      "DEFAULT" : [
-        1,
-        1,
-        1,
-        1
-      ]
-    },
-    {
-      "NAME" : "rotationAngle",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0,
-      "MIN" : 0
-    }
-  ],
-  "CREDIT" : "VIDVOX"
-}
-*/
-
-const float pi = 3.1415926535897932384626433832795;
-
-vec2 rotatePointNorm(vec2 pt, float rot)	{
-	vec2 returnMe = pt;
-
-	float r = distance(vec2(0.50), returnMe);
-	float a = atan((returnMe.y-0.5),(returnMe.x-0.5));
-
-	returnMe.x = r * cos(a + 2.0 * pi * rot - pi) + 0.5;
-	returnMe.y = r * sin(a + 2.0 * pi * rot - pi) + 0.5;
-	
-	returnMe = returnMe;
-	
-	return returnMe;
-}
-
-void main()	{
-	vec2		pt = isf_FragNormCoord;
-	vec4		srcPixel = IMG_NORM_PIXEL(inputImage,pt);
-	vec4		dist = vec4(0.0);
-	pt = rotatePointNorm(pt,rotationAngle+0.5);
-	dist.r = max(1.0-distance(vec2(0.0,0.0),pt),0.0);
-	dist.g = max(1.0-distance(vec2(1.0,0.0),pt),0.0);
-	dist.b = max(1.0-distance(vec2(0.0,1.0),pt),0.0);
-	dist.a = max(1.0-distance(vec2(1.0,1.0),pt),0.0);
-	
-	float		luma1 = (srcPixel.r+srcPixel.g+srcPixel.b)/3.0;
-	vec4		resultPixel = (color1 * dist.r + color2 * dist.g + color3 * dist.b + color4 * dist.a) / (dist.r + dist.g + dist.b + dist.a);
-	float		luma2 = (resultPixel.r+resultPixel.g+resultPixel.b)/3.0;
-	resultPixel.rgb *= luma1 / luma2;
-	resultPixel.a *= srcPixel.a;
-	
-	gl_FragColor = resultPixel;
-}
diff --git a/nannou_isf/test_files/Corner Colors.fs b/nannou_isf/test_files/Corner Colors.fs
deleted file mode 100644
index 7f662671c..000000000
--- a/nannou_isf/test_files/Corner Colors.fs	
+++ /dev/null
@@ -1,89 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Color"
-    ],
-    "CREDIT": "VIDVOX",
-    "DESCRIPTION": "Generates a gradient that fades between four different colors.",
-    "INPUTS": [
-        {
-            "DEFAULT": [
-                1,
-                0,
-                0,
-                1
-            ],
-            "NAME": "color1",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": [
-                0,
-                1,
-                0,
-                1
-            ],
-            "NAME": "color2",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0,
-                1,
-                1
-            ],
-            "NAME": "color3",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": [
-                1,
-                1,
-                1,
-                1
-            ],
-            "NAME": "color4",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "rotationAngle",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-const float pi = 3.1415926535897932384626433832795;
-
-vec2 rotatePointNorm(vec2 pt, float rot)	{
-	vec2 returnMe = pt;
-
-	float r = distance(vec2(0.50), returnMe);
-	float a = atan((returnMe.y-0.5),(returnMe.x-0.5));
-
-	returnMe.x = r * cos(a + 2.0 * pi * rot - pi) + 0.5;
-	returnMe.y = r * sin(a + 2.0 * pi * rot - pi) + 0.5;
-	
-	returnMe = returnMe;
-	
-	return returnMe;
-}
-
-void main()	{
-	vec4		inputPixelColor = vec4(0.0);
-	vec4		dist = vec4(0.0);
-	vec2		pt = isf_FragNormCoord;
-	pt = rotatePointNorm(pt,rotationAngle+0.5);
-	dist.r = max(1.0-distance(vec2(0.0,0.0),pt),0.0);
-	dist.g = max(1.0-distance(vec2(1.0,0.0),pt),0.0);
-	dist.b = max(1.0-distance(vec2(0.0,1.0),pt),0.0);
-	dist.a = max(1.0-distance(vec2(1.0,1.0),pt),0.0);
-	
-	inputPixelColor = (color1 * dist.r + color2 * dist.g + color3 * dist.b + color4 * dist.a) / (dist.r + dist.g + dist.b + dist.a);
-	
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/Crazy Parametric Fun.fs b/nannou_isf/test_files/Crazy Parametric Fun.fs
deleted file mode 100644
index 3607ff3f2..000000000
--- a/nannou_isf/test_files/Crazy Parametric Fun.fs	
+++ /dev/null
@@ -1,82 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/CrazyParametricFun.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 10,
-            "MIN": 0,
-            "NAME": "b",
-            "TYPE": "float"
-        },
-        {
-            "NAME": "smoothness",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 120,
-            "MAX": 360,
-            "MIN": 0,
-            "NAME": "amplitude",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 4,
-            "MAX": 10,
-            "MIN": 0,
-            "NAME": "a",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: mandubian
-// License: MIT
-
-
-vec4 transition(vec2 uv) {
-  vec2 p = uv.xy / vec2(1.0).xy;
-  vec2 dir = p - vec2(.5);
-  float dist = length(dir);
-  float x = (a - b) * cos(progress) + b * cos(progress * ((a / b) - 1.) );
-  float y = (a - b) * sin(progress) - b * sin(progress * ((a / b) - 1.));
-  vec2 offset = dir * vec2(sin(progress  * dist * amplitude * x), sin(progress * dist * amplitude * y)) / smoothness;
-  return mix(getFromColor(p + offset), getToColor(p), smoothstep(0.2, 1.0, progress));
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/CrossZoom.fs b/nannou_isf/test_files/CrossZoom.fs
deleted file mode 100644
index 18f1199b4..000000000
--- a/nannou_isf/test_files/CrossZoom.fs
+++ /dev/null
@@ -1,111 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Dissolve"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/CrossZoom.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "NAME": "strength",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// License: MIT
-// Author: rectalogic
-// ported by gre from https://gist.github.com/rectalogic/b86b90161503a0023231
-
-// Converted from https://github.com/rectalogic/rendermix-basic-effects/blob/master/assets/com/rendermix/CrossZoom/CrossZoom.frag
-// Which is based on https://github.com/evanw/glfx.js/blob/master/src/filters/blur/zoomblur.js
-// With additional easing functions from https://github.com/rectalogic/rendermix-basic-effects/blob/master/assets/com/rendermix/Easing/Easing.glsllib
-
-
-const float PI = 3.141592653589793;
-
-float Linear_ease(in float begin, in float change, in float duration, in float time) {
-    return change * time / duration + begin;
-}
-
-float Exponential_easeInOut(in float begin, in float change, in float duration, in float time) {
-    if (time == 0.0)
-        return begin;
-    else if (time == duration)
-        return begin + change;
-    time = time / (duration / 2.0);
-    if (time < 1.0)
-        return change / 2.0 * pow(2.0, 10.0 * (time - 1.0)) + begin;
-    return change / 2.0 * (-pow(2.0, -10.0 * (time - 1.0)) + 2.0) + begin;
-}
-
-float Sinusoidal_easeInOut(in float begin, in float change, in float duration, in float time) {
-    return -change / 2.0 * (cos(PI * time / duration) - 1.0) + begin;
-}
-
-float rand (vec2 co) {
-  return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-vec3 crossFade(in vec2 uv, in float dissolve) {
-    return mix(getFromColor(uv).rgb, getToColor(uv).rgb, dissolve);
-}
-
-vec4 transition(vec2 uv) {
-    vec2 texCoord = uv.xy / vec2(1.0).xy;
-
-    // Linear interpolate center across center half of the image
-    vec2 center = vec2(Linear_ease(0.25, 0.5, 1.0, progress), 0.5);
-    float dissolve = Exponential_easeInOut(0.0, 1.0, 1.0, progress);
-
-    // Mirrored sinusoidal loop. 0->strength then strength->0
-    float strength = Sinusoidal_easeInOut(0.0, strength, 0.5, progress);
-
-    vec3 color = vec3(0.0);
-    float total = 0.0;
-    vec2 toCenter = center - texCoord;
-
-    /* randomize the lookup values to hide the fixed number of samples */
-    float offset = rand(uv);
-
-    for (float t = 0.0; t <= 40.0; t++) {
-        float percent = (t + offset) / 40.0;
-        float weight = 4.0 * (percent - percent * percent);
-        color += crossFade(texCoord + toCenter * percent * strength, dissolve) * weight;
-        total += weight;
-    }
-    return vec4(color / total, 1.0);
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Crosshatch.fs b/nannou_isf/test_files/Crosshatch.fs
deleted file mode 100644
index ad5922152..000000000
--- a/nannou_isf/test_files/Crosshatch.fs
+++ /dev/null
@@ -1,85 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Dissolve"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/crosshatch.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "NAME": "fadeEdge",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0.5,
-                0.5
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "center",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": 3,
-            "MAX": 10,
-            "MIN": 0,
-            "NAME": "threshold",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2",
-    "VSN": ""
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// License: MIT
-// Author: pthrasher
-// adapted by gre from https://gist.github.com/pthrasher/04fd9a7de4012cbb03f6
-
-
-float rand(vec2 co) {
-  return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-vec4 transition(vec2 p) {
-  float dist = distance(center, p) / threshold;
-  float r = progress - min(rand(vec2(p.y, 0.0)), rand(vec2(0.0, p.x)));
-  return mix(getFromColor(p), getToColor(p), mix(0.0, mix(step(dist, r), 1.0, smoothstep(1.0-fadeEdge, 1.0, progress)), smoothstep(0.0, fadeEdge, progress)));    
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Crosswarp.fs b/nannou_isf/test_files/Crosswarp.fs
deleted file mode 100644
index 8035d19e9..000000000
--- a/nannou_isf/test_files/Crosswarp.fs
+++ /dev/null
@@ -1,51 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/crosswarp.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: Eke Péter <peterekepeter@gmail.com>
-// License: MIT
-vec4 transition(vec2 p) {
-  float x = progress;
-  x=smoothstep(.0,1.0,(x*2.0+p.x-1.0));
-  return mix(getFromColor((p-.5)*(1.-x)+.5), getToColor((p-.5)*x+.5), x);
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Cubic Warp.fs b/nannou_isf/test_files/Cubic Warp.fs
deleted file mode 100644
index fbab80542..000000000
--- a/nannou_isf/test_files/Cubic Warp.fs	
+++ /dev/null
@@ -1,82 +0,0 @@
-/*{
-  "CREDIT": "by carter rosenberg",
-  "CATEGORIES": [
-    "Distortion Effect"
-  ],
-  "INPUTS": [
-    {
-      "NAME": "inputImage",
-      "TYPE": "image"
-    },
-    {
-      "NAME": "level",
-      "TYPE": "float",
-      "MIN": 0,
-      "MAX": 100,
-      "DEFAULT": 1
-    },
-    {
-      "NAME" : "center",
-      "TYPE" : "point2D",
-      "MAX" : [
-        1,
-        1
-      ],
-      "DEFAULT" : [
-        0.5,
-        0.5
-      ],
-      "MIN" : [
-        0,
-        0
-      ]
-    }
-  ]
-}*/
-
-const float pi = 3.14159265359;
-
-
-#ifndef GL_ES
-float distance (vec2 center, vec2 pt)
-{
-	float tmp = pow(center.x-pt.x,2.0)+pow(center.y-pt.y,2.0);
-	return pow(tmp,0.5);
-}
-#endif
-
-
-void main() {
-	vec2		loc;
-	vec2		modifiedCenter;
-
-	loc = isf_FragNormCoord;
-	modifiedCenter = center;
-   
-	// lens distortion coefficient
-	float k = -0.15;
-
-	float r2 = (loc.x-modifiedCenter.x) * (loc.x-modifiedCenter.x) + (loc.y-modifiedCenter.y) * (loc.y-modifiedCenter.y);       
-	float f = 0.0;
-
-	//only compute the cubic distortion if necessary
-	if(level == 0.0){
-		f = 1.0 + r2 * k;
-	}
-	else	{
-		f = 1.0 + r2 * (k + level * sqrt(r2));
-	};
-
-	float zoom = max(sqrt(level),1.0);
-
-	// get the right pixel for the current position
-	loc.x = f*(loc.x-modifiedCenter.x)/zoom+modifiedCenter.x;
-	loc.y = f*(loc.y-modifiedCenter.y)/zoom+modifiedCenter.y;
-
-	if ((loc.x < 0.0)||(loc.y < 0.0)||(loc.x > 1.0)||(loc.y > 1.0))	{
-		gl_FragColor = vec4(0.0);
-	}
-	else	{
-		gl_FragColor = IMG_NORM_PIXEL(inputImage,loc);
-	}
-}
diff --git a/nannou_isf/test_files/Deinterlace.fs b/nannou_isf/test_files/Deinterlace.fs
deleted file mode 100644
index 62532ab53..000000000
--- a/nannou_isf/test_files/Deinterlace.fs
+++ /dev/null
@@ -1,32 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Utility"
-    ],
-    "CREDIT": "by zoidberg",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-const vec2		pointOffset = vec2(0.0, 1.0);
-
-void main() {
-	vec4		outColor;
-	//	"upper" (a.k.a. "the top row")
-	if (fract((gl_FragCoord.y+0.5)/2.0) == 0.0)	{
-		//gl_FragColor = vec4(1,0,0,1);
-		outColor = (IMG_PIXEL(inputImage, gl_FragCoord.xy) + IMG_PIXEL(inputImage, gl_FragCoord.xy - pointOffset))/2.0;
-		gl_FragColor = outColor;
-	}
-	//	"lower" (a.k.a. "the bottom row")
-	else	{
-		//gl_FragColor = vec4(0,1,0,1);
-		outColor = (IMG_PIXEL(inputImage, gl_FragCoord.xy) + IMG_PIXEL(inputImage, gl_FragCoord.xy + pointOffset))/2.0;
-		gl_FragColor = outColor;
-	}
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Diagonal Blur.fs b/nannou_isf/test_files/Diagonal Blur.fs
deleted file mode 100644
index 7c7a7c563..000000000
--- a/nannou_isf/test_files/Diagonal Blur.fs	
+++ /dev/null
@@ -1,82 +0,0 @@
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Blur"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "width",
-			"LABEL": "Width",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.0
-		},
-		{
-			"NAME": "angle",
-			"LABEL": "Angle",
-			"TYPE": "float",
-			"MIN": -1.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.125
-		},
-		{
-			"NAME": "quality",
-			"LABEL": "Quality",
-			"VALUES": [
-				12,
-				8,
-				4,
-				2
-			],
-			"LABELS": [
-				"Low",
-				"Mid",
-				"High",
-				"Best"
-			],
-			"DEFAULT": 4,
-			"TYPE": "long"
-		}
-	]
-}*/
-
-
-const float pi = 3.14159265359;
-
-
-void main() {
-	vec2 loc = isf_FragNormCoord * RENDERSIZE;
-
-	vec2 p1 = vec2(0.0);
-	vec2 p2 = vec2(1.0);
-	vec2 vector = vec2(cos(pi * angle),sin(pi * angle));
-	
-	vec4 returnMe;
-	
-	if (width > 0.0)	{
-		p1 = loc - width * RENDERSIZE * vector;
-		p2 = loc + width * RENDERSIZE * vector;
-		
-		//	now we have the two points to smear between,
-		//float i;
-		float count = clamp(width * max(RENDERSIZE.x,RENDERSIZE.y) / float(quality), 5.0, 125.0);
-		//float count = 10.0;
-		vec2 diff = p2 - p1;
-		for (float i = 0.0; i < 125.0; ++i)	{
-			if (i > float(count))
-				break;
-			float tmp = (i / (count - 1.0));
-			returnMe = returnMe + IMG_PIXEL(inputImage, p1 + diff * tmp) / count;
-		}
-	}
-	else	{
-		returnMe = IMG_THIS_PIXEL(inputImage);
-	}
-	gl_FragColor = returnMe;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Diagonalize.fs b/nannou_isf/test_files/Diagonalize.fs
deleted file mode 100644
index 3df5d3a47..000000000
--- a/nannou_isf/test_files/Diagonalize.fs
+++ /dev/null
@@ -1,108 +0,0 @@
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Stylize", "Distortion Effect"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "width",
-			"LABEL": "Width",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.0
-		},
-		{
-			"NAME": "angle",
-			"LABEL": "Angle",
-			"TYPE": "float",
-			"MIN": -0.5,
-			"MAX": 0.5,
-			"DEFAULT": 0.125
-		}
-	]
-}*/
-
-
-const float pi = 3.14159265359;
-
-
-void main() {
-	vec2 loc = isf_FragNormCoord * RENDERSIZE;
-
-	//	for starters let's just do y = x * tan(angle) + b
-	
-	float b = 0.0;
-	float tanVal = 0.0;
-	vec2 p1 = vec2(0.0);
-	vec2 p2 = vec2(1.0);
-	
-	if (abs(angle) != 0.5)	{
-		tanVal = tan(pi * angle);
-		b = (loc.y - loc.x * tanVal)/RENDERSIZE.y;
-		
-		if (width > 0.0)	{
-			float w = width * (1.0+abs(tanVal));
-			b = w * floor(b/w);
-		}
-		b = b * RENDERSIZE.y;
-		
-		//	if p1 is offscreen, adjust to an onscreen point
-		p1 = vec2(0.0, b);
-		
-		//	in this case instead of using where it hits the left edge, use where it hits the bottom, solving x for y = 0.0 (x = (y - b) / tanVal)
-		if (p1.y < 0.0)	{
-			p1 = vec2(0.0-b / tanVal, 0.0);	
-		}
-		//	in this case instead of using where it hits the left edge, use where it hits the top, solving x for y = 1.0 (x = (y - b) / tanVal)
-		else if (p1.y > RENDERSIZE.y)	{
-			p1 = vec2((RENDERSIZE.x - b) / tanVal, RENDERSIZE.y);
-		}
-	
-		//	get the right side edge
-		p2 = vec2(RENDERSIZE.x, RENDERSIZE.x * tanVal + b);
-		
-		//	if p2 is offscreen, adjust to an onscreen point
-		//	in this case instead of using where it hits the right edge, use where it hits the bottom, solving x for y = 0.0 (x = (y - b) / tanVal)
-		if (p2.y < 0.0)	{
-			p2 = vec2(- b / tanVal, 0.0);
-		}
-		//	in this case instead of using where it hits the right edge, use where it hits the top, solving x for y = 1.0 (x = (y - b) / tanVal)
-		else if (p2.y > RENDERSIZE.y)	{
-			p2 = vec2((RENDERSIZE.y - b) / tanVal, RENDERSIZE.y);
-		}
-		
-	}
-	//	vertical lines! set p1 & p2 to fixed x with y = 0.0 and 1.0
-	else	{
-		if (angle > 0.0)	{
-			p1 = vec2(loc.x, 0.0);
-			p2 = vec2(loc.x, RENDERSIZE.y);
-		}
-		else	{
-			p2 = vec2(loc.x, 0.0);
-			p1 = vec2(loc.x, RENDERSIZE.y);	
-		}
-		if (width > 0.0)	{
-			p1.x = RENDERSIZE.x * width * floor((loc.x/RENDERSIZE.x) / width);
-			p2.x = p1.x;
-		}
-	}
-	
-	//	now average 5 points on the line, p1, p2, their midpoint, and the mid points of those
-	//	midpoint of the line
-	vec2 mid = (p1 + p2) / 2.0;
-	
-	vec4 returnMe = (IMG_PIXEL(inputImage, p1) + IMG_PIXEL(inputImage, (p1 + mid) / 2.0) + IMG_PIXEL(inputImage, mid) + IMG_PIXEL(inputImage, (p2 + mid) / 2.0) + IMG_PIXEL(inputImage, p2)) / 5.0;
-	//vec4 returnMe = IMG_PIXEL(inputImage, p2);
-
-	gl_FragColor = returnMe;
-}
-
-
-
diff --git a/nannou_isf/test_files/Digital Clock.fs b/nannou_isf/test_files/Digital Clock.fs
deleted file mode 100644
index a4d18ccbc..000000000
--- a/nannou_isf/test_files/Digital Clock.fs	
+++ /dev/null
@@ -1,184 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Utility"
-    ],
-    "CREDIT": "VIDVOX",
-    "DESCRIPTION": "Shows the current time of day or time since the composition started",
-    "INPUTS": [
-        {
-            "DEFAULT": [
-                1,
-                0.5899132640831176,
-                0,
-                1
-            ],
-            "LABEL": "Color",
-            "NAME": "colorInput",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Clock Mode",
-            "LABELS": [
-                "Time",
-                "Countdown",
-                "Counter"
-            ],
-            "NAME": "clockMode",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1,
-                2
-            ]
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Y Offset",
-            "MAX": 1,
-            "MIN": -1,
-            "NAME": "yOffset",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Blink",
-            "NAME": "blinkingColons",
-            "TYPE": "bool"
-        },
-        {
-            "LABEL": "24 Hour",
-            "NAME": "twentyFourHourStyle",
-            "TYPE": "bool"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-        }
-    ]
-}
-*/
-
-
-
-float segment(vec2 uv, bool On) {
-	return (On) ?  (1.0 - smoothstep(0.05,0.15,abs(uv.x))) *
-			       (1.-smoothstep(0.35,0.55,abs(uv.y)+abs(uv.x)))
-		        : 0.;
-}
-
-float digit(vec2 uv,int num) {
-	float seg= 0.;
-    seg += segment(uv.yx+vec2(-1., 0.),num!=-1 && num!=1 && num!=4                    );
-	seg += segment(uv.xy+vec2(-.5,-.5),num!=-1 && num!=1 && num!=2 && num!=3 && num!=7);
-	seg += segment(uv.xy+vec2( .5,-.5),num!=-1 && num!=5 && num!=6                    );
-   	seg += segment(uv.yx+vec2( 0., 0.),num!=-1 && num!=0 && num!=1 && num!=7          );
-	seg += segment(uv.xy+vec2(-.5, .5),num==0 || num==2 || num==6 || num==8           );
-	seg += segment(uv.xy+vec2( .5, .5),num!=-1 && num!=2                              );
-    seg += segment(uv.yx+vec2( 1., 0.),num!=-1 && num!=1 && num!=4 && num!=7          );	
-	return seg;
-}
-
-float showNum(vec2 uv,int nr, bool zeroTrim) { // nr: 2 digits + sgn . zeroTrim: trim leading "0"
-	if (abs(uv.x)>2.*1.5 || abs(uv.y)>1.2) return 0.;
-
-	if (nr<0) {
-		nr = -nr;
-		if (uv.x>1.5) {
-			uv.x -= 2.;
-			return segment(uv.yx,true); // minus sign.
-		}
-	}
-	
-	if (uv.x>0.) {
-		nr /= 10; if (nr==0 && zeroTrim) nr = -1;
-		uv -= vec2(.75,0.);
-	} else {
-		uv += vec2(.75,0.); 
-		nr = int(mod(float(nr),10.));
-	}
-
-	return digit(uv,nr);
-}
-
-float colon(vec2 uv, vec2 cCenter, float cRadius)	{
-	float		returnMe = distance(uv,cCenter);
-	if (returnMe > cRadius)
-		returnMe = 0.0;
-	else
-		returnMe = 1.0 - pow(returnMe / cRadius,4.0);
-	return returnMe;
-}
-
-
-
-//	a simplfied version of the number drawing from http://www.interactiveshaderformat.com/sketches/120
-
-
-
-
-void main()	{
-	vec4		returnMe = vec4(0.0);
-	vec2		uv = isf_FragNormCoord;
-	float		adjustedOffset = (yOffset*1.2*(RENDERSIZE.y/RENDERSIZE.x));
-	vec2		loc = uv;
-	loc.y = loc.y - adjustedOffset;	
-	
-	//	The first element of the vector is the year, the second element is the month,
-	//	the third element is the day, and the fourth element is the time (in seconds) within the day.
-	vec4		currentDate = DATE;
-	if (clockMode == 1)
-		currentDate.a = 86400.0 - currentDate.a;
-	else if (clockMode == 2)
-		currentDate = vec4(TIME);
-	
-	float		tmpVal = currentDate.a;
-	float		h = 0.0;
-	float		m = 0.0;
-	float		s = 0.0;
-
-	s = mod(tmpVal,60.0);
-	tmpVal = tmpVal / 60.0;
-	m = mod(tmpVal,60.0);
-	tmpVal = tmpVal / 60.0;
-	h = mod(tmpVal,60.0);
-	if ((!twentyFourHourStyle)&&(clockMode == 0))	{
-		h = mod(h,12.0);
-		if (h < 1.0)
-			h = 12.0;
-	}
-	
-	float		seg = 0.0;
-	int			displayTime = 0;
-	
-	if (loc.x < 0.3)	{
-		loc.x = 1.0 - (loc.x + 0.37);
-		loc = (loc * 3.0 - 1.5) * 4.0;
-		displayTime = int(h);
-	}
-	else if (loc.x < 0.6)	{
-		loc.x = 1.0 - (loc.x+0.05);
-		loc = (loc * 3.0 - 1.5) * 4.0;
-		displayTime = int(m);
-	}
-	else	{
-		loc.x = 1.0 - (loc.x - 0.3);
-		loc = (loc * 3.0 - 1.5) * 4.0;
-		displayTime = int(s);
-	}
-
-	seg = showNum(loc,displayTime,false);
-	
-	if ((!blinkingColons)||(mod(currentDate.a,1.0)<0.5))	{
-		seg += colon(uv,vec2(0.293,0.53+adjustedOffset),0.015);
-		seg += colon(uv,vec2(0.293,0.47+adjustedOffset),0.015);
-	
-		seg += colon(uv,vec2(0.633,0.53+adjustedOffset),0.015);
-		seg += colon(uv,vec2(0.633,0.47+adjustedOffset),0.015);
-	}
-	if (seg > 0.0)
-		returnMe = colorInput * seg;
-	
-	gl_FragColor = returnMe;
-}
diff --git a/nannou_isf/test_files/Dilate-Fast.fs b/nannou_isf/test_files/Dilate-Fast.fs
deleted file mode 100644
index 41677dcca..000000000
--- a/nannou_isf/test_files/Dilate-Fast.fs
+++ /dev/null
@@ -1,152 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Blur"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.25,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "intensity",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 6,
-            "MAX": 15,
-            "MIN": 1,
-            "NAME": "radius",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "DESCRIPTION": "pass 0, 1x horiz sampling (3 wide total) to prevent data loss",
-            "HEIGHT": "floor($HEIGHT/2.0)",
-            "TARGET": "halfSize",
-            "WIDTH": "floor($WIDTH/2.0)"
-        },
-        {
-            "DESCRIPTION": "pass 1, vert sampling, use radius (size is being reduced, halve coords deltas when sampling)",
-            "HEIGHT": "floor($HEIGHT/4.0)",
-            "TARGET": "quarterSize",
-            "WIDTH": "floor($WIDTH/4.0)"
-        },
-        {
-            "DESCRIPTION": "pass 2, horiz sampling, use radius (size is being increased, use normal coords deltas)",
-            "HEIGHT": "floor($HEIGHT/2.0)",
-            "TARGET": "quarterSizePassB",
-            "WIDTH": "floor($WIDTH/2.0)"
-        },
-        {
-            "DESCRIPTION": "pass 3, last pass- samples the input image and the quarterSizePassB to generate the final image at the full original resolution"
-        }
-    ]
-}
-*/
-
-
-
-vec3 rgb2hsv(vec3 c);
-
-void main()
-{
-	
-	//	generally speaking, sample a bunch of pixels, for each sample convert color val to HSV, if luma is greater than max luma, that's the new color
-	vec2		tmpCoord;
-	float		maxLuma;
-	vec4		maxLumaRGBColor = vec4(0.0);
-	vec4		sampleColorRGB;
-	vec4		sampleColorHSV;
-	vec2		pixelWidth = 1.0/RENDERSIZE.xy;
-	float		localBlurRadius;
-	bool		vertFlag = false;
-	
-	if (PASSINDEX != 3)	{
-		//	pass 0 and 2 are doing horizontal erosion
-		if (PASSINDEX==1)
-			vertFlag = true;
-		//	the first pass should have a blur radius of 1.0 simply to prevent the loss of information while reducing resolution
-		if (PASSINDEX==0)
-			localBlurRadius = 1.0;
-		//	other passes go by the blur radius!
-		else
-			localBlurRadius = float(int(radius));
-		//	sample pixels as per the blur radius...
-		for (float i=0.; i<=localBlurRadius; ++i)	{
-			if (PASSINDEX==0)	{
-				tmpCoord = vec2(clamp(isf_FragNormCoord.x+(i*pixelWidth.x), 0., 1.), isf_FragNormCoord.y);
-				sampleColorRGB = IMG_NORM_PIXEL(inputImage, tmpCoord);
-			}
-			else if (PASSINDEX==1)	{
-				tmpCoord = vec2(isf_FragNormCoord.x, clamp(isf_FragNormCoord.y+(i*pixelWidth.y/2.), 0., 1.));
-				sampleColorRGB = IMG_NORM_PIXEL(halfSize, tmpCoord);
-			}
-			else if (PASSINDEX==2)	{
-				tmpCoord = vec2(clamp(isf_FragNormCoord.x+(i*pixelWidth.x), 0., 1.), isf_FragNormCoord.y);
-				sampleColorRGB = IMG_NORM_PIXEL(quarterSize, tmpCoord);
-			}
-			//	if this is the first sample for this fragment, don't bother comparing- just set the max luma stuff
-			if (i == 0.)	{
-				maxLuma = rgb2hsv(sampleColorRGB.rgb).b;
-				maxLumaRGBColor = sampleColorRGB;
-			}
-			//	else this isn't the first sample...
-			else	{
-				//	compare, determine if it's the max luma
-				sampleColorRGB = mix(maxLumaRGBColor, sampleColorRGB, 1.*intensity/i);
-				sampleColorHSV.rgb = rgb2hsv(sampleColorRGB.rgb);
-				if (sampleColorHSV.b < maxLuma)	{
-					maxLuma = sampleColorHSV.b;
-					maxLumaRGBColor = sampleColorRGB;
-				}
-				//	do another sample for the negative coordinate
-				if (PASSINDEX==0)	{
-					tmpCoord = vec2(clamp(isf_FragNormCoord.x-(i*pixelWidth.x), 0., 1.), isf_FragNormCoord.y);
-					sampleColorRGB = IMG_NORM_PIXEL(inputImage, tmpCoord);
-				}
-				else if (PASSINDEX==1)	{
-					tmpCoord = vec2(isf_FragNormCoord.x, clamp(isf_FragNormCoord.y-(i*pixelWidth.y/2.), 0., 1.));
-					sampleColorRGB = IMG_NORM_PIXEL(halfSize, tmpCoord);
-				}
-				else if (PASSINDEX==2)	{
-					tmpCoord = vec2(clamp(isf_FragNormCoord.x-(i*pixelWidth.x), 0., 1.), isf_FragNormCoord.y);
-					sampleColorRGB = IMG_NORM_PIXEL(quarterSize, tmpCoord);
-				}
-				sampleColorRGB = mix(maxLumaRGBColor, sampleColorRGB, 1.*intensity/i);
-				sampleColorHSV.rgb = rgb2hsv(sampleColorRGB.rgb);
-				if (sampleColorHSV.b < maxLuma)	{
-					maxLuma = sampleColorHSV.b;
-					maxLumaRGBColor = sampleColorRGB;
-				}
-			}
-		}
-		gl_FragColor = maxLumaRGBColor;
-	}
-	//	last pass
-	else if (PASSINDEX==3)	{
-		vec4		origPixel = IMG_NORM_PIXEL(inputImage,isf_FragNormCoord);
-		vec4		erodedPixel = IMG_NORM_PIXEL(quarterSizePassB,isf_FragNormCoord);
-		vec4		finalPixel = min(origPixel,erodedPixel);
-		gl_FragColor = mix(origPixel,finalPixel, clamp(min(radius-1.0, intensity*10.0), 0., 1.));
-	}
-}
-
-
-vec3 rgb2hsv(vec3 c)	{
-	vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-	//vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
-	//vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
-	vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
-	vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
-	
-	float d = q.x - min(q.w, q.y);
-	float e = 1.0e-10;
-	return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
-}
-
diff --git a/nannou_isf/test_files/Dilate.fs b/nannou_isf/test_files/Dilate.fs
deleted file mode 100644
index 51882c161..000000000
--- a/nannou_isf/test_files/Dilate.fs
+++ /dev/null
@@ -1,132 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Blur"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "intensity",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 2,
-            "MAX": 15,
-            "MIN": 1,
-            "NAME": "radius",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "TARGET": "firstPass"
-        },
-        {
-        }
-    ]
-}
-*/
-
-
-
-vec3 rgb2hsv(vec3 c);
-
-void main()
-{
-	
-	//	generally speaking, sample a bunch of pixels, for each sample convert color val to HSV, if luma is greater than max luma, that's the new color
-	vec2		tmpCoord;
-	float		maxLuma;
-	vec4		maxLumaRGBColor = vec4(0.0);
-	vec4		sampleColorRGB;
-	vec4		sampleColorHSV;
-	
-	if (PASSINDEX==0)	{
-		//	5 samples on either side + the source pixel = 11 total samples
-		for (float i=0.; i<=float(int(radius)); ++i)	{
-			tmpCoord = vec2(clamp(gl_FragCoord.x+i,0.,RENDERSIZE.x), gl_FragCoord.y);
-			sampleColorRGB = IMG_PIXEL(inputImage, tmpCoord);
-			//	if this is the first sample for this fragment, don't bother comparing- just set the max luma stuff
-			if (i == 0.)	{
-				maxLuma = rgb2hsv(sampleColorRGB.rgb).b;
-				maxLumaRGBColor = sampleColorRGB;
-			}
-			//	else this isn't the first sample...
-			else	{
-				//	compare, determine if it's the max luma
-				sampleColorRGB = mix(maxLumaRGBColor, sampleColorRGB, 1.*intensity/i);
-				sampleColorHSV.rgb = rgb2hsv(sampleColorRGB.rgb);
-				if (sampleColorHSV.b < maxLuma)	{
-					maxLuma = sampleColorHSV.b;
-					maxLumaRGBColor = sampleColorRGB;
-				}
-				//	do another sample for the negative coordinate
-				tmpCoord = vec2(clamp(gl_FragCoord.x-i,0.,RENDERSIZE.x), gl_FragCoord.y);
-				sampleColorRGB = IMG_PIXEL(inputImage, tmpCoord);
-				sampleColorRGB = mix(maxLumaRGBColor, sampleColorRGB, 1.*intensity/i);
-				sampleColorHSV.rgb = rgb2hsv(sampleColorRGB.rgb);
-				if (sampleColorHSV.b < maxLuma)	{
-					maxLuma = sampleColorHSV.b;
-					maxLumaRGBColor = sampleColorRGB;
-				}
-			}
-		}
-		gl_FragColor = maxLumaRGBColor;
-		
-	}
-	else if (PASSINDEX==1)	{
-		//	5 samples up and down + the source pixel = 11 total samples
-		for (float i=0.; i<=float(int(radius)); ++i)	{
-			tmpCoord = vec2(gl_FragCoord.x, clamp(gl_FragCoord.y+i,0.,RENDERSIZE.y));
-			sampleColorRGB = IMG_PIXEL(firstPass, tmpCoord);
-			//	if this is the first sample for this fragment, don't bother comparing- just set the max luma stuff
-			if (i == 0.)	{
-				maxLuma = rgb2hsv(sampleColorRGB.rgb).b;
-				maxLumaRGBColor = sampleColorRGB;
-			}
-			//	else this isn't the first sample...
-			else	{
-				//	compare, determine if it's the max luma
-				sampleColorRGB = mix(maxLumaRGBColor, sampleColorRGB, 1.*intensity/i);
-				sampleColorHSV.rgb = rgb2hsv(sampleColorRGB.rgb);
-				if (sampleColorHSV.b < maxLuma)	{
-					maxLuma = sampleColorHSV.b;
-					maxLumaRGBColor = sampleColorRGB;
-				}
-				//	do another sample for the negative coordinate
-				tmpCoord = vec2(gl_FragCoord.x, clamp(gl_FragCoord.y-i,0.,RENDERSIZE.y));
-				sampleColorRGB = IMG_PIXEL(firstPass, tmpCoord);
-				sampleColorRGB = mix(maxLumaRGBColor, sampleColorRGB, 1.*intensity/i);
-				sampleColorHSV.rgb = rgb2hsv(sampleColorRGB.rgb);
-				if (sampleColorHSV.b < maxLuma)	{
-					maxLuma = sampleColorHSV.b;
-					maxLumaRGBColor = sampleColorRGB;
-				}
-			}
-		}
-		gl_FragColor = maxLumaRGBColor;
-		
-	}
-	
-}
-
-
-vec3 rgb2hsv(vec3 c)	{
-	vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-	//vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
-	//vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
-	vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
-	vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
-	
-	float d = q.x - min(q.w, q.y);
-	float e = 1.0e-10;
-	return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
-}
-
diff --git a/nannou_isf/test_files/Directional Warp.fs b/nannou_isf/test_files/Directional Warp.fs
deleted file mode 100644
index 8ae600c7a..000000000
--- a/nannou_isf/test_files/Directional Warp.fs	
+++ /dev/null
@@ -1,74 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/directionalwarp.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                -1,
-                1
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                -1,
-                -1
-            ],
-            "NAME": "direction",
-            "TYPE": "point2D"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: pschroen
-// License: MIT
-
-
-const float smoothness = 0.5;
-const vec2 center = vec2(0.5, 0.5);
-
-vec4 transition (vec2 uv) {
-  vec2 v = normalize(direction);
-  v /= abs(v.x) + abs(v.y);
-  float d = v.x * center.x + v.y * center.y;
-  float m = 1.0 - smoothstep(-smoothness, 0.0, v.x * uv.x + v.y * uv.y - (d - 0.5 + progress * (1.0 + smoothness)));
-  return mix(getFromColor((uv - 0.5) * (1.0 - m) + 0.5), getToColor((uv - 0.5) * m + 0.5), m);
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Directional Wipe.fs b/nannou_isf/test_files/Directional Wipe.fs
deleted file mode 100644
index c1e764e45..000000000
--- a/nannou_isf/test_files/Directional Wipe.fs	
+++ /dev/null
@@ -1,82 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Wipe"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/directionalwipe.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                1,
-                -1
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                -1,
-                -1
-            ],
-            "NAME": "direction",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "smoothness",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: gre
-// License: MIT
-
- 
-const vec2 center = vec2(0.5, 0.5);
- 
-vec4 transition (vec2 uv) {
-  vec2 v = normalize(direction);
-  v /= abs(v.x)+abs(v.y);
-  float d = v.x * center.x + v.y * center.y;
-  float m =
-    (1.0-step(progress, 0.0)) * // there is something wrong with our formula that makes m not equals 0.0 with progress is 0.0
-    (1.0 - smoothstep(-smoothness, 0.0, v.x * uv.x + v.y * uv.y - (d-0.5+progress*(1.+smoothness))));
-  return mix(getFromColor(uv), getToColor(uv), m);
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Directional.fs b/nannou_isf/test_files/Directional.fs
deleted file mode 100644
index 1269aee81..000000000
--- a/nannou_isf/test_files/Directional.fs
+++ /dev/null
@@ -1,73 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Wipe"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/Directional.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0,
-                1
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                -1,
-                -1
-            ],
-            "NAME": "direction",
-            "TYPE": "point2D"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: Gaëtan Renaudeau
-// License: MIT
-
-
-vec4 transition (vec2 uv) {
-  vec2 p = uv + progress * sign(direction);
-  vec2 f = fract(p);
-  return mix(
-    getToColor(f),
-    getFromColor(f),
-    step(0.0, p.y) * step(p.y, 1.0) * step(0.0, p.x) * step(p.x, 1.0)
-  );
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Dirty Lens.fs b/nannou_isf/test_files/Dirty Lens.fs
deleted file mode 100644
index e0d987fab..000000000
--- a/nannou_isf/test_files/Dirty Lens.fs	
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Film",
-    "Masking"
-  ],
-  "DESCRIPTION" : "Value Noise",
-  "INPUTS" : [
-    {
-      "NAME" : "inputImage",
-      "TYPE" : "image"
-    },
-    {
-      "NAME" : "scale",
-      "TYPE" : "float",
-      "MAX" : 100,
-      "DEFAULT" : 9,
-      "MIN" : 0,
-      "LABEL" : "Dirt Size"
-    },
-    {
-      "NAME" : "brightness",
-      "TYPE" : "float",
-      "MAX" : 4,
-      "DEFAULT" : 0.5,
-      "MIN" : 0,
-      "LABEL" : "Dirt Thickness"
-    },
-    {
-      "NAME" : "brightnessCurve",
-      "TYPE" : "float",
-      "MAX" : 4,
-      "DEFAULT" : 1,
-      "LABEL" : "Dirt Shape",
-      "MIN" : 1
-    },
-    {
-      "NAME" : "radius",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0.5,
-      "LABEL" : "Dirt Spread",
-      "MIN" : 0
-    },
-    {
-      "NAME" : "noiseSeed",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0,
-      "MIN" : 0,
-      "LABEL" : "Dirt Seed"
-    },
-    {
-      "LABELS" : [
-        "Original",
-        "Multiply",
-        "Replace"
-      ],
-      "NAME" : "alphaMode",
-      "TYPE" : "long",
-      "IDENTITY" : 0,
-      "LABEL" : "Alpha Mode",
-      "VALUES" : [
-        0,
-        1,
-        2
-      ]
-    }
-  ],
-  "ISFVSN" : "2",
-  "CREDIT" : "Inigo Quilez ported by @colin_movecraft and VIDVOX"
-}
-*/
-
-
-
-// Value Noise (http://en.wikipedia.org/wiki/Value_noise), not to be confused with Perlin's
-// Noise, is probably the simplest way to generate noise (a random smooth signal with 
-// mostly all its energy in the low frequencies) suitable for procedural texturing/shading,
-// modeling and animation.
-//
-// It produces lowe quality noise than Gradient Noise (https://www.shadertoy.com/view/XdXGW8)
-// but it is slightly faster to compute. When used in a fractal construction, the blockyness
-// of Value Noise gets qcuikly hidden, making it a very popular alternative to Gradient Noise.
-//
-// The princpiple is to create a virtual grid/latice all over the plane, and assign one
-// random value to every vertex in the grid. When querying/requesting a noise value at
-// an arbitrary point in the plane, the grid cell in which the query is performed is
-// determined (line 30), the four vertices of the grid are determined and their random
-// value fetched (lines 35 to 38) and then bilinearly interpolated (lines 35 to 38 again)
-// with a smooth interpolant (line 31 and 33).
-
-
-// Value    Noise 2D, Derivatives: https://www.shadertoy.com/view/4dXBRH
-// Gradient Noise 2D, Derivatives: https://www.shadertoy.com/view/XdXBRH
-// Value    Noise 3D, Derivatives: https://www.shadertoy.com/view/XsXfRH
-// Gradient Noise 3D, Derivatives: https://www.shadertoy.com/view/4dffRH
-// Value    Noise 2D             : https://www.shadertoy.com/view/lsf3WH
-// Value    Noise 3D             : https://www.shadertoy.com/view/4sfGzS
-// Gradient Noise 2D             : https://www.shadertoy.com/view/XdXGW8
-// Gradient Noise 3D             : https://www.shadertoy.com/view/Xsl3Dl
-// Simplex  Noise 2D             : https://www.shadertoy.com/view/Msf3WH
-
-
-float hash(vec2 p)  // replace this by something better
-{
-    p  = 50.0*fract(noiseSeed + p*0.3183099 + vec2(0.71,0.113));
-    return -1.0+2.0*fract( p.x*p.y*(p.x+p.y) );
-}
-
-float noise( in vec2 p )
-{
-    vec2 i = floor( p );
-    vec2 f = fract( p );
-	
-	vec2 u = f*f*(3.0-2.0*f);
-
-    return mix( mix( hash( i + vec2(0.0,0.0) ), 
-                     hash( i + vec2(1.0,0.0) ), u.x),
-                mix( hash( i + vec2(0.0,1.0) ), 
-                     hash( i + vec2(1.0,1.0) ), u.x), u.y);
-}
-
-float map(float n, float i1, float i2, float o1, float o2){
-	return o1 + (o2-o1) * (n-i1)/(i2-i1);
-	
-}
-
-void main(){
-    vec2 p = gl_FragCoord.xy / RENDERSIZE;
-
-	vec2 uv = p*vec2(RENDERSIZE.x/RENDERSIZE.y,1.0);
-	float f = 0.0;
-
-	//fbm - fractal noise (4 octaves)	
-	{
-		uv *= scale;
-        mat2 m = mat2( 1.6,  1.2, -1.2,  1.6 );
-		f  = 0.5000*noise( uv ); uv = m*uv;
-		f += 0.2500*noise( uv ); uv = m*uv;
-		f += 0.1250*noise( uv ); uv = m*uv;
-		f += 0.0625*noise( uv ); uv = m*uv;
-	}
-	
-	f = 1.0-pow(f,(5.0-brightnessCurve))*brightness;
-	
-	float d = distance(isf_FragNormCoord,vec2(0.5));
-	if (d > radius)	{
-		f = f + (d-radius);
-	}
-	
-	f = (f > 1.0) ? 1.0 : f;
-	
-	vec4 returnMe = IMG_THIS_PIXEL(inputImage) * vec4( f, f, f, 1.0 );
-	if (alphaMode == 1)
-		returnMe.a *= f;
-	else if (alphaMode == 2)
-		returnMe.a = f;
-	gl_FragColor = returnMe;
-}
-
-
-
-// The MIT License
-// Copyright © 2013 Inigo Quilez
-// 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/nannou_isf/test_files/Displace.fs b/nannou_isf/test_files/Displace.fs
deleted file mode 100644
index 7c31d07f6..000000000
--- a/nannou_isf/test_files/Displace.fs
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Distortion Effect"
-  ],
-  "DESCRIPTION" : "Simple Displace",
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "NAME" : "inputImage",
-      "TYPE" : "image"
-    },
-    {
-      "NAME" : "displaceImage",
-      "TYPE" : "image",
-      "LABEL" : "displace image"
-    },
-    {
-      "NAME" : "uDisplaceAmt",
-      "TYPE" : "float",
-      "MAX" : 2,
-      "DEFAULT" : 0,
-      "MIN" : -2
-    },
-    {
-      "LABELS" : [
-        "Luma",
-        "R",
-        "G",
-        "B",
-        "A"
-      ],
-      "NAME" : "xComponent",
-      "TYPE" : "long",
-      "DEFAULT" : 1,
-      "VALUES" : [
-        0,
-        1,
-        2,
-        3,
-        4
-      ]
-    },
-    {
-      "LABELS" : [
-        "Luma",
-        "R",
-        "G",
-        "B",
-        "A"
-      ],
-      "NAME" : "yComponent",
-      "TYPE" : "long",
-      "DEFAULT" : 2,
-      "VALUES" : [
-        0,
-        1,
-        2,
-        3,
-        4
-      ]
-    },
-    {
-      "NAME" : "relativeShift",
-      "TYPE" : "bool",
-      "DEFAULT" : 0
-    }
-  ],
-  "CREDIT" : "by @colin_movecraft"
-}
-*/
-
-
-
-void main(){
-	vec2	p = isf_FragNormCoord.xy;
-	vec4	displacePixel = IMG_NORM_PIXEL(displaceImage, p);
-    
-    float	r = (displacePixel.r);
-    float	g = (displacePixel.g);
-    float	b = (displacePixel.b);
-    float	a = (displacePixel.a);
-    float	avg = (r+g+b)/3.0;
-    
-    vec2	displace = vec2(avg,avg);
-    if (xComponent==1)
-    	displace.x = r;
-	else if (xComponent==2)
-    	displace.x = g;
-    else if (xComponent==3)
-    	displace.x = b;
-	else if (xComponent==4)
-    	displace.x = a;
-
-    if (yComponent==1)
-    	displace.y = r;
-	else if (yComponent==2)
-    	displace.y = g;
-    else if (yComponent==3)
-    	displace.y = b;
-	else if (yComponent==4)
-    	displace.y = a;
-    
-    displace = (relativeShift) ? 2.0 * (displace - vec2(0.5)) : displace;
-    displace *= uDisplaceAmt;
-    
-	gl_FragColor = IMG_NORM_PIXEL(inputImage,p+displace);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Displacement.fs b/nannou_isf/test_files/Displacement.fs
deleted file mode 100644
index 77446248d..000000000
--- a/nannou_isf/test_files/Displacement.fs
+++ /dev/null
@@ -1,75 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/displacement.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "NAME": "displacementMap",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "strength",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: Travis Fischer
-// License: MIT
-//
-// Adapted from a Codrops article by Robin Delaporte
-// https://tympanus.net/Development/DistortionHoverEffect
-
-
-
-vec4 transition (vec2 uv) {
-  float displacement = IMG_NORM_PIXEL(displacementMap, uv).r * strength;
-
-  vec2 uvFrom = vec2(uv.x + progress * displacement, uv.y);
-  vec2 uvTo = vec2(uv.x - (1.0 - progress) * displacement, uv.y);
-
-  return mix(
-    getFromColor(uvFrom),
-    getToColor(uvTo),
-    progress
-  );
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Dither-Bayer.fs b/nannou_isf/test_files/Dither-Bayer.fs
deleted file mode 100644
index 4d14e4e7c..000000000
--- a/nannou_isf/test_files/Dither-Bayer.fs
+++ /dev/null
@@ -1,218 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Halftone Effect",
-        "Retro"
-    ],
-    "CREDIT": "Hugh Kennedy, adapted by David Lublin",
-    "DESCRIPTION": "Bayer style dithering",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "colorize",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 2,
-            "LABELS": [
-                "2x2",
-                "4x4",
-                "8x8"
-            ],
-            "NAME": "matrixMode",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1,
-                2
-            ]
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-//	based on https://github.com/hughsk/glsl-dither
-
-float luma(vec3 color)	{
-	return (color.r + color.g + color.b) / 3.0;	
-}
-
-float luma(vec4 color)	{
-	return color.a * (color.r + color.g + color.b) / 3.0;	
-}
-
-float dither8x8(vec2 position, float brightness) {
-  int x = int(mod(position.x, 8.0));
-  int y = int(mod(position.y, 8.0));
-  int index = x + y * 8;
-  float limit = 0.0;
-
-  if (x < 8) {
-    if (index == 0) limit = 0.015625;
-    if (index == 1) limit = 0.515625;
-    if (index == 2) limit = 0.140625;
-    if (index == 3) limit = 0.640625;
-    if (index == 4) limit = 0.046875;
-    if (index == 5) limit = 0.546875;
-    if (index == 6) limit = 0.171875;
-    if (index == 7) limit = 0.671875;
-    if (index == 8) limit = 0.765625;
-    if (index == 9) limit = 0.265625;
-    if (index == 10) limit = 0.890625;
-    if (index == 11) limit = 0.390625;
-    if (index == 12) limit = 0.796875;
-    if (index == 13) limit = 0.296875;
-    if (index == 14) limit = 0.921875;
-    if (index == 15) limit = 0.421875;
-    if (index == 16) limit = 0.203125;
-    if (index == 17) limit = 0.703125;
-    if (index == 18) limit = 0.078125;
-    if (index == 19) limit = 0.578125;
-    if (index == 20) limit = 0.234375;
-    if (index == 21) limit = 0.734375;
-    if (index == 22) limit = 0.109375;
-    if (index == 23) limit = 0.609375;
-    if (index == 24) limit = 0.953125;
-    if (index == 25) limit = 0.453125;
-    if (index == 26) limit = 0.828125;
-    if (index == 27) limit = 0.328125;
-    if (index == 28) limit = 0.984375;
-    if (index == 29) limit = 0.484375;
-    if (index == 30) limit = 0.859375;
-    if (index == 31) limit = 0.359375;
-    if (index == 32) limit = 0.0625;
-    if (index == 33) limit = 0.5625;
-    if (index == 34) limit = 0.1875;
-    if (index == 35) limit = 0.6875;
-    if (index == 36) limit = 0.03125;
-    if (index == 37) limit = 0.53125;
-    if (index == 38) limit = 0.15625;
-    if (index == 39) limit = 0.65625;
-    if (index == 40) limit = 0.8125;
-    if (index == 41) limit = 0.3125;
-    if (index == 42) limit = 0.9375;
-    if (index == 43) limit = 0.4375;
-    if (index == 44) limit = 0.78125;
-    if (index == 45) limit = 0.28125;
-    if (index == 46) limit = 0.90625;
-    if (index == 47) limit = 0.40625;
-    if (index == 48) limit = 0.25;
-    if (index == 49) limit = 0.75;
-    if (index == 50) limit = 0.125;
-    if (index == 51) limit = 0.625;
-    if (index == 52) limit = 0.21875;
-    if (index == 53) limit = 0.71875;
-    if (index == 54) limit = 0.09375;
-    if (index == 55) limit = 0.59375;
-    if (index == 56) limit = 1.0;
-    if (index == 57) limit = 0.5;
-    if (index == 58) limit = 0.875;
-    if (index == 59) limit = 0.375;
-    if (index == 60) limit = 0.96875;
-    if (index == 61) limit = 0.46875;
-    if (index == 62) limit = 0.84375;
-    if (index == 63) limit = 0.34375;
-  }
-
-  return brightness < limit ? 0.0 : 1.0;
-}
-
-vec3 dither8x8(vec2 position, vec3 color) {
-  return color * dither8x8(position, luma(color));
-}
-
-vec4 dither8x8(vec2 position, vec4 color) {
-  return vec4(color.rgb * dither8x8(position, luma(color)), 1.0);
-}
-
-float dither4x4(vec2 position, float brightness) {
-  int x = int(mod(position.x, 4.0));
-  int y = int(mod(position.y, 4.0));
-  int index = x + y * 4;
-  float limit = 0.0;
-
-  if (x < 8) {
-    if (index == 0) limit = 0.0625;
-    if (index == 1) limit = 0.5625;
-    if (index == 2) limit = 0.1875;
-    if (index == 3) limit = 0.6875;
-    if (index == 4) limit = 0.8125;
-    if (index == 5) limit = 0.3125;
-    if (index == 6) limit = 0.9375;
-    if (index == 7) limit = 0.4375;
-    if (index == 8) limit = 0.25;
-    if (index == 9) limit = 0.75;
-    if (index == 10) limit = 0.125;
-    if (index == 11) limit = 0.625;
-    if (index == 12) limit = 1.0;
-    if (index == 13) limit = 0.5;
-    if (index == 14) limit = 0.875;
-    if (index == 15) limit = 0.375;
-  }
-
-  return brightness < limit ? 0.0 : 1.0;
-}
-
-vec3 dither4x4(vec2 position, vec3 color) {
-  return color * dither4x4(position, luma(color));
-}
-
-vec4 dither4x4(vec2 position, vec4 color) {
-  return vec4(color.rgb * dither4x4(position, luma(color)), 1.0);
-}
-
-float dither2x2(vec2 position, float brightness) {
-  int x = int(mod(position.x, 2.0));
-  int y = int(mod(position.y, 2.0));
-  int index = x + y * 2;
-  float limit = 0.0;
-
-  if (x < 8) {
-    if (index == 0) limit = 0.25;
-    if (index == 1) limit = 0.75;
-    if (index == 2) limit = 1.00;
-    if (index == 3) limit = 0.50;
-  }
-
-  return brightness < limit ? 0.0 : 1.0;
-}
-
-vec3 dither2x2(vec2 position, vec3 color) {
-  return color * dither2x2(position, luma(color));
-}
-
-vec4 dither2x2(vec2 position, vec4 color) {
-  return vec4(color.rgb * dither2x2(position, luma(color)), 1.0);
-}
-
-
-void main()	{
-	vec4		inputPixelColor = vec4(0.0);
-	vec2		loc = gl_FragCoord.xy;
-	//	both of these are the same
-	inputPixelColor = IMG_THIS_PIXEL(inputImage);
-	
-	float		val = 1.0;
-	
-	if (matrixMode == 0)	{
-		val = dither2x2(loc, luma(inputPixelColor));
-	}
-	else if (matrixMode == 1)	{
-		val = dither4x4(loc, luma(inputPixelColor));
-	}
-	else if (matrixMode == 2)	{
-		val = dither8x8(loc, luma(inputPixelColor));
-	}
-	
-	inputPixelColor = inputPixelColor * vec4(val,val,val,1.0);
-
-	gl_FragColor = mix(vec4(val,val,val,inputPixelColor.a),inputPixelColor,colorize);
-}
diff --git a/nannou_isf/test_files/Doom Screen Transition.fs b/nannou_isf/test_files/Doom Screen Transition.fs
deleted file mode 100644
index 06a01eda2..000000000
--- a/nannou_isf/test_files/Doom Screen Transition.fs	
+++ /dev/null
@@ -1,130 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Wipe"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/DoomScreenTransition.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "frequency",
-            "TYPE": "float"
-        },
-        {
-            "NAME": "noise",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 50,
-            "MAX": 100,
-            "MIN": 0,
-            "NAME": "bars",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "dripScale",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 2,
-            "MAX": 10,
-            "MIN": 0,
-            "NAME": "amplitude",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: Zeh Fernando
-// License: MIT
-
-
-// Transition parameters --------
-
-// Number of total bars/columns
-
-// Multiplier for speed ratio. 0 = no variation when going down, higher = some elements go much faster
-
-// Further variations in speed. 0 = no noise, 1 = super noisy (ignore frequency)
-
-// Speed variation horizontally. the bigger the value, the shorter the waves
-
-// How much the bars seem to "run" from the middle of the screen first (sticking to the sides). 0 = no drip, 1 = curved drip
-
-
-// The code proper --------
-
-float rand(int num) {
-  return fract(mod(float(num) * 67123.313, 12.0) * sin(float(num) * 10.3) * cos(float(num)));
-}
-
-float wave(int num) {
-  float fn = float(num) * frequency * 0.1 * float(bars);
-  return cos(fn * 0.5) * cos(fn * 0.13) * sin((fn+10.0) * 0.3) / 2.0 + 0.5;
-}
-
-float drip(int num) {
-  return sin(float(num) / float(bars - 1) * 3.141592) * dripScale;
-}
-
-float pos(int num) {
-  return (noise == 0.0 ? wave(num) : mix(wave(num), rand(num), noise)) + (dripScale == 0.0 ? 0.0 : drip(num));
-}
-
-vec4 transition(vec2 uv) {
-  int bar = int(uv.x * (float(bars)));
-  float scale = 1.0 + pos(bar) * amplitude;
-  float phase = progress * scale;
-  float posY = uv.y / vec2(1.0).y;
-  vec2 p;
-  vec4 c;
-  if (phase + posY < 1.0) {
-    p = vec2(uv.x, uv.y + mix(0.0, vec2(1.0).y, phase)) / vec2(1.0).xy;
-    c = getFromColor(p);
-  } else {
-    p = uv.xy / vec2(1.0).xy;
-    c = getToColor(p);
-  }
-
-  // Finally, apply the color
-  return c;
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Doorway.fs b/nannou_isf/test_files/Doorway.fs
deleted file mode 100644
index 7b11d2bdd..000000000
--- a/nannou_isf/test_files/Doorway.fs
+++ /dev/null
@@ -1,112 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Wipe"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/doorway.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.4,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "reflection",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.4,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "perspective",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 3,
-            "MAX": 10,
-            "MIN": 0,
-            "NAME": "depth",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// author: gre
-// License: MIT 
-
-const vec4 black = vec4(0.0, 0.0, 0.0, 1.0);
-const vec2 boundMin = vec2(0.0, 0.0);
-const vec2 boundMax = vec2(1.0, 1.0);
-
-bool inBounds (vec2 p) {
-  return all(lessThan(boundMin, p)) && all(lessThan(p, boundMax));
-}
-
-vec2 project (vec2 p) {
-  return p * vec2(1.0, -1.2) + vec2(0.0, -0.02);
-}
-
-vec4 bgColor (vec2 p, vec2 pto) {
-  vec4 c = black;
-  pto = project(pto);
-  if (inBounds(pto)) {
-    c += mix(black, getToColor(pto), reflection * mix(1.0, 0.0, pto.y));
-  }
-  return c;
-}
-
-
-vec4 transition (vec2 p) {
-  vec2 pfr = vec2(-1.), pto = vec2(-1.);
-  float middleSlit = 2.0 * abs(p.x-0.5) - progress;
-  if (middleSlit > 0.0) {
-    pfr = p + (p.x > 0.5 ? -1.0 : 1.0) * vec2(0.5*progress, 0.0);
-    float d = 1.0/(1.0+perspective*progress*(1.0-middleSlit));
-    pfr.y -= d/2.;
-    pfr.y *= d;
-    pfr.y += d/2.;
-  }
-  float size = mix(1.0, depth, 1.-progress);
-  pto = (p + vec2(-0.5, -0.5)) * vec2(size, size) + vec2(0.5, 0.5);
-  if (inBounds(pfr)) {
-    return getFromColor(pfr);
-  }
-  else if (inBounds(pto)) {
-    return getToColor(pto);
-  }
-  else {
-    return bgColor(p, pto);
-  }
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Dot Screen.fs b/nannou_isf/test_files/Dot Screen.fs
deleted file mode 100644
index 0f63caba7..000000000
--- a/nannou_isf/test_files/Dot Screen.fs	
+++ /dev/null
@@ -1,110 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Halftone Effect",
-        "Retro"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 10,
-            "MIN": 0,
-            "NAME": "sharpness",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "angle",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 2,
-            "MIN": 0,
-            "NAME": "scale",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "colorize",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0.5,
-                0.5
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "center",
-            "TYPE": "point2D"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-in vec2 left_coord;
-in vec2 right_coord;
-in vec2 above_coord;
-in vec2 below_coord;
-
-in vec2 lefta_coord;
-in vec2 righta_coord;
-in vec2 leftb_coord;
-in vec2 rightb_coord;
-#endif
-
-const float tau = 6.28318530718;
-
-float pattern() {
-	float s = sin( angle * tau ), c = cos( angle * tau );
-	vec2 tex = (isf_FragNormCoord - center) * RENDERSIZE;
-	vec2 point = vec2( c * tex.x - s * tex.y, s * tex.x + c * tex.y ) * max(scale,0.001);
-	return ( sin( point.x ) * sin( point.y ) ) * 4.0;
-}
-
-void main() {
-	vec4 color = IMG_THIS_PIXEL(inputImage);
-	vec4 colorL = IMG_NORM_PIXEL(inputImage, left_coord);
-	vec4 colorR = IMG_NORM_PIXEL(inputImage, right_coord);
-	vec4 colorA = IMG_NORM_PIXEL(inputImage, above_coord);
-	vec4 colorB = IMG_NORM_PIXEL(inputImage, below_coord);
-
-	vec4 colorLA = IMG_NORM_PIXEL(inputImage, lefta_coord);
-	vec4 colorRA = IMG_NORM_PIXEL(inputImage, righta_coord);
-	vec4 colorLB = IMG_NORM_PIXEL(inputImage, leftb_coord);
-	vec4 colorRB = IMG_NORM_PIXEL(inputImage, rightb_coord);
-
-	vec4 final = color + sharpness * (8.0*color - colorL - colorR - colorA - colorB - colorLA - colorRA - colorLB - colorRB);
-	
-	float average = ( final.r + final.g + final.b ) / 3.0;
-	final = vec4( vec3( average * 10.0 - 5.0 + pattern() ), color.a );
-	final = mix (color * final, final, 1.0-colorize);
-	gl_FragColor = final;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Dot Screen.vs b/nannou_isf/test_files/Dot Screen.vs
deleted file mode 100644
index 8f2188f5d..000000000
--- a/nannou_isf/test_files/Dot Screen.vs	
+++ /dev/null
@@ -1,39 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-out vec2 left_coord;
-out vec2 right_coord;
-out vec2 above_coord;
-out vec2 below_coord;
-
-out vec2 lefta_coord;
-out vec2 righta_coord;
-out vec2 leftb_coord;
-out vec2 rightb_coord;
-#endif
-
-
-void main()
-{
-	isf_vertShaderInit();
-	vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	vec2 d = 1.0/RENDERSIZE;
-	
-	left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
-	right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
-	above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
-	below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
-
-	lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
-	righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
-	leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
-	rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Double Vision.fs b/nannou_isf/test_files/Double Vision.fs
deleted file mode 100644
index d149aa64e..000000000
--- a/nannou_isf/test_files/Double Vision.fs	
+++ /dev/null
@@ -1,69 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Stylize"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "H Shift",
-            "MAX": 0.05,
-            "MIN": -0.05,
-            "NAME": "hShift",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "V Shift",
-            "MAX": 0.05,
-            "MIN": -0.05,
-            "NAME": "vShift",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "LABEL": "Shift Mix",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "mixAmount1",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "LABEL": "Original Mix",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "mixAmount2",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-void main()
-{
-	vec2 loc = isf_FragNormCoord;
-	vec2 shift = vec2(hShift, vShift);
-
-	//	zoom slightly so that there aren't out of range pixels
-	float zoomAmount = 1.0 + 2.0 * max(hShift, vShift);
-	vec2 modifiedCenter = vec2(0.5,0.5);
-	loc.x = (loc.x - modifiedCenter.x)*(1.0/zoomAmount) + modifiedCenter.x;
-	loc.y = (loc.y - modifiedCenter.y)*(1.0/zoomAmount) + modifiedCenter.y;
-	
-	vec4 color = IMG_NORM_PIXEL(inputImage, isf_FragNormCoord);
-	vec4 colorL = IMG_NORM_PIXEL(inputImage, clamp(loc - shift,0.0,1.0));
-	vec4 colorR = IMG_NORM_PIXEL(inputImage, clamp(loc + shift,0.0,1.0));
-	
-	vec4 outColor = mix(min(colorL, colorR), max(colorL, colorR), mixAmount1);
-	outColor =  mix(min(outColor, color), max(outColor, color), mixAmount2);
-	
-	gl_FragColor = outColor;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Dreamy Zoom.fs b/nannou_isf/test_files/Dreamy Zoom.fs
deleted file mode 100644
index e537a748d..000000000
--- a/nannou_isf/test_files/Dreamy Zoom.fs	
+++ /dev/null
@@ -1,98 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/DreamyZoom.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 6,
-            "MAX": 10,
-            "MIN": 0,
-            "NAME": "rotation",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1.2,
-            "MAX": 10,
-            "MIN": 0,
-            "NAME": "scale",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: Zeh Fernando
-// License: MIT
-
-// Definitions --------
-#define DEG2RAD 0.03926990816987241548078304229099 // 1/180*PI
-
-
-// Transition parameters --------
-
-// In degrees
-
-// Multiplier
-
-
-// The code proper --------
-
-float ratio = RENDERSIZE.x/RENDERSIZE.y;
-
-vec4 transition(vec2 uv) {
-  // Massage parameters
-  float phase = progress < 0.5 ? progress * 2.0 : (progress - 0.5) * 2.0;
-  float angleOffset = progress < 0.5 ? mix(0.0, rotation * DEG2RAD, phase) : mix(-rotation * DEG2RAD, 0.0, phase);
-  float newScale = progress < 0.5 ? mix(1.0, scale, phase) : mix(scale, 1.0, phase);
-  
-  vec2 center = vec2(0, 0);
-
-  // Calculate the source point
-  vec2 assumedCenter = vec2(0.5, 0.5);
-  vec2 p = (uv.xy - vec2(0.5, 0.5)) / newScale * vec2(ratio, 1.0);
-
-  // This can probably be optimized (with distance())
-  float angle = atan(p.y, p.x) + angleOffset;
-  float dist = distance(center, p);
-  p.x = cos(angle) * dist / ratio + 0.5;
-  p.y = sin(angle) * dist + 0.5;
-  vec4 c = progress < 0.5 ? getFromColor(p) : getToColor(p);
-
-  // Finally, apply the color
-  return c + (progress < 0.5 ? mix(0.0, 1.0, phase) : mix(1.0, 0.0, phase));
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Dreamy.fs b/nannou_isf/test_files/Dreamy.fs
deleted file mode 100644
index e0cc9b8dc..000000000
--- a/nannou_isf/test_files/Dreamy.fs
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
-{
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "TYPE" : "image",
-      "NAME" : "startImage"
-    },
-    {
-      "NAME" : "endImage",
-      "TYPE" : "image"
-    },
-    {
-      "TYPE" : "float",
-      "NAME" : "progress",
-      "MIN" : 0,
-      "MAX" : 1,
-      "DEFAULT" : 0
-    }
-  ],
-  "CATEGORIES" : [
-    "Distortion"
-  ],
-  "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/Dreamy.glsl",
-  "DESCRIPTION" : "Automatically converted from https://gl-transitions.com/"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: mikolalysenko
-// License: MIT
-
-vec2 offset(float progress, float x, float theta) {
-  float phase = progress*progress + progress + theta;
-  float shifty = 0.03*progress*cos(10.0*(progress+x));
-  return vec2(0, shifty);
-}
-vec4 transition(vec2 p) {
-  return mix(getFromColor(p + offset(progress, p.x, 0.0)), getToColor(p + offset(1.0-progress, p.x, 3.14)), progress);
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Dual Side Scroller And Flip.fs b/nannou_isf/test_files/Dual Side Scroller And Flip.fs
deleted file mode 100644
index 564de45e3..000000000
--- a/nannou_isf/test_files/Dual Side Scroller And Flip.fs	
+++ /dev/null
@@ -1,91 +0,0 @@
-/*{
-	"CREDIT": "Inspired by Side Scroller and Flip by BrianChasalow",
-	"ISFVSN": "2",
-	 "CATEGORIES": [
-	 	"Geometry Adjustment"
-	 ],
-	 "INPUTS": [
-		 {
-			 "NAME": "inputImage",
-			 "TYPE": "image"
-		 },
-		 {
-			 "NAME": "slidetop",
-			 "TYPE": "float",
-			 "MIN": 0.0,
-			 "MAX": 2.0,
-			 "DEFAULT": 0.0
-		 },
-		 {
-			 "NAME": "shifttop",
-			 "TYPE": "float",
-			 "MIN": 0.0,
-			 "MAX": 2.0,
-			 "DEFAULT": 0.0
-		 },
-		 {
-			 "NAME": "mirrorHorizontaltop",
-			 "TYPE": "bool",
-			 "MIN": false,
-			 "MAX": true,
-			 "DEFAULT": true
-		 },
-		 {
-			 "NAME": "mirrorVerticaltop",
-			 "TYPE": "bool",
-			 "MIN": false,
-			 "MAX": true,
-			 "DEFAULT": true
-		 },
-		 {
-			 "NAME": "slidebot",
-			 "TYPE": "float",
-			 "MIN": 0.0,
-			 "MAX": 2.0,
-			 "DEFAULT": 0.0
-		 },
-		 {
-			 "NAME": "shiftbot",
-			 "TYPE": "float",
-			 "MIN": 0.0,
-			 "MAX": 2.0,
-			 "DEFAULT": 0.0
-		 },
-		 {
-			 "NAME": "mirrorHorizontalbot",
-			 "TYPE": "bool",
-			 "MIN": false,
-			 "MAX": true,
-			 "DEFAULT": true
-		 },
-		 {
-			 "NAME": "mirrorVerticalbot",
-			 "TYPE": "bool",
-			 "MIN": false,
-			 "MAX": true,
-			 "DEFAULT": true
-		 }
- 
-	 ]
- }*/
-
-void main(void)
-{
-	vec2 pt = isf_FragNormCoord;
-	float slide = (isf_FragNormCoord.y > 0.5) ? slidetop : slidebot;
-	float shift = (isf_FragNormCoord.x < 0.5) ? shifttop : shiftbot;
-
-	bool mirrorHorizontal = (isf_FragNormCoord.y > 0.5) ? mirrorHorizontaltop : mirrorHorizontalbot;
-	bool mirrorVertical = (isf_FragNormCoord.x < 0.5) ? mirrorVerticaltop : mirrorVerticalbot;
-	pt.x += slide;
-	pt.y += shift;
-	vec2 moddedRetard = mod(pt,1.0);
-	
-	if(mirrorHorizontal && pt.x >= 1.0 && pt.x <= 2.0)
-		moddedRetard = vec2(1.0-moddedRetard.x, moddedRetard.y);
-	if(mirrorVertical && pt.y >= 1.0 && pt.y <= 2.0)
-		moddedRetard = vec2(moddedRetard.x, 1.0-moddedRetard.y);
-	
-	vec4 pixel = IMG_NORM_PIXEL(inputImage, moddedRetard);
-	gl_FragColor = pixel;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Duotone From Histogram.fs b/nannou_isf/test_files/Duotone From Histogram.fs
deleted file mode 100644
index ae31b32c3..000000000
--- a/nannou_isf/test_files/Duotone From Histogram.fs	
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Color Effect", "Histogram"
-  ],
-  "DESCRIPTION" : "Adjusts an image to use colors determined from a histogram",
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "NAME" : "inputImage",
-      "TYPE" : "image"
-    },
-    {
-      "NAME" : "sourceHistogram",
-      "TYPE" : "image"
-    },
-	{
-		"NAME": "timeSmoothing",
-		"TYPE": "float",
-		"MIN": 0.0,
-		"MAX": 1.0,
-		"DEFAULT": 0.5
-	},
-	{
-		"NAME": "minStart",
-		"TYPE": "float",
-		"MIN": 0.0,
-		"MAX": 0.25,
-		"DEFAULT": 0.0
-	},
-	{
-		"NAME": "midRange",
-		"TYPE": "float",
-		"MIN": 0.0,
-		"MAX": 0.5,
-		"DEFAULT": 0.0
-	},
-	{
-		"NAME": "averaging",
-		"TYPE": "float",
-		"MIN": 0.0,
-		"MAX": 0.2,
-		"DEFAULT": 0.0
-	},
-	{
-		"NAME": "inThreshold",
-		"TYPE": "float",
-		"MIN": 0.0,
-		"MAX": 0.1,
-		"DEFAULT": 0.0
-	},
-	{
-		"NAME": "outAutoThreshold",
-		"TYPE": "bool",
-		"DEFAULT": 1
-	},
-	{
-		"NAME": "outThreshold",
-		"TYPE": "float",
-		"MIN": 0.0,
-		"MAX": 1.0,
-		"DEFAULT": 0.5
-	}
-  ],
-  "PASSES" : [
-    {
-      "WIDTH" : "2",
-      "TARGET" : "minmax",
-      "HEIGHT" : "1"
-    },
-    {
-      "WIDTH" : "2",
-      "TARGET" : "smoothedminmax",
-      "HEIGHT" : "1",
-      "PERSISTENT": true,
-      "FLOAT": true
-    },
-    {
-
-    }
-  ],
-  "CREDIT" : "VIDVOX"
-}
-*/
-
-float brightness(vec3 c)	{
-	return (c.r + c.g + c.b) / 3.0;
-}
-
-float minChannel (vec3 c)	{
-	float	tmpVal = c.r;
-	if (c.g > tmpVal)
-		tmpVal = c.g;
-	if (c.b > tmpVal)
-		tmpVal = c.b;
-	return tmpVal;
-}
-
-float maxChannel (vec3 c)	{
-	float	tmpVal = c.r;
-	if (c.g > tmpVal)
-		tmpVal = c.g;
-	if (c.b > tmpVal)
-		tmpVal = c.b;
-	return tmpVal;
-}
-void main()	{
-	vec4		returnMe = vec4(0.0);
-	if (PASSINDEX==0)	{
-		//float		minOrMax = (isf_FragNormCoord.x < 0.5) ? 0.0 : 1.0;
-		//	go through each pixel of sourceHistogram
-		//		figure out the scan range based on isf_FragNormCoord and number of divisions
-		//int			divisons = 2;
-		int			rangeLength = 128 - int(midRange * 127.0);
-		int			rangeStart = (isf_FragNormCoord.x < 0.5) ? int(minStart * 256.0) : 256 - rangeLength;
-		vec4		currentMax = vec4(0.0);
-		
-		returnMe.a = 1.0;
-		
-		vec4		prev1 = vec4(0.0);
-		vec4		prev2 = vec4(0.0);
-		
-		//	for the given range, find the index 
-		for(int i=rangeStart;i<rangeStart + rangeLength;++i)	{
-			vec4	histoStart = IMG_PIXEL(sourceHistogram,vec2(float(i),0.5));
-			//	average this out with the 
-			vec4	histo = (i <= rangeStart + 1) ? histoStart : (histoStart * (1.0 - averaging) + prev1 * averaging / 2.0 + prev2 * averaging / 2.0);
-			
-			if ((histo.r > inThreshold)&&(currentMax.r < histo.r))	{
-				returnMe.r = float(i)/255.0;
-				currentMax.r = histo.r;
-			}
-			if ((histo.g > inThreshold)&&(currentMax.g < histo.g))	{
-				returnMe.g = float(i)/255.0;
-				currentMax.g = histo.g;
-			}
-			if ((histo.b > inThreshold)&&(currentMax.b < histo.b))	{
-				returnMe.b = float(i)/255.0;
-				currentMax.b = histo.b;
-			}
-			prev2 = prev1;
-			prev1 = histoStart;
-		}
-	}
-	else if (PASSINDEX==1)	{
-		vec4		freshPixel = IMG_PIXEL(minmax,gl_FragCoord.xy);
-		vec4		stalePixel = IMG_PIXEL(smoothedminmax,gl_FragCoord.xy);
-		returnMe = mix(freshPixel,stalePixel,timeSmoothing);
-	}
-	else if (PASSINDEX==2)	{
-		returnMe = IMG_THIS_PIXEL(inputImage);
-		vec4	minColor = IMG_PIXEL(smoothedminmax,vec2(0.5,0.5));
-		vec4	maxColor = IMG_PIXEL(smoothedminmax,vec2(1.5,0.5));
-		float	bVal = brightness(returnMe.rgb);
-		float	outThresh = (outAutoThreshold) ? mix(minChannel(minColor.rgb),maxChannel(maxColor.rgb),0.5) : outThreshold;
-		
-		if (bVal < outThresh)	{
-			returnMe.rgb = minColor.rgb;
-		}
-		else	{
-			returnMe.rgb = maxColor.rgb;
-		}
-	}
-	
-	gl_FragColor = returnMe;
-}
diff --git a/nannou_isf/test_files/Duotone.fs b/nannou_isf/test_files/Duotone.fs
deleted file mode 100644
index 088c96a96..000000000
--- a/nannou_isf/test_files/Duotone.fs
+++ /dev/null
@@ -1,85 +0,0 @@
-/*{
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Color Effect"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "threshold",
-			"TYPE": "float",
-			"DEFAULT": 0.50
-		},
-		{
-			"NAME": "softness",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1,
-			"DEFAULT": 0.0
-		},
-		{
-			"NAME": "brightColor",
-			"TYPE": "color",
-			"DEFAULT": [
-				1.0,
-				1.0,
-				1.0,
-				1.0
-			]
-		},
-		{
-			"NAME": "darkColor",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.0,
-				0.0,
-				0.0,
-				1.0
-			]
-		}
-	]
-}*/
-
-//const vec4		lumcoeff = vec4(0.299, 0.587, 0.114, 0.0);
-const vec4 	lumcoeff = vec4(0.2126, 0.7152, 0.0722, 0.0);
-
-void main() {
-	vec4		srcPixel = IMG_THIS_PIXEL(inputImage);
-	float		luminance = dot(srcPixel,lumcoeff);
-	//gl_FragColor = (luminance>=threshold) ? (brightColor) : (darkColor);
-	
-	//	if i'm doing hard edges, it's either one color or the other
-	if (softness<=0.0)	{
-		gl_FragColor = (luminance>=threshold) ? vec4(brightColor.rgb, srcPixel.a) : vec4(darkColor.rgb, srcPixel.a);
-	}
-	//	else i'm doing soft edges...
-	else	{
-		//	'softness' is normalized proportion of luminance on either side of threshold to be interpolated
-		//	e.g.: 'softness' is 0.5 and 'threshold' is 0.5: vals < 0.25 are "dark", vals from 0.25-0.75 are "interpolated", and vals > 0.75 are "light"
-		vec4		midColor = (brightColor+darkColor)/vec4(2.0);
-		vec4		dstPixel;
-		if (luminance>=threshold)	{
-			gl_FragColor = mix(midColor, brightColor, smoothstep(threshold, threshold+((1.0-threshold)*softness), luminance));
-		}
-		else	{
-			gl_FragColor = mix(darkColor, midColor, smoothstep(threshold-((1.0-threshold)*softness), threshold, luminance));
-		}
-		
-		/*
-		//	'softness' is the absolute width (in luminance) on either side of the threshold to be interpolated
-		//	e.g.: if softness is 0.25 and threshold is 0.5, vals < 0.25 are "dark", vals from 0.25-0.75 are "smoothed", and vals > 0.75 are "light"
-		vec4		midColor = (brightColor+darkColor)/vec4(2.0);
-		vec4		dstPixel;
-		if (luminance>=threshold)	{
-			gl_FragColor = mix(midColor, brightColor, smoothstep(threshold, threshold+softness, luminance));
-		}
-		else	{
-			gl_FragColor = mix(darkColor, midColor, smoothstep(threshold-softness, threshold, luminance));
-		}
-		*/
-	}
-}
diff --git a/nannou_isf/test_files/Echo Trace.fs b/nannou_isf/test_files/Echo Trace.fs
deleted file mode 100644
index 7efd5e92f..000000000
--- a/nannou_isf/test_files/Echo Trace.fs	
+++ /dev/null
@@ -1,69 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Feedback"
-    ],
-    "CREDIT": "by VIDVOX",
-    "DESCRIPTION": "Pixel with brightness levels below the threshold do not update.",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Threshold",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "thresh",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Gain",
-            "MAX": 2,
-            "MIN": 0,
-            "NAME": "gain",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": true,
-            "LABEL": "Hard Cutoff",
-            "NAME": "hardCutoff",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": false,
-            "LABEL": "Invert",
-            "NAME": "invert",
-            "TYPE": "bool"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "FLOAT": true,
-            "PERSISTENT": true,
-            "TARGET": "bufferVariableNameA"
-        },
-        {
-        }
-    ]
-}
-*/
-
-void main()
-{
-	vec4		freshPixel = IMG_PIXEL(inputImage,gl_FragCoord.xy);
-	vec4		stalePixel = IMG_PIXEL(bufferVariableNameA,gl_FragCoord.xy);
-	float		brightLevel = (freshPixel.r + freshPixel.b + freshPixel.g) / 3.0;
-	if (invert)
-		brightLevel = 1.0 - brightLevel;
-	brightLevel = brightLevel * gain;
-	if (hardCutoff)	{
-		if (brightLevel < thresh)
-			brightLevel = 1.0;
-		else
-			brightLevel = 0.0;
-	}
-	gl_FragColor = mix(freshPixel,stalePixel, brightLevel);
-}
diff --git a/nannou_isf/test_files/Edge Blowout.fs b/nannou_isf/test_files/Edge Blowout.fs
deleted file mode 100644
index 4857d094d..000000000
--- a/nannou_isf/test_files/Edge Blowout.fs	
+++ /dev/null
@@ -1,230 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Stylize"
-    ],
-    "CREDIT": "VIDVOX",
-    "DESCRIPTION": "Stretches the edges out a region of the video",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.25,
-            "IDENTITY": 0,
-            "LABEL": "Left Edge",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "leftEdge",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.75,
-            "IDENTITY": 1,
-            "LABEL": "Right Edge",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "rightEdge",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.25,
-            "IDENTITY": 0,
-            "LABEL": "Bottom Edge",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "bottomEdge",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.75,
-            "IDENTITY": 1,
-            "LABEL": "Top Edge",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "topEdge",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": true,
-            "LABEL": "Horizontal Bleed",
-            "NAME": "doHorizontal",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": true,
-            "LABEL": "Vertical Bleed",
-            "NAME": "doVertical",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": true,
-            "LABEL": "Inside Bleed",
-            "NAME": "insideBleed",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": true,
-            "LABEL": "Outside Bleed",
-            "NAME": "outsideBleed",
-            "TYPE": "bool"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-void main()	{
-	vec4		outputPixelColor;
-	float		realLeftEdge = (leftEdge < rightEdge) ? leftEdge : rightEdge;
-	float		realRightEdge = (leftEdge > rightEdge) ? leftEdge : rightEdge;
-	
-	float		realBottomEdge = (bottomEdge < topEdge) ? bottomEdge : topEdge;
-	float		realTopEdge = (bottomEdge > topEdge) ? bottomEdge : topEdge;
-	
-	vec2		sampleCoord = isf_FragNormCoord.xy;
-
-	bool		insideBox = false;
-	
-	vec2		region = vec2(0.0,0.0);
-	
-	if (sampleCoord.x < realLeftEdge)	{
-		region.x = 0.0;
-	}
-	else if (sampleCoord.x > realRightEdge)	{
-		region.x = 2.0;
-	}
-	else {
-		region.x = 1.0;
-	}
-	
-	if (sampleCoord.y < realBottomEdge)	{
-		region.y = 0.0;
-	}
-	else if (sampleCoord.y > realTopEdge)	{
-		region.y = 2.0;
-	}
-	else {
-		region.y = 1.0;
-	}
-	
-	if ((region.x == 1.0) && (region.y == 1.0) && (insideBleed == true))	{
-		insideBox = true;
-	}
-	else if (outsideBleed == true)	{
-		//	if we are in the bottom left...
-		if ((region.x == 0.0) && (region.y == 0.0))	{
-			if ((doHorizontal) && (doVertical))	{
-				insideBox = true;
-				realRightEdge = realLeftEdge;
-				realLeftEdge = 0.0;
-				realTopEdge = realBottomEdge;
-				realBottomEdge = 0.0;
-			}
-		}
-		else if ((region.x == 1.0) && (region.y == 0.0))	{
-			if ((doHorizontal) && (doVertical))	{
-				insideBox = true;
-				realTopEdge = realBottomEdge;
-				realBottomEdge = 0.0;
-			}
-			else if (doVertical)	{
-				insideBox = true;
-				realTopEdge = realBottomEdge;
-				realBottomEdge = 0.0;
-			}
-		}
-		else if ((region.x == 2.0) && (region.y == 0.0))	{
-			if ((doHorizontal) && (doVertical))	{
-				insideBox = true;
-				realLeftEdge = realRightEdge;
-				realRightEdge = 1.0;
-				realTopEdge = realBottomEdge;
-				realBottomEdge = 0.0;
-			}
-		}
-		else if ((region.x == 0.0) && (region.y == 1.0))	{
-			if (doHorizontal)	{
-				insideBox = true;
-				realRightEdge = realLeftEdge;
-				realLeftEdge = 0.0;
-			}
-		}
-		else if ((region.x == 2.0) && (region.y == 1.0))	{
-			if (doHorizontal)	{
-				insideBox = true;
-				realLeftEdge = realRightEdge;
-				realRightEdge = 1.0;
-			}
-		}
-		else if ((region.x == 0.0) && (region.y == 2.0))	{
-			if ((doHorizontal) && (doVertical))	{
-				insideBox = true;
-				realRightEdge = realLeftEdge;
-				realLeftEdge = 0.0;
-				realBottomEdge = realTopEdge;
-				realTopEdge = 1.0;
-			}
-		}
-		else if ((region.x == 1.0) && (region.y == 2.0))	{
-			if (doVertical)	{
-				insideBox = true;
-				realBottomEdge = realTopEdge;
-				realTopEdge = 1.0;
-			}
-		}
-		else if ((region.x == 2.0) && (region.y == 2.0))	{
-			if ((doHorizontal) && (doVertical))	{
-				insideBox = true;
-				realLeftEdge = realRightEdge;
-				realRightEdge = 1.0;
-				realBottomEdge = realTopEdge;
-				realTopEdge = 1.0;
-			}
-		}
-	}
-	
-	//	if we're doing inside bleed
-	if (insideBox)	{
-		
-		//	how close are we to each edge?			
-		if ((doHorizontal) && (doVertical))	{
-			float	leftDistance = sampleCoord.x - realLeftEdge;
-			float	rightDistance = realRightEdge - sampleCoord.x;
-			float	bottomDistance = sampleCoord.y - realBottomEdge;
-			float	topDistance = realTopEdge - sampleCoord.y;
-			float	totalDistance = (leftDistance + rightDistance + bottomDistance + topDistance);
-			
-			vec4	leftPixel = IMG_NORM_PIXEL(inputImage, vec2(realLeftEdge, sampleCoord.y));
-			vec4	rightPixel = IMG_NORM_PIXEL(inputImage, vec2(realRightEdge, sampleCoord.y));
-			vec4	bottomPixel = IMG_NORM_PIXEL(inputImage, vec2(sampleCoord.x, realBottomEdge));
-			vec4	topPixel = IMG_NORM_PIXEL(inputImage, vec2(sampleCoord.x, realTopEdge));
-				
-			outputPixelColor = (rightDistance * leftPixel + leftDistance * rightPixel + topDistance * bottomPixel + bottomDistance * topPixel) / totalDistance;
-		}
-		else if (doHorizontal)	{
-			float	leftDistance = sampleCoord.x - realLeftEdge;
-			float	rightDistance = realRightEdge - sampleCoord.x;
-			float	totalDistance = leftDistance + rightDistance;
-			vec4	leftPixel = IMG_NORM_PIXEL(inputImage, vec2(realLeftEdge, sampleCoord.y));
-			vec4	rightPixel = IMG_NORM_PIXEL(inputImage, vec2(realRightEdge, sampleCoord.y));
-			outputPixelColor = (rightDistance * leftPixel + leftDistance * rightPixel) / totalDistance;
-		}
-		else if (doVertical)	{
-			float	bottomDistance = sampleCoord.y - realBottomEdge;
-			float	topDistance = realTopEdge - sampleCoord.y;
-			float	totalDistance = bottomDistance + topDistance;
-			vec4	bottomPixel = IMG_NORM_PIXEL(inputImage, vec2(sampleCoord.x, realBottomEdge));
-			vec4	topPixel = IMG_NORM_PIXEL(inputImage, vec2(sampleCoord.x, realTopEdge));
-			outputPixelColor = (topDistance * bottomPixel + bottomDistance * topPixel) / totalDistance;	
-		}
-		else	{
-			outputPixelColor = IMG_NORM_PIXEL(inputImage, sampleCoord);	
-		}
-	}
-	else	{
-		outputPixelColor = IMG_NORM_PIXEL(inputImage, sampleCoord);
-	}
-	
-	gl_FragColor = outputPixelColor;
-}
diff --git a/nannou_isf/test_files/Edge Blur.fs b/nannou_isf/test_files/Edge Blur.fs
deleted file mode 100644
index 5c6528f72..000000000
--- a/nannou_isf/test_files/Edge Blur.fs	
+++ /dev/null
@@ -1,184 +0,0 @@
-/*{
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Blur"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "intensity",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 20.0,
-			"DEFAULT": 5.0
-		},
-		{
-			"NAME": "blurAmount",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 24.0,
-			"DEFAULT": 10.0
-		},
-		{
-			"NAME": "invert_map",
-			"TYPE": "bool",
-			"DEFAULT": 0.0
-		}
-	],
-	"PASSES": [
-		{
-			"TARGET": "halfSizeBaseRender",
-			"WIDTH": "floor($WIDTH/2.0)",
-			"HEIGHT": "floor($HEIGHT/2.0)",
-			"DESCRIPTION": "Pass 0"
-		},
-		{
-			"TARGET": "quarterSizeBaseRender",
-			"WIDTH": "floor($WIDTH/4.0)",
-			"HEIGHT": "floor($HEIGHT/4.0)",
-			"DESCRIPTION": "Pass 1"
-		},
-		{
-			"TARGET": "eighthSizeBaseRender",
-			"WIDTH": "floor($WIDTH/8.0)",
-			"HEIGHT": "floor($HEIGHT/8.0)",
-			"DESCRIPTION": "Pass 2"
-		},
-		{
-			"TARGET": "quarterGaussA",
-			"WIDTH": "floor($WIDTH/4.0)",
-			"HEIGHT": "floor($HEIGHT/4.0)",
-			"DESCRIPTION": "Pass 3"
-		},
-		{
-			"TARGET": "quarterGaussB",
-			"WIDTH": "floor($WIDTH/4.0)",
-			"HEIGHT": "floor($HEIGHT/4.0)",
-			"DESCRIPTION": "Pass 4"
-		},
-		{
-			"TARGET": "fullGaussA",
-			"DESCRIPTION": "Pass 5"
-		},
-		{
-			"TARGET": "fullGaussB",
-			"DESCRIPTION": "Pass 6"
-		}
-	]
-}*/
-
-#if __VERSION__ <= 120
-varying vec2		texOffsets[5];
-
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-in vec2		texOffsets[5];
-in vec2 left_coord;
-in vec2 right_coord;
-in vec2 above_coord;
-in vec2 below_coord;
-
-in vec2 lefta_coord;
-in vec2 righta_coord;
-in vec2 leftb_coord;
-in vec2 rightb_coord;
-#endif
-
-
-float gray(vec4 n)
-{
-	return (n.r + n.g + n.b)/3.0;
-}
-
-
-void main() {
-	int			blurLevel = int(floor(blurAmount/6.0));
-	float		blurLevelModulus = mod(blurAmount, 6.0);
-	//	first three passes are just copying the input image into the buffer at varying sizes
-	if (PASSINDEX==0)	{
-		gl_FragColor = IMG_NORM_PIXEL(inputImage, isf_FragNormCoord);
-	}
-	else if (PASSINDEX==1)	{
-		gl_FragColor = IMG_NORM_PIXEL(halfSizeBaseRender, isf_FragNormCoord);
-	}
-	else if (PASSINDEX==2)	{
-		gl_FragColor = IMG_NORM_PIXEL(quarterSizeBaseRender, isf_FragNormCoord);
-	}
-	//	start reading from the previous stage- each two passes completes a gaussian blur, then 
-	//	we increase the resolution & blur (the lower-res blurred image from the previous pass) again...
-	else if (PASSINDEX == 3)	{
-		vec4		sample0 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[2]);
-		vec4		sample3 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[3]);
-		vec4		sample4 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[4]);
-		//gl_FragColor = vec4((sample0 + sample1 + sample2).rgb / (3.0), 1.0);
-		gl_FragColor = vec4((sample0 + sample1 + sample2 + sample3 + sample4).rgba / (5.0));
-	}
-	else if (PASSINDEX == 4)	{
-		vec4		sample0 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[2]);
-		vec4		sample3 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[3]);
-		vec4		sample4 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[4]);
-		//gl_FragColor = vec4((sample0 + sample1 + sample2).rgb / (3.0), 1.0);
-		gl_FragColor = vec4((sample0 + sample1 + sample2 + sample3 + sample4).rgba / (5.0));
-	}
-	//	...writes into the full-size
-	else if (PASSINDEX == 5)	{
-		vec4		sample0 = IMG_NORM_PIXEL(quarterGaussB,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(quarterGaussB,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(quarterGaussB,texOffsets[2]);
-		gl_FragColor =  vec4((sample0 + sample1 + sample2).rgba / (3.0));
-	}
-	else if (PASSINDEX == 6)	{
-		//	this is the last pass- calculate the blurred image as i have in previous passes, then mix it in with the full-size input image using the blur amount so i get a smooth transition into the blur at low blur levels
-		vec4		sample0 = IMG_NORM_PIXEL(fullGaussA,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(fullGaussA,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(fullGaussA,texOffsets[2]);
-		vec4		blurredImg =  vec4((sample0 + sample1 + sample2).rgba / (3.0));
-		vec4		origImg = IMG_NORM_PIXEL(inputImage,isf_FragNormCoord);
-		
-		
-		
-		vec4 colorL = IMG_NORM_PIXEL(inputImage, left_coord);
-		vec4 colorR = IMG_NORM_PIXEL(inputImage, right_coord);
-		vec4 colorA = IMG_NORM_PIXEL(inputImage, above_coord);
-		vec4 colorB = IMG_NORM_PIXEL(inputImage, below_coord);
-
-		vec4 colorLA = IMG_NORM_PIXEL(inputImage, lefta_coord);
-		vec4 colorRA = IMG_NORM_PIXEL(inputImage, righta_coord);
-		vec4 colorLB = IMG_NORM_PIXEL(inputImage, leftb_coord);
-		vec4 colorRB = IMG_NORM_PIXEL(inputImage, rightb_coord);
-		
-		float		gx = (-1.0 * gray(colorLA)) + (-2.0 * gray(colorL)) + (-1.0 * gray(colorLB)) + (1.0 * gray(colorRA)) + (2.0 * gray(colorR)) + (1.0 * gray(colorRB));
-		float		gy = (1.0 * gray(colorLA)) + (2.0 * gray(colorA)) + (1.0 * gray(colorRA)) + (-1.0 * gray(colorRB)) + (-2.0 * gray(colorB)) + (-1.0 * gray(colorLB));
-		float		edge = 0.0;
-		edge = intensity * pow(gx*gx + gy*gy,0.5);
-		if (invert_map)	{
-			edge = 1.0 - edge;
-		}
-		
-		blurredImg = mix(blurredImg, origImg, edge);
-		
-		
-		
-		if (blurLevel == 0)
-			gl_FragColor = mix(origImg, blurredImg, (blurLevelModulus/6.1));
-		else
-			gl_FragColor = blurredImg;
-	}
-	
-}
diff --git a/nannou_isf/test_files/Edge Blur.vs b/nannou_isf/test_files/Edge Blur.vs
deleted file mode 100644
index e6a0f26dd..000000000
--- a/nannou_isf/test_files/Edge Blur.vs	
+++ /dev/null
@@ -1,103 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2		texOffsets[5];
-
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-out vec2		texOffsets[5];
-
-out vec2 left_coord;
-out vec2 right_coord;
-out vec2 above_coord;
-out vec2 below_coord;
-
-out vec2 lefta_coord;
-out vec2 righta_coord;
-out vec2 leftb_coord;
-out vec2 rightb_coord;
-#endif
-
-void main(void)	{
-	//	load the main shader stuff
-	isf_vertShaderInit();
-	
-	
-	int			blurLevel = int(floor(blurAmount/6.0));
-	float		blurLevelModulus = mod(blurAmount, 6.0);
-	float		blurRadius = 0.0;
-	float		blurRadiusInPixels = 0.0;
-	//	first three passes are just drawing the texture- do nothing
-	
-	//	the next four passes do gaussion blurs on the various levels
-	if (PASSINDEX==3 || PASSINDEX==5)	{
-		float		pixelWidth = 1.0/RENDERSIZE.x;
-		//	pass 3 is sampling 1/12, but writing to 1/4
-		if (PASSINDEX==3)	{
-			if (blurLevel==1)
-				blurRadius = blurLevelModulus/1.5;
-			else if (blurLevel>1)
-				blurRadius = 4.0;
-		}
-		//	pass 5 is sampling 1/4 and writing to full-size
-		else if (PASSINDEX==5)	{
-			if (blurLevel==0)
-				blurRadius = blurLevelModulus;
-			else if (blurLevel>0)
-				blurRadius = 6.0;
-		}
-		blurRadiusInPixels = pixelWidth * blurRadius;
-		texOffsets[0] = isf_FragNormCoord;
-		texOffsets[1] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0]-blurRadiusInPixels, isf_FragNormCoord[1]),0.0,1.0);
-		texOffsets[2] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0]+blurRadiusInPixels, isf_FragNormCoord[1]),0.0,1.0);
-		if (PASSINDEX==3)	{
-			texOffsets[3] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0]-(2.0*blurRadiusInPixels), isf_FragNormCoord[1]),0.0,1.0);
-			texOffsets[4] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0]+(2.0*blurRadiusInPixels), isf_FragNormCoord[1]),0.0,1.0);
-		}
-	}
-	else if (PASSINDEX==4 || PASSINDEX==6)	{
-		float		pixelHeight = 1.0/RENDERSIZE.y;
-		//	pass 4 is sampling 1/12, but writing to 1/4
-		if (PASSINDEX==4)	{
-			if (blurLevel==1)
-				blurRadius = blurLevelModulus/1.5;
-			else if (blurLevel>1)
-				blurRadius = 4.0;
-		}
-		//	pass 6 is sampling 1/4 and writing to full-size
-		else if (PASSINDEX==6)	{
-			if (blurLevel==0)
-				blurRadius = blurLevelModulus;
-			else if (blurLevel>0)
-				blurRadius = 6.0;
-			
-			vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-			vec2 d = 1.0/RENDERSIZE;
-		
-			left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
-			right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
-			above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
-			below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
-	
-			lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
-			righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
-			leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
-			rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
-		}
-		blurRadiusInPixels = pixelHeight * blurRadius;
-		texOffsets[0] = isf_FragNormCoord;
-		texOffsets[1] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]-blurRadiusInPixels),0.0,1.0);
-		texOffsets[2] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]+blurRadiusInPixels),0.0,1.0);
-		if (PASSINDEX==4)	{
-			texOffsets[3] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]-(2.0*blurRadiusInPixels)),0.0,1.0);
-			texOffsets[4] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]+(2.0*blurRadiusInPixels)),0.0,1.0);
-		}
-	}
-	
-}
diff --git a/nannou_isf/test_files/Edge Distort.fs b/nannou_isf/test_files/Edge Distort.fs
deleted file mode 100644
index 295ccbda5..000000000
--- a/nannou_isf/test_files/Edge Distort.fs	
+++ /dev/null
@@ -1,96 +0,0 @@
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Distortion Effect"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "intensity",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 10.0,
-			"DEFAULT": 0.2
-		},
-		{
-			"NAME": "invert_map",
-			"TYPE": "bool",
-			"DEFAULT": 0.0
-		}
-	]
-}*/
-
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-in vec2 left_coord;
-in vec2 right_coord;
-in vec2 above_coord;
-in vec2 below_coord;
-
-in vec2 lefta_coord;
-in vec2 righta_coord;
-in vec2 leftb_coord;
-in vec2 rightb_coord;
-#endif
-
-float gray(vec4 n)
-{
-	return (n.r + n.g + n.b)/3.0;
-}
-
-const float tau = 6.28318530718;
-
-void main()
-{
-
-	vec4 color = IMG_THIS_PIXEL(inputImage);
-	vec4 colorL = IMG_NORM_PIXEL(inputImage, left_coord);
-	vec4 colorR = IMG_NORM_PIXEL(inputImage, right_coord);
-	vec4 colorA = IMG_NORM_PIXEL(inputImage, above_coord);
-	vec4 colorB = IMG_NORM_PIXEL(inputImage, below_coord);
-
-	vec4 colorLA = IMG_NORM_PIXEL(inputImage, lefta_coord);
-	vec4 colorRA = IMG_NORM_PIXEL(inputImage, righta_coord);
-	vec4 colorLB = IMG_NORM_PIXEL(inputImage, leftb_coord);
-	vec4 colorRB = IMG_NORM_PIXEL(inputImage, rightb_coord);
-
-
-
-	float gx = (-1.0 * gray(colorLA)) + (-1.0 * gray(colorL)) + (-1.0 * gray(colorLB)) + (1.0 * gray(colorRA)) + (1.0 * gray(colorR)) + (1.0 * gray(colorRB));
-	float gy = (1.0 * gray(colorLA)) + (1.0 * gray(colorA)) + (1.0 * gray(colorRA)) + (-1.0 * gray(colorRB)) + (-1.0 * gray(colorB)) + (-1.0 * gray(colorLB));
-
-	float edge = pow(gx*gx + gy*gy,0.5);
-	float brightness = (color.r + color.g + color.b) / 3.0;
-
-	vec2 tc = isf_FragNormCoord;
-	vec2 modifiedCenter = vec2(0.5,0.5);
-	float r = distance(modifiedCenter, tc);
-	float a = atan ((tc.y-modifiedCenter.y),(tc.x-modifiedCenter.x));
-	
-	//	adjust the angle and radius based on the brightness and edge level
-	if (invert_map)	{
-		edge = 1.0 - edge;
-	}
-	r = r + intensity * (1.0-edge) * (brightness - 0.5);
-	//a = a + intensity * pow(1.0+edge,brightness);
-	
-	tc.x = r * cos(a) + 0.5;
-	tc.y = r * sin(a) + 0.5;
-	
-	vec4 final = IMG_NORM_PIXEL(inputImage, tc);
-	
-	gl_FragColor = final;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Edge Distort.vs b/nannou_isf/test_files/Edge Distort.vs
deleted file mode 100644
index 8f2188f5d..000000000
--- a/nannou_isf/test_files/Edge Distort.vs	
+++ /dev/null
@@ -1,39 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-out vec2 left_coord;
-out vec2 right_coord;
-out vec2 above_coord;
-out vec2 below_coord;
-
-out vec2 lefta_coord;
-out vec2 righta_coord;
-out vec2 leftb_coord;
-out vec2 rightb_coord;
-#endif
-
-
-void main()
-{
-	isf_vertShaderInit();
-	vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	vec2 d = 1.0/RENDERSIZE;
-	
-	left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
-	right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
-	above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
-	below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
-
-	lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
-	righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
-	leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
-	rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Edge Trace.fs b/nannou_isf/test_files/Edge Trace.fs
deleted file mode 100644
index f06df9088..000000000
--- a/nannou_isf/test_files/Edge Trace.fs	
+++ /dev/null
@@ -1,86 +0,0 @@
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Stylize"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "intensity",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 50.0,
-			"DEFAULT": 2.5
-		},
-		{
-			"NAME": "spread",
-			"TYPE": "float",
-			"MIN": 1.0,
-			"MAX": 20.0,
-			"DEFAULT": 5.0
-		},
-		{
-			"NAME": "invert_lines",
-			"TYPE": "bool",
-			"DEFAULT": 0
-		}
-	]
-}*/
-
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-in vec2 left_coord;
-in vec2 right_coord;
-in vec2 above_coord;
-in vec2 below_coord;
-
-in vec2 lefta_coord;
-in vec2 righta_coord;
-in vec2 leftb_coord;
-in vec2 rightb_coord;
-#endif
-
-float gray(vec4 n)
-{
-	return (n.r + n.g + n.b)/3.0;
-}
-
-void main()
-{
-
-	vec4 color = IMG_THIS_PIXEL(inputImage);
-	vec4 colorL = IMG_NORM_PIXEL(inputImage, left_coord);
-	vec4 colorR = IMG_NORM_PIXEL(inputImage, right_coord);
-	vec4 colorA = IMG_NORM_PIXEL(inputImage, above_coord);
-	vec4 colorB = IMG_NORM_PIXEL(inputImage, below_coord);
-
-	vec4 colorLA = IMG_NORM_PIXEL(inputImage, lefta_coord);
-	vec4 colorRA = IMG_NORM_PIXEL(inputImage, righta_coord);
-	vec4 colorLB = IMG_NORM_PIXEL(inputImage, leftb_coord);
-	vec4 colorRB = IMG_NORM_PIXEL(inputImage, rightb_coord);
-
-	float gx = (-1.0 * gray(colorLA)) + (-1.0 * gray(colorL)) + (-1.0 * gray(colorLB)) + (1.0 * gray(colorRA)) + (1.0 * gray(colorR)) + (1.0 * gray(colorRB));
-	float gy = (1.0 * gray(colorLA)) + (1.0 * gray(colorA)) + (1.0 * gray(colorRA)) + (-1.0 * gray(colorRB)) + (-1.0 * gray(colorB)) + (-1.0 * gray(colorLB));
-	
-	vec4	blurred = (colorL + colorR + colorA + colorLA + colorLB + colorRB) / 8.0;
-	float	bright = pow(gx*gx + gy*gy,0.5);
-	vec4	final = color * bright;
-
-	final.rgb = (invert_lines) ? blurred.rgb + final.rgb * intensity : blurred.rgb - final.rgb * intensity;
-	final.a = color.a;
-	
-	gl_FragColor = final;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Edge Trace.vs b/nannou_isf/test_files/Edge Trace.vs
deleted file mode 100644
index 0c87959a1..000000000
--- a/nannou_isf/test_files/Edge Trace.vs	
+++ /dev/null
@@ -1,39 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-out vec2 left_coord;
-out vec2 right_coord;
-out vec2 above_coord;
-out vec2 below_coord;
-
-out vec2 lefta_coord;
-out vec2 righta_coord;
-out vec2 leftb_coord;
-out vec2 rightb_coord;
-#endif
-
-
-void main()
-{
-	isf_vertShaderInit();
-	vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	vec2 d = spread/RENDERSIZE;
-	
-	left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
-	right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
-	above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
-	below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
-
-	lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
-	righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
-	leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
-	rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Edges.fs b/nannou_isf/test_files/Edges.fs
deleted file mode 100644
index 3138b89b2..000000000
--- a/nannou_isf/test_files/Edges.fs
+++ /dev/null
@@ -1,110 +0,0 @@
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Stylize"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "intensity",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 50.0,
-			"DEFAULT": 50.0
-		},
-		{
-			"NAME": "threshold",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.0
-		},
-		{
-			"NAME": "sobel",
-			"TYPE": "bool",
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "opaque",
-			"TYPE": "bool",
-			"DEFAULT": true
-		}
-	]
-}*/
-
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-in vec2 left_coord;
-in vec2 right_coord;
-in vec2 above_coord;
-in vec2 below_coord;
-
-in vec2 lefta_coord;
-in vec2 righta_coord;
-in vec2 leftb_coord;
-in vec2 rightb_coord;
-#endif
-
-float gray(vec4 n)
-{
-	return (n.r + n.g + n.b)/3.0;
-}
-
-void main()
-{
-
-	vec4 color = IMG_THIS_PIXEL(inputImage);
-	vec4 colorL = IMG_NORM_PIXEL(inputImage, left_coord);
-	vec4 colorR = IMG_NORM_PIXEL(inputImage, right_coord);
-	vec4 colorA = IMG_NORM_PIXEL(inputImage, above_coord);
-	vec4 colorB = IMG_NORM_PIXEL(inputImage, below_coord);
-
-	vec4 colorLA = IMG_NORM_PIXEL(inputImage, lefta_coord);
-	vec4 colorRA = IMG_NORM_PIXEL(inputImage, righta_coord);
-	vec4 colorLB = IMG_NORM_PIXEL(inputImage, leftb_coord);
-	vec4 colorRB = IMG_NORM_PIXEL(inputImage, rightb_coord);
-
-	float gx = (0.0);
-	float gy = (0.0);
-	if (sobel)	{
-		gx = (-1.0 * gray(colorLA)) + (-2.0 * gray(colorL)) + (-1.0 * gray(colorLB)) + (1.0 * gray(colorRA)) + (2.0 * gray(colorR)) + (1.0 * gray(colorRB));
-		gy = (1.0 * gray(colorLA)) + (2.0 * gray(colorA)) + (1.0 * gray(colorRA)) + (-1.0 * gray(colorRB)) + (-2.0 * gray(colorB)) + (-1.0 * gray(colorLB));
-	}
-	else	{
-		gx = (-1.0 * gray(colorLA)) + (-1.0 * gray(colorL)) + (-1.0 * gray(colorLB)) + (1.0 * gray(colorRA)) + (1.0 * gray(colorR)) + (1.0 * gray(colorRB));
-		gy = (1.0 * gray(colorLA)) + (1.0 * gray(colorA)) + (1.0 * gray(colorRA)) + (-1.0 * gray(colorRB)) + (-1.0 * gray(colorB)) + (-1.0 * gray(colorLB));
-	}
-
-	float bright = pow(gx*gx + gy*gy,0.5);
-	vec4 final = color * bright;
-	
-	//	if the brightness is below the threshold draw black
-	if (bright < threshold)	{
-		if (opaque)
-			final = vec4(0.0, 0.0, 0.0, 1.0);
-		else
-			final = vec4(0.0, 0.0, 0.0, 0.0);
-	}
-	else	{
-		final.rgb = final.rgb * intensity;
-		if (opaque)
-			final.a = 1.0;
-		else
-			final.a = color.a;
-	}
-	
-	gl_FragColor = final;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Edges.vs b/nannou_isf/test_files/Edges.vs
deleted file mode 100644
index 8f2188f5d..000000000
--- a/nannou_isf/test_files/Edges.vs
+++ /dev/null
@@ -1,39 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-out vec2 left_coord;
-out vec2 right_coord;
-out vec2 above_coord;
-out vec2 below_coord;
-
-out vec2 lefta_coord;
-out vec2 righta_coord;
-out vec2 leftb_coord;
-out vec2 rightb_coord;
-#endif
-
-
-void main()
-{
-	isf_vertShaderInit();
-	vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	vec2 d = 1.0/RENDERSIZE;
-	
-	left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
-	right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
-	above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
-	below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
-
-	lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
-	righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
-	leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
-	rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Emboss.fs b/nannou_isf/test_files/Emboss.fs
deleted file mode 100644
index 0aebf9a25..000000000
--- a/nannou_isf/test_files/Emboss.fs
+++ /dev/null
@@ -1,74 +0,0 @@
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Stylize"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "intensity",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 10.0,
-			"DEFAULT": 2.0
-		},
-		{
-			"NAME": "colorize",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "brightness",
-			"TYPE": "float",
-			"MIN": 0.25,
-			"MAX": 0.75,
-			"DEFAULT": 0.5
-		}
-	]
-}*/
-
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 rightb_coord;
-#else
-in vec2 left_coord;
-in vec2 right_coord;
-in vec2 above_coord;
-in vec2 below_coord;
-
-in vec2 lefta_coord;
-in vec2 rightb_coord;
-#endif
-
-float gray(vec4 n)
-{
-	return (n.r + n.g + n.b)/3.0;
-}
-
-void main()
-{
-
-	vec4 colorL = IMG_NORM_PIXEL(inputImage, left_coord);
-	vec4 colorR = IMG_NORM_PIXEL(inputImage, right_coord);
-	vec4 colorA = IMG_NORM_PIXEL(inputImage, above_coord);
-	vec4 colorB = IMG_NORM_PIXEL(inputImage, below_coord);
-
-	vec4 colorLA = IMG_NORM_PIXEL(inputImage, lefta_coord);
-	vec4 colorRB = IMG_NORM_PIXEL(inputImage, rightb_coord);
-
-	vec4 final = intensity * (colorR + colorB + colorRB - colorL - colorA - colorLA) + brightness;
-	float grayscale = gray(final);
-	final = mix(vec4(grayscale,grayscale,grayscale,final.a),final,colorize);
-	gl_FragColor = final;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Emboss.vs b/nannou_isf/test_files/Emboss.vs
deleted file mode 100644
index 9388af9a2..000000000
--- a/nannou_isf/test_files/Emboss.vs
+++ /dev/null
@@ -1,33 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 rightb_coord;
-#else
-out vec2 left_coord;
-out vec2 right_coord;
-out vec2 above_coord;
-out vec2 below_coord;
-
-out vec2 lefta_coord;
-out vec2 rightb_coord;
-#endif
-
-
-void main()
-{
-	isf_vertShaderInit();
-	vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	vec2 d = 1.0/RENDERSIZE;
-	
-	left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
-	right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
-	above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
-	below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
-
-	lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
-	rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Erode-Fast.fs b/nannou_isf/test_files/Erode-Fast.fs
deleted file mode 100644
index 617dcb8e2..000000000
--- a/nannou_isf/test_files/Erode-Fast.fs
+++ /dev/null
@@ -1,152 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Blur"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.25,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "intensity",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 6,
-            "MAX": 15,
-            "MIN": 1,
-            "NAME": "radius",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "DESCRIPTION": "pass 0, 1x horiz sampling (3 wide total) to prevent data loss",
-            "HEIGHT": "floor($HEIGHT/2.0)",
-            "TARGET": "halfSize",
-            "WIDTH": "floor($WIDTH/2.0)"
-        },
-        {
-            "DESCRIPTION": "pass 1, vert sampling, use radius (size is being reduced, halve coords deltas when sampling)",
-            "HEIGHT": "floor($HEIGHT/4.0)",
-            "TARGET": "quarterSize",
-            "WIDTH": "floor($WIDTH/4.0)"
-        },
-        {
-            "DESCRIPTION": "pass 2, horiz sampling, use radius (size is being increased, use normal coords deltas)",
-            "HEIGHT": "floor($HEIGHT/2.0)",
-            "TARGET": "quarterSizePassB",
-            "WIDTH": "floor($WIDTH/2.0)"
-        },
-        {
-            "DESCRIPTION": "pass 3, last pass- samples the input image and the quarterSizePassB to generate the final image at the full original resolution"
-        }
-    ]
-}
-*/
-
-
-
-vec3 rgb2hsv(vec3 c);
-
-void main()
-{
-	
-	//	generally speaking, sample a bunch of pixels, for each sample convert color val to HSV, if luma is greater than max luma, that's the new color
-	vec2		tmpCoord;
-	float		maxLuma;
-	vec4		maxLumaRGBColor = vec4(0.0);
-	vec4		sampleColorRGB;
-	vec4		sampleColorHSV;
-	vec2		pixelWidth = 1.0/RENDERSIZE.xy;
-	float		localBlurRadius;
-	bool		vertFlag = false;
-	
-	if (PASSINDEX != 3)	{
-		//	pass 0 and 2 are doing horizontal erosion
-		if (PASSINDEX==1)
-			vertFlag = true;
-		//	the first pass should have a blur radius of 1.0 simply to prevent the loss of information while reducing resolution
-		if (PASSINDEX==0)
-			localBlurRadius = 1.0;
-		//	other passes go by the blur radius!
-		else
-			localBlurRadius = float(int(radius));
-		//	sample pixels as per the blur radius...
-		for (float i=0.; i<=localBlurRadius; ++i)	{
-			if (PASSINDEX==0)	{
-				tmpCoord = vec2(clamp(isf_FragNormCoord.x+(i*pixelWidth.x), 0., 1.), isf_FragNormCoord.y);
-				sampleColorRGB = IMG_NORM_PIXEL(inputImage, tmpCoord);
-			}
-			else if (PASSINDEX==1)	{
-				tmpCoord = vec2(isf_FragNormCoord.x, clamp(isf_FragNormCoord.y+(i*pixelWidth.y/2.), 0., 1.));
-				sampleColorRGB = IMG_NORM_PIXEL(halfSize, tmpCoord);
-			}
-			else if (PASSINDEX==2)	{
-				tmpCoord = vec2(clamp(isf_FragNormCoord.x+(i*pixelWidth.x), 0., 1.), isf_FragNormCoord.y);
-				sampleColorRGB = IMG_NORM_PIXEL(quarterSize, tmpCoord);
-			}
-			//	if this is the first sample for this fragment, don't bother comparing- just set the max luma stuff
-			if (i == 0.)	{
-				maxLuma = rgb2hsv(sampleColorRGB.rgb).b;
-				maxLumaRGBColor = sampleColorRGB;
-			}
-			//	else this isn't the first sample...
-			else	{
-				//	compare, determine if it's the max luma
-				sampleColorRGB = mix(maxLumaRGBColor, sampleColorRGB, 1.*intensity/i);
-				sampleColorHSV.rgb = rgb2hsv(sampleColorRGB.rgb);
-				if (sampleColorHSV.b > maxLuma)	{
-					maxLuma = sampleColorHSV.b;
-					maxLumaRGBColor = sampleColorRGB;
-				}
-				//	do another sample for the negative coordinate
-				if (PASSINDEX==0)	{
-					tmpCoord = vec2(clamp(isf_FragNormCoord.x-(i*pixelWidth.x), 0., 1.), isf_FragNormCoord.y);
-					sampleColorRGB = IMG_NORM_PIXEL(inputImage, tmpCoord);
-				}
-				else if (PASSINDEX==1)	{
-					tmpCoord = vec2(isf_FragNormCoord.x, clamp(isf_FragNormCoord.y-(i*pixelWidth.y/2.), 0., 1.));
-					sampleColorRGB = IMG_NORM_PIXEL(halfSize, tmpCoord);
-				}
-				else if (PASSINDEX==2)	{
-					tmpCoord = vec2(clamp(isf_FragNormCoord.x-(i*pixelWidth.x), 0., 1.), isf_FragNormCoord.y);
-					sampleColorRGB = IMG_NORM_PIXEL(quarterSize, tmpCoord);
-				}
-				sampleColorRGB = mix(maxLumaRGBColor, sampleColorRGB, 1.*intensity/i);
-				sampleColorHSV.rgb = rgb2hsv(sampleColorRGB.rgb);
-				if (sampleColorHSV.b > maxLuma)	{
-					maxLuma = sampleColorHSV.b;
-					maxLumaRGBColor = sampleColorRGB;
-				}
-			}
-		}
-		gl_FragColor = maxLumaRGBColor;
-	}
-	//	last pass
-	else if (PASSINDEX==3)	{
-		vec4		origPixel = IMG_NORM_PIXEL(inputImage,isf_FragNormCoord);
-		vec4		erodedPixel = IMG_NORM_PIXEL(quarterSizePassB,isf_FragNormCoord);
-		vec4		finalPixel = max(origPixel,erodedPixel);
-		gl_FragColor = mix(origPixel,finalPixel, clamp(min(radius-1.0, intensity*10.0), 0., 1.));
-	}
-}
-
-
-vec3 rgb2hsv(vec3 c)	{
-	vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-	//vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
-	//vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
-	vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
-	vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
-	
-	float d = q.x - min(q.w, q.y);
-	float e = 1.0e-10;
-	return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
-}
-
diff --git a/nannou_isf/test_files/Erode.fs b/nannou_isf/test_files/Erode.fs
deleted file mode 100644
index 2fbb4ba5a..000000000
--- a/nannou_isf/test_files/Erode.fs
+++ /dev/null
@@ -1,132 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Blur"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "intensity",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 2,
-            "MAX": 15,
-            "MIN": 1,
-            "NAME": "bleedRadius",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "TARGET": "firstPass"
-        },
-        {
-        }
-    ]
-}
-*/
-
-
-
-vec3 rgb2hsv(vec3 c);
-
-void main()
-{
-	
-	//	generally speaking, sample a bunch of pixels, for each sample convert color val to HSV, if luma is greater than max luma, that's the new color
-	vec2		tmpCoord;
-	float		maxLuma;
-	vec4		maxLumaRGBColor = vec4(0.0);
-	vec4		sampleColorRGB;
-	vec4		sampleColorHSV;
-	
-	if (PASSINDEX==0)	{
-		//	5 samples on either side + the source pixel = 11 total samples
-		for (float i=0.; i<=float(int(bleedRadius)); ++i)	{
-			tmpCoord = vec2(clamp(gl_FragCoord.x+i,0.,RENDERSIZE.x), gl_FragCoord.y);
-			sampleColorRGB = IMG_PIXEL(inputImage, tmpCoord);
-			//	if this is the first sample for this fragment, don't bother comparing- just set the max luma stuff
-			if (i == 0.)	{
-				maxLuma = rgb2hsv(sampleColorRGB.rgb).b;
-				maxLumaRGBColor = sampleColorRGB;
-			}
-			//	else this isn't the first sample...
-			else	{
-				//	compare, determine if it's the max luma
-				sampleColorRGB = mix(maxLumaRGBColor, sampleColorRGB, 1.*intensity/i);
-				sampleColorHSV.rgb = rgb2hsv(sampleColorRGB.rgb);
-				if (sampleColorHSV.b > maxLuma)	{
-					maxLuma = sampleColorHSV.b;
-					maxLumaRGBColor = sampleColorRGB;
-				}
-				//	do another sample for the negative coordinate
-				tmpCoord = vec2(clamp(gl_FragCoord.x-i,0.,RENDERSIZE.x), gl_FragCoord.y);
-				sampleColorRGB = IMG_PIXEL(inputImage, tmpCoord);
-				sampleColorRGB = mix(maxLumaRGBColor, sampleColorRGB, 1.*intensity/i);
-				sampleColorHSV.rgb = rgb2hsv(sampleColorRGB.rgb);
-				if (sampleColorHSV.b > maxLuma)	{
-					maxLuma = sampleColorHSV.b;
-					maxLumaRGBColor = sampleColorRGB;
-				}
-			}
-		}
-		gl_FragColor = maxLumaRGBColor;
-		
-	}
-	else if (PASSINDEX==1)	{
-		//	5 samples up and down + the source pixel = 11 total samples
-		for (float i=0.; i<=float(int(bleedRadius)); ++i)	{
-			tmpCoord = vec2(gl_FragCoord.x, clamp(gl_FragCoord.y+i,0.,RENDERSIZE.y));
-			sampleColorRGB = IMG_PIXEL(firstPass, tmpCoord);
-			//	if this is the first sample for this fragment, don't bother comparing- just set the max luma stuff
-			if (i == 0.)	{
-				maxLuma = rgb2hsv(sampleColorRGB.rgb).b;
-				maxLumaRGBColor = sampleColorRGB;
-			}
-			//	else this isn't the first sample...
-			else	{
-				//	compare, determine if it's the max luma
-				sampleColorRGB = mix(maxLumaRGBColor, sampleColorRGB, 1.*intensity/i);
-				sampleColorHSV.rgb = rgb2hsv(sampleColorRGB.rgb);
-				if (sampleColorHSV.b > maxLuma)	{
-					maxLuma = sampleColorHSV.b;
-					maxLumaRGBColor = sampleColorRGB;
-				}
-				//	do another sample for the negative coordinate
-				tmpCoord = vec2(gl_FragCoord.x, clamp(gl_FragCoord.y-i,0.,RENDERSIZE.y));
-				sampleColorRGB = IMG_PIXEL(firstPass, tmpCoord);
-				sampleColorRGB = mix(maxLumaRGBColor, sampleColorRGB, 1.*intensity/i);
-				sampleColorHSV.rgb = rgb2hsv(sampleColorRGB.rgb);
-				if (sampleColorHSV.b > maxLuma)	{
-					maxLuma = sampleColorHSV.b;
-					maxLumaRGBColor = sampleColorRGB;
-				}
-			}
-		}
-		gl_FragColor = maxLumaRGBColor;
-		
-	}
-	
-}
-
-
-vec3 rgb2hsv(vec3 c)	{
-	vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-	//vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
-	//vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
-	vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
-	vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
-	
-	float d = q.x - min(q.w, q.y);
-	float e = 1.0e-10;
-	return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
-}
-
diff --git a/nannou_isf/test_files/Etch-a-Sketch.fs b/nannou_isf/test_files/Etch-a-Sketch.fs
deleted file mode 100644
index 3ca8a5b03..000000000
--- a/nannou_isf/test_files/Etch-a-Sketch.fs
+++ /dev/null
@@ -1,138 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Drawing"
-    ],
-    "CREDIT": "VIDVOX",
-    "DESCRIPTION": "Draw images one pixel at a time",
-    "INPUTS": [
-        {
-            "NAME": "moveUp",
-            "TYPE": "event"
-        },
-        {
-            "NAME": "moveDown",
-            "TYPE": "event"
-        },
-        {
-            "NAME": "moveLeft",
-            "TYPE": "event"
-        },
-        {
-            "NAME": "moveRight",
-            "TYPE": "event"
-        },
-        {
-            "DEFAULT": [
-                0.5,
-                0.5,
-                0.5,
-                1
-            ],
-            "NAME": "penColor",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": 0.05,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "penSize",
-            "TYPE": "float"
-        },
-        {
-            "NAME": "resetPosition",
-            "TYPE": "event"
-        },
-        {
-            "NAME": "clearBuffer",
-            "TYPE": "event"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0,
-                0,
-                0
-            ],
-            "NAME": "clearColor",
-            "TYPE": "color"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "FLOAT": true,
-            "HEIGHT": "1",
-            "PERSISTENT": true,
-            "TARGET": "currentPosition",
-            "WIDTH": "1"
-        },
-        {
-            "PERSISTENT": true,
-            "TARGET": "lastState"
-        }
-    ]
-}
-*/
-
-
-float round (float x)	{
-	if (fract(x) < 0.5)
-		return floor(x);
-	else
-		return ceil(x);	
-}
-
-
-void main()	{
-	vec4		inputPixelColor = vec4(0.0);
-	
-	if (PASSINDEX == 0)	{
-		if ((FRAMEINDEX==0)||(resetPosition))
-			inputPixelColor = vec4(0.5,0.5,0.0,1.0);
-		else
-			inputPixelColor = IMG_THIS_PIXEL(currentPosition);
-		
-		vec2		pos = inputPixelColor.rg;
-		vec2		outputSize = IMG_SIZE(lastState);
-		vec2		penSizeInPixels = vec2(penSize * min(outputSize.x,outputSize.y));
-		penSizeInPixels.x = (penSizeInPixels.x < 1.0) ? (1.0) : (penSizeInPixels.x);
-		penSizeInPixels.y = (penSizeInPixels.y < 1.0) ? (1.0) : (penSizeInPixels.y);
-		vec2		normalizedPenSize = penSizeInPixels / outputSize;
-		
-		if ((moveUp)&&(pos.y<1.0-normalizedPenSize.y))	{
-			pos.y = pos.y + normalizedPenSize.y;
-		}
-		else if ((moveDown)&&(pos.y>0.0))	{
-			pos.y = pos.y - normalizedPenSize.y;
-		}
-		else if ((moveLeft)&&(pos.x>0.0))	{
-			pos.x = pos.x - normalizedPenSize.x;
-		}
-		else if ((moveRight)&&(pos.x<1.0-normalizedPenSize.x))	{
-			pos.x = pos.x + normalizedPenSize.x;
-		}
-		pos = min(pos,vec2(1.0)-normalizedPenSize);
-		pos = max(pos,vec2(0.0));
-		inputPixelColor.rg = pos;
-	}
-	else if (PASSINDEX == 1)	{
-		if ((FRAMEINDEX==0)||(clearBuffer))	{
-			inputPixelColor = clearColor;
-		}
-		else	{
-			vec4		posPixel = IMG_PIXEL(currentPosition,vec2(0.0));
-			vec2		pos = posPixel.rg * RENDERSIZE;
-			vec2		penSizeInPixels = vec2(penSize * min(RENDERSIZE.x,RENDERSIZE.y));
-			penSizeInPixels.x = (penSizeInPixels.x < 1.0) ? (1.0) : (penSizeInPixels.x);
-			penSizeInPixels.y = (penSizeInPixels.y < 1.0) ? (1.0) : (penSizeInPixels.y);
-			//pos.x = round(pos.x);
-			//pos.y = round(pos.y);
-			if (((gl_FragCoord.x) >= pos.x)&&((gl_FragCoord.y) >= pos.y)&&((gl_FragCoord.x) < pos.x + penSizeInPixels.x)&&((gl_FragCoord.y) < pos.y + penSizeInPixels.y))
-				inputPixelColor = penColor;
-			else
-				inputPixelColor = IMG_THIS_PIXEL(lastState);
-		}
-	}
-	
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/Exposure Adjust.fs b/nannou_isf/test_files/Exposure Adjust.fs
deleted file mode 100644
index 32133f09e..000000000
--- a/nannou_isf/test_files/Exposure Adjust.fs	
+++ /dev/null
@@ -1,30 +0,0 @@
-/*{
-	"CREDIT": "by carter rosenberg",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Color Adjustment"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "inputEV",
-			"TYPE": "float",
-			"MIN": -10.0,
-			"MAX": 10.0,
-			"DEFAULT": 0.5
-		}
-	]
-}*/
-
-
-
-void main() {
-	//	based on
-	//	https://developer.apple.com/library/mac/documentation/graphicsimaging/reference/CoreImageFilterReference/Reference/reference.html#//apple_ref/doc/filter/ci/CIExposureAdjust
-	vec4		tmpColorA = IMG_THIS_PIXEL(inputImage);
-	tmpColorA.rgb = tmpColorA.rgb * pow(2.0, inputEV);
-	gl_FragColor = tmpColorA;
-}
diff --git a/nannou_isf/test_files/FFT Color Lines.fs b/nannou_isf/test_files/FFT Color Lines.fs
deleted file mode 100644
index efdf20d99..000000000
--- a/nannou_isf/test_files/FFT Color Lines.fs	
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Audio Visualizer"
-  ],
-  "ISFVSN": "2",
-  "DESCRIPTION" : "Visualizes an FFT analysis image with custom set colors for frequency domain",
-  "INPUTS" : [
-    {
-      "NAME" : "fftImage",
-      "TYPE" : "audioFFT"
-    },
-    {
-      "NAME" : "waveImage",
-      "TYPE" : "audio"
-    },
-    {
-      "NAME" : "gainFFT",
-      "TYPE" : "float",
-      "MAX" : 5,
-      "DEFAULT" : 1,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "rangeFFT",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0.9,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "waveSize",
-      "TYPE" : "float",
-      "MAX" : 0.5,
-      "DEFAULT" : 0.05,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "vertical",
-      "TYPE" : "bool",
-      "DEFAULT" : 1
-    },
-    {
-      "NAME" : "stereo",
-      "TYPE" : "bool",
-      "DEFAULT" : 1
-    },
-    {
-      "NAME" : "color1",
-      "TYPE" : "color",
-      "DEFAULT" : [
-        0.2087394440714313,
-        0.9861069917678833,
-        0.1871179742814854,
-        1
-      ]
-    },
-    {
-      "NAME" : "color2",
-      "TYPE" : "color",
-      "DEFAULT" : [
-        0,
-        0.5,
-        1,
-        1
-      ]
-    },
-    {
-      "NAME" : "color3",
-      "TYPE" : "color",
-      "DEFAULT" : [
-        0,
-        1,
-        0,
-        1
-      ]
-    },
-    {
-      "NAME" : "wavecolor",
-      "TYPE" : "color",
-      "DEFAULT" : [
-        1,
-        1,
-        1,
-        1
-      ]
-    }
-  ],
-  "CREDIT" : "by VIDVOX"
-}
-*/
-
-
-
-void main() {
-	
-	vec2		loc = isf_FragNormCoord;
-
-	if (vertical)	{
-		loc.x = isf_FragNormCoord[1];
-		loc.y = isf_FragNormCoord[0];
-	}
-	
-	vec4 mixColor = color1;
-	
-	if (loc.y > 0.5)	{
-		mixColor = mix (color2,color3,(loc.y-0.5)*2.0);
-	}
-	else	{
-		mixColor = mix (color1,color2,(loc.y*2.0));
-	}
-	
-	loc.y = loc.y * rangeFFT;
-	
-	vec2		fftSize = IMG_SIZE(fftImage);
-	vec2		rawSize = IMG_SIZE(waveImage);
-	float		channel = 0.5;
-	float		offset = 0.0;
-	if (stereo == true)	{
-		channel = (loc.x > 0.5) ? 0.0 : 1.0;
-		offset = (loc.x > 0.5) ? 0.25 : -0.25;
-	}
-	
-	vec4 		fft = IMG_NORM_PIXEL(fftImage, vec2(loc.y,channel));
-	fft = mixColor * fft.r * 3.0;
-	fft.rgb = gainFFT * fft.rgb;
-	vec2		waveLoc = vec2(loc.y,channel);
-	vec4		wave = IMG_NORM_PIXEL(waveImage, waveLoc)+offset;
-	//wave = vec4(wave.r);
-	vec4		waveAdd = ((1.0 - smoothstep(0.0, waveSize, abs(wave - loc.x))) * wavecolor) * wavecolor.a;
-	fft += waveAdd;
-	fft.a = mixColor.a + clamp((waveAdd.r + waveAdd.g + waveAdd.b) * wavecolor.a,0.0,1.0);
-	
-	gl_FragColor = fft;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/FFT Filled Waveform.fs b/nannou_isf/test_files/FFT Filled Waveform.fs
deleted file mode 100644
index 7272f49fe..000000000
--- a/nannou_isf/test_files/FFT Filled Waveform.fs	
+++ /dev/null
@@ -1,95 +0,0 @@
-/*{
-	"DESCRIPTION": "Visualizes an FFT analysis image with custom set colors for frequency domain",
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Audio Visualizer"
-	],
-	"INPUTS": [
-		{
-			"NAME": "fftImage",
-			"TYPE": "audioFFT"
-		},
-		{
-			"NAME": "strokeSize",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 0.25,
-			"DEFAULT": 0.1
-		},
-		{
-			"NAME": "gain",
-			"TYPE": "float",
-			"MIN": 1.0,
-			"MAX": 5.0,
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "minRange",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.1
-		},
-		{
-			"NAME": "maxRange",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.9
-		},
-		{
-			"NAME": "topColor",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.0,
-				0.0,
-				0.0,
-				0.0
-			]
-		},
-		{
-			"NAME": "bottomColor",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.0,
-				0.5,
-				0.9,
-				1.0
-			]
-		},
-		{
-			"NAME": "strokeColor",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.25,
-				0.25,
-				0.25,
-				1.0
-			]
-		}
-	]
-}*/
-
-
-
-void main() {
-	
-	vec2 loc = isf_FragNormCoord;
-	
-	//	the fftImage is 256 steps
-	loc.x = loc.x * abs(maxRange - minRange) + minRange;
-	
-	vec4 fft = IMG_NORM_PIXEL(fftImage, vec2(loc.x,0.5));
-	float fftVal = gain * (fft.r + fft.g + fft.b) / 3.0;
-	if (loc.y > fftVal)
-		fft = topColor;
-	else
-		fft = bottomColor;
-	if ((strokeSize > 0.0) && (abs(fftVal - loc.y) < strokeSize))	{
-		fft = mix(strokeColor, fft, abs(fftVal - loc.y) / strokeSize);
-	}
-	
-	//(smoothstep(0.0, stroke, abs(fftVal - loc.y))) * strokeColor);
-	gl_FragColor = fft;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/FFT Spectrogram.fs b/nannou_isf/test_files/FFT Spectrogram.fs
deleted file mode 100644
index 845ba2030..000000000
--- a/nannou_isf/test_files/FFT Spectrogram.fs	
+++ /dev/null
@@ -1,159 +0,0 @@
-/*{
-	"DESCRIPTION": "Buffers the incoming FFTs for timed display",
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Audio Visualizer"
-	],
-	"INPUTS": [
-		{
-			"NAME": "fftImage",
-			"TYPE": "audioFFT"
-		},
-		{
-			"NAME": "clear",
-			"TYPE": "event"
-		},
-		{
-			"NAME": "gain",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 2.0,
-			"DEFAULT":1.0
-		},
-		{
-			"NAME": "range",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "axis_scale",
-			"TYPE": "float",
-			"MIN": 1.0,
-			"MAX": 6.0,
-			"DEFAULT": 1.25
-		},
-		{
-			"NAME": "lumaMode",
-			"TYPE": "bool",
-			"DEFAULT": 0.0
-		},
-		{
-			"NAME": "color1",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.0,
-				0.5,
-				1.0,
-				1.0
-			]
-		},
-		{
-			"NAME": "color2",
-			"TYPE": "color",
-			"DEFAULT": [
-				1.0,
-				0.0,
-				0.0,
-				1.0
-			]
-		},
-		{
-			"NAME": "color3",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.0,
-				1.0,
-				0.0,
-				1.0
-			]
-		}
-	],
-	"PASSES": [
-		{
-			"TARGET": "fftValues",
-			"DESCRIPTION": "This buffer stores all of the previous fft values",
-			"HEIGHT": "512",
-			"FLOAT": true,
-			"PERSISTENT": true
-		},
-		{
-	
-		}
-	]
-    
-}*/
-
-void main()
-{
-	//    first pass- read the value from the fft image, store it in the "fftValues" persistent buffer
-	if (PASSINDEX==0)    {
-		//    the first column of pixels is copied from the newly received fft image
-		if (clear)	{
-			gl_FragColor = vec4(0.0);
-		}
-		else if (gl_FragCoord.x<1.0)    {
-			vec2		loc = vec2(isf_FragNormCoord.y, isf_FragNormCoord.x);
-			vec4		rawColor = IMG_NORM_PIXEL(fftImage, loc);
-			gl_FragColor = rawColor;
-		}
-		//    all other columns of pixels come from the "fftValues" persistent buffer (we're scrolling)
-		else    {
-			gl_FragColor = IMG_PIXEL(fftValues, vec2(gl_FragCoord.x-1.0, gl_FragCoord.y));
-		}
-	}
-	//    second pass- read from the buffer of raw values, apply gain/range and colors
-	else if (PASSINDEX==1)    {
-		vec2		loc = vec2(isf_FragNormCoord.x, pow(isf_FragNormCoord.y*range, axis_scale));
-		vec4		rawColor = IMG_NORM_PIXEL(fftValues, loc);
-	
-		rawColor = rawColor * vec4(gain);
-	
-		float		mixVal = 0.0;
-		
-		if (lumaMode)	{
-			float		locus_1 = 0.20;
-			float		locus_2 = 0.50;
-			float		locus_3 = 0.75;
-	
-			if (rawColor.r < locus_1)    {
-				mixVal = (rawColor.r)/(locus_1);
-				gl_FragColor = mix(vec4(0,0,0,0), color1, mixVal);
-			}
-			else if (rawColor.r>=locus_1 && rawColor.r<locus_2)    {
-				mixVal = (rawColor.r - locus_1)/(locus_2 - locus_1);
-				gl_FragColor = mix(color1, color2, mixVal);
-			}
-			else if (rawColor.r>=locus_2 && rawColor.r<locus_3)    {
-				mixVal = (rawColor.r - locus_2)/(locus_3 - locus_2);
-				gl_FragColor = mix(color2, color3, mixVal);
-			}
-			else if (rawColor.r>=locus_3)    {
-				mixVal = (rawColor.r - locus_3);
-				gl_FragColor = mix(color3, vec4(1,1,1,1), mixVal);
-			}
-		}
-		else	{
-			float		locus_1 = 0.25;
-			float		locus_2 = 0.5;
-			float		locus_3 = 0.75;
-	
-			if (loc.y < locus_1)    {
-				gl_FragColor = rawColor.r * color1;
-			}
-			else if (loc.y>=locus_1 && loc.y<locus_2)    {
-				mixVal = (loc.y - locus_1)/(locus_2 - locus_1);
-				gl_FragColor = rawColor.r * mix(color1, color2, mixVal);
-			}
-			else if (loc.y>=locus_2 && loc.y<locus_3)    {
-				mixVal = (loc.y - locus_2)/(locus_3 - locus_2);
-				gl_FragColor = rawColor.r * mix(color2, color3, mixVal);
-			}
-			else if (loc.y > locus_3)    {
-				gl_FragColor = rawColor.r * color3;
-			}
-		}
-	}
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Fade Color.fs b/nannou_isf/test_files/Fade Color.fs
deleted file mode 100644
index ff264cea0..000000000
--- a/nannou_isf/test_files/Fade Color.fs	
+++ /dev/null
@@ -1,69 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Dissolve"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/fadecolor.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.25,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "colorPhase",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0,
-                0,
-                1
-            ],
-            "NAME": "color",
-            "TYPE": "color"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// author: gre
-// License: MIT
-vec4 transition (vec2 uv) {
-  return mix(
-    mix(color, getFromColor(uv), smoothstep(1.0-colorPhase, 0.0, progress)),
-    mix(color, getToColor(uv), smoothstep(    colorPhase, 1.0, progress)),
-    progress);
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Fade Gray Scale.fs b/nannou_isf/test_files/Fade Gray Scale.fs
deleted file mode 100644
index a0f67d1de..000000000
--- a/nannou_isf/test_files/Fade Gray Scale.fs	
+++ /dev/null
@@ -1,67 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Dissolve"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/fadegrayscale.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.3,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "intensity",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: gre
-// License: MIT
-
- 
-vec3 grayscale (vec3 color) {
-  return vec3(0.2126*color.r + 0.7152*color.g + 0.0722*color.b);
-}
- 
-vec4 transition (vec2 uv) {
-  vec4 fc = getFromColor(uv);
-  vec4 tc = getToColor(uv);
-  return mix(
-    mix(vec4(grayscale(fc.rgb), 1.0), fc, smoothstep(1.0-intensity, 0.0, progress)),
-    mix(vec4(grayscale(tc.rgb), 1.0), tc, smoothstep(    intensity, 1.0, progress)),
-    progress);
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Fade.fs b/nannou_isf/test_files/Fade.fs
deleted file mode 100644
index a731bd92a..000000000
--- a/nannou_isf/test_files/Fade.fs
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
-{
-  "INPUTS" : [
-    {
-      "TYPE" : "image",
-      "NAME" : "startImage"
-    },
-    {
-      "NAME" : "endImage",
-      "TYPE" : "image"
-    },
-    {
-      "MAX" : 1,
-      "TYPE" : "float",
-      "MIN" : 0,
-      "NAME" : "progress",
-      "DEFAULT" : 0
-    }
-  ],
-  "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/fade.glsl",
-  "DESCRIPTION": "",
-  "CATEGORIES" : [
-    "Dissolve"
-  ],
-  "ISFVSN" : "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// author: gre
-// license: MIT
-
-vec4 transition (vec2 uv) {
-  return mix(
-    getFromColor(uv),
-    getToColor(uv),
-    progress
-  );
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/False Color.fs b/nannou_isf/test_files/False Color.fs
deleted file mode 100644
index ec23b2ac5..000000000
--- a/nannou_isf/test_files/False Color.fs	
+++ /dev/null
@@ -1,42 +0,0 @@
-/*{
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Color Effect"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "brightColor",
-			"TYPE": "color",
-			"DEFAULT": [
-				1.0,
-				0.9,
-				0.8,
-				1.0
-			]
-		},
-		{
-			"NAME": "darkColor",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.3,
-				0.0,
-				0.0,
-				1.0
-			]
-		}
-	]
-}*/
-
-//const vec4		lumcoeff = vec4(0.299, 0.587, 0.114, 0.0);
-const vec4 	lumcoeff = vec4(0.2126, 0.7152, 0.0722, 0.0);
-
-void main() {
-	vec4		srcPixel = IMG_THIS_PIXEL(inputImage);
-	float		luminance = dot(srcPixel,lumcoeff);
-	gl_FragColor = mix(vec4(darkColor.rgb, srcPixel.a), vec4(brightColor.rgb, srcPixel.a), luminance);
-}
diff --git a/nannou_isf/test_files/Fast Blur.fs b/nannou_isf/test_files/Fast Blur.fs
deleted file mode 100644
index d6a166dee..000000000
--- a/nannou_isf/test_files/Fast Blur.fs	
+++ /dev/null
@@ -1,122 +0,0 @@
-/*{
-	"CREDIT": "by zoidberg WOOP WOOP WOOP WOOP WOOP",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Blur"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "blurAmount",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 12.0,
-			"DEFAULT": 12.0
-		}
-	],
-	"PASSES": [
-		{
-			"TARGET": "halfSizeBaseRender",
-			"WIDTH": "floor($WIDTH/2.0)",
-			"HEIGHT": "floor($HEIGHT/2.0)",
-			"DESCRIPTION": "Pass 0"
-		},
-		{
-			"TARGET": "quarterSizeBaseRender",
-			"WIDTH": "floor($WIDTH/4.0)",
-			"HEIGHT": "floor($HEIGHT/4.0)",
-			"DESCRIPTION": "Pass 1"
-		},
-		{
-			"TARGET": "eighthSizeBaseRender",
-			"WIDTH": "floor($WIDTH/8.0)",
-			"HEIGHT": "floor($HEIGHT/8.0)",
-			"DESCRIPTION": "Pass 2"
-		},
-		{
-			"TARGET": "quarterGaussA",
-			"WIDTH": "floor($WIDTH/4.0)",
-			"HEIGHT": "floor($HEIGHT/4.0)",
-			"DESCRIPTION": "Pass 3"
-		},
-		{
-			"TARGET": "quarterGaussB",
-			"WIDTH": "floor($WIDTH/4.0)",
-			"HEIGHT": "floor($HEIGHT/4.0)",
-			"DESCRIPTION": "Pass 4"
-		},
-		{
-			"TARGET": "fullGaussA",
-			"DESCRIPTION": "Pass 5"
-		},
-		{
-			"TARGET": "fullGaussB",
-			"DESCRIPTION": "Pass 6"
-		}
-	]
-}*/
-
-
-#if __VERSION__ <= 120
-varying vec2		texOffsets[5];
-#else
-in vec2		texOffsets[5];
-#endif
-
-
-void main() {
-	int			blurLevel = int(floor(blurAmount/6.0));
-	float		blurLevelModulus = mod(blurAmount, 6.0);
-	//	first three passes are just copying the input image into the buffer at varying sizes
-	if (PASSINDEX==0)	{
-		gl_FragColor = IMG_NORM_PIXEL(inputImage, isf_FragNormCoord);
-	}
-	else if (PASSINDEX==1)	{
-		gl_FragColor = IMG_NORM_PIXEL(halfSizeBaseRender, isf_FragNormCoord);
-	}
-	else if (PASSINDEX==2)	{
-		gl_FragColor = IMG_NORM_PIXEL(quarterSizeBaseRender, isf_FragNormCoord);
-	}
-	//	start reading from the previous stage- each two passes completes a gaussian blur, then 
-	//	we increase the resolution & blur (the lower-res blurred image from the previous pass) again...
-	else if (PASSINDEX == 3)	{
-		vec4		sample0 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[2]);
-		vec4		sample3 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[3]);
-		vec4		sample4 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[4]);
-		//gl_FragColor = vec4((sample0 + sample1 + sample2).rgb / (3.0), 1.0);
-		gl_FragColor = vec4((sample0 + sample1 + sample2 + sample3 + sample4).rgba / (5.0));
-	}
-	else if (PASSINDEX == 4)	{
-		vec4		sample0 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[2]);
-		vec4		sample3 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[3]);
-		vec4		sample4 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[4]);
-		//gl_FragColor = vec4((sample0 + sample1 + sample2).rgb / (3.0), 1.0);
-		gl_FragColor = vec4((sample0 + sample1 + sample2 + sample3 + sample4).rgba / (5.0));
-	}
-	//	...writes into the full-size
-	else if (PASSINDEX == 5)	{
-		vec4		sample0 = IMG_NORM_PIXEL(quarterGaussB,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(quarterGaussB,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(quarterGaussB,texOffsets[2]);
-		gl_FragColor =  vec4((sample0 + sample1 + sample2).rgba / (3.0));
-	}
-	else if (PASSINDEX == 6)	{
-		//	this is the last pass- calculate the blurred image as i have in previous passes, then mix it in with the full-size input image using the blur amount so i get a smooth transition into the blur at low blur levels
-		vec4		sample0 = IMG_NORM_PIXEL(fullGaussA,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(fullGaussA,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(fullGaussA,texOffsets[2]);
-		vec4		blurredImg =  vec4((sample0 + sample1 + sample2).rgba / (3.0));
-		if (blurLevel == 0)
-			gl_FragColor = mix(IMG_NORM_PIXEL(inputImage,isf_FragNormCoord), blurredImg, (blurLevelModulus/6.1));
-		else
-			gl_FragColor = blurredImg;
-	}
-	
-}
diff --git a/nannou_isf/test_files/Fast Blur.vs b/nannou_isf/test_files/Fast Blur.vs
deleted file mode 100644
index 3c9a24ee7..000000000
--- a/nannou_isf/test_files/Fast Blur.vs	
+++ /dev/null
@@ -1,70 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2		texOffsets[5];
-#else
-out vec2		texOffsets[5];
-#endif
-
-void main(void)	{
-	//	load the main shader stuff
-	isf_vertShaderInit();
-	
-	
-	int			blurLevel = int(floor(blurAmount/6.0));
-	float		blurLevelModulus = mod(blurAmount, 6.0);
-	float		blurRadius = 0.0;
-	float		blurRadiusInPixels = 0.0;
-	//	first three passes are just drawing the texture- do nothing
-	
-	//	the next four passes do gaussion blurs on the various levels
-	if (PASSINDEX==3 || PASSINDEX==5)	{
-		float		pixelWidth = 1.0/RENDERSIZE.x;
-		//	pass 3 is sampling 1/12, but writing to 1/4
-		if (PASSINDEX==3)	{
-			if (blurLevel==1)
-				blurRadius = blurLevelModulus/1.5;
-			else if (blurLevel>1)
-				blurRadius = 4.0;
-		}
-		//	pass 5 is sampling 1/4 and writing to full-size
-		else if (PASSINDEX==5)	{
-			if (blurLevel==0)
-				blurRadius = blurLevelModulus;
-			else if (blurLevel>0)
-				blurRadius = 6.0;
-		}
-		blurRadiusInPixels = pixelWidth * blurRadius;
-		texOffsets[0] = isf_FragNormCoord;
-		texOffsets[1] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0]-blurRadiusInPixels, isf_FragNormCoord[1]),0.0,1.0);
-		texOffsets[2] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0]+blurRadiusInPixels, isf_FragNormCoord[1]),0.0,1.0);
-		if (PASSINDEX==3)	{
-			texOffsets[3] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0]-(2.0*blurRadiusInPixels), isf_FragNormCoord[1]),0.0,1.0);
-			texOffsets[4] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0]+(2.0*blurRadiusInPixels), isf_FragNormCoord[1]),0.0,1.0);
-		}
-	}
-	else if (PASSINDEX==4 || PASSINDEX==6)	{
-		float		pixelHeight = 1.0/RENDERSIZE.y;
-		//	pass 4 is sampling 1/12, but writing to 1/4
-		if (PASSINDEX==4)	{
-			if (blurLevel==1)
-				blurRadius = blurLevelModulus/1.5;
-			else if (blurLevel>1)
-				blurRadius = 4.0;
-		}
-		//	pass 6 is sampling 1/4 and writing to full-size
-		else if (PASSINDEX==6)	{
-			if (blurLevel==0)
-				blurRadius = blurLevelModulus;
-			else if (blurLevel>0)
-				blurRadius = 6.0;
-		}
-		blurRadiusInPixels = pixelHeight * blurRadius;
-		texOffsets[0] = isf_FragNormCoord;
-		texOffsets[1] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]-blurRadiusInPixels),0.0,1.0);
-		texOffsets[2] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]+blurRadiusInPixels),0.0,1.0);
-		if (PASSINDEX==4)	{
-			texOffsets[3] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]-(2.0*blurRadiusInPixels)),0.0,1.0);
-			texOffsets[4] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]+(2.0*blurRadiusInPixels)),0.0,1.0);
-		}
-	}
-	
-}
diff --git a/nannou_isf/test_files/FastMosh.fs b/nannou_isf/test_files/FastMosh.fs
deleted file mode 100644
index f1f527f32..000000000
--- a/nannou_isf/test_files/FastMosh.fs
+++ /dev/null
@@ -1,160 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Feedback",
-        "Glitch"
-    ],
-    "CREDIT": "by VIDVOX",
-    "DESCRIPTION": "Does a fast faked data-mosh style",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 1,
-            "NAME": "update_keyframe",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 0.95,
-            "MAX": 1,
-            "MIN": 0.01,
-            "NAME": "update_rate",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 10,
-            "MIN": 0,
-            "NAME": "sharpen",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.25,
-            "MAX": 2,
-            "MIN": 0,
-            "NAME": "blur",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.25,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "posterize",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABELS": [
-                "relative",
-                "absolute",
-                "difference"
-            ],
-            "NAME": "mode",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1,
-                2
-            ]
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "HEIGHT": "$HEIGHT/16.0",
-            "PERSISTENT": true,
-            "TARGET": "keyFrameBuffer1",
-            "WIDTH": "$WIDTH/16.0"
-        },
-        {
-            "HEIGHT": "$HEIGHT",
-            "PERSISTENT": true,
-            "TARGET": "keyFrameBuffer2",
-            "WIDTH": "$WIDTH"
-        }
-    ]
-}
-*/
-
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-in vec2 left_coord;
-in vec2 right_coord;
-in vec2 above_coord;
-in vec2 below_coord;
-
-in vec2 lefta_coord;
-in vec2 righta_coord;
-in vec2 leftb_coord;
-in vec2 rightb_coord;
-#endif
-
-void main()
-{
-
-	//	first pass: read the "inputImage"- remember, we're drawing to the persistent buffer "keyFrameBuffer1" on the first pass
-	//	store it if we're taking in a new keyframe
-	if (PASSINDEX == 0)	{
-		vec4		stalePixel = IMG_THIS_NORM_PIXEL(keyFrameBuffer1);		
-		vec4		freshPixel = IMG_THIS_NORM_PIXEL(inputImage);
-		if (update_keyframe==true)	{
-			gl_FragColor = freshPixel;
-		}
-		else	{
-			gl_FragColor = stalePixel;
-		}
-	}
-	//	second pass: read from "bufferVariableNameA".  output looks chunky and low-res.
-	else if (PASSINDEX == 1)	{
-		vec4		stalePixel1 = IMG_THIS_NORM_PIXEL(keyFrameBuffer1);
-		vec4		stalePixel2 = IMG_THIS_NORM_PIXEL(keyFrameBuffer2);
-		vec4 color = IMG_THIS_NORM_PIXEL(inputImage);
-		vec4 colorL = IMG_NORM_PIXEL(inputImage, left_coord);
-		vec4 colorR = IMG_NORM_PIXEL(inputImage, right_coord);
-		vec4 colorA = IMG_NORM_PIXEL(inputImage, above_coord);
-		vec4 colorB = IMG_NORM_PIXEL(inputImage, below_coord);
-
-		vec4 colorLA = IMG_NORM_PIXEL(inputImage, lefta_coord);
-		vec4 colorRA = IMG_NORM_PIXEL(inputImage, righta_coord);
-		vec4 colorLB = IMG_NORM_PIXEL(inputImage, leftb_coord);
-		vec4 colorRB = IMG_NORM_PIXEL(inputImage, rightb_coord);
-
-		vec4 final = color;
-		vec4 diff = (color - stalePixel2);
-		if (blur > 0.0)	{
-			float blurAmount = blur / 8.0;
-			diff = diff * (1.0 - blur) + (colorL + colorR + colorA + colorB + colorLA + colorRA + colorLB + colorRB) * blurAmount;
-		}
-		
-		if (mode == 0)	{
-			final = mix(stalePixel2,(diff + stalePixel1),update_rate);
-		}
-		else if (mode == 1)	{
-			final = mix(stalePixel2,abs(diff) + stalePixel1,update_rate);
-		}
-		else if (mode == 2)	{
-			final = mix(stalePixel2,abs(diff + stalePixel2) * stalePixel1,update_rate);
-		}
-		
-		if (posterize > 0.0)	{
-			float qLevel = 128.0 - posterize * 126.0;
-			final = floor(final*qLevel)/qLevel;
-		}
-		
-		if (sharpen > 0.0)	{
-			final = final + sharpen * (8.0*color - colorL - colorR - colorA - colorB - colorLA - colorRA - colorLB - colorRB);
-		}
-		
-		gl_FragColor = final;
-	}
-}
diff --git a/nannou_isf/test_files/FastMosh.vs b/nannou_isf/test_files/FastMosh.vs
deleted file mode 100644
index 8f2188f5d..000000000
--- a/nannou_isf/test_files/FastMosh.vs
+++ /dev/null
@@ -1,39 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-out vec2 left_coord;
-out vec2 right_coord;
-out vec2 above_coord;
-out vec2 below_coord;
-
-out vec2 lefta_coord;
-out vec2 righta_coord;
-out vec2 leftb_coord;
-out vec2 rightb_coord;
-#endif
-
-
-void main()
-{
-	isf_vertShaderInit();
-	vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	vec2 d = 1.0/RENDERSIZE;
-	
-	left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
-	right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
-	above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
-	below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
-
-	lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
-	righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
-	leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
-	rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Film Burn.fs b/nannou_isf/test_files/Film Burn.fs
deleted file mode 100644
index c3693ca1a..000000000
--- a/nannou_isf/test_files/Film Burn.fs	
+++ /dev/null
@@ -1,109 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Dissolve"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/FilmBurn.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 2.31,
-            "MAX": 10,
-            "MIN": 0,
-            "NAME": "Seed",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// author: Anastasia Dunbar
-// license: MIT
-float sigmoid(float x, float a) {
-    float b = pow(x*2.,a)/2.;
-    if (x > .5) {
-        b = 1.-pow(2.-(x*2.),a)/2.;
-    }
-	return b;
-}
-float rand(float co){
-    return fract(sin((co*24.9898)+Seed)*43758.5453);
-}
-float rand(vec2 co){
-    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-float apow(float a,float b) { return pow(abs(a),b)*sign(b); }
-vec3 pow3(vec3 a,vec3 b) { return vec3(apow(a.r,b.r),apow(a.g,b.g),apow(a.b,b.b)); }
-float smooth_mix(float a,float b,float c) { return mix(a,b,sigmoid(c,2.)); }
-float random(vec2 co, float shft){
-    co += 10.;
-    return smooth_mix(fract(sin(dot(co.xy ,vec2(12.9898+(floor(shft)*.5),78.233+Seed))) * 43758.5453),fract(sin(dot(co.xy ,vec2(12.9898+(floor(shft+1.)*.5),78.233+Seed))) * 43758.5453),fract(shft));
-}
-float smooth_random(vec2 co, float shft) {
-	return smooth_mix(smooth_mix(random(floor(co),shft),random(floor(co+vec2(1.,0.)),shft),fract(co.x)),smooth_mix(random(floor(co+vec2(0.,1.)),shft),random(floor(co+vec2(1.,1.)),shft),fract(co.x)),fract(co.y));
-}
-vec4 texture(vec2 p) {
-    return mix(getFromColor(p), getToColor(p), sigmoid(progress,10.));
-}
-#define pi 3.14159265358979323
-#define clamps(x) clamp(x,0.,1.)
-
-vec4 transition(vec2 p) {
-  vec3 f = vec3(0.);
-  for (float i = 0.; i < 13.; i++) {
-    f += sin(((p.x*rand(i)*6.)+(progress*8.))+rand(i+1.43))*sin(((p.y*rand(i+4.4)*6.)+(progress*6.))+rand(i+2.4));
-    f += 1.-clamps(length(p-vec2(smooth_random(vec2(progress*1.3),i+1.),smooth_random(vec2(progress*.5),i+6.25)))*mix(20.,70.,rand(i)));
-  }
-  f += 4.;
-  f /= 11.;
-  f = pow3(f*vec3(1.,0.7,0.6),vec3(1.,2.-sin(progress*pi),1.3));
-  f *= sin(progress*pi);
-  
-  p -= .5;
-  p *= 1.+(smooth_random(vec2(progress*5.),6.3)*sin(progress*pi)*.05);
-  p += .5;
-  
-  vec4 blurred_image = vec4(0.);
-  float bluramount = sin(progress*pi)*.03;
-  #define repeats  50.
-  for (float i = 0.; i < repeats; i++) { 
-      vec2 q = vec2(cos(degrees((i/repeats)*360.)),sin(degrees((i/repeats)*360.))) *  (rand(vec2(i,p.x+p.y))+bluramount); 
-      vec2 uv2 = p+(q*bluramount);
-      blurred_image += texture(uv2);
-  }
-  blurred_image /= repeats;
-  
-  return blurred_image+vec4(f,0.);
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Flip H.fs b/nannou_isf/test_files/Flip H.fs
deleted file mode 100644
index ca74d68b4..000000000
--- a/nannou_isf/test_files/Flip H.fs	
+++ /dev/null
@@ -1,24 +0,0 @@
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Geometry Adjustment"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		}
-	]
-}*/
-
-void main() {
-	vec2		normSrcCoord;
-
-	normSrcCoord.x = isf_FragNormCoord[0];
-	normSrcCoord.y = isf_FragNormCoord[1];
-
-	normSrcCoord.x = (1.0-normSrcCoord.x);
-
-	gl_FragColor = IMG_NORM_PIXEL(inputImage, normSrcCoord);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Flip V.fs b/nannou_isf/test_files/Flip V.fs
deleted file mode 100644
index 95ba34ed0..000000000
--- a/nannou_isf/test_files/Flip V.fs	
+++ /dev/null
@@ -1,24 +0,0 @@
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Geometry Adjustment"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		}
-	]
-}*/
-
-void main() {
-	vec2		normSrcCoord;
-
-	normSrcCoord.x = isf_FragNormCoord[0];
-	normSrcCoord.y = isf_FragNormCoord[1];
-
-	normSrcCoord.y = (1.0-normSrcCoord.y);
-
-	gl_FragColor = IMG_NORM_PIXEL(inputImage, normSrcCoord);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Flipbook.fs b/nannou_isf/test_files/Flipbook.fs
deleted file mode 100644
index c3620f553..000000000
--- a/nannou_isf/test_files/Flipbook.fs
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Stylize"
-  ],
-  "DESCRIPTION" : "Creates a flipbook like effect",
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "NAME" : "inputImage",
-      "TYPE" : "image"
-    },
-    {
-      "NAME" : "flipRate",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0.1,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "stretchMode",
-      "TYPE" : "bool",
-      "DEFAULT" : 1
-    },
-    {
-      "LABELS" : [
-        "Left",
-        "Right",
-        "Up",
-        "Down"
-      ],
-      "NAME" : "flipDirection",
-      "TYPE" : "long",
-      "DEFAULT" : 3,
-      "VALUES" : [
-        0,
-        1,
-        2,
-        3
-      ]
-    },
-    {
-      "NAME" : "holdTime",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0,
-      "MIN" : 0
-    }
-  ],
-  "PASSES" : [
-    {
-      "FLOAT" : true,
-      "WIDTH" : "1",
-      "HEIGHT" : "1",
-      "TARGET" : "writePos",
-      "PERSISTENT" : true
-    },
-    {
-      "TARGET" : "frameGrab",
-      "PERSISTENT" : true
-    },
-    {
-      "TARGET" : "lastOutput",
-      "PERSISTENT" : true
-    }
-  ],
-  "CREDIT" : "VIDVOX"
-}
-*/
-
-void main()	{
-	vec4		inputPixelColor = vec4(0.0);
-	
-	if (PASSINDEX == 0)	{
-		inputPixelColor = (FRAMEINDEX <= 1) ? vec4(0.0) : IMG_PIXEL(writePos, vec2(0.0));
-		float		oldG = inputPixelColor.g;
-		inputPixelColor.g = inputPixelColor.g + flipRate;
-		inputPixelColor.b = 1.0;
-		inputPixelColor.a = 1.0;
-		if (inputPixelColor.g >= 1.0 + flipRate)	{
-			//inputPixelColor.g = 0.0;
-			if (inputPixelColor.r >= holdTime)	{
-				inputPixelColor.b = 0.0;
-				inputPixelColor.g = (holdTime > 0.0) ? 0.0 : mod(oldG,1.0);
-			}
-			else	{
-				inputPixelColor.r = inputPixelColor.r + TIMEDELTA;
-				inputPixelColor.g = oldG;
-			}
-		}
-		else	{
-			inputPixelColor.r = 0.0;
-		}
-	}
-	else if (PASSINDEX == 1)	{
-		vec4	tmpColor = (FRAMEINDEX <= 1) ? vec4(0.0) : IMG_PIXEL(writePos, vec2(0.0));
-		//	update the image buffer
-		if (tmpColor.b == 0.0)	{
-			inputPixelColor = IMG_THIS_PIXEL(inputImage);
-		}
-		//
-		else	{
-			inputPixelColor = IMG_THIS_PIXEL(frameGrab);
-		}
-	}
-	else if (PASSINDEX == 2)	{
-		if (FRAMEINDEX <= 1)	{
-			inputPixelColor = IMG_THIS_PIXEL(frameGrab);
-		}
-		else	{
-			vec4	tmpColor = (FRAMEINDEX <= 1) ? vec4(0.0) : IMG_PIXEL(writePos, vec2(0.0));
-			vec2	loc = isf_FragNormCoord;
-			float	grabTime = (tmpColor.g > 1.0) ? 1.0 : tmpColor.g;
-			float	transTime = 0.0;
-			if (flipDirection == 0)	{
-				transTime = loc.x;
-				loc.x = (stretchMode) ? 1.0 - (1.0 - loc.x) / (grabTime) : loc.x - (1.0 - grabTime);
-			}
-			else if (flipDirection == 1)	{
-				transTime = 1.0 - loc.x;
-				loc.x = (stretchMode) ? loc.x / (grabTime) : loc.x + (1.0 - grabTime);
-			}
-			else if (flipDirection == 2)	{
-				transTime = 1.0 - loc.y;
-				loc.y = (stretchMode) ? loc.y / (grabTime) : loc.y + (1.0 - grabTime);
-			}
-			else if (flipDirection == 3)	{
-				transTime = loc.y;
-				loc.y = (stretchMode) ? 1.0 - (1.0 - loc.y) / (grabTime) : loc.y - (1.0 - grabTime);
-			}
-			
-			if (transTime <= 1.0 - grabTime)	{
-				inputPixelColor = IMG_THIS_PIXEL(lastOutput);
-			}
-			else	{
-				inputPixelColor = IMG_NORM_PIXEL(frameGrab, loc);
-			}
-		}
-	}
-	
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/Fly Eye.fs b/nannou_isf/test_files/Fly Eye.fs
deleted file mode 100644
index 8a94086c2..000000000
--- a/nannou_isf/test_files/Fly Eye.fs	
+++ /dev/null
@@ -1,79 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/flyeye.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.04,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "size",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.3,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "colorSeparation",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 50,
-            "MAX": 100,
-            "MIN": 0,
-            "NAME": "zoom",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: gre
-// License: MIT
-
-vec4 transition(vec2 p) {
-  float inv = 1. - progress;
-  vec2 disp = size*vec2(cos(zoom*p.x), sin(zoom*p.y));
-  vec4 texTo = getToColor(p + inv*disp);
-  vec4 texFrom = vec4(
-    getFromColor(p + progress*disp*(1.0 - colorSeparation)).r,
-    getFromColor(p + progress*disp).g,
-    getFromColor(p + progress*disp*(1.0 + colorSeparation)).b,
-    1.0);
-  return texTo*progress + texFrom*inv;
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Freeze Frame.fs b/nannou_isf/test_files/Freeze Frame.fs
deleted file mode 100644
index 6906df986..000000000
--- a/nannou_isf/test_files/Freeze Frame.fs	
+++ /dev/null
@@ -1,38 +0,0 @@
-/*{
-	"DESCRIPTION": "Holds the output on the captured freeze frame",
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Utility"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "freeze",
-			"TYPE": "bool",
-			"DEFAULT": 0.0
-		}
-	],
-	"PASSES": [
-		{
-			"TARGET":"freezeBuffer",
-			"PERSISTENT": true
-		}
-	]
-	
-}*/
-
-//	Essentially the same as a feedback buffer where you can only set it to a mix of 1.0
-
-void main()
-{
-	if (freeze)	{
-		gl_FragColor = IMG_THIS_PIXEL(freezeBuffer);
-	}
-	else	{
-		gl_FragColor = IMG_THIS_PIXEL(inputImage);
-	}
-}
diff --git a/nannou_isf/test_files/Frosted Glass.fs b/nannou_isf/test_files/Frosted Glass.fs
deleted file mode 100644
index 6c15b87c4..000000000
--- a/nannou_isf/test_files/Frosted Glass.fs	
+++ /dev/null
@@ -1,131 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Stylize",
-        "Blur"
-    ],
-    "CREDIT": "geeks3d",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.01,
-            "LABEL": "Magnitude",
-            "MAX": 0.1,
-            "MIN": 0,
-            "NAME": "magnitude",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.345,
-            "LABEL": "Seed",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "seed",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-/*
-
-	adapted from http://www.geeks3d.com/20101228/shader-library-frosted-glass-post-processing-shader-glsl/
-
-*/
-
-
-const float vx_offset = 0.5;
-
-vec4 spline(float x, vec4 c1, vec4 c2, vec4 c3, vec4 c4, vec4 c5, vec4 c6, vec4 c7, vec4 c8, vec4 c9)
-{
-	float w1, w2, w3, w4, w5, w6, w7, w8, w9;
-	w1 = 0.0;
-	w2 = 0.0;
-	w3 = 0.0;
-	w4 = 0.0;
-	w5 = 0.0;
-	w6 = 0.0;
-	w7 = 0.0;
-	w8 = 0.0;
-	w9 = 0.0;
-	float tmp = x * 8.0;
-	if (tmp<=1.0) {
-		w1 = 1.0 - tmp;
-		w2 = tmp;
-	}
-	else if (tmp<=2.0) {
-		tmp = tmp - 1.0;
-		w2 = 1.0 - tmp;
-		w3 = tmp;
-	}
-	else if (tmp<=3.0) {
-		tmp = tmp - 2.0;
-		w3 = 1.0-tmp;
-		w4 = tmp;
-	}
-	else if (tmp<=4.0) {
-		tmp = tmp - 3.0;
-		w4 = 1.0-tmp;
-		w5 = tmp;
-	}
-	else if (tmp<=5.0) {
-		tmp = tmp - 4.0;
-		w5 = 1.0-tmp;
-		w6 = tmp;
-	}
-	else if (tmp<=6.0) {
-		tmp = tmp - 5.0;
-		w6 = 1.0-tmp;
-		w7 = tmp;
-	}
-	else if (tmp<=7.0) {
-		tmp = tmp - 6.0;
-		w7 = 1.0 - tmp;
-		w8 = tmp;
-	}
-	else {
-		//tmp = saturate(tmp - 7.0);
-		// http://www.ozone3d.net/blogs/lab/20080709/saturate-function-in-glsl/
-		tmp = clamp(tmp - 7.0, 0.0, 1.0);
-		w8 = 1.0-tmp;
-		w9 = tmp;
-	}
-	return w1*c1 + w2*c2 + w3*c3 + w4*c4 + w5*c5 + w6*c6 + w7*c7 + w8*c8 + w9*c9;
-}
-
-float rand(vec2 co){
-    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-void main()	{
-	vec2 uv = isf_FragNormCoord.xy;
-	vec4 tc = vec4(1.0, 0.0, 0.0, 0.0);
-
-	float DeltaX = magnitude / 2.0;
-	float DeltaY = magnitude / 2.0;
-	vec2 ox = vec2(DeltaX,0.0);
-	vec2 oy = vec2(0.0,DeltaY);
-	vec2 PP = uv - oy;
-	vec4 C00 = IMG_NORM_PIXEL(inputImage,PP - ox);
-	vec4 C01 = IMG_NORM_PIXEL(inputImage,PP);
-	vec4 C02 = IMG_NORM_PIXEL(inputImage,PP + ox);
-	PP = uv;
-	vec4 C10 = IMG_NORM_PIXEL(inputImage,PP - ox);
-	vec4 C11 = IMG_NORM_PIXEL(inputImage,PP);
-	vec4 C12 = IMG_NORM_PIXEL(inputImage,PP + ox);
-	PP = uv + oy;
-	vec4 C20 = IMG_NORM_PIXEL(inputImage,PP - ox);
-	vec4 C21 = IMG_NORM_PIXEL(inputImage,PP);
-	vec4 C22 = IMG_NORM_PIXEL(inputImage,PP + ox);
-
-	float n = rand(seed*uv);
-	n = mod(n, 0.111111)/0.111111;
-	vec4 result = spline(n,C00,C01,C02,C10,C11,C12,C20,C21,C22);
-	tc = result.rgba;  
-
-	gl_FragColor = tc;
-}
diff --git a/nannou_isf/test_files/Gamma Correction.fs b/nannou_isf/test_files/Gamma Correction.fs
deleted file mode 100644
index 4014945de..000000000
--- a/nannou_isf/test_files/Gamma Correction.fs	
+++ /dev/null
@@ -1,33 +0,0 @@
-/*{
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Color Adjustment", "Utility"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "gamma",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.5
-		}
-	]
-}*/
-
-
-
-void main() {
-	//	the input gamma range is 0.0-1.0 (normalized).  the actual gamma range i want to use is 0.0 - 5.0.
-	//	however, actual gamma 0.0-1.0 is just as interesting as actual gamma 1.0-5.0, so we scale the normalized input to match...
-	float		realGamma = (gamma<=0.5) ? (gamma * 2.0) : (((gamma-0.5) * 2.0 * 4.0) + 1.0);
-	vec4		tmpColorA = IMG_THIS_PIXEL(inputImage);
-	vec4		tmpColorB;
-	tmpColorB.rgb = pow(tmpColorA.rgb, vec3(1.0/realGamma));
-	tmpColorB.a = tmpColorA.a;
-	gl_FragColor = tmpColorB;
-}
diff --git a/nannou_isf/test_files/Ghosting.fs b/nannou_isf/test_files/Ghosting.fs
deleted file mode 100644
index d714ed85b..000000000
--- a/nannou_isf/test_files/Ghosting.fs
+++ /dev/null
@@ -1,130 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Stylize",
-        "Feedback",
-        "Color Effect"
-    ],
-    "CREDIT": "by VIDVOX",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": -0.5,
-            "LABEL": "Bias",
-            "MAX": 0,
-            "MIN": -1,
-            "NAME": "uBias",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "LABEL": "Scale",
-            "MAX": 2,
-            "MIN": 0,
-            "NAME": "uScale",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 5,
-            "LABEL": "Ghosts",
-            "MAX": 5,
-            "MIN": 0,
-            "NAME": "uGhosts",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.0125,
-            "LABEL": "Ghost Dispersal",
-            "MAX": 0.1,
-            "MIN": 0,
-            "NAME": "uGhostDispersal",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Additive Mode",
-            "NAME": "uAdditive",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": [
-                0.5,
-                0.5
-            ],
-            "LABEL": "Direction",
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "uDirection",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": [
-                0.9,
-                0.8,
-                0.7,
-                1
-            ],
-            "LABEL": "Lens Color",
-            "NAME": "uLensColor",
-            "TYPE": "color"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "DESCRIPTION": "Downsample and threshold",
-            "HEIGHT": "floor($HEIGHT/1.0)",
-            "TARGET": "downsampleAndThresholdImage",
-            "WIDTH": "floor($WIDTH/1.0)"
-        },
-        {
-        }
-    ]
-}
-*/
-
-
-
-
-void main()
-{
-
-	if (PASSINDEX == 0)	{
-		vec2 loc = isf_FragNormCoord;
-		gl_FragColor = max(vec4(0.0), IMG_NORM_PIXEL(inputImage,loc) + uBias) * uScale;
-	}
-	else if (PASSINDEX == 1)	{
-		vec2 texcoord = isf_FragNormCoord;
-		vec2 texelSize = 1.0 / RENDERSIZE;
-		vec2 direction = vec2(1.0) - uDirection;
-		vec2 ghostVec = (direction - texcoord) * uGhostDispersal;
-		//vec2 direction = vec2(0.5,0.5);
-		vec4 result = vec4(0.0);
-		for (int i = 0; i < 5; ++i) { 
-			if (float(i)>uGhosts)
-				break;
-			vec2 offset = fract(texcoord + ghostVec * float(i));
-
-			result += IMG_NORM_PIXEL(downsampleAndThresholdImage, offset) * uLensColor;
-		}
-		//	apply the alpha
-		result.rgb = result.rgb * uLensColor.a;
-		if (uAdditive)	{
-			result = result + IMG_NORM_PIXEL(inputImage, texcoord);
-		}
-		else	{
-			result = result * IMG_NORM_PIXEL(inputImage, texcoord);
-		}
-		gl_FragColor = result;
-	}
-
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Glitch Displace.fs b/nannou_isf/test_files/Glitch Displace.fs
deleted file mode 100644
index 1db064e2b..000000000
--- a/nannou_isf/test_files/Glitch Displace.fs	
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Distortion"
-  ],
-  "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/GlitchDisplace.glsl",
-  "DESCRIPTION": "",
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "TYPE" : "image",
-      "NAME" : "startImage"
-    },
-    {
-      "TYPE" : "image",
-      "NAME" : "endImage"
-    },
-    {
-      "DEFAULT" : 0,
-      "MAX" : 1,
-      "NAME" : "progress",
-      "MIN" : 0,
-      "TYPE" : "float"
-    }
-  ]
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: Matt DesLauriers
-// License: MIT
-
-highp float random(vec2 co)
-{
-    highp float a = 12.9898;
-    highp float b = 78.233;
-    highp float c = 43758.5453;
-    highp float dt= dot(co.xy ,vec2(a,b));
-    highp float sn= mod(dt,3.14);
-    return fract(sin(sn) * c);
-}
-float voronoi( in vec2 x ) {
-    vec2 p = floor( x );
-    vec2 f = fract( x );
-    float res = 8.0;
-    for( float j=-1.; j<=1.; j++ )
-    for( float i=-1.; i<=1.; i++ ) {
-        vec2  b = vec2( i, j );
-        vec2  r = b - f + random( p + b );
-        float d = dot( r, r );
-        res = min( res, d );
-    }
-    return sqrt( res );
-}
-
-vec2 displace(vec4 tex, vec2 texCoord, float dotDepth, float textureDepth, float strength) {
-    float b = voronoi(.003 * texCoord + 2.0);
-    float g = voronoi(0.2 * texCoord);
-    float r = voronoi(texCoord - 1.0);
-    vec4 dt = tex * 1.0;
-    vec4 dis = dt * dotDepth + 1.0 - tex * textureDepth;
-
-    dis.x = dis.x - 1.0 + textureDepth*dotDepth;
-    dis.y = dis.y - 1.0 + textureDepth*dotDepth;
-    dis.x *= strength;
-    dis.y *= strength;
-    vec2 res_uv = texCoord ;
-    res_uv.x = res_uv.x + dis.x - 0.0;
-    res_uv.y = res_uv.y + dis.y;
-    return res_uv;
-}
-
-float ease1(float t) {
-  return t == 0.0 || t == 1.0
-    ? t
-    : t < 0.5
-      ? +0.5 * pow(2.0, (20.0 * t) - 10.0)
-      : -0.5 * pow(2.0, 10.0 - (t * 20.0)) + 1.0;
-}
-float ease2(float t) {
-  return t == 1.0 ? t : 1.0 - pow(2.0, -10.0 * t);
-}
-
-
-
-vec4 transition(vec2 uv) {
-  vec2 p = uv.xy / vec2(1.0).xy;
-  vec4 color1 = getFromColor(p);
-  vec4 color2 = getToColor(p);
-  vec2 disp = displace(color1, p, 0.33, 0.7, 1.0-ease1(progress));
-  vec2 disp2 = displace(color2, p, 0.33, 0.5, ease2(progress));
-  vec4 dColor1 = getToColor(disp);
-  vec4 dColor2 = getFromColor(disp2);
-  float val = ease1(progress);
-  vec3 gray = vec3(dot(min(dColor2, dColor1).rgb, vec3(0.299, 0.587, 0.114)));
-  dColor2 = vec4(gray, 1.0);
-  dColor2 *= 2.0;
-  color1 = mix(color1, dColor2, smoothstep(0.0, 0.5, progress));
-  color2 = mix(color2, dColor1, smoothstep(1.0, 0.5, progress));
-  return mix(color1, color2, val);
-  //gl_FragColor = mix(gl_FragColor, dColor, smoothstep(0.0, 0.5, progress));
-  
-   //gl_FragColor = mix(texture2D(from, p), texture2D(to, p), progress);
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Glitch Memories.fs b/nannou_isf/test_files/Glitch Memories.fs
deleted file mode 100644
index 39b851cbf..000000000
--- a/nannou_isf/test_files/Glitch Memories.fs	
+++ /dev/null
@@ -1,60 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion",
-        "Glitch"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/GlitchMemories.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// author: Gunnar Roth
-// based on work from natewave
-// license: MIT
-vec4 transition(vec2 p) {
-  vec2 block = floor(p.xy / vec2(16));
-  vec2 uv_noise = block / vec2(64);
-  uv_noise += floor(vec2(progress) * vec2(1200.0, 3500.0)) / vec2(64);
-  vec2 dist = progress > 0.0 ? (fract(uv_noise) - 0.5) * 0.3 *(1.0 -progress) : vec2(0.0);
-  vec2 red = p + dist * 0.2;
-  vec2 green = p + dist * .3;
-  vec2 blue = p + dist * .5;
-
-  return vec4(mix(getFromColor(red), getToColor(red), progress).r,mix(getFromColor(green), getToColor(green), progress).g,mix(getFromColor(blue), getToColor(blue), progress).b,1.0);
-}
-
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Glitch Shifter.fs b/nannou_isf/test_files/Glitch Shifter.fs
deleted file mode 100644
index f6ced9cbc..000000000
--- a/nannou_isf/test_files/Glitch Shifter.fs	
+++ /dev/null
@@ -1,155 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Glitch"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.1,
-            "LABEL": "Size",
-            "MAX": 0.5,
-            "MIN": 0,
-            "NAME": "glitch_size",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.2,
-            "LABEL": "Horizontal Amount",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "glitch_horizontal",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Vertical Amount",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "glitch_vertical",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Randomize Size",
-            "NAME": "randomize_size",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Randomize Zoom",
-            "NAME": "randomize_zoom",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Use Alt Image",
-            "NAME": "use_alt_image",
-            "TYPE": "bool"
-        },
-        {
-            "NAME": "altImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0
-            ],
-            "LABEL": "Offset",
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "offset",
-            "TYPE": "point2D"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-float rand(vec2 co){
-    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-void main()
-{
-	vec2 xy;
-	vec4 returnMe;
-	bool shifted = false;
-	xy.x = isf_FragNormCoord[0];
-	xy.y = isf_FragNormCoord[1];
-	
-	//	quantize the xy to the glitch_amount size
-	//xy = floor(xy / glitch_size) * glitch_size;
-	vec2 random;
-
-	float local_glitch_size = glitch_size;
-	float random_offset = 0.0;
-	
-	if (randomize_size)	{
-		random_offset = mod(rand(vec2(TIME,TIME)), 1.0);
-		local_glitch_size = random_offset * glitch_size;
-	}
-	
-	if (local_glitch_size > 0.0)	{
-		random.x = rand(vec2(floor(random_offset + xy.y / local_glitch_size) * local_glitch_size, TIME));
-		random.y = rand(vec2(floor(random_offset + xy.x / local_glitch_size) * local_glitch_size, TIME));
-	}
-	else	{
-		random.x = rand(vec2(xy.x, TIME));
-		random.y = rand(vec2(xy.y, TIME));
-	}
-	
-	if (randomize_zoom)	{
-		if ((random.x < glitch_horizontal)&&(random.y < glitch_vertical))	{
-			float level = rand(vec2(random.x, random.y)) / 5.0 + 0.90;
-			xy = (xy - vec2(0.5))*(1.0/level) + vec2(0.5);
-		}
-		else if (random.x < glitch_horizontal)	{
-			float level = (random.x) + 0.98;
-			xy = (xy - vec2(0.5))*(1.0/level) + vec2(0.5);
-		}
-		else if (random.y < glitch_vertical)	{
-			float level = (random.y) + 0.98;
-			xy = (xy - vec2(0.5))*(1.0/level) + vec2(0.5);
-		}
-	}
-	
-	//	if doing a horizontal glitch do a random shift
-	if ((random.x < glitch_horizontal)&&(random.y < glitch_vertical))	{
-		vec2 shift = (offset - 0.5);
-		shift = shift * rand(shift + random);
-		xy.x = mod(xy.x + random.x, 1.0);
-		xy.y = mod(xy.y + random.y, 1.0);
-		xy = xy + shift;
-		shifted = true;
-	}
-	else if (random.x < glitch_horizontal)	{
-		vec2 shift = (offset - 0.5);
-		shift = shift * rand(shift + random);
-		xy = mod(xy + vec2(0.0, random.x) + shift, 1.0);
-		shifted = true;
-	}
-	else if (random.y < glitch_vertical)	{
-		vec2 shift = (offset - 0.5);
-		shift = shift * rand(shift + random);
-		xy = mod(xy + vec2(random.y, 0.0) + shift, 1.0);
-		shifted = true;
-	}
-	
-	if ((shifted) && (use_alt_image) && (rand(vec2(TIME, xy.x)) < 0.5))
-		returnMe = IMG_NORM_PIXEL(altImage, xy);
-	else
-		returnMe = IMG_NORM_PIXEL(inputImage, xy);
-	
-	gl_FragColor = returnMe;
-}
diff --git a/nannou_isf/test_files/Gloom.fs b/nannou_isf/test_files/Gloom.fs
deleted file mode 100644
index 7230667af..000000000
--- a/nannou_isf/test_files/Gloom.fs
+++ /dev/null
@@ -1,131 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Blur",
-        "Film"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 12,
-            "MAX": 12,
-            "MIN": 0,
-            "NAME": "blurAmount",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "intensity",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "DESCRIPTION": "Pass 0",
-            "HEIGHT": "floor($HEIGHT/2.0)",
-            "TARGET": "halfSizeBaseRender",
-            "WIDTH": "floor($WIDTH/2.0)"
-        },
-        {
-            "DESCRIPTION": "Pass 1",
-            "HEIGHT": "floor($HEIGHT/4.0)",
-            "TARGET": "quarterSizeBaseRender",
-            "WIDTH": "floor($WIDTH/4.0)"
-        },
-        {
-            "DESCRIPTION": "Pass 2",
-            "HEIGHT": "floor($HEIGHT/8.0)",
-            "TARGET": "eighthSizeBaseRender",
-            "WIDTH": "floor($WIDTH/8.0)"
-        },
-        {
-            "DESCRIPTION": "Pass 3",
-            "HEIGHT": "floor($HEIGHT/4.0)",
-            "TARGET": "quarterGaussA",
-            "WIDTH": "floor($WIDTH/4.0)"
-        },
-        {
-            "DESCRIPTION": "Pass 4",
-            "HEIGHT": "floor($HEIGHT/4.0)",
-            "TARGET": "quarterGaussB",
-            "WIDTH": "floor($WIDTH/4.0)"
-        },
-        {
-            "DESCRIPTION": "Pass 5",
-            "TARGET": "fullGaussA"
-        },
-        {
-            "DESCRIPTION": "Pass 6",
-            "TARGET": "fullGaussB"
-        }
-    ]
-}
-*/
-
-
-#if __VERSION__ <= 120
-varying vec2		texOffsets[5];
-#else
-in vec2		texOffsets[5];
-#endif
-
-
-void main() {
-	int			blurLevel = int(floor(blurAmount/6.0));
-	float		blurLevelModulus = mod(blurAmount, 6.0);
-	//	first three passes are just copying the input image into the buffer at varying sizes
-	if (PASSINDEX==0)	{
-		gl_FragColor = IMG_NORM_PIXEL(inputImage, isf_FragNormCoord);
-	}
-	else if (PASSINDEX==1)	{
-		gl_FragColor = IMG_NORM_PIXEL(halfSizeBaseRender, isf_FragNormCoord);
-	}
-	else if (PASSINDEX==2)	{
-		gl_FragColor = IMG_NORM_PIXEL(quarterSizeBaseRender, isf_FragNormCoord);
-	}
-	//	start reading from the previous stage- each two passes completes a gaussian blur, then 
-	//	we increase the resolution & blur (the lower-res blurred image from the previous pass) again...
-	else if (PASSINDEX == 3)	{
-		vec4		sample0 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[2]);
-		vec4		sample3 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[3]);
-		vec4		sample4 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[4]);
-		//gl_FragColor = vec4((sample0 + sample1 + sample2).rgb / (3.0), 1.0);
-		gl_FragColor = vec4((sample0 + sample1 + sample2 + sample3 + sample4).rgb / (5.0), 1.0);
-	}
-	else if (PASSINDEX == 4)	{
-		vec4		sample0 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[2]);
-		vec4		sample3 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[3]);
-		vec4		sample4 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[4]);
-		//gl_FragColor = vec4((sample0 + sample1 + sample2).rgb / (3.0), 1.0);
-		gl_FragColor = vec4((sample0 + sample1 + sample2 + sample3 + sample4).rgb / (5.0), 1.0);
-	}
-	//	...writes into the full-size
-	else if (PASSINDEX == 5)	{
-		vec4		sample0 = IMG_NORM_PIXEL(quarterGaussB,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(quarterGaussB,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(quarterGaussB,texOffsets[2]);
-		gl_FragColor =  vec4((sample0 + sample1 + sample2).rgb / (3.0), 1.0);
-	}
-	else if (PASSINDEX == 6)	{
-		//	this is the last pass- calculate the blurred image as i have in previous passes, then mix it in with the full-size input image using the blur amount so i get a smooth transition into the blur at low blur levels
-		vec4		sample0 = IMG_NORM_PIXEL(fullGaussA,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(fullGaussA,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(fullGaussA,texOffsets[2]);
-		vec4		blurredImg =  vec4((sample0 + sample1 + sample2).rgb / (3.0), 1.0);
-		vec4		originalImg = IMG_NORM_PIXEL(inputImage,isf_FragNormCoord);
-		if (blurLevel == 0)
-			blurredImg = mix(originalImg, blurredImg, (blurLevelModulus/6.0));
-		
-		gl_FragColor = min(mix(originalImg,blurredImg*0.9,intensity), originalImg);
-	}
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Gloom.vs b/nannou_isf/test_files/Gloom.vs
deleted file mode 100644
index 3c9a24ee7..000000000
--- a/nannou_isf/test_files/Gloom.vs
+++ /dev/null
@@ -1,70 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2		texOffsets[5];
-#else
-out vec2		texOffsets[5];
-#endif
-
-void main(void)	{
-	//	load the main shader stuff
-	isf_vertShaderInit();
-	
-	
-	int			blurLevel = int(floor(blurAmount/6.0));
-	float		blurLevelModulus = mod(blurAmount, 6.0);
-	float		blurRadius = 0.0;
-	float		blurRadiusInPixels = 0.0;
-	//	first three passes are just drawing the texture- do nothing
-	
-	//	the next four passes do gaussion blurs on the various levels
-	if (PASSINDEX==3 || PASSINDEX==5)	{
-		float		pixelWidth = 1.0/RENDERSIZE.x;
-		//	pass 3 is sampling 1/12, but writing to 1/4
-		if (PASSINDEX==3)	{
-			if (blurLevel==1)
-				blurRadius = blurLevelModulus/1.5;
-			else if (blurLevel>1)
-				blurRadius = 4.0;
-		}
-		//	pass 5 is sampling 1/4 and writing to full-size
-		else if (PASSINDEX==5)	{
-			if (blurLevel==0)
-				blurRadius = blurLevelModulus;
-			else if (blurLevel>0)
-				blurRadius = 6.0;
-		}
-		blurRadiusInPixels = pixelWidth * blurRadius;
-		texOffsets[0] = isf_FragNormCoord;
-		texOffsets[1] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0]-blurRadiusInPixels, isf_FragNormCoord[1]),0.0,1.0);
-		texOffsets[2] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0]+blurRadiusInPixels, isf_FragNormCoord[1]),0.0,1.0);
-		if (PASSINDEX==3)	{
-			texOffsets[3] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0]-(2.0*blurRadiusInPixels), isf_FragNormCoord[1]),0.0,1.0);
-			texOffsets[4] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0]+(2.0*blurRadiusInPixels), isf_FragNormCoord[1]),0.0,1.0);
-		}
-	}
-	else if (PASSINDEX==4 || PASSINDEX==6)	{
-		float		pixelHeight = 1.0/RENDERSIZE.y;
-		//	pass 4 is sampling 1/12, but writing to 1/4
-		if (PASSINDEX==4)	{
-			if (blurLevel==1)
-				blurRadius = blurLevelModulus/1.5;
-			else if (blurLevel>1)
-				blurRadius = 4.0;
-		}
-		//	pass 6 is sampling 1/4 and writing to full-size
-		else if (PASSINDEX==6)	{
-			if (blurLevel==0)
-				blurRadius = blurLevelModulus;
-			else if (blurLevel>0)
-				blurRadius = 6.0;
-		}
-		blurRadiusInPixels = pixelHeight * blurRadius;
-		texOffsets[0] = isf_FragNormCoord;
-		texOffsets[1] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]-blurRadiusInPixels),0.0,1.0);
-		texOffsets[2] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]+blurRadiusInPixels),0.0,1.0);
-		if (PASSINDEX==4)	{
-			texOffsets[3] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]-(2.0*blurRadiusInPixels)),0.0,1.0);
-			texOffsets[4] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]+(2.0*blurRadiusInPixels)),0.0,1.0);
-		}
-	}
-	
-}
diff --git a/nannou_isf/test_files/Glow-Fast.fs b/nannou_isf/test_files/Glow-Fast.fs
deleted file mode 100644
index bac632088..000000000
--- a/nannou_isf/test_files/Glow-Fast.fs
+++ /dev/null
@@ -1,154 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Stylize"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "intensity",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 12,
-            "MAX": 12,
-            "MIN": 0,
-            "NAME": "blurAmount",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "DESCRIPTION": "Pass 0",
-            "HEIGHT": "floor($HEIGHT/2.0)",
-            "TARGET": "halfSizeBaseRender",
-            "WIDTH": "floor($WIDTH/2.0)"
-        },
-        {
-            "DESCRIPTION": "Pass 1",
-            "HEIGHT": "floor($HEIGHT/4.0)",
-            "TARGET": "quarterSizeBaseRender",
-            "WIDTH": "floor($WIDTH/4.0)"
-        },
-        {
-            "DESCRIPTION": "Pass 2",
-            "HEIGHT": "floor($HEIGHT/8.0)",
-            "TARGET": "eighthSizeBaseRender",
-            "WIDTH": "floor($WIDTH/8.0)"
-        },
-        {
-            "DESCRIPTION": "Pass 3",
-            "HEIGHT": "floor($HEIGHT/4.0)",
-            "TARGET": "quarterGaussA",
-            "WIDTH": "floor($WIDTH/4.0)"
-        },
-        {
-            "DESCRIPTION": "Pass 4",
-            "HEIGHT": "floor($HEIGHT/4.0)",
-            "TARGET": "quarterGaussB",
-            "WIDTH": "floor($WIDTH/4.0)"
-        },
-        {
-            "DESCRIPTION": "Pass 5",
-            "TARGET": "fullGaussA"
-        },
-        {
-            "DESCRIPTION": "Pass 6",
-            "TARGET": "fullGaussB"
-        }
-    ]
-}
-*/
-
-
-//	original blur implementation as v002.blur in QC by anton marini and tom butterworth, ported by zoidberg
-
-#if __VERSION__ <= 120
-varying vec2		texOffsets[5];
-#else
-in vec2		texOffsets[5];
-#endif
-
-
-void main() {
-	int			blurLevel = int(floor(blurAmount/6.0));
-	float		blurLevelModulus = mod(blurAmount, 6.0);
-	//	first three passes are just copying the input image into the buffer at varying sizes
-	if (PASSINDEX==0)	{
-		gl_FragColor = IMG_NORM_PIXEL(inputImage, isf_FragNormCoord);
-	}
-	else if (PASSINDEX==1)	{
-		gl_FragColor = IMG_NORM_PIXEL(halfSizeBaseRender, isf_FragNormCoord);
-	}
-	else if (PASSINDEX==2)	{
-		gl_FragColor = IMG_NORM_PIXEL(quarterSizeBaseRender, isf_FragNormCoord);
-	}
-	//	start reading from the previous stage- each two passes completes a gaussian blur, then 
-	//	we increase the resolution & blur (the lower-res blurred image from the previous pass) again...
-	else if (PASSINDEX == 3)	{
-		vec4		sample0 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[2]);
-		vec4		sample3 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[3]);
-		vec4		sample4 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[4]);
-		//gl_FragColor = vec4((sample0 + sample1 + sample2).rgb / (3.0), 1.0);
-		//gl_FragColor = vec4((sample0 + sample1 + sample2 + sample3 + sample4).rgb / (5.0), 1.0);
-		vec4		final = vec4((sample0 + sample1 + sample2 + sample3 + sample4).rgba / (5.0));
-		final = mix(sample0, final, intensity);
-		gl_FragColor = final;
-	}
-	else if (PASSINDEX == 4)	{
-		vec4		sample0 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[2]);
-		vec4		sample3 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[3]);
-		vec4		sample4 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[4]);
-		//gl_FragColor = vec4((sample0 + sample1 + sample2).rgb / (3.0), 1.0);
-		//gl_FragColor = vec4((sample0 + sample1 + sample2 + sample3 + sample4).rgb / (5.0), 1.0);
-		vec4		final = vec4((sample0 + sample1 + sample2 + sample3 + sample4).rgba / (5.0));
-		final = mix(sample0, final, intensity);
-		gl_FragColor = final;
-	}
-	//	...writes into the full-size
-	else if (PASSINDEX == 5)	{
-		vec4		sample0 = IMG_NORM_PIXEL(quarterGaussB,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(quarterGaussB,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(quarterGaussB,texOffsets[2]);
-		//gl_FragColor =  vec4((sample0 + sample1 + sample2).rgb / (3.0), 1.0);
-		vec4		final = vec4((sample0 + sample1 + sample2).rgba / (3.0));
-		final = mix(sample0, final, intensity);
-		gl_FragColor = final;
-	}
-	else if (PASSINDEX == 6)	{
-		//	this is the last pass- calculate the blurred image as i have in previous passes, then mix it in with the full-size input image using the blur amount so i get a smooth transition into the blur at low blur levels
-		vec4		sample0 = IMG_NORM_PIXEL(fullGaussA,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(fullGaussA,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(fullGaussA,texOffsets[2]);
-		vec4		final = vec4((sample0 + sample1 + sample2).rgba / (3.0));
-		vec4		original = IMG_NORM_PIXEL(inputImage,isf_FragNormCoord);
-		final = mix(original, min((final*original),1.0), intensity);
-		//	First do a gloom,
-		//	then a bright / contrast tweak based on the amount
-		//	then a bloom
-		vec4		tmpColorA = final;
-		float		bright = intensity*0.222;
-		vec4		tmpColorB = tmpColorA + vec4(bright,bright,bright,bright);
-		//	contrast
-		float		contrast = 1.0 + intensity * (2.893);
-		tmpColorA.rgba = ((vec4(2.0) * (tmpColorB.rgba - vec4(0.5))) * vec4(contrast) / vec4(2.0)) + vec4(0.5);
-		final = min((tmpColorA + tmpColorA * original), 1.0);
-		gl_FragColor = final;
-		//if (blurLevel == 0)
-		//	gl_FragColor = mix(IMG_NORM_PIXEL(inputImage,isf_FragNormCoord), blurredImg, (blurLevelModulus/6.1));
-		//else
-		//	gl_FragColor = blurredImg;
-	}
-	
-}
diff --git a/nannou_isf/test_files/Glow-Fast.vs b/nannou_isf/test_files/Glow-Fast.vs
deleted file mode 100644
index 3c9a24ee7..000000000
--- a/nannou_isf/test_files/Glow-Fast.vs
+++ /dev/null
@@ -1,70 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2		texOffsets[5];
-#else
-out vec2		texOffsets[5];
-#endif
-
-void main(void)	{
-	//	load the main shader stuff
-	isf_vertShaderInit();
-	
-	
-	int			blurLevel = int(floor(blurAmount/6.0));
-	float		blurLevelModulus = mod(blurAmount, 6.0);
-	float		blurRadius = 0.0;
-	float		blurRadiusInPixels = 0.0;
-	//	first three passes are just drawing the texture- do nothing
-	
-	//	the next four passes do gaussion blurs on the various levels
-	if (PASSINDEX==3 || PASSINDEX==5)	{
-		float		pixelWidth = 1.0/RENDERSIZE.x;
-		//	pass 3 is sampling 1/12, but writing to 1/4
-		if (PASSINDEX==3)	{
-			if (blurLevel==1)
-				blurRadius = blurLevelModulus/1.5;
-			else if (blurLevel>1)
-				blurRadius = 4.0;
-		}
-		//	pass 5 is sampling 1/4 and writing to full-size
-		else if (PASSINDEX==5)	{
-			if (blurLevel==0)
-				blurRadius = blurLevelModulus;
-			else if (blurLevel>0)
-				blurRadius = 6.0;
-		}
-		blurRadiusInPixels = pixelWidth * blurRadius;
-		texOffsets[0] = isf_FragNormCoord;
-		texOffsets[1] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0]-blurRadiusInPixels, isf_FragNormCoord[1]),0.0,1.0);
-		texOffsets[2] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0]+blurRadiusInPixels, isf_FragNormCoord[1]),0.0,1.0);
-		if (PASSINDEX==3)	{
-			texOffsets[3] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0]-(2.0*blurRadiusInPixels), isf_FragNormCoord[1]),0.0,1.0);
-			texOffsets[4] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0]+(2.0*blurRadiusInPixels), isf_FragNormCoord[1]),0.0,1.0);
-		}
-	}
-	else if (PASSINDEX==4 || PASSINDEX==6)	{
-		float		pixelHeight = 1.0/RENDERSIZE.y;
-		//	pass 4 is sampling 1/12, but writing to 1/4
-		if (PASSINDEX==4)	{
-			if (blurLevel==1)
-				blurRadius = blurLevelModulus/1.5;
-			else if (blurLevel>1)
-				blurRadius = 4.0;
-		}
-		//	pass 6 is sampling 1/4 and writing to full-size
-		else if (PASSINDEX==6)	{
-			if (blurLevel==0)
-				blurRadius = blurLevelModulus;
-			else if (blurLevel>0)
-				blurRadius = 6.0;
-		}
-		blurRadiusInPixels = pixelHeight * blurRadius;
-		texOffsets[0] = isf_FragNormCoord;
-		texOffsets[1] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]-blurRadiusInPixels),0.0,1.0);
-		texOffsets[2] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]+blurRadiusInPixels),0.0,1.0);
-		if (PASSINDEX==4)	{
-			texOffsets[3] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]-(2.0*blurRadiusInPixels)),0.0,1.0);
-			texOffsets[4] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]+(2.0*blurRadiusInPixels)),0.0,1.0);
-		}
-	}
-	
-}
diff --git a/nannou_isf/test_files/Glow.fs b/nannou_isf/test_files/Glow.fs
deleted file mode 100644
index 272455bf5..000000000
--- a/nannou_isf/test_files/Glow.fs
+++ /dev/null
@@ -1,158 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Stylize"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "intensity",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "HEIGHT": "floor($HEIGHT*min((0.2),1.0))",
-            "TARGET": "smallA",
-            "WIDTH": "floor($WIDTH*min((0.2),1.0))"
-        },
-        {
-            "HEIGHT": "floor($HEIGHT*min((0.2),1.0))",
-            "TARGET": "smallB",
-            "WIDTH": "floor($WIDTH*min((0.2),1.0))"
-        },
-        {
-            "HEIGHT": "floor($HEIGHT*min((0.3),1.0))",
-            "TARGET": "smallC",
-            "WIDTH": "floor($WIDTH*min((0.3),1.0))"
-        },
-        {
-            "HEIGHT": "floor($HEIGHT*min((0.3),1.0))",
-            "TARGET": "smallD",
-            "WIDTH": "floor($WIDTH*min((0.3),1.0))"
-        },
-        {
-            "HEIGHT": "floor($HEIGHT*min((0.5),1.0))",
-            "TARGET": "smallE",
-            "WIDTH": "floor($WIDTH*min((0.5),1.0))"
-        },
-        {
-            "HEIGHT": "floor($HEIGHT*min((0.5),1.0))",
-            "TARGET": "smallF",
-            "WIDTH": "floor($WIDTH*min((0.5),1.0))"
-        },
-        {
-            "HEIGHT": "floor($HEIGHT*min((0.8),1.0))",
-            "TARGET": "smallG",
-            "WIDTH": "floor($WIDTH*min((0.8),1.0))"
-        },
-        {
-            "HEIGHT": "floor($HEIGHT*min((0.8),1.0))",
-            "TARGET": "smallH",
-            "WIDTH": "floor($WIDTH*min((0.8),1.0))"
-        },
-        {
-            "TARGET": "smallI"
-        },
-        {
-        }
-    ]
-}
-*/
-
-
-//	original blur implementation as v002.blur in QC by anton marini and tom butterworth, ported by zoidberg
-
-#if __VERSION__ <= 120
-varying vec2		texOffsets[3];
-#else
-in vec2		texOffsets[3];
-#endif
-
-
-void main() {
-	vec4		sample0;
-	vec4		sample1;
-	vec4		sample2;
-	if (PASSINDEX == 0)	{
-		sample0 = IMG_NORM_PIXEL(inputImage,texOffsets[0]);
-		sample1 = IMG_NORM_PIXEL(inputImage,texOffsets[1]);
-		sample2 = IMG_NORM_PIXEL(inputImage,texOffsets[2]);
-	}
-	else if (PASSINDEX == 1)	{
-		sample0 = IMG_NORM_PIXEL(smallA,texOffsets[0]);
-		sample1 = IMG_NORM_PIXEL(smallA,texOffsets[1]);
-		sample2 = IMG_NORM_PIXEL(smallA,texOffsets[2]);
-	}
-	else if (PASSINDEX == 2)	{
-		sample0 = IMG_NORM_PIXEL(smallB,texOffsets[0]);
-		sample1 = IMG_NORM_PIXEL(smallB,texOffsets[1]);
-		sample2 = IMG_NORM_PIXEL(smallB,texOffsets[2]);
-	}
-	else if (PASSINDEX == 3)	{
-		sample0 = IMG_NORM_PIXEL(smallC,texOffsets[0]);
-		sample1 = IMG_NORM_PIXEL(smallC,texOffsets[1]);
-		sample2 = IMG_NORM_PIXEL(smallC,texOffsets[2]);
-	}
-	else if (PASSINDEX == 4)	{
-		sample0 = IMG_NORM_PIXEL(smallD,texOffsets[0]);
-		sample1 = IMG_NORM_PIXEL(smallD,texOffsets[1]);
-		sample2 = IMG_NORM_PIXEL(smallD,texOffsets[2]);
-	}
-	else if (PASSINDEX == 5)	{
-		sample0 = IMG_NORM_PIXEL(smallE,texOffsets[0]);
-		sample1 = IMG_NORM_PIXEL(smallE,texOffsets[1]);
-		sample2 = IMG_NORM_PIXEL(smallE,texOffsets[2]);
-	}
-	else if (PASSINDEX == 6)	{
-		sample0 = IMG_NORM_PIXEL(smallF,texOffsets[0]);
-		sample1 = IMG_NORM_PIXEL(smallF,texOffsets[1]);
-		sample2 = IMG_NORM_PIXEL(smallF,texOffsets[2]);
-	}
-	else if (PASSINDEX == 7)	{
-		sample0 = IMG_NORM_PIXEL(smallG,texOffsets[0]);
-		sample1 = IMG_NORM_PIXEL(smallG,texOffsets[1]);
-		sample2 = IMG_NORM_PIXEL(smallG,texOffsets[2]);
-	}
-	else if (PASSINDEX == 8)	{
-		sample0 = IMG_NORM_PIXEL(smallH,texOffsets[0]);
-		sample1 = IMG_NORM_PIXEL(smallH,texOffsets[1]);
-		sample2 = IMG_NORM_PIXEL(smallH,texOffsets[2]);
-	}
-	else if (PASSINDEX == 9)	{
-		sample0 = IMG_NORM_PIXEL(smallI,texOffsets[0]);
-		sample1 = IMG_NORM_PIXEL(smallI,texOffsets[1]);
-		sample2 = IMG_NORM_PIXEL(smallI,texOffsets[2]);
-	}
-	else	{
-		sample0 = vec4(1,0,0,1);
-		sample1 = vec4(1,0,0,1);
-		sample2 = vec4(1,0,0,1);
-	}
-	vec4 final = vec4((sample0 + sample1 + sample2).rgba / (3.0));
-	vec4 original = IMG_NORM_PIXEL(inputImage,texOffsets[0]);
-	if (PASSINDEX == 9)	{
-		final = mix(original,min((final * original), 1.0), intensity);
-		//	First do a gloom,
-		//	then a bright / contrast tweak based on the amount
-		//	then a bloom
-		vec4 tmpColorA = final;
-		float bright = intensity * 0.222;
-		vec4 tmpColorB = tmpColorA + vec4(bright, bright, bright, bright);
-		//	contrast
-		float contrast = 1.0 + intensity * (2.893);
-		tmpColorA.rgba = ((vec4(2.0) * (tmpColorB.rgba - vec4(0.5))) * vec4(contrast) / vec4(2.0)) + vec4(0.5);
-		final = min((tmpColorA + tmpColorA * original), 1.0);
-	}
-	else	{
-		final = mix(sample0, final, intensity);
-	}
-	gl_FragColor = final;
-}
diff --git a/nannou_isf/test_files/Glow.vs b/nannou_isf/test_files/Glow.vs
deleted file mode 100644
index cd97f0c14..000000000
--- a/nannou_isf/test_files/Glow.vs
+++ /dev/null
@@ -1,33 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2		texOffsets[3];
-#else
-out vec2		texOffsets[3];
-#endif
-
-const float radius = 10.0;
-
-void main(void)	{
-	//	load the main shader stuff
-	isf_vertShaderInit();
-	
-	if (PASSINDEX==0 || PASSINDEX==2 || PASSINDEX==4 || PASSINDEX==6 || PASSINDEX==8)	{
-		float		pixelWidth = 1.0/RENDERSIZE[0]*radius;
-		if (PASSINDEX >= 2)
-			pixelWidth *= .7;
-		else if (PASSINDEX >= 6)
-			pixelWidth *= 1.0;
-		texOffsets[0] = isf_FragNormCoord;
-		texOffsets[1] = clamp(vec2(isf_FragNormCoord[0]-pixelWidth, isf_FragNormCoord[1]),0.0,1.0);
-		texOffsets[2] = clamp(vec2(isf_FragNormCoord[0]+pixelWidth, isf_FragNormCoord[1]),0.0,1.0);
-	}
-	else if (PASSINDEX==1 || PASSINDEX==3 || PASSINDEX==5 || PASSINDEX==7 || PASSINDEX==9)	{
-		float		pixelHeight = 1.0/RENDERSIZE[1]*radius;
-		if (PASSINDEX >= 3)
-			pixelHeight *= .7;
-		else if (PASSINDEX >= 6)
-			pixelHeight *= 1.0;
-		texOffsets[0] = isf_FragNormCoord;
-		texOffsets[1] = clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]-pixelHeight),0.0,1.0);
-		texOffsets[2] = clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]+pixelHeight),0.0,1.0);
-	}
-}
diff --git a/nannou_isf/test_files/God Rays.fs b/nannou_isf/test_files/God Rays.fs
deleted file mode 100644
index 4d366dc20..000000000
--- a/nannou_isf/test_files/God Rays.fs	
+++ /dev/null
@@ -1,91 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Stylize"
-    ],
-    "CREDIT": "by VIDVOX",
-    "DESCRIPTION": "adapted from https://github.com/neilmendoza/ofxPostProcessing/blob/master/src/GodRaysPass.cpp",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "lightDirDOTviewDir",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0.5,
-                0.5
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "lightPositionOnScreen",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": 10,
-            "LABELS": [
-                "Low",
-                "Mid",
-                "High"
-            ],
-            "NAME": "quality",
-            "TYPE": "long",
-            "VALUES": [
-                5,
-                10,
-                25
-            ]
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-void main(void)
-{
-	vec4 origColor = IMG_THIS_PIXEL(inputImage);
-	vec4 raysColor = IMG_THIS_PIXEL(inputImage);
-	int NUM_SAMPLES = quality;
-
-	if (lightDirDOTviewDir>0.0){
-		float exposure	= 0.1/float(NUM_SAMPLES);
-		float decay		= 1.0 ;
-		float density	= 0.5;
-		float weight	= 6.0;
-		float illuminationDecay = 1.0;
-		vec2		normSrcCoord;
-
-		normSrcCoord.x = isf_FragNormCoord[0];
-		normSrcCoord.y = isf_FragNormCoord[1];
-
-		vec2 deltaTextCoord = vec2(normSrcCoord.st - lightPositionOnScreen);
-		vec2 textCoo = normSrcCoord;
-		deltaTextCoord *= 1.0 / float(NUM_SAMPLES) * density;
-
-		for(int i=0; i < NUM_SAMPLES ; i++)	{
-			textCoo -= deltaTextCoord;
-			vec4 tsample = IMG_NORM_PIXEL(inputImage, textCoo);
-			tsample *= illuminationDecay * weight;
-			raysColor += tsample;
-			illuminationDecay *= decay;
-		}
-		raysColor *= exposure * lightDirDOTviewDir;
-		float p = 0.3 *raysColor.g + 0.59*raysColor.r + 0.11*raysColor.b;
-		gl_FragColor = origColor + p;
-	}
-	else {
-		gl_FragColor = origColor;
-	}
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Graph Paper.fs b/nannou_isf/test_files/Graph Paper.fs
deleted file mode 100644
index f728e76aa..000000000
--- a/nannou_isf/test_files/Graph Paper.fs	
+++ /dev/null
@@ -1,172 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Pattern", "Color"
-  ],
-  "DESCRIPTION" : "Draws basic graph paper pattern",
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "NAME" : "bgColor",
-      "TYPE" : "color",
-      "DEFAULT" : [
-        0.93999999761581421,
-        0.93999999761581421,
-        0.97000002861022949,
-        1
-      ]
-    },
-    {
-      "NAME" : "lineColor",
-      "TYPE" : "color",
-      "DEFAULT" : [
-        0.63999998569488525,
-        0.76999998092651367,
-        0.95999997854232788,
-        1
-      ]
-    },
-    {
-      "LABELS" : [
-        "0",
-        "1",
-        "2",
-        "3",
-        "4",
-        "5",
-        "6",
-        "7",
-        "8",
-        "9",
-        "10",
-        "11",
-        "12",
-        "13",
-        "14",
-        "15",
-        "16"
-      ],
-      "NAME" : "majorDivisions",
-      "TYPE" : "long",
-      "DEFAULT" : 3,
-      "VALUES" : [
-        0,
-        1,
-        2,
-        3,
-        4,
-        5,
-        6,
-        7,
-        8,
-        9,
-        10,
-        11,
-        12,
-        13,
-        14,
-        15,
-        16
-      ]
-    },
-    {
-      "LABELS" : [
-        "0",
-        "1",
-        "2",
-        "3",
-        "4",
-        "5",
-        "6",
-        "7",
-        "8"
-      ],
-      "NAME" : "minorHDivisions",
-      "TYPE" : "long",
-      "DEFAULT" : 2,
-      "VALUES" : [
-        0,
-        1,
-        2,
-        3,
-        4,
-        5,
-        6,
-        7,
-        8
-      ]
-    },
-    {
-      "LABELS" : [
-        "0",
-        "1",
-        "2",
-        "3",
-        "4",
-        "5",
-        "6",
-        "7",
-        "8"
-      ],
-      "NAME" : "minorVDivisions",
-      "TYPE" : "long",
-      "DEFAULT" : 2,
-      "VALUES" : [
-        0,
-        1,
-        2,
-        3,
-        4,
-        5,
-        6,
-        7,
-        8
-      ]
-    },
-    {
-      "NAME" : "majorDivisionLineWidth",
-      "TYPE" : "float",
-      "MAX" : 5,
-      "DEFAULT" : 3,
-      "MIN" : 1
-    },
-    {
-      "NAME" : "square",
-      "TYPE" : "bool",
-      "DEFAULT" : true
-    }
-  ],
-  "CREDIT" : "VIDVOX"
-}
-*/
-
-
-const float minorDivisionLineWidth = 1.0;
-
-
-void main()	{
-	vec4		inputPixelColor = bgColor;
-	vec2		loc = gl_FragCoord.xy;
-	vec2		divisionSize = (square) ? vec2(max(RENDERSIZE.x,RENDERSIZE.y)) : RENDERSIZE;
-	divisionSize = (divisionSize - majorDivisionLineWidth) / (1.0 + float(majorDivisions));
-	vec2		modLoc = mod(loc,divisionSize);
-	if ((modLoc.x < majorDivisionLineWidth)||(modLoc.y < majorDivisionLineWidth))	{
-		inputPixelColor = lineColor;
-	}
-	if (minorHDivisions > 0)	{
-		vec2	locDivisionSize = (divisionSize) / (1.0+float(minorHDivisions));
-		modLoc = mod(loc,locDivisionSize);
-		if (modLoc.x < minorDivisionLineWidth)	{
-			inputPixelColor = lineColor;
-		}
-	}
-	if (minorVDivisions > 0)	{
-		vec2	locDivisionSize = (divisionSize) / (1.0+float(minorVDivisions));
-		modLoc = mod(loc,locDivisionSize);
-		if (modLoc.y < minorDivisionLineWidth)	{
-			inputPixelColor = lineColor;
-		}
-	}
-
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/Grid Flip.fs b/nannou_isf/test_files/Grid Flip.fs
deleted file mode 100644
index a68faf030..000000000
--- a/nannou_isf/test_files/Grid Flip.fs	
+++ /dev/null
@@ -1,158 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Wipe"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/GridFlip.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.1,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "pause",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.05,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "dividerWidth",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.1,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "randomness",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0,
-                0,
-                1
-            ],
-            "NAME": "bgcolor",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": [
-                4,
-                4
-            ],
-            "MAX": [
-                10,
-                10
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "size",
-            "TYPE": "point2D"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// License: MIT
-// Author: TimDonselaar
-// ported by gre from https://gist.github.com/TimDonselaar/9bcd1c4b5934ba60087bdb55c2ea92e5
-
- 
-float rand (vec2 co) {
-  return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-float getDelta(vec2 p) {
-  vec2 rectanglePos = floor(vec2(size) * p);
-  vec2 rectangleSize = vec2(1.0 / vec2(size).x, 1.0 / vec2(size).y);
-  float top = rectangleSize.y * (rectanglePos.y + 1.0);
-  float bottom = rectangleSize.y * rectanglePos.y;
-  float left = rectangleSize.x * rectanglePos.x;
-  float right = rectangleSize.x * (rectanglePos.x + 1.0);
-  float minX = min(abs(p.x - left), abs(p.x - right));
-  float minY = min(abs(p.y - top), abs(p.y - bottom));
-  return min(minX, minY);
-}
-
-float getDividerSize() {
-  vec2 rectangleSize = vec2(1.0 / vec2(size).x, 1.0 / vec2(size).y);
-  return min(rectangleSize.x, rectangleSize.y) * dividerWidth;
-}
-
-vec4 transition(vec2 p) {
-  if(progress < pause) {
-    float currentProg = progress / pause;
-    float a = 1.0;
-    if(getDelta(p) < getDividerSize()) {
-      a = 1.0 - currentProg;
-    }
-    return mix(bgcolor, getFromColor(p), a);
-  }
-  else if(progress < 1.0 - pause){
-    if(getDelta(p) < getDividerSize()) {
-      return bgcolor;
-    } else {
-      float currentProg = (progress - pause) / (1.0 - pause * 2.0);
-      vec2 q = p;
-      vec2 rectanglePos = floor(vec2(size) * q);
-      
-      float r = rand(rectanglePos) - randomness;
-      float cp = smoothstep(0.0, 1.0 - r, currentProg);
-    
-      float rectangleSize = 1.0 / vec2(size).x;
-      float delta = rectanglePos.x * rectangleSize;
-      float offset = rectangleSize / 2.0 + delta;
-      
-      p.x = (p.x - offset)/abs(cp - 0.5)*0.5 + offset;
-      vec4 a = getFromColor(p);
-      vec4 b = getToColor(p);
-      
-      float s = step(abs(vec2(size).x * (q.x - delta) - 0.5), abs(cp - 0.5));
-      return mix(bgcolor, mix(b, a, step(cp, 0.5)), s);
-    }
-  }
-  else {
-    float currentProg = (progress - 1.0 + pause) / pause;
-    float a = 1.0;
-    if(getDelta(p) < getDividerSize()) {
-      a = currentProg;
-    }
-    return mix(bgcolor, getToColor(p), a);
-  }
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Grid Warp.fs b/nannou_isf/test_files/Grid Warp.fs
deleted file mode 100644
index 65d998b26..000000000
--- a/nannou_isf/test_files/Grid Warp.fs	
+++ /dev/null
@@ -1,232 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Geometry"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "DEFAULT": -0.5,
-            "MAX": 1,
-            "MIN": -1,
-            "NAME": "level",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.25,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "radius",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0.5,
-                0.5
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "center",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0,
-                0,
-                0
-            ],
-            "NAME": "bgColor",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": [
-                0.9436030983924866,
-                0.5601619482040405,
-                0,
-                1
-            ],
-            "NAME": "lineColor",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": 6,
-            "LABELS": [
-                "0",
-                "1",
-                "2",
-                "3",
-                "4",
-                "5",
-                "6",
-                "7",
-                "8",
-                "9",
-                "10",
-                "11",
-                "12",
-                "13",
-                "14",
-                "15",
-                "16"
-            ],
-            "NAME": "majorDivisions",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1,
-                2,
-                3,
-                4,
-                5,
-                6,
-                7,
-                8,
-                9,
-                10,
-                11,
-                12,
-                13,
-                14,
-                15,
-                16
-            ]
-        },
-        {
-            "DEFAULT": 2,
-            "LABELS": [
-                "0",
-                "1",
-                "2",
-                "3",
-                "4",
-                "5",
-                "6",
-                "7",
-                "8"
-            ],
-            "NAME": "minorHDivisions",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1,
-                2,
-                3,
-                4,
-                5,
-                6,
-                7,
-                8
-            ]
-        },
-        {
-            "DEFAULT": 1,
-            "LABELS": [
-                "0",
-                "1",
-                "2",
-                "3",
-                "4",
-                "5",
-                "6",
-                "7",
-                "8"
-            ],
-            "NAME": "minorVDivisions",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1,
-                2,
-                3,
-                4,
-                5,
-                6,
-                7,
-                8
-            ]
-        },
-        {
-            "DEFAULT": 3,
-            "MAX": 5,
-            "MIN": 1,
-            "NAME": "majorDivisionLineWidth",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": true,
-            "NAME": "square",
-            "TYPE": "bool"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-const float minorDivisionLineWidth = 1.0;
-const float pi = 3.14159265359;
-
-#ifndef GL_ES
-float distance (vec2 center, vec2 pt)
-{
-	float tmp = pow(center.x-pt.x,2.0)+pow(center.y-pt.y,2.0);
-	return pow(tmp,0.5);
-}
-#endif
-
-void main() {
-	vec2 uv = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	vec2 texSize = RENDERSIZE;
-	vec2 tc = uv * texSize;
-	vec2 modifiedCenter = center * RENDERSIZE;
-	float r = distance(modifiedCenter, tc);
-	float a = atan ((tc.y-modifiedCenter.y),(tc.x-modifiedCenter.x));
-	float radius_sized = radius * length(RENDERSIZE);
-	vec4 inputPixelColor = bgColor;
-	
-	tc -= modifiedCenter;
-
-	if (r < radius_sized) 	{
-		float percent = 1.0-(radius_sized - r) / radius_sized;
-		if (level>=0.0)	{
-			percent = percent * percent;
-			tc.x = r*pow(percent,level) * cos(a);
-			tc.y = r*pow(percent,level) * sin(a);
-		}
-		else	{
-			float adjustedLevel = level/2.0;
-			tc.x = r*pow(percent,adjustedLevel) * cos(a);
-			tc.y = r*pow(percent,adjustedLevel) * sin(a);		
-		}
-	}
-	tc += modifiedCenter;
-	
-	vec2 loc = tc;
-	vec2 divisionSize = (square) ? vec2(max(RENDERSIZE.x,RENDERSIZE.y)) : RENDERSIZE;
-	divisionSize = (divisionSize - majorDivisionLineWidth) / (1.0 + float(majorDivisions));
-	vec2 modLoc = mod(loc,divisionSize);
-	if ((modLoc.x < majorDivisionLineWidth)||(modLoc.y < majorDivisionLineWidth))	{
-		inputPixelColor = lineColor;
-	}
-	if (minorHDivisions > 0)	{
-		vec2	locDivisionSize = (divisionSize) / (1.0+float(minorHDivisions));
-		modLoc = mod(loc,locDivisionSize);
-		if (modLoc.x < minorDivisionLineWidth)	{
-			inputPixelColor = lineColor;
-		}
-	}
-	if (minorVDivisions > 0)	{
-		vec2	locDivisionSize = (divisionSize) / (1.0+float(minorVDivisions));
-		modLoc = mod(loc,locDivisionSize);
-		if (modLoc.y < minorDivisionLineWidth)	{
-			inputPixelColor = lineColor;
-		}
-	}
-	
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/HSVtoRGB.fs b/nannou_isf/test_files/HSVtoRGB.fs
deleted file mode 100644
index c7c36519b..000000000
--- a/nannou_isf/test_files/HSVtoRGB.fs
+++ /dev/null
@@ -1,46 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Color Effect",
-        "Utility"
-    ],
-    "CREDIT": "by zoidberg",
-    "DESCRIPTION": "swizzles RGBA to BGRA and vice versa",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-
-vec3 rgb2hsv(vec3 c)	{
-	vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-	//vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
-	//vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
-	vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
-	vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
-	
-	float d = q.x - min(q.w, q.y);
-	float e = 1.0e-10;
-	return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
-}
-
-vec3 hsv2rgb(vec3 c)	{
-	vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
-	vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
-	return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
-}
-
-
-
-
-void main()
-{
-	vec4		inColor = IMG_NORM_PIXEL(inputImage, isf_FragNormCoord);
-	gl_FragColor = vec4(hsv2rgb(inColor.rgb), inColor.a);
-}
diff --git a/nannou_isf/test_files/Hatch Blur.fs b/nannou_isf/test_files/Hatch Blur.fs
deleted file mode 100644
index edc7cc1c1..000000000
--- a/nannou_isf/test_files/Hatch Blur.fs	
+++ /dev/null
@@ -1,95 +0,0 @@
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Blur"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "width",
-			"LABEL": "Width",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.0
-		},
-		{
-			"NAME": "angle",
-			"LABEL": "Angle",
-			"TYPE": "float",
-			"MIN": -1.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.125
-		},
-		{
-			"NAME": "quality",
-			"LABEL": "Quality",
-			"VALUES": [
-				24,
-				16,
-				8,
-				4
-			],
-			"LABELS": [
-				"Low",
-				"Mid",
-				"High",
-				"Best"
-			],
-			"DEFAULT": 16,
-			"TYPE": "long"
-		}
-	]
-}*/
-
-
-const float pi = 3.14159265359;
-
-
-void main() {
-	vec2 loc = isf_FragNormCoord * RENDERSIZE;
-
-	vec2 p1 = vec2(0.0);
-	vec2 p2 = vec2(1.0);
-	vec2 vector = vec2(cos(pi * angle),sin(pi * angle));
-	
-	vec4 returnMe;
-	
-	if (width > 0.0)	{
-		p1 = loc - width * RENDERSIZE * vector;
-		p2 = loc + width * RENDERSIZE * vector;
-		
-		//	now we have the two points to smear between,
-		float i;
-		float count = clamp(width * max(RENDERSIZE.x,RENDERSIZE.y) / float(quality), 5.0, 75.0);
-		vec2 diff = p2 - p1;
-		for (float i = 0.0; i < 75.0; ++i)	{
-			if (i > float(count))
-				break;
-			float tmp = (i / (count - 1.0));
-			returnMe = returnMe + IMG_PIXEL(inputImage, p1 + diff * tmp) / count;
-		}
-		
-		vector = vec2(cos(pi * (0.5+ angle)),sin(pi * (0.5+ angle)));
-		p1 = loc - width * RENDERSIZE * vector;
-		p2 = loc + width * RENDERSIZE * vector;
-		
-		//	now we have the two points to smear between,
-		diff = p2 - p1;
-		for (float i = 0.0; i < 75.0; ++i)	{
-			if (i > float(count))
-				break;
-			float tmp = (i / (count - 1.0));
-			returnMe = returnMe + IMG_PIXEL(inputImage, p1 + diff * tmp) / count;
-		}
-		returnMe = returnMe / 2.0;
-	}
-	else	{
-		returnMe = IMG_THIS_PIXEL(inputImage);
-	}
-	gl_FragColor = returnMe;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Heart Transition.fs b/nannou_isf/test_files/Heart Transition.fs
deleted file mode 100644
index e6b252c99..000000000
--- a/nannou_isf/test_files/Heart Transition.fs	
+++ /dev/null
@@ -1,61 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Wipe",
-        "Retro"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/heart.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: gre
-// License: MIT
-
-float inHeart (vec2 p, vec2 center, float size) {
-  if (size==0.0) return 0.0;
-  vec2 o = (p-center)/(1.6*size);
-  float a = o.x*o.x+o.y*o.y-0.3;
-  return step(a*a*a, o.x*o.x*o.y*o.y*o.y);
-}
-vec4 transition (vec2 uv) {
-  return mix(
-    getFromColor(uv),
-    getToColor(uv),
-    inHeart(uv, vec2(0.5, 0.4), progress)
-  );
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Heart.fs b/nannou_isf/test_files/Heart.fs
deleted file mode 100644
index 3fbe4f1f6..000000000
--- a/nannou_isf/test_files/Heart.fs
+++ /dev/null
@@ -1,44 +0,0 @@
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Geometry"
-	],
-	"INPUTS": [
-		{
-			"NAME": "size",
-			"LABEL": "Size",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.25
-		},
-		{
-			"NAME": "color",
-			"LABEL": "Fill Color",
-			"TYPE": "color",
-			"DEFAULT": [
-				1.0,
-				0.0,
-				0.0,
-				1.0
-			]
-		}
-	]
-}*/
-
-
-//	Adapted from https://glsl.io/transition/d71472a550601b96d69d
-
- 
-bool inHeart (vec2 p, vec2 center, float size) {
-	if (size == 0.0) return false;
-	vec2 o = (p-center)/(1.6*size);
-	return pow(o.x*o.x+o.y*o.y-0.3, 3.0) < o.x*o.x*pow(o.y, 3.0);
-}
- 
-void main() {
-	vec2 p = isf_FragNormCoord;
-	float m = inHeart(p, vec2(0.5, 0.4), size) ? 1.0 : 0.0;
-	gl_FragColor = mix(vec4(0.0), color, m);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Hexagon.tiff b/nannou_isf/test_files/Hexagon.tiff
deleted file mode 100644
index 2eec5be3c..000000000
Binary files a/nannou_isf/test_files/Hexagon.tiff and /dev/null differ
diff --git a/nannou_isf/test_files/Hexagonalize.fs b/nannou_isf/test_files/Hexagonalize.fs
deleted file mode 100644
index ef6a2418d..000000000
--- a/nannou_isf/test_files/Hexagonalize.fs
+++ /dev/null
@@ -1,131 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/hexagonalize.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 50,
-            "MAX": 100,
-            "MIN": 0,
-            "NAME": "steps",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 20,
-            "MAX": 100,
-            "MIN": 0,
-            "NAME": "horizontalHexagons",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-float ratio = RENDERSIZE.x/RENDERSIZE.y;
-// Author: Fernando Kuteken
-// License: MIT
-// Hexagonal math from: http://www.redblobgames.com/grids/hexagons/
-
-
-struct Hexagon {
-  float q;
-  float r;
-  float s;
-};
-
-Hexagon createHexagon(float q, float r){
-  Hexagon hex;
-  hex.q = q;
-  hex.r = r;
-  hex.s = -q - r;
-  return hex;
-}
-
-Hexagon roundHexagon(Hexagon hex){
-  
-  float q = floor(hex.q + 0.5);
-  float r = floor(hex.r + 0.5);
-  float s = floor(hex.s + 0.5);
-
-  float deltaQ = abs(q - hex.q);
-  float deltaR = abs(r - hex.r);
-  float deltaS = abs(s - hex.s);
-
-  if (deltaQ > deltaR && deltaQ > deltaS)
-    q = -r - s;
-  else if (deltaR > deltaS)
-    r = -q - s;
-  else
-    s = -q - r;
-
-  return createHexagon(q, r);
-}
-
-Hexagon hexagonFromPoint(vec2 point, float size) {
-  
-  point.y /= ratio;
-  point = (point - 0.5) / size;
-  
-  float q = (sqrt(3.0) / 3.0) * point.x + (-1.0 / 3.0) * point.y;
-  float r = 0.0 * point.x + 2.0 / 3.0 * point.y;
-
-  Hexagon hex = createHexagon(q, r);
-  return roundHexagon(hex);
-  
-}
-
-vec2 pointFromHexagon(Hexagon hex, float size) {
-  
-  float x = (sqrt(3.0) * hex.q + (sqrt(3.0) / 2.0) * hex.r) * size + 0.5;
-  float y = (0.0 * hex.q + (3.0 / 2.0) * hex.r) * size + 0.5;
-  
-  return vec2(x, y * ratio);
-}
-
-vec4 transition (vec2 uv) {
-  
-  float dist = 2.0 * min(progress, 1.0 - progress);
-  dist = steps > 0 ? ceil(dist * float(steps)) / float(steps) : dist;
-  
-  float size = (sqrt(3.0) / 3.0) * dist / horizontalHexagons;
-  
-  vec2 point = dist > 0.0 ? pointFromHexagon(hexagonFromPoint(uv, size), size) : uv;
-
-  return mix(getFromColor(point), getToColor(point), progress);
-  
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Histogram Viewer.fs b/nannou_isf/test_files/Histogram Viewer.fs
deleted file mode 100644
index c158864ba..000000000
--- a/nannou_isf/test_files/Histogram Viewer.fs	
+++ /dev/null
@@ -1,35 +0,0 @@
-/*{
-	"CATEGORIES" : [
-		"Histogram", "Utility"
-  	],
-	"DESCRIPTION": "Draws an RGB histogram from a provided histogram image",
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"INPUTS": [
-		{
-			"NAME": "histogramImage",
-			"TYPE": "image"
-		}
-	]
-}*/
-
-
-void main()	{
-	vec4        outColor = vec4(0., 0., 0., 0.);
-	vec4        histoVals = IMG_NORM_PIXEL(histogramImage, vec2(isf_FragNormCoord.x, 0.5));
-	if (histoVals.r >= isf_FragNormCoord.y)	{
-		outColor.r = 1.0;
-		outColor.a = 1.0;
-	}
-	if (histoVals.g >= isf_FragNormCoord.y)	{
-		outColor.g = 1.0;
-		outColor.a = 1.0;
-	}
-	if (histoVals.b >= isf_FragNormCoord.y)	{
-		outColor.b = 1.0;
-		outColor.a = 1.0;
-	}
-	
-	gl_FragColor = outColor;
-	
-}
diff --git a/nannou_isf/test_files/HorizVertHold.fs b/nannou_isf/test_files/HorizVertHold.fs
deleted file mode 100644
index d35a121d7..000000000
--- a/nannou_isf/test_files/HorizVertHold.fs
+++ /dev/null
@@ -1,65 +0,0 @@
-/*{
-	"DESCRIPTION": "",
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Geometry Adjustment"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "hHold",
-			"LABEL": "Horiz. Hold",
-			"TYPE": "float",
-			"MIN": -0.45,
-			"MAX": 0.45,
-			"DEFAULT": 0.0
-		},
-		{
-			"NAME": "vHold",
-			"LABEL": "Vert. Hold",
-			"TYPE": "float",
-			"MIN": -0.45,
-			"MAX": 0.45,
-			"DEFAULT": 0.0
-		},
-		{
-			"NAME": "flashEvent",
-			"TYPE": "event"
-		}
-	],
-	"PASSES": [
-		{
-			"TARGET":"lastPosition",
-			"WIDTH": 1,
-			"HEIGHT": 1,
-			"FLOAT": true,
-			"PERSISTENT": true,
-			"DESCRIPTION": "this buffer stores the last frame's x/y offset in the first two components of its only pixel- note that it's requesting a FLOAT target buffer..."
-		},
-		{
-			
-		}
-	]
-	
-}*/
-
-void main()
-{
-	//	if this is the first pass, i'm going to read the position from the "lastPosition" image, and write a new position based on this and the hold variables
-	if (PASSINDEX == 0)	{
-		vec4		srcPixel = IMG_PIXEL(lastPosition,vec2(0.5));
-		//	i'm only using the X and Y components, which are the X and Y offset (normalized) for the frame
-		srcPixel.xy = (flashEvent) ? vec2(0.0) : (srcPixel.xy - vec2(hHold,vHold));
-		gl_FragColor = mod(srcPixel,1.0);
-	}
-	//	else this isn't the first pass- read the position value from the buffer which stores it
-	else	{
-		vec4		lastPosVector = IMG_PIXEL(lastPosition,vec2(0.5));
-		vec2		normPixelCoord = mod((isf_FragNormCoord.xy + lastPosVector.xy), 1.0);
-		gl_FragColor = IMG_NORM_PIXEL(inputImage,normPixelCoord);
-	}
-}
diff --git a/nannou_isf/test_files/Hyperspace.fs b/nannou_isf/test_files/Hyperspace.fs
deleted file mode 100644
index dd31f0df0..000000000
--- a/nannou_isf/test_files/Hyperspace.fs
+++ /dev/null
@@ -1,85 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion Effect"
-    ],
-    "CREDIT": "VIDVOX",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "centerX",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 2,
-            "MIN": 0,
-            "NAME": "scrollAmount",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "rightScrollOffset",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "IDENTITY": 1,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "midHeight",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "NAME": "seamless",
-            "TYPE": "bool"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-void main()	{
-	vec2		loc = isf_FragNormCoord.xy;
-	if (centerX == 0.0)	{
-		
-	}
-	else if (centerX == 1.0)	{
-		
-	}
-	else if (loc.x < centerX)	{
-		loc.x = loc.x / centerX;
-		loc.y = mix(0.5 + (loc.y-0.5) / midHeight,loc.y,1.0-loc.x);
-		loc.x = loc.x+scrollAmount;
-		if (seamless)	{
-			loc.x = ((loc.x <= 1.0)||(loc.x >= 2.0)) ? loc.x : 3.0 - loc.x;
-		}
-		loc.x = mod(loc.x,1.0);
-	}
-	else	{
-		float		rightScroll = mod(rightScrollOffset+scrollAmount,2.0);
-		loc.x = (1.0-loc.x) / (1.0-centerX);
-		loc.y = mix(0.5 + (loc.y-0.5) / midHeight,loc.y,1.0-loc.x);
-		loc.x = loc.x+rightScroll;
-		if (seamless)	{
-			loc.x = ((loc.x <= 1.0)||(loc.x >= 2.0)) ? loc.x : 3.0 - loc.x;
-		}
-		loc.x = mod(loc.x,1.0);
-	}
-	
-	vec4		inputPixelColor = vec4(0.0);
-	
-	if ((loc.y >= 0.0)&&(loc.y <= 1.0))
-		inputPixelColor = IMG_NORM_PIXEL(inputImage,loc);
-	
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/Interlace Mirror.fs b/nannou_isf/test_files/Interlace Mirror.fs
deleted file mode 100644
index 8a104f352..000000000
--- a/nannou_isf/test_files/Interlace Mirror.fs	
+++ /dev/null
@@ -1,45 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Glitch",
-        "Retro"
-    ],
-    "CREDIT": "by Carter Rosenberg",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Horizontal",
-            "NAME": "horizontal",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Vertical",
-            "NAME": "vertical",
-            "TYPE": "bool"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-void main()
-{
-	vec2 pixelCoord = isf_FragNormCoord * RENDERSIZE;
-	vec2 loc = pixelCoord;
-	if (vertical)	{
-		if (mod(pixelCoord.x,2.0)>1.0)	{
-			loc.y = RENDERSIZE.y - pixelCoord.y;
-		}
-	}
-	if (horizontal)	{
-		if (mod(pixelCoord.y,2.0)>1.0)	{
-			loc.x = RENDERSIZE.x - pixelCoord.x;
-		}	
-	}
-	gl_FragColor = IMG_PIXEL(inputImage,loc);
-}
diff --git a/nannou_isf/test_files/Interlace.fs b/nannou_isf/test_files/Interlace.fs
deleted file mode 100644
index 662aa241f..000000000
--- a/nannou_isf/test_files/Interlace.fs
+++ /dev/null
@@ -1,58 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Glitch",
-        "Retro"
-    ],
-    "CREDIT": "by Carter Rosenberg",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 4,
-            "LABEL": "Line Size",
-            "MAX": 50,
-            "MIN": 1,
-            "NAME": "lineSize",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "DESCRIPTION": "this buffer stores the last frame's odd / even state",
-            "HEIGHT": "1",
-            "PERSISTENT": true,
-            "TARGET": "lastRow",
-            "WIDTH": "1"
-        },
-        {
-            "PERSISTENT": true,
-            "TARGET": "lastFrame"
-        }
-    ]
-}
-*/
-
-void main()
-{
-	//	if this is the first pass, i'm going to read the position from the "lastRow" image, and write a new position based on this and the hold variables
-	if (PASSINDEX == 0)	{
-		vec4		srcPixel = IMG_PIXEL(lastRow,vec2(0.5));
-		//	i'm only using the X and Y components, which are the X and Y offset (normalized) for the frame
-		srcPixel.x = (srcPixel.x) > 0.5 ? 0.0 : 1.0;
-		gl_FragColor = srcPixel;
-	}
-	//	else this isn't the first pass- read the position value from the buffer which stores it
-	else	{
-		vec4		lastRow = IMG_PIXEL(lastRow,vec2(0.5));
-		vec2		pixelCoord = isf_FragNormCoord * RENDERSIZE;
-		
-		if (mod(floor(pixelCoord.y),2.0 * lineSize) < lineSize + lineSize * lastRow.x)
-			gl_FragColor = IMG_NORM_PIXEL(inputImage,isf_FragNormCoord);
-		else
-			gl_FragColor = IMG_NORM_PIXEL(lastFrame,isf_FragNormCoord);
-	}
-}
diff --git a/nannou_isf/test_files/Inverted Page Curl.fs b/nannou_isf/test_files/Inverted Page Curl.fs
deleted file mode 100644
index 2f96f32cc..000000000
--- a/nannou_isf/test_files/Inverted Page Curl.fs	
+++ /dev/null
@@ -1,259 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Wipe",
-        "Retro"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/InvertedPageCurl.glsl",
-    "DESCRIPTION": "Automatically converted from https://gl-transitions.com/",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// author: Hewlett-Packard
-// license: BSD 3 Clause
-// Adapted by Sergey Kosarevsky from:
-// http://rectalogic.github.io/webvfx/examples_2transition-shader-pagecurl_8html-example.html
-
-/*
-Copyright (c) 2010 Hewlett-Packard Development Company, L.P. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-     notice, this list of conditions and the following disclaimer.
-   * Redistributions in binary form must reproduce the above
-     copyright notice, this list of conditions and the following disclaimer
-     in the documentation and/or other materials provided with the
-     distribution.
-   * Neither the name of Hewlett-Packard nor the names of its
-     contributors may be used to endorse or promote products derived from
-     this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-in vec2 texCoord;
-*/
-
-const float MIN_AMOUNT = -0.16;
-const float MAX_AMOUNT = 1.5;
-float amount = progress * (MAX_AMOUNT - MIN_AMOUNT) + MIN_AMOUNT;
-
-const float PI = 3.141592653589793;
-
-const float scale = 512.0;
-const float sharpness = 3.0;
-
-float cylinderCenter = amount;
-// 360 degrees * amount
-float cylinderAngle = 2.0 * PI * amount;
-
-const float cylinderRadius = 1.0 / PI / 2.0;
-
-vec3 hitPoint(float hitAngle, float yc, vec3 point, mat3 rrotation)
-{
-        float hitPoint = hitAngle / (2.0 * PI);
-        point.y = hitPoint;
-        return rrotation * point;
-}
-
-vec4 antiAlias(vec4 color1, vec4 color2, float distanc)
-{
-        distanc *= scale;
-        if (distanc < 0.0) return color2;
-        if (distanc > 2.0) return color1;
-        float dd = pow(1.0 - distanc / 2.0, sharpness);
-        return ((color2 - color1) * dd) + color1;
-}
-
-float distanceToEdge(vec3 point)
-{
-        float dx = abs(point.x > 0.5 ? 1.0 - point.x : point.x);
-        float dy = abs(point.y > 0.5 ? 1.0 - point.y : point.y);
-        if (point.x < 0.0) dx = -point.x;
-        if (point.x > 1.0) dx = point.x - 1.0;
-        if (point.y < 0.0) dy = -point.y;
-        if (point.y > 1.0) dy = point.y - 1.0;
-        if ((point.x < 0.0 || point.x > 1.0) && (point.y < 0.0 || point.y > 1.0)) return sqrt(dx * dx + dy * dy);
-        return min(dx, dy);
-}
-
-vec4 seeThrough(float yc, vec2 p, mat3 rotation, mat3 rrotation)
-{
-        float hitAngle = PI - (acos(yc / cylinderRadius) - cylinderAngle);
-        vec3 point = hitPoint(hitAngle, yc, rotation * vec3(p, 1.0), rrotation);
-        if (yc <= 0.0 && (point.x < 0.0 || point.y < 0.0 || point.x > 1.0 || point.y > 1.0))
-        {
-            return getToColor(p);
-        }
-
-        if (yc > 0.0) return getFromColor(p);
-
-        vec4 color = getFromColor(point.xy);
-        vec4 tcolor = vec4(0.0);
-
-        return antiAlias(color, tcolor, distanceToEdge(point));
-}
-
-vec4 seeThroughWithShadow(float yc, vec2 p, vec3 point, mat3 rotation, mat3 rrotation)
-{
-        float shadow = distanceToEdge(point) * 30.0;
-        shadow = (1.0 - shadow) / 3.0;
-
-        if (shadow < 0.0) shadow = 0.0; else shadow *= amount;
-
-        vec4 shadowColor = seeThrough(yc, p, rotation, rrotation);
-        shadowColor.r -= shadow;
-        shadowColor.g -= shadow;
-        shadowColor.b -= shadow;
-
-        return shadowColor;
-}
-
-vec4 backside(float yc, vec3 point)
-{
-        vec4 color = getFromColor(point.xy);
-        float gray = (color.r + color.b + color.g) / 15.0;
-        gray += (8.0 / 10.0) * (pow(1.0 - abs(yc / cylinderRadius), 2.0 / 10.0) / 2.0 + (5.0 / 10.0));
-        color.rgb = vec3(gray);
-        return color;
-}
-
-vec4 behindSurface(vec2 p, float yc, vec3 point, mat3 rrotation)
-{
-        float shado = (1.0 - ((-cylinderRadius - yc) / amount * 7.0)) / 6.0;
-        shado *= 1.0 - abs(point.x - 0.5);
-
-        yc = (-cylinderRadius - cylinderRadius - yc);
-
-        float hitAngle = (acos(yc / cylinderRadius) + cylinderAngle) - PI;
-        point = hitPoint(hitAngle, yc, point, rrotation);
-
-        if (yc < 0.0 && point.x >= 0.0 && point.y >= 0.0 && point.x <= 1.0 && point.y <= 1.0 && (hitAngle < PI || amount > 0.5))
-        {
-                shado = 1.0 - (sqrt(pow(point.x - 0.5, 2.0) + pow(point.y - 0.5, 2.0)) / (71.0 / 100.0));
-                shado *= pow(-yc / cylinderRadius, 3.0);
-                shado *= 0.5;
-        }
-        else
-        {
-                shado = 0.0;
-        }
-        return vec4(getToColor(p).rgb - shado, 1.0);
-}
-
-vec4 transition(vec2 p) {
-
-  const float angle = 100.0 * PI / 180.0;
-        float c = cos(-angle);
-        float s = sin(-angle);
-
-        mat3 rotation = mat3( c, s, 0,
-                                                                -s, c, 0,
-                                                                -0.801, 0.8900, 1
-                                                                );
-        c = cos(angle);
-        s = sin(angle);
-
-        mat3 rrotation = mat3(	c, s, 0,
-                                                                        -s, c, 0,
-                                                                        0.98500, 0.985, 1
-                                                                );
-
-        vec3 point = rotation * vec3(p, 1.0);
-
-        float yc = point.y - cylinderCenter;
-
-        if (yc < -cylinderRadius)
-        {
-                // Behind surface
-                return behindSurface(p,yc, point, rrotation);
-        }
-
-        if (yc > cylinderRadius)
-        {
-                // Flat surface
-                return getFromColor(p);
-        }
-
-        float hitAngle = (acos(yc / cylinderRadius) + cylinderAngle) - PI;
-
-        float hitAngleMod = mod(hitAngle, 2.0 * PI);
-        if ((hitAngleMod > PI && amount < 0.5) || (hitAngleMod > PI/2.0 && amount < 0.0))
-        {
-                return seeThrough(yc, p, rotation, rrotation);
-        }
-
-        point = hitPoint(hitAngle, yc, point, rrotation);
-
-        if (point.x < 0.0 || point.y < 0.0 || point.x > 1.0 || point.y > 1.0)
-        {
-                return seeThroughWithShadow(yc, p, point, rotation, rrotation);
-        }
-
-        vec4 color = backside(yc, point);
-
-        vec4 otherColor;
-        if (yc < 0.0)
-        {
-                float shado = 1.0 - (sqrt(pow(point.x - 0.5, 2.0) + pow(point.y - 0.5, 2.0)) / 0.71);
-                shado *= pow(-yc / cylinderRadius, 3.0);
-                shado *= 0.5;
-                otherColor = vec4(0.0, 0.0, 0.0, shado);
-        }
-        else
-        {
-                otherColor = getFromColor(p);
-        }
-
-        color = antiAlias(color, otherColor, cylinderRadius - abs(yc));
-
-        vec4 cl = seeThroughWithShadow(yc, p, point, rotation, rrotation);
-        float dist = distanceToEdge(point);
-
-        return antiAlias(color, cl, dist);
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Kaleidoscope Tile.fs b/nannou_isf/test_files/Kaleidoscope Tile.fs
deleted file mode 100644
index 5ec3047c2..000000000
--- a/nannou_isf/test_files/Kaleidoscope Tile.fs	
+++ /dev/null
@@ -1,148 +0,0 @@
-/*{
-    "CATEGORIES": [
-    	"Kaleidoscope",
-        "Tile Effect"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 2,
-            "MIN": 0,
-            "NAME": "size",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 6,
-            "MAX": 32,
-            "MIN": 1,
-            "NAME": "sides",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.125,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "rotation",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "angle",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "slide1",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "slide2",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "shift",
-            "TYPE": "point2D"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-const float tau = 6.28318530718;
-
-
-vec2 pattern() {
-	float s = sin(tau * rotation);
-	float c = cos(tau * rotation);
-	vec2 tex = isf_FragNormCoord * RENDERSIZE;
-	float scale = 1.0 / max(size,0.001);
-	vec2 point = vec2( c * tex.x - s * tex.y, s * tex.x + c * tex.y ) * scale;
-	point = (point - (shift*RENDERSIZE)) / RENDERSIZE;
-	//	do this to repeat
-	point = mod(point,1.0);
-	if (point.x < 0.5)	{
-		point.y = mod(point.y + slide1.y, 1.0);
-	}
-	else	{
-		point.y = mod(point.y + slide2.y, 1.0);
-	}
-	if (point.y < 0.5)	{
-		point.x = mod(point.x + slide1.x, 1.0);
-	}
-	else	{
-		point.x = mod(point.x + slide2.x, 1.0);
-	}
-	//	do this for relections
-	point = 1.0-abs(1.0-2.0*point);
-	
-	//	Now let's do a squish based on angle
-	//	convert to polar coordinates
-	vec2 center = vec2(0.5,0.5);
-	float r = distance(center, point);
-	float a = atan ((point.y-center.y),(point.x-center.x));
-	
-	// now do the kaleidoscope
-	a = mod(a, tau/sides);
-	a = abs(a - tau/sides/2.);
-	
-	s = sin(a + tau * angle);
-	c = cos(a + tau * angle);
-	
-	float zoom = RENDERSIZE.x / RENDERSIZE.y;
-	
-	point.x = (r * c)/zoom + 0.5;
-	point.y = (r * s)/zoom + 0.5;
-	
-	return point;
-}
-
-
-void main() {
-
-	vec2 pat = pattern();
-
-	gl_FragColor = IMG_NORM_PIXEL(inputImage,pat);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Kaleidoscope Transition.fs b/nannou_isf/test_files/Kaleidoscope Transition.fs
deleted file mode 100644
index dd654dbcd..000000000
--- a/nannou_isf/test_files/Kaleidoscope Transition.fs	
+++ /dev/null
@@ -1,84 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/kaleidoscope.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1.5,
-            "MAX": 5,
-            "MIN": 0,
-            "NAME": "power",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "speed",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "angle",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: nwoeanhinnogaehr
-// License: MIT
-
-
-vec4 transition(vec2 uv) {
-  vec2 p = uv.xy / vec2(1.0).xy;
-  vec2 q = p;
-  float t = pow(progress, power)*speed;
-  p = p -0.5;
-  for (int i = 0; i < 7; i++) {
-    p = vec2(sin(t)*p.x + cos(t)*p.y, sin(t)*p.y - cos(t)*p.x);
-    t += angle;
-    p = abs(mod(p, 2.0) - 1.0);
-  }
-  abs(mod(p, 1.0));
-  return mix(
-    mix(getFromColor(q), getToColor(q), progress),
-    mix(getFromColor(p), getToColor(p), progress), 1.0 - 2.0*abs(progress - 0.5));
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Kaleidoscope.fs b/nannou_isf/test_files/Kaleidoscope.fs
deleted file mode 100644
index 7fce10ae6..000000000
--- a/nannou_isf/test_files/Kaleidoscope.fs
+++ /dev/null
@@ -1,99 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Kaleidoscope",
-        "Stylize"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 6,
-            "MAX": 32,
-            "MIN": 1,
-            "NAME": "sides",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": -1,
-            "NAME": "angle",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "slidex",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "slidey",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "center",
-            "TYPE": "point2D"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-const float tau = 6.28318530718;
-
-
-
-
-void main() {
-  // normalize to the center
-	vec2 loc = RENDERSIZE * vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	float r = distance(center*RENDERSIZE, loc);
-	float a = atan ((loc.y-center.y*RENDERSIZE.y),(loc.x-center.x*RENDERSIZE.x));
-	
-	// kaleidoscope
-	a = mod(a, tau/sides);
-	a = abs(a - tau/sides/2.);
-	
-	loc.x = r * cos(a + tau * angle);
-	loc.y = r * sin(a + tau * angle);
-	
-	loc = (center*RENDERSIZE + loc) / RENDERSIZE;
-	
-	loc.x = mod(loc.x + slidex, 1.0);
-	loc.y = mod(loc.y + slidey, 1.0);
-
-	// sample the image
-	if (loc.x < 0.0)	{
-		loc.x = mod(abs(loc.x), 1.0);
-	}
-	if (loc.y < 0.0)	{
-		loc.y = mod(abs(loc.y),1.0);
-	}
-	if (loc.x > 1.0)	{
-		loc.x = mod(abs(1.0-loc.x),1.0);
-	}
-	if(loc.y > 1.0)	{
-		loc.y = mod(abs(1.0-loc.y),1.0);	
-	}
-	gl_FragColor = IMG_NORM_PIXEL(inputImage, loc);;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Key Frame Artifacts.fs b/nannou_isf/test_files/Key Frame Artifacts.fs
deleted file mode 100644
index 53b409e8a..000000000
--- a/nannou_isf/test_files/Key Frame Artifacts.fs	
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Glitch"
-  ],
-  "DESCRIPTION" : "Keeps an accumulation of difference since a key frame",
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "NAME" : "inputImage",
-      "TYPE" : "image"
-    },
-    {
-      "NAME" : "updateKeyFrame",
-      "TYPE" : "bool",
-      "DEFAULT" : 0,
-      "LABEL" : "Update Key Frame"
-    },
-    {
-      "NAME" : "adaptRate",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0,
-      "LABEL" : "Adapt Rate",
-      "MIN" : 0
-    },
-    {
-      "NAME" : "numColors",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 1,
-      "LABEL" : "Color Quality",
-      "MIN" : 0
-    },
-    {
-      "NAME" : "buffQuality",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 1.0,
-      "LABEL" : "Buffer Quality",
-      "MIN" : 0
-    }
-  ],
-  "PASSES" : [
-    {
-      "TARGET" : "keyFrame",
-      "PERSISTENT" : true
-    },
-    {
-      "TARGET" : "diffFrame",
-      "PERSISTENT" : true,
-      "WIDTH" : "max(8.0,floor($WIDTH*$buffQuality))",
-      "HEIGHT" : "max(8.0,floor($HEIGHT*$buffQuality))"
-    },
-    {
-      "TARGET" : "lastFrame",
-      "PERSISTENT" : true
-    },
-    {
-
-    }
-  ],
-  "CREDIT" : "by zoidberg"
-}
-*/
-
-vec3 cround (vec3 r)	{
-	vec3 returnMe = r;
-	returnMe.r = (fract(returnMe.r) < 0.5) ? floor(returnMe.r) : ceil(returnMe.r);
-	returnMe.g = (fract(returnMe.g) < 0.5) ? floor(returnMe.g) : ceil(returnMe.g);
-	returnMe.b = (fract(returnMe.b) < 0.5) ? floor(returnMe.b) : ceil(returnMe.b);	
-	return returnMe;	
-}
-
-void main()
-{
-	//	on the first pass, set the key frame if needed
-	
-	if (PASSINDEX==0)	{
-		
-		bool		doUpdateKeyFrame = ((updateKeyFrame)||(FRAMEINDEX<5)) ? true : false;
-		vec4		result = (doUpdateKeyFrame) ? IMG_THIS_NORM_PIXEL(inputImage) : IMG_THIS_NORM_PIXEL(keyFrame);
-		if ((doUpdateKeyFrame)&&(numColors < 1.0))	{
-			float		scaledColors = floor(pow(2.0,numColors * 8.0));
-			scaledColors = (scaledColors < 2.0) ? 2.0 : scaledColors;
- 			result.rgb = result.rgb * scaledColors;
- 			result.rgb = cround(result.rgb);
- 			result.rgb = result.rgb / (scaledColors);
-		}
-		gl_FragColor = result;
-		
-	}
-	//	on the second pass, compare lastFrame to inputImage and add that amount to diffFrame
-	else if (PASSINDEX==1)	{
-		bool		doUpdateKeyFrame = ((updateKeyFrame)||(FRAMEINDEX<5)) ? true : false;
-		vec4		freshPixel = IMG_THIS_NORM_PIXEL(inputImage);
-		vec4		stalePixel = (doUpdateKeyFrame) ? IMG_THIS_NORM_PIXEL(keyFrame) : IMG_THIS_NORM_PIXEL(lastFrame);
-		vec4		diffPixel = (doUpdateKeyFrame) ? vec4(0.5) : IMG_THIS_NORM_PIXEL(diffFrame);
-		diffPixel.rgb = 2.0 * diffPixel.rgb - 1.0;
-		vec4		result = diffPixel + freshPixel - stalePixel;
-		result = (result + 1.0) / 2.0;
-		if (numColors < 1.0)	{
-			float		scaledColors = floor(pow(2.0,numColors * 8.0));
-			scaledColors = (scaledColors < 2.0) ? 2.0 : scaledColors;
- 			result.rgb = result.rgb * scaledColors;
- 			result.rgb = cround(result.rgb);
- 			result.rgb = result.rgb / (scaledColors);
-		}
-		
-		gl_FragColor = result;
-		
-	}
-	//	add the new diffFrame to keyFrame to get the new resulting frame
-	else if (PASSINDEX==2)	{
-		gl_FragColor = IMG_THIS_NORM_PIXEL(inputImage);
-	}
-	else	{
-		vec4		keyFramePixel = IMG_THIS_NORM_PIXEL(keyFrame);
-		vec4		diffPixel = IMG_THIS_NORM_PIXEL(diffFrame);
-		diffPixel.rgb = (2.0 * diffPixel.rgb - 1.0);
-		vec4		result = keyFramePixel + diffPixel;
-		vec4		freshPixel = IMG_THIS_NORM_PIXEL(inputImage);
-		result = mix(result,freshPixel,adaptRate);
-		gl_FragColor = result;
-	}
-}
diff --git a/nannou_isf/test_files/Layer Mask.fs b/nannou_isf/test_files/Layer Mask.fs
deleted file mode 100644
index 16c0d4ac4..000000000
--- a/nannou_isf/test_files/Layer Mask.fs	
+++ /dev/null
@@ -1,182 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Masking",
-        "Color Effect",
-        "Utility"
-    ],
-    "CREDIT": "by zoidberg",
-    "DESCRIPTION": "Takes a mask image and applies it to the input image's alpha channel.",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "LABEL": "mask image",
-            "NAME": "maskImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "mask size mode",
-            "LABELS": [
-                "Fit",
-                "Fill",
-                "Stretch",
-                "Copy"
-            ],
-            "NAME": "maskSizingMode",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1,
-                2,
-                3
-            ]
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": -1,
-            "NAME": "bright",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 4,
-            "MIN": -4,
-            "NAME": "contrast",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 2,
-            "LABEL": "Alpha Mode",
-            "LABELS": [
-                "Additive",
-                "Multiply",
-                "Replace"
-            ],
-            "NAME": "alphaMode",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1,
-                2
-            ]
-        },
-        {
-            "DEFAULT": 0,
-            "NAME": "applyAlpha",
-            "TYPE": "bool"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-const vec4		lumcoeff = vec4(0.299, 0.587, 0.114, 0.0);
-
-//	'a' and 'b' are rects (x and y are the originx, z and w are the width and height)
-//	'm' is the sizing mode as described above (fit/fill/stretch/copy)
-vec4 RectThatFitsRectInRect(vec4 a, vec4 b, int m);
-
-
-
-
-void main() {
-	vec4		srcPixel = IMG_THIS_PIXEL(inputImage);
-	
-	//	get the rect of the mask image after it's been resized according to the passed sizing mode.  this is in pixel coords relative to the rendering space!
-	//vec4		rectOfResizedMaskImage = RectThatFitsRectInRect(vec4(0.0, 0.0, _maskImage_imgRect.z, _maskImage_imgRect.w), vec4(0,0,RENDERSIZE.x,RENDERSIZE.y), maskSizingMode);
-	vec4		rectOfResizedMaskImage = RectThatFitsRectInRect(vec4(0.0, 0.0, IMG_SIZE(maskImage).x, IMG_SIZE(maskImage).y), vec4(0,0,RENDERSIZE.x,RENDERSIZE.y), maskSizingMode);
-	//	i know the pixel coords of this frag in the render space- convert this to NORMALIZED texture coords for the resized mask image
-	vec2		normMaskSrcCoord;
-	normMaskSrcCoord.x = (gl_FragCoord.x-rectOfResizedMaskImage.x)/rectOfResizedMaskImage.z;
-	normMaskSrcCoord.y = (gl_FragCoord.y-rectOfResizedMaskImage.y)/rectOfResizedMaskImage.w;
-	
-	//	get the color of the pixel from the mask image for these normalized coords
-	vec4		tmpColorA = IMG_NORM_PIXEL(maskImage, normMaskSrcCoord);
-	
-	//	apply bright/contrast to this pixel value
-	vec4		tmpColorB = tmpColorA + vec4(bright, bright, bright, 0.0);
-	tmpColorA.rgb = ((vec3(2.0) * (tmpColorB.rgb - vec3(0.5))) * vec3(contrast) / vec3(2.0)) + vec3(0.5);
-	tmpColorA.a = ((2.0 * (tmpColorB.a - 0.5)) * abs(contrast) / 2.0) + 0.5;
-	
-	//	get the luminance of this pixel value: this will be the new alpha for the source pixel
-	float		luminance = dot(tmpColorA,lumcoeff);
-	
-	//	if the alpha mode isn't replacing, add or multiply now
-	//	(this makes it possible to stack multiple mask FX or preserve alpha from input)
-	if (alphaMode == 0)	{
-		luminance = luminance + srcPixel.a;
-	}
-	else if (alphaMode == 1)	{
-		luminance = luminance * srcPixel.a;
-	}
-	
-	if (applyAlpha)
-		gl_FragColor = vec4(luminance*srcPixel.r, luminance*srcPixel.g, luminance*srcPixel.b, 1.0);
-	else
-		gl_FragColor = vec4(srcPixel.r, srcPixel.g, srcPixel.b, luminance);
-}
-
-
-//	rect that fits 'a' in 'b' using sizing mode 'm'
-vec4 RectThatFitsRectInRect(vec4 a, vec4 b, int m)	{
-	float		bAspect = b.z/b.w;
-	float		aAspect = a.z/a.w;
-	if (aAspect==bAspect)	{
-		return b;
-	}
-	vec4		returnMe = vec4(0.0);
-	//	fit
-	if (m==0)	{
-		//	if the rect i'm trying to fit stuff *into* is wider than the rect i'm resizing
-		if (bAspect > aAspect)	{
-			returnMe.w = b.w;
-			returnMe.z = returnMe.w * aAspect;
-		}
-		//	else if the rect i'm resizing is wider than the rect it's going into
-		else if (bAspect < aAspect)	{
-			returnMe.z = b.z;
-			returnMe.w = returnMe.z / aAspect;
-		}
-		else	{
-			returnMe.z = b.z;
-			returnMe.w = b.w;
-		}
-		returnMe.x = (b.z-returnMe.z)/2.0+b.x;
-		returnMe.y = (b.w-returnMe.w)/2.0+b.y;
-	}
-	//	fill
-	else if (m==1)	{
-		//	if the rect i'm trying to fit stuff *into* is wider than the rect i'm resizing
-		if (bAspect > aAspect)	{
-			returnMe.z = b.z;
-			returnMe.w = returnMe.z / aAspect;
-		}
-		//	else if the rect i'm resizing is wider than the rect it's going into
-		else if (bAspect < aAspect)	{
-			returnMe.w = b.w;
-			returnMe.z = returnMe.w * aAspect;
-		}
-		else	{
-			returnMe.z = b.z;
-			returnMe.w = b.w;
-		}
-		returnMe.x = (b.z-returnMe.z)/2.0+b.x;
-		returnMe.y = (b.w-returnMe.w)/2.0+b.y;
-	}
-	//	stretch
-	else if (m==2)	{
-		returnMe = vec4(b.x, b.y, b.z, b.w);
-	}
-	//	copy
-	else if (m==3)	{
-		returnMe.z = float(int(a.z));
-		returnMe.w = float(int(a.w));
-		returnMe.x = float(int((b.z-returnMe.z)/2.0+b.x));
-		returnMe.y = float(int((b.w-returnMe.w)/2.0+b.y));
-	}
-	return returnMe;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Layer Position.fs b/nannou_isf/test_files/Layer Position.fs
deleted file mode 100644
index 188f5eed2..000000000
--- a/nannou_isf/test_files/Layer Position.fs	
+++ /dev/null
@@ -1,57 +0,0 @@
-/*{
-	"DESCRIPTION": "",
-	"CREDIT": "",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Geometry Adjustment", "Utility"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "offset",
-			"TYPE": "point2D",
-			"DEFAULT": [
-				0.5,
-				0.5
-			],
-			"MIN": [
-				0.0,
-				0.0
-			],
-			"MAX": [
-				1.0,
-				1.0
-			]
-		},
-		{
-			"NAME": "repeatImage",
-			"TYPE": "bool",
-			"DEFAULT": 0.0
-		}
-	]
-	
-}*/
-
-void main()	{
-	vec4		outputColor = vec4(0.0);
-	vec2		newLoc = offset;
-	vec2		topSize = RENDERSIZE;
-	
-	newLoc = offset * RENDERSIZE;
-	newLoc.x = topSize.x - newLoc.x;
-	newLoc.y = topSize.y - newLoc.y;
-	newLoc = (gl_FragCoord.xy + 2.0*newLoc) - topSize;
-	
-	if (repeatImage)	{
-		newLoc = mod(newLoc, RENDERSIZE);	
-	}
-	
-	if ((newLoc.x >= 0.0)&&(newLoc.x < RENDERSIZE.x)&&(newLoc.y >= 0.0)&&(newLoc.y <= RENDERSIZE.y))	{
-		outputColor = IMG_PIXEL(inputImage, newLoc);
-	}
-	
-	gl_FragColor = outputColor;
-}
diff --git a/nannou_isf/test_files/Lens Flare.fs b/nannou_isf/test_files/Lens Flare.fs
deleted file mode 100644
index ffde4e630..000000000
--- a/nannou_isf/test_files/Lens Flare.fs	
+++ /dev/null
@@ -1,248 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Film"
-    ],
-    "CREDIT": "by VIDVOX",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": -0.67,
-            "LABEL": "Bias",
-            "MAX": 0,
-            "MIN": -1,
-            "NAME": "uBias",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1.25,
-            "LABEL": "Scale",
-            "MAX": 10,
-            "MIN": 0,
-            "NAME": "uScale",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Source Gain",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "uSource",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0.75,
-                0.875,
-                1,
-                0.75
-            ],
-            "LABEL": "Chromatic Distortion",
-            "NAME": "uChromatic",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": 3,
-            "LABEL": "Ghosts",
-            "MAX": 5,
-            "MIN": 0,
-            "NAME": "uGhosts",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.25,
-            "LABEL": "Ghost Dispersal",
-            "MAX": 0.75,
-            "MIN": 0.125,
-            "NAME": "uGhostDispersal",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0.67,
-                0.5,
-                0.75,
-                1
-            ],
-            "LABEL": "Lens Color",
-            "NAME": "uLensColor",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": 0.33,
-            "LABEL": "Halo Width",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "uHaloWidth",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.25,
-            "LABEL": "Dirt",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "uNoise",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0.5,
-                0.5
-            ],
-            "LABEL": "Center",
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "uCenter",
-            "TYPE": "point2D"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "DESCRIPTION": "Downsample and threshold",
-            "HEIGHT": "floor($HEIGHT/2.0)",
-            "TARGET": "downsampleAndThresholdImage",
-            "WIDTH": "floor($WIDTH/2.0)"
-        },
-        {
-            "DESCRIPTION": "Feature generation",
-            "HEIGHT": "floor($HEIGHT/2.0)",
-            "TARGET": "featureGenerationImage",
-            "WIDTH": "floor($WIDTH/2.0)"
-        },
-        {
-            "DESCRIPTION": "Blur",
-            "HEIGHT": "floor($HEIGHT/4.0)",
-            "TARGET": "blurredImage",
-            "WIDTH": "floor($WIDTH/4.0)"
-        },
-        {
-        }
-    ]
-}
-*/
-
-
-//	as a guide, http://john-chapman-graphics.blogspot.co.uk/2013/02/pseudo-lens-flare.html
-//	1 downsample and threshold
-//	2 feature generation: ghosts, halos and chromatic distortion
-//	3 blur
-//	4 upscale / blend
-
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-in vec2 left_coord;
-in vec2 right_coord;
-in vec2 above_coord;
-in vec2 below_coord;
-
-in vec2 lefta_coord;
-in vec2 righta_coord;
-in vec2 leftb_coord;
-in vec2 rightb_coord;
-#endif
-
-
-const float seed = 0.87342;
-
-
-
-float rand(vec2 co){
-    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-
-
-void main()
-{
-
-	if (PASSINDEX == 0)	{
-		vec2 loc = isf_FragNormCoord;
-		gl_FragColor = max(vec4(0.0), IMG_NORM_PIXEL(inputImage,loc) + uBias) * uScale;
-	}
-	else if (PASSINDEX == 1)	{
-		//	flip the coordinates on this pass
-		vec2 centerVec = 2.0*(uCenter - vec2(0.5));
-		vec2 texcoord = vec2(1.0) - isf_FragNormCoord;
-		vec2 texelSize = 1.0 / RENDERSIZE;
-		vec2 ghostVec = (vec2(0.5) - texcoord + centerVec) * uGhostDispersal;
-		vec4 result = vec4(0.0);
-		for (int i = 0; i < 5; ++i) { 
-			if (float(i)>uGhosts)
-				break;
-			vec2 offset = fract(texcoord + ghostVec * float(i));
-
-			//result += IMG_NORM_PIXEL(downsampleAndThresholdImage, offset);
-
-			result.r += IMG_NORM_PIXEL(downsampleAndThresholdImage, offset * uChromatic.r).r * uChromatic.a;
-			result.g += IMG_NORM_PIXEL(downsampleAndThresholdImage, offset * uChromatic.g).g * uChromatic.a;
-			result.b += IMG_NORM_PIXEL(downsampleAndThresholdImage, offset * uChromatic.b).b * uChromatic.a;
-			
-		}
-		
-		//vec4 result = vec4(0.0);
-		for (int i = 0; i < 5; ++i) {
-			if (float(i)>uGhosts)
-				break;
-			vec2 offset = fract(texcoord + ghostVec * float(i));
-
-			float weight = length(vec2(0.5) - offset) / length(vec2(0.5));
-			weight = pow(1.0 - weight, 10.0);
-
-			result += IMG_NORM_PIXEL(downsampleAndThresholdImage, offset) * weight;
-		}
-		
-		vec2 haloVec = normalize(ghostVec) * uHaloWidth;
-		float weight = length(vec2(0.5) - fract(texcoord + haloVec)) / length(vec2(0.5));
-		weight = pow(1.0 - weight, 5.0);
-		result += IMG_NORM_PIXEL(downsampleAndThresholdImage, texcoord + haloVec) * weight;
-		
-		result *= uLensColor;
-		
-		gl_FragColor = result;
-	}
-	else if (PASSINDEX == 2)	{
-		vec4 color = IMG_THIS_NORM_PIXEL(featureGenerationImage);
-		vec4 colorL = IMG_NORM_PIXEL(featureGenerationImage, left_coord);
-		vec4 colorR = IMG_NORM_PIXEL(featureGenerationImage, right_coord);
-		vec4 colorA = IMG_NORM_PIXEL(featureGenerationImage, above_coord);
-		vec4 colorB = IMG_NORM_PIXEL(featureGenerationImage, below_coord);
-
-		vec4 colorLA = IMG_NORM_PIXEL(featureGenerationImage, lefta_coord);
-		vec4 colorRA = IMG_NORM_PIXEL(featureGenerationImage, righta_coord);
-		vec4 colorLB = IMG_NORM_PIXEL(featureGenerationImage, leftb_coord);
-		vec4 colorRB = IMG_NORM_PIXEL(featureGenerationImage, rightb_coord);
-
-		vec4 avg = (color + colorL + colorR + colorA + colorB + colorLA + colorRA + colorLB + colorRB) / 9.0;
-		//avg = mix(color, (avg + depth*blur)/(1.0+depth), softness);
-		gl_FragColor = avg;
-	}
-	else	{
-		vec2	loc = isf_FragNormCoord;
-		//	SHOULD REPLACE THIS WITH A BETTER / ADJUSTABLE FILM GRAIN OR DIRT GENERATOR
-		vec4	noise = vec4(0.0);
-		noise = (1.0 - uNoise) + uNoise * vec4(rand(loc*vec2(uNoise*seed,uChromatic.x)),rand(loc*vec2(uNoise*seed,uChromatic.y)),rand(loc*vec2(uNoise*seed,uChromatic.z)),1.0);
-
-		vec4	srcColor = IMG_NORM_PIXEL(inputImage,loc);
-		vec4	lensFlareColor = IMG_NORM_PIXEL(blurredImage,loc) * noise;
-		gl_FragColor = uSource * srcColor + lensFlareColor * lensFlareColor.a;
-	}
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Lens Flare.vs b/nannou_isf/test_files/Lens Flare.vs
deleted file mode 100644
index b0ba4b037..000000000
--- a/nannou_isf/test_files/Lens Flare.vs	
+++ /dev/null
@@ -1,39 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-out vec2 left_coord;
-out vec2 right_coord;
-out vec2 above_coord;
-out vec2 below_coord;
-
-out vec2 lefta_coord;
-out vec2 righta_coord;
-out vec2 leftb_coord;
-out vec2 rightb_coord;
-#endif
-
-
-void main()
-{
-	isf_vertShaderInit();
-	vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	vec2 d = 1.0/RENDERSIZE;
-
-	left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
-	right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
-	above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
-	below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
-
-	lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
-	righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
-	leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
-	rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Life.fs b/nannou_isf/test_files/Life.fs
deleted file mode 100644
index 5a39cf2f7..000000000
--- a/nannou_isf/test_files/Life.fs
+++ /dev/null
@@ -1,154 +0,0 @@
-/*{
-	"DESCRIPTION": "Based on Conway Game of Life",
-	"CREDIT": "VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Noise"
-	],
-	"INPUTS": [
-		{
-			"NAME": "restartNow",
-			"TYPE": "event"
-		},
-		{
-			"NAME": "startThresh",
-			"TYPE": "float",
-			"DEFAULT": 0.5,
-			"MIN": 0.0,
-			"MAX": 1.0
-		},
-		{
-			"NAME": "randomRegrowth",
-			"TYPE": "float",
-			"DEFAULT": 0.0,
-			"MIN": 0.0,
-			"MAX": 0.1
-		},
-		{
-			"NAME": "randomDeath",
-			"TYPE": "float",
-			"DEFAULT": 0.0,
-			"MIN": 0.0,
-			"MAX": 0.1
-		}
-	],
-	"PASSES": [
-		{
-			"TARGET":"lastData",
-			"PERSISTENT": true
-		}
-	]
-	
-}*/
-
-
-/*
-
-Any live cell with fewer than two live neighbours dies, as if caused by under-population.
-Any live cell with two or three live neighbours lives on to the next generation.
-Any live cell with more than three live neighbours dies, as if by over-population.
-Any dead cell with exactly three live neighbours becomes a live cell, as if by reproduction.
-
-*/
-
-
-
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-in vec2 left_coord;
-in vec2 right_coord;
-in vec2 above_coord;
-in vec2 below_coord;
-
-in vec2 lefta_coord;
-in vec2 righta_coord;
-in vec2 leftb_coord;
-in vec2 rightb_coord;
-#endif
-
-
-
-float gray(vec4 n)
-{
-	return (n.r + n.g + n.b)/3.0;
-}
-
-float rand(vec2 co){
-    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-
-void main()	{
-	vec4		inputPixelColor = vec4(0.0);
-	vec2		loc = gl_FragCoord.xy;
-	
-	if ((TIME < 0.1)||(restartNow))	{
-		//	randomize the start conditions
-		float	alive = rand(vec2(TIME+1.0,2.1*TIME+0.1)*loc);
-		if (alive > 1.0 - startThresh)	{
-			inputPixelColor = vec4(1.0);
-		}
-	}
-	else	{
-		vec4	color = IMG_PIXEL(lastData, loc);
-		vec4	colorL = IMG_PIXEL(lastData, left_coord);
-		vec4	colorR = IMG_PIXEL(lastData, right_coord);
-		vec4	colorA = IMG_PIXEL(lastData, above_coord);
-		vec4	colorB = IMG_PIXEL(lastData, below_coord);
-
-		vec4	colorLA = IMG_PIXEL(lastData, lefta_coord);
-		vec4	colorRA = IMG_PIXEL(lastData, righta_coord);
-		vec4	colorLB = IMG_PIXEL(lastData, leftb_coord);
-		vec4	colorRB = IMG_PIXEL(lastData, rightb_coord);
-		
-		float	neighborSum = gray(colorL + colorR + colorA + colorB + colorLA + colorRA + colorLB + colorRB);
-		float	state = gray(color);
-		
-		//	live cell
-		if (state > 0.0)	{
-			if (neighborSum < 2.0)	{
-				//	under population
-				inputPixelColor = vec4(0.0);
-			}
-			else if (neighborSum < 4.0)	{
-				//	status quo
-				inputPixelColor = vec4(1.0);
-				
-				//	spontaneous death?
-				float	alive = rand(vec2(TIME+1.0,2.1*TIME+0.1)*loc);
-				if (alive > 1.0 - randomDeath)	{
-					inputPixelColor = vec4(0.0);
-				}
-			}
-			else	{
-				//	over population
-				inputPixelColor = vec4(0.0);
-			}
-		}
-		//	dead cell
-		else	{
-			if ((neighborSum > 2.0)&&(neighborSum < 4.0))	{
-				//	reproduction
-				inputPixelColor = vec4(1.0);
-			}
-			else if (neighborSum < 2.0)	{
-				//	spontaneous reproduction
-				float	alive = rand(vec2(TIME+1.0,2.1*TIME+0.1)*loc);
-				if (alive > 1.0 - randomRegrowth)	{
-					inputPixelColor = vec4(1.0);
-				}
-			}
-		}
-	}
-	
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/Life.vs b/nannou_isf/test_files/Life.vs
deleted file mode 100644
index 1821fadd6..000000000
--- a/nannou_isf/test_files/Life.vs
+++ /dev/null
@@ -1,38 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-out vec2 left_coord;
-out vec2 right_coord;
-out vec2 above_coord;
-out vec2 below_coord;
-
-out vec2 lefta_coord;
-out vec2 righta_coord;
-out vec2 leftb_coord;
-out vec2 rightb_coord;
-#endif
-
-
-void main()
-{
-	isf_vertShaderInit();
-	vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]) * RENDERSIZE;
-	
-	left_coord = vec2(texc.xy + vec2(-1.0 , 0));
-	right_coord = vec2(texc.xy + vec2(1.0 , 0));
-	above_coord = vec2(texc.xy + vec2(0,1.0));
-	below_coord = vec2(texc.xy + vec2(0,-1.0));
-	
-	lefta_coord = vec2(texc.xy + vec2(-1.0 , 1.0));
-	righta_coord = vec2(texc.xy + vec2(1.0 , 1.0));
-	leftb_coord = vec2(texc.xy + vec2(-1.0 , -1.0));
-	rightb_coord = vec2(texc.xy + vec2(1.0 , -1.0));
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Line Screen.fs b/nannou_isf/test_files/Line Screen.fs
deleted file mode 100644
index 1292ae514..000000000
--- a/nannou_isf/test_files/Line Screen.fs	
+++ /dev/null
@@ -1,109 +0,0 @@
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Halftone Effect"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "sharpness",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 10.0,
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "offset",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.0
-		},
-		{
-			"NAME": "angle",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.5
-		},
-		{
-			"NAME": "scale",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 2.0,
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "colorize",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.0
-		},
-		{
-			"NAME": "fill",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.0
-		}
-	]
-}*/
-
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-in vec2 left_coord;
-in vec2 right_coord;
-in vec2 above_coord;
-in vec2 below_coord;
-
-in vec2 lefta_coord;
-in vec2 righta_coord;
-in vec2 leftb_coord;
-in vec2 rightb_coord;
-#endif
-
-const float tau = 6.28318530718;
-
-float pattern() {
-	float s = sin(tau * angle * 0.5);
-	float c = cos(tau * angle * 0.5);
-	vec2 tex = isf_FragNormCoord * RENDERSIZE;
-	vec2 point = vec2( c * tex.x - s * tex.y, s * tex.x + c * tex.y ) * max(scale,0.001);
-	float d = point.y;
-
-	return ( fill + sin(d + offset * tau) ) * 4.0;
-}
-
-void main() {
-	vec4 color = IMG_THIS_PIXEL(inputImage);
-	vec4 colorL = IMG_NORM_PIXEL(inputImage, left_coord);
-	vec4 colorR = IMG_NORM_PIXEL(inputImage, right_coord);
-	vec4 colorA = IMG_NORM_PIXEL(inputImage, above_coord);
-	vec4 colorB = IMG_NORM_PIXEL(inputImage, below_coord);
-
-	vec4 colorLA = IMG_NORM_PIXEL(inputImage, lefta_coord);
-	vec4 colorRA = IMG_NORM_PIXEL(inputImage, righta_coord);
-	vec4 colorLB = IMG_NORM_PIXEL(inputImage, leftb_coord);
-	vec4 colorRB = IMG_NORM_PIXEL(inputImage, rightb_coord);
-
-	vec4 final = color + sharpness * (8.0*color - colorL - colorR - colorA - colorB - colorLA - colorRA - colorLB - colorRB);
-	
-	float average = ( final.r + final.g + final.b ) / 3.0;
-	final = vec4( vec3( average * 10.0 - 5.0 + pattern() ), color.a );
-	final = mix (color * final, final, 1.0-colorize);
-	gl_FragColor = final;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Line Screen.vs b/nannou_isf/test_files/Line Screen.vs
deleted file mode 100644
index 8f2188f5d..000000000
--- a/nannou_isf/test_files/Line Screen.vs	
+++ /dev/null
@@ -1,39 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-out vec2 left_coord;
-out vec2 right_coord;
-out vec2 above_coord;
-out vec2 below_coord;
-
-out vec2 lefta_coord;
-out vec2 righta_coord;
-out vec2 leftb_coord;
-out vec2 rightb_coord;
-#endif
-
-
-void main()
-{
-	isf_vertShaderInit();
-	vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	vec2 d = 1.0/RENDERSIZE;
-	
-	left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
-	right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
-	above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
-	below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
-
-	lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
-	righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
-	leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
-	rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Linear Blur.fs b/nannou_isf/test_files/Linear Blur.fs
deleted file mode 100644
index e77092756..000000000
--- a/nannou_isf/test_files/Linear Blur.fs	
+++ /dev/null
@@ -1,76 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Dissolve"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/LinearBlur.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.1,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "intensity",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// author: gre
-// license: MIT
-const int passes = 6;
-
-vec4 transition(vec2 uv) {
-    vec4 c1 = vec4(0.0);
-    vec4 c2 = vec4(0.0);
-
-    float disp = intensity*(0.5-distance(0.5, progress));
-    for (int xi=0; xi<passes; xi++)
-    {
-        float x = float(xi) / float(passes) - 0.5;
-        for (int yi=0; yi<passes; yi++)
-        {
-            float y = float(yi) / float(passes) - 0.5;
-            vec2 v = vec2(x,y);
-            float d = disp;
-            c1 += getFromColor( uv + d*v);
-            c2 += getToColor( uv + d*v);
-        }
-    }
-    c1 /= float(passes*passes);
-    c2 /= float(passes*passes);
-    return mix(c1, c2, progress);
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Linear Gradient.fs b/nannou_isf/test_files/Linear Gradient.fs
deleted file mode 100644
index e67d18fb7..000000000
--- a/nannou_isf/test_files/Linear Gradient.fs	
+++ /dev/null
@@ -1,95 +0,0 @@
-/*{
-	"CREDIT": "by Carter Rosenberg",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Color"
-	],
-	"INPUTS": [
-		{
-			"NAME": "offset",
-			"TYPE": "float",
-			"DEFAULT": 0.5
-		},
-		{
-			"NAME": "frequency",
-			"TYPE": "float",
-			"MAX": 16.0,
-			"MIN": 1.0,
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "curve",
-			"TYPE": "long",
-			"VALUES": [
-				0,
-				1,
-				2
-			],
-			"LABELS": [
-				"Linear",
-				"Sine",
-				"Exponential"
-			],
-			"DEFAULT": 0
-		},
-		{
-			"NAME": "vertical",
-			"TYPE": "bool",
-			"DEFAULT": 0.0
-		},
-		{
-			"NAME": "startColor",
-			"TYPE": "color",
-			"DEFAULT": [
-				1.0,
-				0.75,
-				0.0,
-				1.0
-			]
-		},
-		{
-			"NAME": "endColor",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.0,
-				0.25,
-				0.75,
-				1.0
-			]
-		}
-	]
-}*/
-
-
-
-const float pi = 3.14159265359;
-const float e = 2.71828182846;
-
-
-
-void main() {
-	float mixAmount = 0.0;
-	float phase = offset;
-	
-	if (vertical)	{
-		mixAmount = phase + frequency * isf_FragNormCoord[1];
-	}
-	else	{
-		mixAmount = phase + frequency * isf_FragNormCoord[0];
-	}
-	
-	if (curve == 0)	{
-		mixAmount = mod(2.0 * mixAmount,2.0);
-		mixAmount = (mixAmount < 1.0) ? mixAmount : 1.0 - (mixAmount - floor(mixAmount));
-	}
-	else if (curve == 1)	{
-		mixAmount = sin(mixAmount * pi * 2.0 - pi / 2.0) * 0.5 + 0.5;
-	}
-	else if (curve == 2)	{
-		mixAmount = mod(2.0 * mixAmount, 2.0);
-		mixAmount = (mixAmount < 1.0) ? mixAmount : 1.0 - (mixAmount - floor(mixAmount));
-		mixAmount = pow(mixAmount, 2.0);
-	}
-	
-	gl_FragColor = mix(startColor,endColor,mixAmount);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Lines.fs b/nannou_isf/test_files/Lines.fs
deleted file mode 100644
index 984b7f1b3..000000000
--- a/nannou_isf/test_files/Lines.fs
+++ /dev/null
@@ -1,98 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Geometry"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "spacing",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.05,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "line_width",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.25,
-            "MAX": 1,
-            "MIN": -1,
-            "NAME": "angle",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "shift",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                1,
-                1,
-                1,
-                1
-            ],
-            "NAME": "color1",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0,
-                0,
-                1
-            ],
-            "NAME": "color2",
-            "TYPE": "color"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-const float pi = 3.14159265359;
-
-
-float pattern() {
-	float s = sin(angle * pi);
-	float c = cos(angle * pi);
-	vec2 tex = isf_FragNormCoord * RENDERSIZE;
-	float spaced = RENDERSIZE.y * spacing;
-	vec2 point = vec2( c * tex.x - s * tex.y, s * tex.x + c * tex.y ) * max(1.0/spaced,0.001);
-	float d = point.y;
-	float w = line_width;
-	if (w > spacing)	{
-		w = 0.99*spacing;	
-	}
-	return ( mod(d + shift*spacing + w * 0.5,spacing) );
-}
-
-
-void main() {
-	//	determine if we are on a line
-	//	math goes something like, figure out distance to the closest line, then draw color2 if we're within range
-	//	y = m*x + b
-	//	m = (y1-y0)/(x1-x0) = tan(angle)
-	
-	vec4 out_color = color2;
-	float w = line_width;
-	if (w > spacing)	{
-		w = 0.99*spacing;	
-	}
-	float pat = pattern();
-	if ((pat > 0.0)&&(pat <= w))	{
-		float percent = (1.0-abs(w-2.0*pat)/w);
-		percent = clamp(percent,0.0,1.0);
-		out_color = mix(color2,color1,percent);
-	}
-	
-	gl_FragColor = out_color;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Long Exposure.fs b/nannou_isf/test_files/Long Exposure.fs
deleted file mode 100644
index dec72f3a7..000000000
--- a/nannou_isf/test_files/Long Exposure.fs	
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Color Effect", "Feedback", "Film"
-  ],
-  "DESCRIPTION" : "Bright objects burn in and optionally decay",
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "NAME" : "inputImage",
-      "TYPE" : "image"
-    },
-    {
-      "NAME" : "absorptionRate",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0.5,
-      "MIN" : -1,
-      "LABEL" : "Absorption Rate"
-    },
-    {
-      "NAME" : "dischargeRate",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0.25,
-      "MIN" : 0,
-      "LABEL" : "Discharge Rate"
-    }
-  ],
-  "PASSES" : [
-    {
-      "TARGET" : "feedbackBuffer",
-      "PERSISTENT" : true,
-      "FLOAT" : true
-    },
-    {
-
-    }
-  ],
-  "CREDIT" : "VIDVOX"
-}
-*/
-
-void main()
-{
-	vec4		freshPixel = IMG_PIXEL(inputImage,gl_FragCoord.xy);
-	vec4		stalePixel = IMG_PIXEL(feedbackBuffer,gl_FragCoord.xy);
-	vec4		resultPixel = vec4(0.0);
-	
-	//	absorb and discharge
-	if (PASSINDEX==0)	{
-		//	start with the old pixel amount
-		resultPixel = stalePixel;
-		//	discharge from previous pass
-		resultPixel *= (1.0 - dischargeRate);
-		//	add this pass
-		resultPixel += (freshPixel * absorptionRate);
-		resultPixel = clamp(resultPixel,0.0,1.0);
-	}
-	//	composite 
-	else if (PASSINDEX==1)	{
-		resultPixel = freshPixel + stalePixel;
-	}
-	
-	gl_FragColor = resultPixel;
-}
diff --git a/nannou_isf/test_files/Luma Transition.fs b/nannou_isf/test_files/Luma Transition.fs
deleted file mode 100644
index 470bb1244..000000000
--- a/nannou_isf/test_files/Luma Transition.fs	
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
-{
-  "ISFVSN" : "2",
-  "CATEGORIES" : [
-    "Dissolve"
-  ],
-  "INPUTS" : [
-    {
-      "TYPE" : "image",
-      "NAME" : "startImage"
-    },
-    {
-      "NAME" : "endImage",
-      "TYPE" : "image"
-    },
-    {
-      "TYPE" : "float",
-      "MIN" : 0,
-      "DEFAULT" : 0,
-      "NAME" : "progress",
-      "MAX" : 1
-    },
-    {
-      "NAME" : "luma",
-      "TYPE" : "image"
-    }
-  ],
-  "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/luma.glsl",
-  "DESCRIPTION" : "Automatically converted from https://gl-transitions.com/"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: gre
-// License: MIT
-
-
-vec4 transition(vec2 uv) {
-  return mix(
-    getToColor(uv),
-    getFromColor(uv),
-    step(progress, IMG_NORM_PIXEL(luma, uv).r-0.001)
-  );
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Luminance Melt.fs b/nannou_isf/test_files/Luminance Melt.fs
deleted file mode 100644
index 86e84f8a8..000000000
--- a/nannou_isf/test_files/Luminance Melt.fs	
+++ /dev/null
@@ -1,183 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Dissolve"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/luminance_melt.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": true,
-            "NAME": "direction",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 0.8,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "l_threshold",
-            "TYPE": "float"
-        },
-        {
-            "NAME": "above",
-            "TYPE": "bool"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: 0gust1
-// License: MIT
-//My own first transition — based on crosshatch code (from pthrasher), using  simplex noise formula (copied and pasted)
-//-> cooler with high contrasted images (isolated dark subject on light background f.e.)
-//TODO : try to rebase it on DoomTransition (from zeh)?
-//optimizations :
-//luminance (see http://stackoverflow.com/questions/596216/formula-to-determine-brightness-of-rgb-color#answer-596241)
-// Y = (R+R+B+G+G+G)/6
-//or Y = (R+R+R+B+G+G+G+G)>>3 
-
-
-//direction of movement :  0 : up, 1, down
-//luminance threshold
-//does the movement takes effect above or below luminance threshold ?
-
-
-//Random function borrowed from everywhere
-float rand(vec2 co){
-  return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-
-// Simplex noise :
-// Description : Array and textureless GLSL 2D simplex noise function.
-//      Author : Ian McEwan, Ashima Arts.
-//  Maintainer : ijm
-//     Lastmod : 20110822 (ijm)
-//     License : MIT  
-//               2011 Ashima Arts. All rights reserved.
-//               Distributed under the MIT License. See LICENSE file.
-//               https://github.com/ashima/webgl-noise
-// 
-
-vec3 mod289(vec3 x) {
-  return x - floor(x * (1.0 / 289.0)) * 289.0;
-}
-
-vec2 mod289(vec2 x) {
-  return x - floor(x * (1.0 / 289.0)) * 289.0;
-}
-
-vec3 permute(vec3 x) {
-  return mod289(((x*34.0)+1.0)*x);
-}
-
-float snoise(vec2 v)
-  {
-  const vec4 C = vec4(0.211324865405187,  // (3.0-sqrt(3.0))/6.0
-                      0.366025403784439,  // 0.5*(sqrt(3.0)-1.0)
-                     -0.577350269189626,  // -1.0 + 2.0 * C.x
-                      0.024390243902439); // 1.0 / 41.0
-// First corner
-  vec2 i  = floor(v + dot(v, C.yy) );
-  vec2 x0 = v -   i + dot(i, C.xx);
-
-// Other corners
-  vec2 i1;
-  //i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
-  //i1.y = 1.0 - i1.x;
-  i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
-  // x0 = x0 - 0.0 + 0.0 * C.xx ;
-  // x1 = x0 - i1 + 1.0 * C.xx ;
-  // x2 = x0 - 1.0 + 2.0 * C.xx ;
-  vec4 x12 = x0.xyxy + C.xxzz;
-  x12.xy -= i1;
-
-// Permutations
-  i = mod289(i); // Avoid truncation effects in permutation
-  vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 ))
-		+ i.x + vec3(0.0, i1.x, 1.0 ));
-
-  vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);
-  m = m*m ;
-  m = m*m ;
-
-// Gradients: 41 points uniformly over a line, mapped onto a diamond.
-// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
-
-  vec3 x = 2.0 * fract(p * C.www) - 1.0;
-  vec3 h = abs(x) - 0.5;
-  vec3 ox = floor(x + 0.5);
-  vec3 a0 = x - ox;
-
-// Normalise gradients implicitly by scaling m
-// Approximation of: m *= inversesqrt( a0*a0 + h*h );
-  m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h );
-
-// Compute final noise value at P
-  vec3 g;
-  g.x  = a0.x  * x0.x  + h.x  * x0.y;
-  g.yz = a0.yz * x12.xz + h.yz * x12.yw;
-  return 130.0 * dot(m, g);
-}
-
-// Simplex noise -- end
-
-float luminance(vec4 color){
-  //(0.299*R + 0.587*G + 0.114*B)
-  return color.r*0.299+color.g*0.587+color.b*0.114;
-}
-
-vec2 center = vec2(1.0, direction);
-
-vec4 transition(vec2 uv) {
-  vec2 p = uv.xy / vec2(1.0).xy;
-  if (progress == 0.0) {
-    return getFromColor(p);
-  } else if (progress == 1.0) {
-    return getToColor(p);
-  } else {
-    float x = progress;
-    float dist = distance(center, p)- progress*exp(snoise(vec2(p.x, 0.0)));
-    float r = x - rand(vec2(p.x, 0.1));
-    float m;
-    if(above){
-     m = dist <= r && luminance(getFromColor(p))>l_threshold ? 1.0 : (progress*progress*progress);
-    }
-    else{
-     m = dist <= r && luminance(getFromColor(p))<l_threshold ? 1.0 : (progress*progress*progress);  
-    }
-    return mix(getFromColor(p), getToColor(p), m);    
-  }
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Luminance Posterize.fs b/nannou_isf/test_files/Luminance Posterize.fs
deleted file mode 100644
index ee9d417bd..000000000
--- a/nannou_isf/test_files/Luminance Posterize.fs	
+++ /dev/null
@@ -1,58 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Color Effect",
-        "Retro"
-    ],
-    "CREDIT": "by zoidberg",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 30,
-            "MAX": 30,
-            "MIN": 2,
-            "NAME": "levels",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-vec3 rgb2hsv(vec3 c);
-vec3 hsv2rgb(vec3 c);
-
-void main() {
-	//	get the src pixel, convert to HSL, posterize the 'L', convert back to RGB
-	
-	vec4		srcPixel = IMG_THIS_PIXEL(inputImage);
-	vec4		tmpColor;
-	tmpColor.xyz = rgb2hsv(srcPixel.rgb);
-	float		amountPerLevel = 1.0/(levels);
-	float		numOfLevels = floor(tmpColor.z/amountPerLevel);
-	tmpColor.z = numOfLevels*(1.0/(levels-1.0));
-	gl_FragColor.rgb = hsv2rgb(tmpColor.xyz);
-	gl_FragColor.a = srcPixel.a;
-	
-}
-
-
-vec3 rgb2hsv(vec3 c)	{
-	vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-	//vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
-	//vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
-	vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
-	vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
-	
-	float d = q.x - min(q.w, q.y);
-	float e = 1.0e-10;
-	return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
-}
-
-vec3 hsv2rgb(vec3 c)	{
-	vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
-	vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
-	return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Maximum Component.fs b/nannou_isf/test_files/Maximum Component.fs
deleted file mode 100644
index a5b34ef05..000000000
--- a/nannou_isf/test_files/Maximum Component.fs	
+++ /dev/null
@@ -1,19 +0,0 @@
-/*{
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Color Effect", "Utility"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		}
-	]
-}*/
-
-void main() {
-	vec4		srcPixel = IMG_THIS_PIXEL(inputImage);
-	float		maxComponent = max(srcPixel.r, max(srcPixel.g, srcPixel.b));
-	gl_FragColor = vec4(maxComponent, maxComponent, maxComponent, srcPixel.a);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Median.fs b/nannou_isf/test_files/Median.fs
deleted file mode 100644
index e07fe1e8f..000000000
--- a/nannou_isf/test_files/Median.fs
+++ /dev/null
@@ -1,70 +0,0 @@
-/*{
-	"DESCRIPTION": "",
-	"CREDIT": "VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Blur"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "radius",
-			"LABEL": "Radius",
-			"TYPE": "float",
-			"DEFAULT": 4.0,
-			"MIN": 0.0,
-			"MAX": 8.0
-		}
-	]
-	
-}*/
-
-
-
-//	adapted from 
-//	3x3 Median by Morgan McGuire and Kyle Whitson 
-//	http://graphics.cs.williams.edu/papers/MedianShaderX6/median.pix
-
-
-
-#define s2(a, b)				temp = a; a = min(a, b); b = max(temp, b);
-#define mn3(a, b, c)			s2(a, b); s2(a, c);
-#define mx3(a, b, c)			s2(b, c); s2(a, c);
-
-#define mnmx3(a, b, c)			mx3(a, b, c); s2(a, b);                                   // 3 exchanges
-#define mnmx4(a, b, c, d)		s2(a, b); s2(c, d); s2(a, c); s2(b, d);                   // 4 exchanges
-#define mnmx5(a, b, c, d, e)	s2(a, b); s2(c, d); mn3(a, c, e); mx3(b, d, e);           // 6 exchanges
-#define mnmx6(a, b, c, d, e, f) s2(a, d); s2(b, e); s2(c, f); mn3(a, b, c); mx3(d, e, f); // 7 exchanges
-
-
-
-
-void main()	{	
-	vec4 		v[9];
-
-  	// Add the pixels which make up our window to the pixel array.
-	for(int dX = -1; dX <= 1; ++dX) {
-		for(int dY = -1; dY <= 1; ++dY) {		
-			vec2 offset = vec2(float(dX), float(dY));
-		    
-			// If a pixel in the window is located at (x+dX, y+dY), put it at index (dX + R)(2R + 1) + (dY + R) of the
-			// pixel array. This will fill the pixel array, with the top left pixel of the window at pixel[0] and the
-			// bottom right pixel of the window at pixel[N-1].
-			v[(dX + 1) * 3 + (dY + 1)] = IMG_PIXEL(inputImage, gl_FragCoord.xy + offset * radius);
-			//v[(dX + 1) * 3 + (dY + 1)] = IMG_PIXEL(inputImage, gl_FragCoord.xy);
-		}
-	}
-
-	vec4 temp;
-
-	// Starting with a subset of size 6, remove the min and max each time
-	mnmx6(v[0], v[1], v[2], v[3], v[4], v[5]);
-	mnmx5(v[1], v[2], v[3], v[4], v[6]);
-	mnmx4(v[2], v[3], v[4], v[7]);
-	mnmx3(v[3], v[4], v[8]);
-	
-	gl_FragColor = v[4];
-}
diff --git a/nannou_isf/test_files/Meta Image.fs b/nannou_isf/test_files/Meta Image.fs
deleted file mode 100755
index ee4c7336d..000000000
--- a/nannou_isf/test_files/Meta Image.fs	
+++ /dev/null
@@ -1,99 +0,0 @@
-/*{
-	"CREDIT": "by Toneburst",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Stylize", "Tile Effect"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "cell_size",
-			"TYPE": "float",
-			"MIN": 0.001,
-			"MAX": 1.0,
-			"DEFAULT": 0.125
-		},
-		{
-			"NAME": "zoom_tile",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 2.0,
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "mixAmt",
-			"LABEL": "mix",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.5
-		},
-		{
-			"NAME": "mode",
-			"VALUES": [
-				0,
-				1
-			],
-			"LABELS": [
-				"Multiply",
-				"Mix"
-			],
-			"DEFAULT": 0,
-			"TYPE": "long"
-		}
-	]
-}*/
-
-void main()
-{
-// CALCULATE EDGES OF CURRENT CELL
-	// Position of current pixel
-	vec2 xy = gl_FragCoord.xy / RENDERSIZE.xy;
-	// Left and right of tile
-	float CellWidth = cell_size;
-	float CellHeight = cell_size;
-	float x1 = floor(xy.x / CellWidth)*CellWidth;
-	float x2 = clamp((ceil(xy.x / CellWidth)*CellWidth), 0.0, 1.0);
-	// Top and bottom of tile
-	float y1 = floor(xy.y / CellHeight)*CellHeight;
-	float y2 = clamp((ceil(xy.y / CellHeight)*CellHeight), 0.0, 1.0);
-
-	// GET AVERAGE CELL COLOUR
-	// Average left and right pixels
-	vec4 avgX = (IMG_NORM_PIXEL(inputImage, vec2(x1, y1))+(IMG_NORM_PIXEL(inputImage, vec2(x2, y1)))) / 2.0;
-	// Average top and bottom pixels
-	vec4 avgY = (IMG_NORM_PIXEL(inputImage, vec2(x1, y1))+(IMG_NORM_PIXEL(inputImage, vec2(x1, y2)))) / 2.0;
-	// Centre pixel
-	vec4 avgC = IMG_NORM_PIXEL(inputImage, vec2(x1+(CellWidth/2.0), y2+(CellHeight/2.0)));	// Average the averages + centre
-	vec4 avgClr = (avgX+avgY+avgC) / 3.0;
-
-	// GET PIXELS FROM LITTLE IMAGE	
-	// X-position in current cell
-	float cellPosX = (xy.x - x1) / CellWidth;
-	// Y-position in current cell
-	float cellPosY = (xy.y - y1) / CellHeight;
-	
-	vec2 loc = vec2(cellPosX, cellPosY);
-	vec2 modifiedCenter = vec2(0.5);
-	loc.x = (loc.x - modifiedCenter.x)*(1.0/zoom_tile) + modifiedCenter.x;
-	loc.y = (loc.y - modifiedCenter.y)*(1.0/zoom_tile) + modifiedCenter.y;
-	
-	vec4 littlePix;
-	if ((loc.x < 0.0)||(loc.y < 0.0)||(loc.x > 1.0)||(loc.y > 1.0))	{
-		littlePix = vec4(0.0);
-	}
-	else	{
-		littlePix = IMG_NORM_PIXEL(inputImage, loc);
-	}
-	
-	// MULTIPLY LITTLE IMAGE COLOUR WITH AVERAGE CELL COLOUR AND OUTPUT
-	if (mode == 0)	{
-		gl_FragColor = vec4(littlePix * avgClr);
-	}
-	else	{
-		gl_FragColor = vec4(mix(littlePix, avgClr, mixAmt));
-	}
-}
diff --git a/nannou_isf/test_files/Micro Buffer RGB.fs b/nannou_isf/test_files/Micro Buffer RGB.fs
deleted file mode 100644
index ace9480c4..000000000
--- a/nannou_isf/test_files/Micro Buffer RGB.fs	
+++ /dev/null
@@ -1,316 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Glitch"
-  ],
-  "DESCRIPTION" : "Buffers 8 recent frames",
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "NAME" : "inputImage",
-      "TYPE" : "image"
-    },
-    {
-      "NAME" : "inputRate",
-      "TYPE" : "float",
-      "MAX" : 20,
-      "DEFAULT" : 1,
-      "LABEL" : "Buffer Lag",
-      "MIN" : 0
-    },
-    {
-      "LABELS" : [
-        "Color Picker",
-        "Image Input"
-      ],
-      "NAME" : "delayMode",
-      "TYPE" : "long",
-      "LABEL" : "Delay Mode",
-      "VALUES" : [
-        0,
-        1
-      ]
-    },
-    {
-      "NAME" : "inputDelay",
-      "LABEL" : "Buffer",
-      "TYPE" : "color"
-    },
-    {
-      "NAME" : "inputDelayImage",
-      "TYPE" : "image",
-      "LABEL" : "Delay Image"
-    }
-  ],
-  "PASSES" : [
-    {
-      "WIDTH" : "1",
-      "DESCRIPTION" : "this buffer stores the last frame's odd \/ even state",
-      "HEIGHT" : "1",
-      "TARGET" : "lastRow",
-      "PERSISTENT" : true
-    },
-    {
-      "TARGET" : "buffer8",
-      "PERSISTENT" : true
-    },
-    {
-      "TARGET" : "buffer7",
-      "PERSISTENT" : true
-    },
-    {
-      "TARGET" : "buffer6",
-      "PERSISTENT" : true
-    },
-    {
-      "TARGET" : "buffer5",
-      "PERSISTENT" : true
-    },
-    {
-      "TARGET" : "buffer4",
-      "PERSISTENT" : true
-    },
-    {
-      "TARGET" : "buffer3",
-      "PERSISTENT" : true
-    },
-    {
-      "TARGET" : "buffer2",
-      "PERSISTENT" : true
-    },
-    {
-      "TARGET" : "buffer1",
-      "PERSISTENT" : true
-    },
-    {
-
-    }
-  ],
-  "CREDIT" : "by VIDVOX"
-}
-*/
-
-void main()
-{
-	//	first pass: read the "buffer7" into "buffer8"
-	//	apply lag on each pass
-	//	if this is the first pass, i'm going to read the position from the "lastRow" image, and write a new position based on this and the hold variables
-	if (PASSINDEX == 0)	{
-		vec4		srcPixel = IMG_PIXEL(lastRow,vec2(0.5));
-		//	i'm only using the X and Y components, which are the X and Y offset (normalized) for the frame
-		if (inputRate == 0.0)	{
-			srcPixel.x = 0.0;
-			srcPixel.y = 0.0;
-		}
-		else if (inputRate <= 1.0)	{
-			srcPixel.x = (srcPixel.x) > 0.5 ? 0.0 : 1.0;
-			srcPixel.y = 0.0;
-		}
-		else {
-			srcPixel.x = srcPixel.x + 1.0 / inputRate + srcPixel.y;
-			if (srcPixel.x > 1.0)	{
-				srcPixel.y = mod(srcPixel.x, 1.0);
-				srcPixel.x = 0.0;
-			}
-		}
-		gl_FragColor = srcPixel;
-	}
-	if (PASSINDEX == 1)	{
-		vec4		lastRow = IMG_PIXEL(lastRow,vec2(0.5));
-		if (lastRow.x == 0.0)	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer7);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer8);
-		}
-	}
-	else if (PASSINDEX == 2)	{
-		vec4		lastRow = IMG_PIXEL(lastRow,vec2(0.5));
-		if (lastRow.x == 0.0)	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer6);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer7);
-		}
-	}
-	else if (PASSINDEX == 3)	{
-		vec4		lastRow = IMG_PIXEL(lastRow,vec2(0.5));
-		if (lastRow.x == 0.0)	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer5);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer6);
-		}
-	}
-	else if (PASSINDEX == 4)	{
-		vec4		lastRow = IMG_PIXEL(lastRow,vec2(0.5));
-		if (lastRow.x == 0.0)	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer4);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer5);
-		}
-	}
-	else if (PASSINDEX == 5)	{
-		vec4		lastRow = IMG_PIXEL(lastRow,vec2(0.5));
-		if (lastRow.x == 0.0)	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer3);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer4);
-		}
-	}
-	else if (PASSINDEX == 6)	{
-		vec4		lastRow = IMG_PIXEL(lastRow,vec2(0.5));
-		if (lastRow.x == 0.0)	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer2);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer3);
-		}
-	}
-	else if (PASSINDEX == 7)	{
-		vec4		lastRow = IMG_PIXEL(lastRow,vec2(0.5));
-		if (lastRow.x == 0.0)	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer1);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer2);
-		}
-	}
-	else if (PASSINDEX == 8)	{
-		vec4		lastRow = IMG_PIXEL(lastRow,vec2(0.5));
-		if (lastRow.x == 0.0)	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(inputImage);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer1);
-		}
-	}
-	else if (PASSINDEX == 9)	{
-		//	Figure out which section I'm in and draw the appropriate buffer there
-		vec2 tex = isf_FragNormCoord;
-		vec4 color = vec4(0.0);
-		vec4 pixelBuffer = vec4(0.0);
-		if (delayMode == 0)	{
-			pixelBuffer = inputDelay * 9.0;
-		}
-		else if (delayMode == 1)	{
-			pixelBuffer = IMG_NORM_PIXEL(inputDelayImage, tex) * 9.0;
-		}
-
-		if (pixelBuffer.r < 1.0)	{
-			color.r = IMG_NORM_PIXEL(inputImage, tex).r;
-		}
-		else if (pixelBuffer.r < 2.0)	{
-			color.r = IMG_NORM_PIXEL(buffer1, tex).r;
-		}
-		else if (pixelBuffer.r < 3.0)	{
-			color.r = IMG_NORM_PIXEL(buffer2, tex).r;
-		}
-		else if (pixelBuffer.r < 4.0)	{
-			color.r = IMG_NORM_PIXEL(buffer3, tex).r;
-		}
-		else if (pixelBuffer.r < 5.0)	{
-			color.r = IMG_NORM_PIXEL(buffer4, tex).r;
-		}
-		else if (pixelBuffer.r < 6.0)	{
-			color.r = IMG_NORM_PIXEL(buffer5, tex).r;
-		}
-		else if (pixelBuffer.r < 7.0)	{
-			color.r = IMG_NORM_PIXEL(buffer6, tex).r;
-		}
-		else if (pixelBuffer.r < 8.0)	{
-			color.r = IMG_NORM_PIXEL(buffer7, tex).r;
-		}
-		else	{
-			color.r = IMG_NORM_PIXEL(buffer8, tex).r;
-		}
-		
-		if (pixelBuffer.g < 1.0)	{
-			color.g = IMG_NORM_PIXEL(inputImage, tex).g;
-		}
-		else if (pixelBuffer.g < 2.0)	{
-			color.g = IMG_NORM_PIXEL(buffer1, tex).g;
-		}
-		else if (pixelBuffer.g < 3.0)	{
-			color.g = IMG_NORM_PIXEL(buffer2, tex).g;
-		}
-		else if (pixelBuffer.g < 4.0)	{
-			color.g = IMG_NORM_PIXEL(buffer3, tex).g;
-		}
-		else if (pixelBuffer.g < 5.0)	{
-			color.g = IMG_NORM_PIXEL(buffer4, tex).g;
-		}
-		else if (pixelBuffer.g < 6.0)	{
-			color.g = IMG_NORM_PIXEL(buffer5, tex).g;
-		}
-		else if (pixelBuffer.g < 7.0)	{
-			color.g = IMG_NORM_PIXEL(buffer6, tex).g;
-		}
-		else if (pixelBuffer.g < 8.0)	{
-			color.g = IMG_NORM_PIXEL(buffer7, tex).g;
-		}
-		else	{
-			color.g = IMG_NORM_PIXEL(buffer8, tex).g;
-		}
-		
-		if (pixelBuffer.b < 1.0)	{
-			color.b = IMG_NORM_PIXEL(inputImage, tex).b;
-		}
-		else if (pixelBuffer.b < 2.0)	{
-			color.b = IMG_NORM_PIXEL(buffer1, tex).b;
-		}
-		else if (pixelBuffer.b < 3.0)	{
-			color.b = IMG_NORM_PIXEL(buffer2, tex).b;
-		}
-		else if (pixelBuffer.b < 4.0)	{
-			color.b = IMG_NORM_PIXEL(buffer3, tex).b;
-		}
-		else if (pixelBuffer.b < 5.0)	{
-			color.b = IMG_NORM_PIXEL(buffer4, tex).b;
-		}
-		else if (pixelBuffer.b < 6.0)	{
-			color.b = IMG_NORM_PIXEL(buffer5, tex).b;
-		}
-		else if (pixelBuffer.b < 7.0)	{
-			color.b = IMG_NORM_PIXEL(buffer6, tex).b;
-		}
-		else if (pixelBuffer.b < 8.0)	{
-			color.b = IMG_NORM_PIXEL(buffer7, tex).b;
-		}
-		else	{
-			color.b = IMG_NORM_PIXEL(buffer8, tex).b;
-		}
-		
-		if (pixelBuffer.a < 1.0)	{
-			color.a = IMG_NORM_PIXEL(inputImage, tex).a;
-		}
-		else if (pixelBuffer.a < 2.0)	{
-			color.a = IMG_NORM_PIXEL(buffer1, tex).a;
-		}
-		else if (pixelBuffer.a < 3.0)	{
-			color.a = IMG_NORM_PIXEL(buffer2, tex).a;
-		}
-		else if (pixelBuffer.a < 4.0)	{
-			color.a = IMG_NORM_PIXEL(buffer3, tex).a;
-		}
-		else if (pixelBuffer.a < 5.0)	{
-			color.a = IMG_NORM_PIXEL(buffer4, tex).a;
-		}
-		else if (pixelBuffer.a < 6.0)	{
-			color.a = IMG_NORM_PIXEL(buffer5, tex).a;
-		}
-		else if (pixelBuffer.a < 7.0)	{
-			color.a = IMG_NORM_PIXEL(buffer6, tex).a;
-		}
-		else if (pixelBuffer.a < 8.0)	{
-			color.a = IMG_NORM_PIXEL(buffer7, tex).a;
-		}
-		else	{
-			color.a = IMG_NORM_PIXEL(buffer8, tex).a;
-		}
-
-		gl_FragColor = color;
-	}
-}
diff --git a/nannou_isf/test_files/Micro Buffer.fs b/nannou_isf/test_files/Micro Buffer.fs
deleted file mode 100644
index 3f9f21f9b..000000000
--- a/nannou_isf/test_files/Micro Buffer.fs	
+++ /dev/null
@@ -1,312 +0,0 @@
-/*{
-	"DESCRIPTION": "Buffers 8 recent frames",
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Glitch"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "inputDelay",
-			"LABEL": "Buffer",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 9.0,
-			"DEFAULT": 0.0
-		},
-		{
-			"NAME": "inputDelay2",
-			"LABEL": "Buffer 2",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 9.0,
-			"DEFAULT": 0.0
-		},
-		{
-			"NAME": "inputDelay3",
-			"LABEL": "Buffer 3",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 9.0,
-			"DEFAULT": 0.0
-		},
-		{
-			"NAME": "inputRate",
-			"LABEL": "Buffer Lag",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 20.0,
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "mode",
-			"VALUES": [
-				0,
-				1,
-				2
-			],
-			"LABELS": [
-				"Single",
-				"Double",
-				"Triple"
-			],
-			"DEFAULT": 0,
-			"TYPE": "long"
-		}
-	],
-	"PASSES": [
-		{
-			"TARGET":"lastRow",
-			"WIDTH": "1",
-			"HEIGHT": "1",
-			"PERSISTENT": true,
-			"DESCRIPTION": "this buffer stores the last frame's odd / even state"
-		},
-		{
-			"TARGET":"buffer8",
-			"PERSISTENT": true
-		},
-		{
-			"TARGET":"buffer7",
-			"PERSISTENT": true
-		},
-		{
-			"TARGET":"buffer6",
-			"PERSISTENT": true
-		},
-		{
-			"TARGET":"buffer5",
-			"PERSISTENT": true
-		},
-		{
-			"TARGET":"buffer4",
-			"PERSISTENT": true
-		},
-		{
-			"TARGET":"buffer3",
-			"PERSISTENT": true
-		},
-		{
-			"TARGET":"buffer2",
-			"PERSISTENT": true
-		},
-		{
-			"TARGET":"buffer1",
-			"PERSISTENT": true
-		},
-		{
-		
-		}
-	]
-	
-}*/
-
-void main()
-{
-	//	first pass: read the "buffer7" into "buffer8"
-	//	apply lag on each pass
-	//	if this is the first pass, i'm going to read the position from the "lastRow" image, and write a new position based on this and the hold variables
-	if (PASSINDEX == 0)	{
-		vec4		srcPixel = IMG_PIXEL(lastRow,vec2(0.5));
-		//	i'm only using the X and Y components, which are the X and Y offset (normalized) for the frame
-		if (inputRate == 0.0)	{
-			srcPixel.x = 0.0;
-			srcPixel.y = 0.0;
-		}
-		else if (inputRate <= 1.0)	{
-			srcPixel.x = (srcPixel.x) > 0.5 ? 0.0 : 1.0;
-			srcPixel.y = 0.0;
-		}
-		else {
-			srcPixel.x = srcPixel.x + 1.0 / inputRate + srcPixel.y;
-			if (srcPixel.x > 1.0)	{
-				srcPixel.y = mod(srcPixel.x, 1.0);
-				srcPixel.x = 0.0;
-			}
-		}
-		gl_FragColor = srcPixel;
-	}
-	if (PASSINDEX == 1)	{
-		vec4		lastRow = IMG_PIXEL(lastRow,vec2(0.5));
-		if (lastRow.x == 0.0)	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer7);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer8);
-		}
-	}
-	else if (PASSINDEX == 2)	{
-		vec4		lastRow = IMG_PIXEL(lastRow,vec2(0.5));
-		if (lastRow.x == 0.0)	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer6);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer7);
-		}
-	}
-	else if (PASSINDEX == 3)	{
-		vec4		lastRow = IMG_PIXEL(lastRow,vec2(0.5));
-		if (lastRow.x == 0.0)	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer5);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer6);
-		}
-	}
-	else if (PASSINDEX == 4)	{
-		vec4		lastRow = IMG_PIXEL(lastRow,vec2(0.5));
-		if (lastRow.x == 0.0)	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer4);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer5);
-		}
-	}
-	else if (PASSINDEX == 5)	{
-		vec4		lastRow = IMG_PIXEL(lastRow,vec2(0.5));
-		if (lastRow.x == 0.0)	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer3);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer4);
-		}
-	}
-	else if (PASSINDEX == 6)	{
-		vec4		lastRow = IMG_PIXEL(lastRow,vec2(0.5));
-		if (lastRow.x == 0.0)	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer2);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer3);
-		}
-	}
-	else if (PASSINDEX == 7)	{
-		vec4		lastRow = IMG_PIXEL(lastRow,vec2(0.5));
-		if (lastRow.x == 0.0)	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer1);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer2);
-		}
-	}
-	else if (PASSINDEX == 8)	{
-		vec4		lastRow = IMG_PIXEL(lastRow,vec2(0.5));
-		if (lastRow.x == 0.0)	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(inputImage);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer1);
-		}
-	}
-	else if (PASSINDEX == 9)	{
-		//	Figure out which section I'm in and draw the appropriate buffer there
-		vec2 tex = isf_FragNormCoord;
-		vec4 returnMe = vec4(0.0);
-		vec4 color = vec4(0.0);
-		float pixelBuffer = inputDelay;
-		
-		//	If the glitch factor is turned on I might randomly go to another delay point
-
-		if (pixelBuffer < 1.0)	{
-			color = IMG_NORM_PIXEL(inputImage, tex);
-		}
-		else if (pixelBuffer < 2.0)	{
-			color = IMG_NORM_PIXEL(buffer1, tex);
-		}
-		else if (pixelBuffer < 3.0)	{
-			color = IMG_NORM_PIXEL(buffer2, tex);
-		}
-		else if (pixelBuffer < 4.0)	{
-			color = IMG_NORM_PIXEL(buffer3, tex);
-		}
-		else if (pixelBuffer < 5.0)	{
-			color = IMG_NORM_PIXEL(buffer4, tex);
-		}
-		else if (pixelBuffer < 6.0)	{
-			color = IMG_NORM_PIXEL(buffer5, tex);
-		}
-		else if (pixelBuffer < 7.0)	{
-			color = IMG_NORM_PIXEL(buffer6, tex);
-		}
-		else if (pixelBuffer < 8.0)	{
-			color = IMG_NORM_PIXEL(buffer7, tex);
-		}
-		else	{
-			color = IMG_NORM_PIXEL(buffer8, tex);
-		}
-		
-		returnMe = color;
-		
-		if ((mode == 1)||(mode == 2))	{
-			pixelBuffer = inputDelay2;
-			if (pixelBuffer < 1.0)	{
-				color = IMG_NORM_PIXEL(inputImage, tex);
-			}
-			else if (pixelBuffer < 2.0)	{
-				color = IMG_NORM_PIXEL(buffer1, tex);
-			}
-			else if (pixelBuffer < 3.0)	{
-				color = IMG_NORM_PIXEL(buffer2, tex);
-			}
-			else if (pixelBuffer < 4.0)	{
-				color = IMG_NORM_PIXEL(buffer3, tex);
-			}
-			else if (pixelBuffer < 5.0)	{
-				color = IMG_NORM_PIXEL(buffer4, tex);
-			}
-			else if (pixelBuffer < 6.0)	{
-				color = IMG_NORM_PIXEL(buffer5, tex);
-			}
-			else if (pixelBuffer < 7.0)	{
-				color = IMG_NORM_PIXEL(buffer6, tex);
-			}
-			else if (pixelBuffer < 8.0)	{
-				color = IMG_NORM_PIXEL(buffer7, tex);
-			}
-			else	{
-				color = IMG_NORM_PIXEL(buffer8, tex);
-			}
-			returnMe = (returnMe + color);
-		}
-		
-		if (mode == 2)	{
-			pixelBuffer = inputDelay3;
-			if (pixelBuffer < 1.0)	{
-				color = IMG_NORM_PIXEL(inputImage, tex);
-			}
-			else if (pixelBuffer < 2.0)	{
-				color = IMG_NORM_PIXEL(buffer1, tex);
-			}
-			else if (pixelBuffer < 3.0)	{
-				color = IMG_NORM_PIXEL(buffer2, tex);
-			}
-			else if (pixelBuffer < 4.0)	{
-				color = IMG_NORM_PIXEL(buffer3, tex);
-			}
-			else if (pixelBuffer < 5.0)	{
-				color = IMG_NORM_PIXEL(buffer4, tex);
-			}
-			else if (pixelBuffer < 6.0)	{
-				color = IMG_NORM_PIXEL(buffer5, tex);
-			}
-			else if (pixelBuffer < 7.0)	{
-				color = IMG_NORM_PIXEL(buffer6, tex);
-			}
-			else if (pixelBuffer < 8.0)	{
-				color = IMG_NORM_PIXEL(buffer7, tex);
-			}
-			else	{
-				color = IMG_NORM_PIXEL(buffer8, tex);
-			}
-			returnMe = (returnMe + color);
-		}
-		
-		returnMe = returnMe / (1.0+float(mode));
-
-		gl_FragColor = returnMe;
-	}
-}
diff --git a/nannou_isf/test_files/Minimum Component.fs b/nannou_isf/test_files/Minimum Component.fs
deleted file mode 100644
index c27fdfead..000000000
--- a/nannou_isf/test_files/Minimum Component.fs	
+++ /dev/null
@@ -1,21 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Color Effect",
-        "Utility"
-    ],
-    "CREDIT": "by zoidberg",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-void main() {
-	vec4		srcPixel = IMG_THIS_PIXEL(inputImage);
-	float		minComponent = min(srcPixel.r, min(srcPixel.g, srcPixel.b));
-	gl_FragColor = vec4(minComponent, minComponent, minComponent, srcPixel.a);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Mirror Edge.fs b/nannou_isf/test_files/Mirror Edge.fs
deleted file mode 100644
index b36f77b92..000000000
--- a/nannou_isf/test_files/Mirror Edge.fs	
+++ /dev/null
@@ -1,58 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Tile Effect"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Angle",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "angle",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0.5
-            ],
-            "LABEL": "Shift",
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "shift",
-            "TYPE": "point2D"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-#if __VERSION__ <= 120
-varying vec2 translated_coord;
-#else
-in vec2 translated_coord;
-#endif
-
-
-void main() {
-	vec2 loc = translated_coord;
-	vec2 modifiedCenter = shift;
-	
-	loc = mod(loc + modifiedCenter, 1.0);
-	
-	//	mirror the image so it's repeated 4 times at different reflections
-	loc = 2.0 * abs(loc - 0.5);
-	
-	gl_FragColor = IMG_NORM_PIXEL(inputImage, loc);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Mirror Edge.vs b/nannou_isf/test_files/Mirror Edge.vs
deleted file mode 100644
index 773d2a054..000000000
--- a/nannou_isf/test_files/Mirror Edge.vs	
+++ /dev/null
@@ -1,22 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2 translated_coord;
-#else
-out vec2 translated_coord;
-#endif
-
-const float pi = 3.14159265359;
-
-void main()	{
-	isf_vertShaderInit();
-
-	vec2 loc = RENDERSIZE * vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	
-	float r = distance(RENDERSIZE/2.0, loc);
-	float a = atan ((loc.y-RENDERSIZE.y/2.0),(loc.x-RENDERSIZE.x/2.0));
-
-	loc.x = r * cos(a + 2.0 * pi * angle) + 0.5;
-	loc.y = r * sin(a + 2.0 * pi * angle) + 0.5;
-	
-	translated_coord = loc / RENDERSIZE + vec2(0.5);
-
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Mirror.fs b/nannou_isf/test_files/Mirror.fs
deleted file mode 100644
index cb83d2fce..000000000
--- a/nannou_isf/test_files/Mirror.fs
+++ /dev/null
@@ -1,41 +0,0 @@
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Geometry Adjustment"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "horizontal",
-			"TYPE": "bool",
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "vertical",
-			"TYPE": "bool",
-			"DEFAULT": 0.0
-		}
-	]
-}*/
-
-void main() {
-	//	isf_FragNormCoord[0] and isf_FragNormCoord[1] are my normalized x/y coordinates
-	//	if we're not doing a flip in either direction we can just pass thru
-	vec2		normSrcCoord;
-
-	normSrcCoord.x = isf_FragNormCoord[0];
-	normSrcCoord.y = isf_FragNormCoord[1];
-
-	if ((normSrcCoord.x > 0.5)&&(horizontal))	{
-		normSrcCoord.x = (1.0-normSrcCoord.x);
-	}
-	if ((normSrcCoord.y > 0.5)&&(vertical))	{
-		normSrcCoord.y = (1.0-normSrcCoord.y);
-	}
-	
-	gl_FragColor = IMG_NORM_PIXEL(inputImage, normSrcCoord);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Morph.fs b/nannou_isf/test_files/Morph.fs
deleted file mode 100644
index 3f15f9874..000000000
--- a/nannou_isf/test_files/Morph.fs
+++ /dev/null
@@ -1,66 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/morph.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.1,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "strength",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: paniq
-// License: MIT
-
-vec4 transition(vec2 p) {
-  vec4 ca = getFromColor(p);
-  vec4 cb = getToColor(p);
-  
-  vec2 oa = (((ca.rg+ca.b)*0.5)*2.0-1.0);
-  vec2 ob = (((cb.rg+cb.b)*0.5)*2.0-1.0);
-  vec2 oc = mix(oa,ob,0.5)*strength;
-  
-  float w0 = progress;
-  float w1 = 1.0-w0;
-  return mix(getFromColor(p+oc*w0), getToColor(p-oc*w1), progress);
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Mosaic.fs b/nannou_isf/test_files/Mosaic.fs
deleted file mode 100644
index dd48541b6..000000000
--- a/nannou_isf/test_files/Mosaic.fs
+++ /dev/null
@@ -1,98 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Wipe"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/Mosaic.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": -1,
-            "MAX": 10,
-            "MIN": -10,
-            "NAME": "endy",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 2,
-            "MAX": 10,
-            "MIN": -10,
-            "NAME": "endx",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// License: MIT
-// Author: Xaychru
-// ported by gre from https://gist.github.com/Xaychru/130bb7b7affedbda9df5
-
-#define PI 3.14159265358979323
-#define POW2(X) X*X
-#define POW3(X) X*X*X
-
-float Rand(vec2 v) {
-  return fract(sin(dot(v.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-vec2 Rotate(vec2 v, float a) {
-  mat2 rm = mat2(cos(a), -sin(a),
-                 sin(a), cos(a));
-  return rm*v;
-}
-float CosInterpolation(float x) {
-  return -cos(x*PI)/2.+.5;
-}
-vec4 transition(vec2 uv) {
-  vec2 p = uv.xy / vec2(1.0).xy - .5;
-  vec2 rp = p;
-  float rpr = (progress*2.-1.);
-  float z = -(rpr*rpr*2.) + 3.;
-  float az = abs(z);
-  rp *= az;
-  rp += mix(vec2(.5, .5), vec2(float(endx) + .5, float(endy) + .5), POW2(CosInterpolation(progress)));
-  vec2 mrp = mod(rp, 1.);
-  vec2 crp = rp;
-  bool onEnd = int(floor(crp.x))==endx&&int(floor(crp.y))==endy;
-  if(!onEnd) {
-    float ang = float(int(Rand(floor(crp))*4.))*.5*PI;
-    mrp = vec2(.5) + Rotate(mrp-vec2(.5), ang);
-  }
-  if(onEnd || Rand(floor(crp))>.5) {
-    return getToColor(mrp);
-  } else {
-    return getFromColor(mrp);
-  }
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Motion Heat Map.fs b/nannou_isf/test_files/Motion Heat Map.fs
deleted file mode 100644
index 13dffaffa..000000000
--- a/nannou_isf/test_files/Motion Heat Map.fs	
+++ /dev/null
@@ -1,151 +0,0 @@
-/*{
-	"DESCRIPTION": "Shows where there is motion between frames",
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Color Effect", "Utility"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "motionThreshold",
-			"LABEL": "Threshold",
-			"TYPE": "float",
-			"MAX": 1.0,
-			"MIN": 0.0,
-			"DEFAULT": 0.1
-		},
-		{
-			"NAME": "motionGain",
-			"LABEL": "Gain",
-			"TYPE": "float",
-			"MAX": 2.0,
-			"MIN": 0.0,
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "motionColor",
-			"LABEL": "Motion Color",
-			"TYPE": "bool",
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "displayMode",
-			"LABEL": "Display Mode",
-			"TYPE": "long",
-			"VALUES": [
-				0,
-				1
-			],
-			"LABELS": [
-				"Motion Only",
-				"Motion Overlay"
-			],
-			"DEFAULT": 1
-		}
-	],
-	"PASSES": [
-		{
-			"TARGET":"differenceBuffer",
-			"FLOAT": true
-		},		{
-			"TARGET":"lastFrameBuffer",
-			"PERSISTENT": true
-		},
-		{
-		
-		}
-	]
-	
-}*/
-
-
-vec4 heatColor(float lum)	{
-	vec4 returnMe = vec4(1.0);
-	vec4 colors[9];
-	//	8 color stages with variable ranges to get this to look right
-	//	black, purple, blue, cyan, green, yellow, orange, red, red
-	colors[0] = vec4(0.0,0.0,0.0,1.0);
-	colors[1] = vec4(0.272,0.0,0.4,1.0);	//	dark deep purple, (RGB: 139, 0, 204)
-	colors[2] = vec4(0.0,0.0,1.0,1.0);		//	full blue
-	colors[3] = vec4(0.0,1.0,1.0,1.0);		//	cyan
-	colors[4] = vec4(0.0,1.0,0.0,1.0);		//	green
-	colors[5] = vec4(0.0,1.0,0.0,1.0);		//	green
-	colors[6] = vec4(1.0,1.0,0.0,1.0);		//	yellow
-	colors[7] = vec4(1.0,0.5,0.0,1.0);		//	orange
-	colors[8] = vec4(1.0,0.0,0.0,1.0);		//	red
-
-	int ix = 0;
-	float range = 1.0 / 8.0;
-	
-	//	orange to red
-	if (lum > range * 7.0)	{
-		ix = 7;
-	}
-	//	yellow to orange
-	else if (lum > range * 6.0)	{
-		ix = 6;
-	}
-	//	green to yellow
-	else if (lum > range * 5.0)	{
-		ix = 5;
-	}
-	//	green to green
-	else if (lum > range * 4.0)	{
-		ix = 4;
-	}
-	//	cyan to green
-	else if (lum > range * 3.0)	{
-		ix = 3;
-	}
-	//	blue to cyan
-	else if (lum > range * 2.0)	{
-		ix = 2;
-	}
-	// purple to blue
-	else if (lum > range)	{
-		ix = 1;
-	}
-	
-	returnMe = colors[ix];
-
-	return returnMe;
-}
-
-
-void main()
-{
-	vec4		freshPixel = IMG_PIXEL(inputImage,gl_FragCoord.xy);
-	vec4		returnMe = freshPixel;
-	
-	if (PASSINDEX == 0)	{
-		vec4		stalePixel = IMG_PIXEL(lastFrameBuffer,gl_FragCoord.xy);
-		vec3		rgbChange = abs(freshPixel.rgb - stalePixel.rgb);
-		float		totalChange = (rgbChange.r + rgbChange.g + rgbChange.b) / 3.0;
-		if (motionColor)
-			returnMe = heatColor(totalChange * motionGain);
-		else
-			returnMe = vec4(totalChange * motionGain);
-	}
-	else if (PASSINDEX == 1)	{
-		
-	}
-	else	{
-		vec4		differencePixel = IMG_PIXEL(differenceBuffer,gl_FragCoord.xy);
-		if (displayMode == 0)	{
-			returnMe = differencePixel;
-		}
-		else if (displayMode == 1)	{
-			const vec4 	lumacoeff = vec4(0.2126, 0.7152, 0.0722, 0.0);
-			float		luma = dot(differencePixel, lumacoeff);
-			if (luma > motionThreshold)	{
-				returnMe = differencePixel;
-			}
-		}
-	}
-	
-	gl_FragColor = returnMe;
-}
diff --git a/nannou_isf/test_files/Motion Mask.fs b/nannou_isf/test_files/Motion Mask.fs
deleted file mode 100644
index 2b1f20045..000000000
--- a/nannou_isf/test_files/Motion Mask.fs	
+++ /dev/null
@@ -1,210 +0,0 @@
-/*{
-	"DESCRIPTION": "Masks an image based on the amount of motion",
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Masking"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"LABEL": "Threshold",
-			"NAME": "threshold",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.25
-		},
-		{
-			"LABEL": "Persistence",
-			"NAME": "persistence",
-			"TYPE": "float",
-			"MIN": 0.9,
-			"MAX": 1.0,
-			"DEFAULT": 0.95
-		},
-		{
-			"LABEL": "Reset BG",
-			"NAME": "updateBackground",
-			"TYPE": "event"
-		},
-		{
-			"LABEL": "Dilate",
-			"NAME": "dilate",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 6.0,
-			"DEFAULT": 0.0
-		},
-		{
-			"LABEL": "Blur",
-			"NAME": "blur",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 6.0,
-			"DEFAULT": 0.0
-		},
-		{
-			"LABEL": "Output Mask",
-			"NAME": "showAlpha",
-			"TYPE": "bool",
-			"DEFAULT": false
-		},
-		{
-			"LABEL": "Hard Cutoff",
-			"NAME": "applyCutOff",
-			"TYPE": "bool",
-			"DEFAULT": true
-		}
-	],
-	"PASSES": [
-		{
-			"TARGET":"freezeBuffer",
-			"PERSISTENT": true
-		},
-		{
-			"TARGET":"mask"
-		},
-		{
-			"TARGET": "horizDilate"
-		},
-		{
-			"TARGET": "vertDilate"
-		},
-		{
-			"TARGET": "horizBlur"
-		},
-		{
-			"TARGET": "vertBlur"
-		},
-		{
-			
-		}
-	]
-	
-}*/
-
-//	Essentially the same as a feedback buffer where you can only set it to a mix of 1.0
-
-void main()
-{
-	vec2		tmpCoord;
-	float		maxAlpha;
-	vec4		sampleColorRGB;
-	vec4		src_rgb;
-	
-	if (PASSINDEX==0)	{
-		vec4	srcPixel = IMG_THIS_PIXEL(inputImage);
-		vec4	oldPixel = IMG_THIS_PIXEL(freezeBuffer);
-		gl_FragColor = (updateBackground) ? srcPixel : mix(srcPixel,oldPixel,persistence);
-	}
-	else if (PASSINDEX==1)	{
-		vec4	srcPixel = IMG_THIS_PIXEL(inputImage);
-		vec4	oldPixel = IMG_THIS_PIXEL(freezeBuffer);
-		vec4	resultPixel = vec4(0.0);
-		float	difference = abs(srcPixel.r - oldPixel.r) + abs(srcPixel.g - oldPixel.g) + abs(srcPixel.b - oldPixel.b);
-		resultPixel = vec4(difference);
-		gl_FragColor = resultPixel;	
-	}
-	else if (PASSINDEX==2)	{
-		//	'dilate' samples on either side + the source pixel = 2*dilate+1 total samples
-		for (float i=0.; i<=dilate; ++i)	{
-			tmpCoord = vec2(clamp(gl_FragCoord.x+i,0.,RENDERSIZE.x), gl_FragCoord.y);
-			sampleColorRGB = IMG_PIXEL(mask, tmpCoord);
-			//	if this is the first sample for this fragment, don't bother comparing- just set the max luma stuff
-			if (i == 0.)	{
-				maxAlpha = sampleColorRGB.a;
-				src_rgb = sampleColorRGB;
-			}
-			//	else this isn't the first sample...
-			else	{
-				//	compare, determine if it's the max luma
-				if (sampleColorRGB.a < maxAlpha)	{
-					maxAlpha = sampleColorRGB.a;
-				}
-				//	do another sample for the negative coordinate
-				tmpCoord = vec2(clamp(gl_FragCoord.x-i,0.,RENDERSIZE.x), gl_FragCoord.y);
-				sampleColorRGB = IMG_PIXEL(mask, tmpCoord);
-				if (sampleColorRGB.a < maxAlpha)	{
-					maxAlpha = sampleColorRGB.a;
-				}
-			}
-		}
-		gl_FragColor = vec4(src_rgb.rgb, maxAlpha);
-	}
-	else if (PASSINDEX==3)	{
-		//	'dilate' samples up and down + the source pixel = 2*dilate+1 total samples
-		for (float i=0.; i<=float(int(dilate)); ++i)	{
-			tmpCoord = vec2(gl_FragCoord.x, clamp(gl_FragCoord.y+i,0.,RENDERSIZE.y));
-			sampleColorRGB = IMG_PIXEL(horizDilate, tmpCoord);
-			//	if this is the first sample for this fragment, don't bother comparing- just set the max luma stuff
-			if (i == 0.)	{
-				maxAlpha = sampleColorRGB.a;
-				src_rgb = sampleColorRGB;
-			}
-			//	else this isn't the first sample...
-			else	{
-				//	compare, determine if it's the max luma
-				if (sampleColorRGB.a < maxAlpha)	{
-					maxAlpha = sampleColorRGB.a;
-				}
-				//	do another sample for the negative coordinate
-				tmpCoord = vec2(gl_FragCoord.x, clamp(gl_FragCoord.y-i,0.,RENDERSIZE.y));
-				sampleColorRGB = IMG_PIXEL(horizDilate, tmpCoord);
-				if (sampleColorRGB.a < maxAlpha)	{
-					maxAlpha = sampleColorRGB.a;
-				}
-			}
-		}
-		gl_FragColor = vec4(src_rgb.rgb, maxAlpha);
-	}
-	else if (PASSINDEX==4)	{
-		float		tmpRadius = float(int(blur));
-		vec4		tmpColor;
-		vec4		srcColor;
-		float		totalAlpha = 0.0;
-		for (float i=-1.*tmpRadius; i<=tmpRadius; ++i)	{
-			tmpColor = IMG_PIXEL(vertDilate, gl_FragCoord.xy+vec2(i,0.0));
-			totalAlpha += tmpColor.a;
-			if (i==0.0)
-				srcColor = tmpColor;
-		}
-		totalAlpha /= ((tmpRadius*2.)+1.);
-		gl_FragColor = vec4(srcColor.r, srcColor.g, srcColor.b, totalAlpha);
-	}
-	else if (PASSINDEX==5)	{
-		float		tmpRadius = float(int(blur));
-		vec4		tmpColor;
-		vec4		srcColor;
-		float		totalAlpha = 0.0;
-		for (float i=-1.*tmpRadius; i<=tmpRadius; ++i)	{
-			tmpColor = IMG_PIXEL(horizBlur, gl_FragCoord.xy+vec2(0.0,i));
-			totalAlpha += tmpColor.a;
-			if (i==0.0)
-				srcColor = tmpColor;
-		}
-		totalAlpha /= ((tmpRadius*2.)+1.);
-		
-		gl_FragColor = vec4(srcColor.r, srcColor.g, srcColor.b, totalAlpha);
-	}
-	else if (PASSINDEX==6)	{
-		vec4	srcPixel = IMG_THIS_PIXEL(inputImage);
-		vec4	oldPixel = IMG_THIS_PIXEL(vertBlur);
-		vec4	resultPixel = vec4(0.0);
-		float	difference = oldPixel.a;
-		if (difference > threshold)	{
-			if (showAlpha)
-				resultPixel = vec4(1.0,1.0,1.0,1.0);
-			else 
-				resultPixel = srcPixel;
-			
-			if (!applyCutOff)
-				resultPixel = resultPixel * difference;
-		}
-		gl_FragColor = resultPixel;
-	}
-
-}
diff --git a/nannou_isf/test_files/Multi Gradient.fs b/nannou_isf/test_files/Multi Gradient.fs
deleted file mode 100644
index ee837da1f..000000000
--- a/nannou_isf/test_files/Multi Gradient.fs	
+++ /dev/null
@@ -1,339 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Color"
-  ],
-  "ISFVSN" : "2",
-  "INPUTS" : [
-  	{
-  	  "NAME" : "lookupImage",
-  	  "TYPE" : "image"
-  	},
-    {
-      "NAME" : "frequency1",
-      "TYPE" : "float",
-      "MAX" : 16,
-      "DEFAULT" : 1.0,
-      "MIN" : 0.5
-    },
-    {
-      "NAME" : "phase1",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "amplitude1",
-      "TYPE" : "float",
-      "MAX" : 2,
-      "DEFAULT" : 1,
-      "MIN" : -2
-    },
-    {
-      "NAME" : "offset1",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0,
-      "MIN" : -1
-    },
-    {
-      "NAME" : "angle1",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0,
-      "MIN" : 0
-    },
-    {
-      "VALUES" : [
-        0,
-        1,
-        2,
-        3,
-        4
-      ],
-      "NAME" : "curve1",
-      "TYPE" : "long",
-      "DEFAULT" : 0,
-      "LABELS" : [
-      	"Ramp",
-        "Triangle",
-        "Sine",
-        "Exponential",
-        "Look Up Table"
-      ]
-    },
-    {
-      "NAME" : "mixLevel1",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 1,
-      "MIN" : -1
-    },
-    {
-      "NAME" : "startColor1",
-      "TYPE" : "color",
-      "DEFAULT" : [
-        0,
-        0,
-        0,
-        0
-      ]
-    },
-    {
-      "NAME" : "endColor1",
-      "TYPE" : "color",
-      "DEFAULT" : [
-        1,
-        0,
-        0,
-        1
-      ]
-    },
-    {
-      "NAME" : "frequency2",
-      "TYPE" : "float",
-      "MAX" : 16,
-      "DEFAULT" : 1.0,
-      "MIN" : 0.5
-    },
-    {
-      "NAME" : "phase2",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "amplitude2",
-      "TYPE" : "float",
-      "MAX" : 2,
-      "DEFAULT" : 1,
-      "MIN" : -2
-    },
-    {
-      "NAME" : "offset2",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0,
-      "MIN" : -1
-    },
-    {
-      "NAME" : "angle2",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0.75,
-      "MIN" : 0
-    },
-    {
-      "VALUES" : [
-        0,
-        1,
-        2,
-        3,
-        4
-      ],
-      "NAME" : "curve2",
-      "TYPE" : "long",
-      "DEFAULT" : 0,
-      "LABELS" : [
-      	"Ramp",
-        "Triangle",
-        "Sine",
-        "Exponential",
-        "Look Up Table"
-      ]
-    },
-    {
-      "NAME" : "mixLevel2",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 1,
-      "MIN" : -1
-    },
-    {
-      "NAME" : "startColor2",
-      "TYPE" : "color",
-      "DEFAULT" : [
-        0,
-        0,
-        0,
-        0
-      ]
-    },
-    {
-      "NAME" : "endColor2",
-      "TYPE" : "color",
-      "DEFAULT" : [
-        0,
-        1,
-        0,
-        1
-      ]
-    },
-    {
-      "NAME" : "frequency3",
-      "TYPE" : "float",
-      "MAX" : 16,
-      "DEFAULT" : 2.0,
-      "MIN" : 0.5
-    },
-    {
-      "NAME" : "phase3",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "amplitude3",
-      "TYPE" : "float",
-      "MAX" : 2,
-      "DEFAULT" : 1,
-      "MIN" : -2
-    },
-    {
-      "NAME" : "offset3",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0,
-      "MIN" : -1
-    },
-    {
-      "NAME" : "angle3",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0,
-      "MIN" : 0
-    },
-    {
-      "VALUES" : [
-        0,
-        1,
-        2,
-        3,
-        4
-      ],
-      "NAME" : "curve3",
-      "TYPE" : "long",
-      "DEFAULT" : 0,
-      "LABELS" : [
-      	"Ramp",
-        "Triangle",
-        "Sine",
-        "Exponential",
-        "Look Up Table"
-      ]
-    },
-    {
-      "NAME" : "mixLevel3",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 1,
-      "MIN" : -1
-    },
-    {
-      "NAME" : "startColor3",
-      "TYPE" : "color",
-      "DEFAULT" : [
-        0,
-        0,
-        0,
-        0
-      ]
-    },
-    {
-      "NAME" : "endColor3",
-      "TYPE" : "color",
-      "DEFAULT" : [
-        0,
-        0,
-        1,
-        1
-      ]
-    }
-  ],
-  "CREDIT" : "by Carter Rosenberg"
-}
-*/
-
-
-
-const float pi = 3.14159265359;
-const float e = 2.71828182846;
-
-
-float doMath(int curve, float freq, float phase, float val)	{
-	float	returnMe = phase + freq * val;
-
-	if (curve == 0)	{
-		returnMe = mod(returnMe,1.0);
-	}
-	else if (curve == 1)	{
-		returnMe = mod(2.0 * returnMe,2.0);
-		returnMe = (returnMe < 1.0) ? returnMe : 1.0 - (returnMe - floor(returnMe));
-	}
-	else if (curve == 2)	{
-		returnMe = sin(returnMe * pi * 2.0 - pi / 2.0) * 0.5 + 0.5;
-	}
-	else if (curve == 3)	{
-		returnMe = mod(2.0 * returnMe, 2.0);
-		returnMe = (returnMe < 1.0) ? returnMe : 1.0 - (returnMe - floor(returnMe));
-		returnMe = pow(returnMe, 2.0);
-	}
-	else if (curve == 4)	{
-		vec2	loc = mod(returnMe+isf_FragNormCoord,1.0);
-		vec4	tmp = IMG_NORM_PIXEL(lookupImage,loc);
-		returnMe = (tmp.r+tmp.g+tmp.b)*tmp.a/3.0;
-	}
-	return returnMe;	
-}
-
-//	note that this works on normalized points, but respects aspect ratio
-vec2 rotatePoint(vec2 pt, float angle)	{
-	vec2 returnMe = pt * RENDERSIZE;;
-
-	float r = distance(RENDERSIZE/2.0, returnMe);
-	float a = atan ((returnMe.y-RENDERSIZE.y/2.0),(returnMe.x-RENDERSIZE.x/2.0));
-
-	returnMe.x = r * cos(a + 2.0 * pi * angle - pi) + 0.5;
-	returnMe.y = r * sin(a + 2.0 * pi * angle - pi) + 0.5;
-	
-	returnMe = returnMe / RENDERSIZE + vec2(0.5);
-	
-	return returnMe;
-}
-
-
-void main() {
-	vec4 returnMe = vec4(0.0);
-	vec4 blendColor = vec4(0.0);
-	float mixAmount = 0.0;
-	vec2 loc = isf_FragNormCoord;
-
-	loc = rotatePoint(isf_FragNormCoord,angle1);
-	mixAmount = doMath(curve1,frequency1,phase1,1.0-loc.x);
-	mixAmount = (amplitude1 >= 0.0) ? mixAmount * amplitude1 : (1.0 - mixAmount) * abs(amplitude1);
-	mixAmount += offset1;
-	blendColor = mix(startColor1,endColor1,mixAmount);
-	returnMe.rgb += blendColor.rgb * mixLevel1;
-	returnMe.a += abs(blendColor.a);
-	
-	loc = rotatePoint(isf_FragNormCoord,angle2);
-	mixAmount = doMath(curve2,frequency2,phase2,1.0-loc.x);
-	mixAmount = (amplitude2 >= 0.0) ? mixAmount * amplitude2 : (1.0 - mixAmount) * abs(amplitude2);
-	mixAmount += offset2;
-	blendColor = mix(startColor2,endColor2,mixAmount);
-	returnMe.rgb += blendColor.rgb  * mixLevel2;
-	returnMe.a += abs(blendColor.a);
-	
-	loc = rotatePoint(isf_FragNormCoord,angle3);
-	mixAmount = doMath(curve3,frequency3,phase3,loc.x);
-	mixAmount = (amplitude3 >= 0.0) ? mixAmount * amplitude3 : (1.0 - mixAmount) * abs(amplitude3);
-	mixAmount += offset3;
-	blendColor = mix(startColor3,endColor3,mixAmount);
-	returnMe.rgb += blendColor.rgb  * mixLevel3;
-	returnMe.a += abs(blendColor.a);
-	
-	gl_FragColor = returnMe;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Multi Hue Shift.fs b/nannou_isf/test_files/Multi Hue Shift.fs
deleted file mode 100644
index e536ce92b..000000000
--- a/nannou_isf/test_files/Multi Hue Shift.fs	
+++ /dev/null
@@ -1,89 +0,0 @@
-/*{
-	"DESCRIPTION": "Performs hue shifts of different amounts depending on brightness levels",
-	"CREDIT": "VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Color Effect"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "shiftLow",
-			"TYPE": "float",
-			"DEFAULT": 0.0,
-			"MIN": 0.0,
-			"MAX": 1.0
-		},
-		{
-			"NAME": "shiftMid",
-			"TYPE": "float",
-			"DEFAULT": 0.0,
-			"MIN": 0.0,
-			"MAX": 1.0
-		},
-		{
-			"NAME": "shiftHigh",
-			"TYPE": "float",
-			"DEFAULT": 0.0,
-			"MIN": 0.0,
-			"MAX": 1.0
-		}
-	]
-	
-}*/
-
-
-
-vec3 rgb2hsv(vec3 c)	{
-	vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-	//vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
-	//vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
-	vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
-	vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
-	
-	float d = q.x - min(q.w, q.y);
-	float e = 1.0e-10;
-	return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
-}
-
-vec3 hsv2rgb(vec3 c)	{
-	vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
-	vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
-	return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
-}
-
-
-
-void main()	{
-	vec4		inputPixelColor = IMG_THIS_PIXEL(inputImage);
-
-	//	don't bother doing anything if we're not shifting anything
-	if ((shiftLow > 0.0)||(shiftMid > 0.0)||(shiftHigh > 0.0))	{
-		//	what is the brightness?
-		float		val = (inputPixelColor.r + inputPixelColor.g + inputPixelColor.b) / 3.0;
-		
-		//	how much do we shift by based on that brightness?
-		if (val < 0.25)	{
-			val = shiftLow;
-		}
-		else if (val < 0.5)	{
-			val = mix(shiftLow, shiftMid, (val-0.25) * 4.0);
-		}
-		else if (val < 0.75)	{
-			val = mix(shiftMid, shiftHigh, (val-0.5) * 4.0);
-		}
-		else	{
-			val = shiftHigh;
-		}
-		
-		inputPixelColor.rgb = rgb2hsv(inputPixelColor.rgb);
-		inputPixelColor.r = fract(inputPixelColor.r + val);
-		inputPixelColor.rgb = hsv2rgb(inputPixelColor.rgb);
-		
-	}
-	
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/Multi Pass Gaussian Blur.fs b/nannou_isf/test_files/Multi Pass Gaussian Blur.fs
deleted file mode 100644
index 74e467dc2..000000000
--- a/nannou_isf/test_files/Multi Pass Gaussian Blur.fs	
+++ /dev/null
@@ -1,183 +0,0 @@
-/*{
-	"CREDIT": "original implementation as v002.blur in QC by anton marini and tom butterworth, ported by zoidberg",
-	"ISFVSN": "2",
-	"DESCRIPTION": "Performs a deep blur",
-	"CATEGORIES": [
-		"Blur"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "blurAmount",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 24.0,
-			"DEFAULT": 24.0
-		}
-	],
-	"PASSES": [
-		{
-			"TARGET": "halfSizeBaseRender",
-			"WIDTH": "floor($WIDTH/3.0)",
-			"HEIGHT": "floor($HEIGHT/3.0)",
-			"DESCRIPTION": "Pass 0"
-		},
-		{
-			"TARGET": "quarterSizeBaseRender",
-			"WIDTH": "floor($WIDTH/6.0)",
-			"HEIGHT": "floor($HEIGHT/6.0)",
-			"DESCRIPTION": "Pass 1"
-		},
-		{
-			"TARGET": "eighthSizeBaseRender",
-			"WIDTH": "floor($WIDTH/12.0)",
-			"HEIGHT": "floor($HEIGHT/12.0)",
-			"DESCRIPTION": "Pass 2"
-		},
-		{
-			"TARGET": "eighthGaussA",
-			"WIDTH": "floor($WIDTH/12.0)",
-			"HEIGHT": "floor($HEIGHT/12.0)",
-			"DESCRIPTION": "Pass 3"
-		},
-		{
-			"TARGET": "eighthGaussB",
-			"WIDTH": "floor($WIDTH/12.0)",
-			"HEIGHT": "floor($HEIGHT/12.0)",
-			"DESCRIPTION": "Pass 4"
-		},
-		{
-			"TARGET": "quarterGaussA",
-			"WIDTH": "floor($WIDTH/6.0)",
-			"HEIGHT": "floor($HEIGHT/6.0)",
-			"DESCRIPTION": "Pass 5"
-		},
-		{
-			"TARGET": "quarterGaussB",
-			"WIDTH": "floor($WIDTH/6.0)",
-			"HEIGHT": "floor($HEIGHT/6.0)",
-			"DESCRIPTION": "Pass 6"
-		},
-		{
-			"TARGET": "halfGaussA",
-			"WIDTH": "floor($WIDTH/3.0)",
-			"HEIGHT": "floor($HEIGHT/3.0)",
-			"DESCRIPTION": "Pass 7"
-		},
-		{
-			"TARGET": "halfGaussB",
-			"WIDTH": "floor($WIDTH/3.0)",
-			"HEIGHT": "floor($HEIGHT/3.0)",
-			"DESCRIPTION": "Pass 8"
-		},
-		{
-			"TARGET": "fullGaussA",
-			"DESCRIPTION": "Pass 9"
-		},
-		{
-			"TARGET": "fullGaussB",
-			"DESCRIPTION": "Pass 10"
-		}
-	]
-}*/
-
-
-/*
-																			eighth
-													quarter					0	1	2	3	4	5		"blurRadius" (different resolutions have different blur radiuses based on the "blurAmount" and its derived "blurLevel")
-							half					0	1	2	3	4	5								"blurRadius"
-	normal					0	1	2	3	4	5														"blurRadius"
-	0	1	2	3	4	5	5																			"blurRadius"
-	0						6						12						18						24	"blurAmount" (attrib)
-				0						1						2						3				"blurLevel" (local var)
-*/
-
-#if __VERSION__ <= 120
-varying vec2		texOffsets[5];
-#else
-in vec2		texOffsets[5];
-#endif
-
-
-void main() {
-	int			blurLevel = int(floor(blurAmount/6.0));
-	float		blurLevelModulus = mod(blurAmount, 6.0);
-	//	first three passes are just copying the input image into the buffer at varying sizes
-	if (PASSINDEX==0)	{
-		gl_FragColor = IMG_NORM_PIXEL(inputImage, isf_FragNormCoord);
-	}
-	else if (PASSINDEX==1)	{
-		gl_FragColor = IMG_NORM_PIXEL(halfSizeBaseRender, isf_FragNormCoord);
-	}
-	else if (PASSINDEX==2)	{
-		gl_FragColor = IMG_NORM_PIXEL(quarterSizeBaseRender, isf_FragNormCoord);
-	}
-	//	start reading from the previous stage- each two passes completes a gaussian blur, then 
-	//	we increase the resolution & blur (the lower-res blurred image from the previous pass) again...
-	else if (PASSINDEX == 3)	{
-		vec4		sample0 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[2]);
-		vec4		sample3 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[3]);
-		vec4		sample4 = IMG_NORM_PIXEL(eighthSizeBaseRender,texOffsets[4]);
-		//gl_FragColor = vec4((sample0 + sample1 + sample2).rgb / (3.0), 1.0);
-		gl_FragColor = vec4((sample0 + sample1 + sample2 + sample3 + sample4).rgba / (5.0));
-	}
-	else if (PASSINDEX == 4)	{
-		vec4		sample0 = IMG_NORM_PIXEL(eighthGaussA,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(eighthGaussA,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(eighthGaussA,texOffsets[2]);
-		vec4		sample3 = IMG_NORM_PIXEL(eighthGaussA,texOffsets[3]);
-		vec4		sample4 = IMG_NORM_PIXEL(eighthGaussA,texOffsets[4]);
-		//gl_FragColor = vec4((sample0 + sample1 + sample2).rgb / (3.0), 1.0);
-		gl_FragColor = vec4((sample0 + sample1 + sample2 + sample3 + sample4).rgba / (5.0));
-	}
-	//	...writes into the quarter-size
-	else if (PASSINDEX == 5)	{
-		vec4		sample0 = IMG_NORM_PIXEL(eighthGaussB,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(eighthGaussB,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(eighthGaussB,texOffsets[2]);
-		gl_FragColor =  vec4((sample0 + sample1 + sample2).rgba / (3.0));
-	}
-	else if (PASSINDEX == 6)	{
-		vec4		sample0 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(quarterGaussA,texOffsets[2]);
-		gl_FragColor =  vec4((sample0 + sample1 + sample2).rgba / (3.0));
-	}
-	//	...writes into the half-size
-	else if (PASSINDEX == 7)	{
-		vec4		sample0 = IMG_NORM_PIXEL(quarterGaussB,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(quarterGaussB,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(quarterGaussB,texOffsets[2]);
-		gl_FragColor =  vec4((sample0 + sample1 + sample2).rgba / (3.0));
-	}
-	else if (PASSINDEX == 8)	{
-		vec4		sample0 = IMG_NORM_PIXEL(halfGaussA,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(halfGaussA,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(halfGaussA,texOffsets[2]);
-		gl_FragColor =  vec4((sample0 + sample1 + sample2).rgba / (3.0));
-	}
-	//	...writes into the full-size
-	else if (PASSINDEX == 9)	{
-		vec4		sample0 = IMG_NORM_PIXEL(halfGaussB,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(halfGaussB,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(halfGaussB,texOffsets[2]);
-		gl_FragColor =  vec4((sample0 + sample1 + sample2).rgba / (3.0));
-	}
-	else if (PASSINDEX == 10)	{
-		//	this is the last pass- calculate the blurred image as i have in previous passes, then mix it in with the full-size input image using the blur amount so i get a smooth transition into the blur at low blur levels
-		vec4		sample0 = IMG_NORM_PIXEL(fullGaussA,texOffsets[0]);
-		vec4		sample1 = IMG_NORM_PIXEL(fullGaussA,texOffsets[1]);
-		vec4		sample2 = IMG_NORM_PIXEL(fullGaussA,texOffsets[2]);
-		vec4		blurredImg =  vec4((sample0 + sample1 + sample2).rgba / (3.0));
-		if (blurLevel == 0)
-			gl_FragColor = mix(IMG_NORM_PIXEL(inputImage,isf_FragNormCoord), blurredImg, (blurLevelModulus/6.0));
-		else
-			gl_FragColor = blurredImg;
-	}
-	
-}
diff --git a/nannou_isf/test_files/Multi Pass Gaussian Blur.vs b/nannou_isf/test_files/Multi Pass Gaussian Blur.vs
deleted file mode 100644
index ef7ba5114..000000000
--- a/nannou_isf/test_files/Multi Pass Gaussian Blur.vs	
+++ /dev/null
@@ -1,98 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2		texOffsets[5];
-#else
-out vec2		texOffsets[5];
-#endif
-
-void main(void)	{
-	//	load the main shader stuff
-	isf_vertShaderInit();
-	
-	
-	int			blurLevel = int(floor(blurAmount/6.0));
-	float		blurLevelModulus = mod(blurAmount, 6.0);
-	float		blurRadius = 0.0;
-	float		blurRadiusInPixels = 0.0;
-	//	first three passes are just drawing the texture- do nothing
-	
-	//	the next six passes do gaussion blurs on the various levels
-	if (PASSINDEX==3 || PASSINDEX==5 || PASSINDEX==7 || PASSINDEX==9)	{
-		float		pixelWidth = 1.0/RENDERSIZE.x;
-		//	pass 3 is eighth-size (blurLevel 3)
-		if (PASSINDEX==3)	{
-			if (blurLevel==3)
-				blurRadius = blurLevelModulus/2.0;
-			else if (blurLevel>3)
-				blurRadius = 3.0;
-		}
-		//	pass 5 is quarter-size (blurLevel 2)
-		else if (PASSINDEX==5)	{
-			if (blurLevel==2)
-				blurRadius = blurLevelModulus/1.5;
-			else if (blurLevel>2)
-				blurRadius = 4.0;
-		}
-		//	pass 7 is half-size (blurLevel 1)
-		else if (PASSINDEX==7)	{
-			if (blurLevel==1)
-				blurRadius = blurLevelModulus;
-			else if (blurLevel>1)
-				blurRadius = 6.0;
-		}
-		//	pass 9 is normal-size (blurLevel 0)
-		else if (PASSINDEX==9)	{
-			if (blurLevel==0)
-				blurRadius = blurLevelModulus;
-			else if (blurLevel>0)
-				blurRadius = 6.0;
-		}
-		blurRadiusInPixels = pixelWidth * blurRadius;
-		texOffsets[0] = isf_FragNormCoord;
-		texOffsets[1] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0]-blurRadiusInPixels, isf_FragNormCoord[1]),0.0,1.0);
-		texOffsets[2] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0]+blurRadiusInPixels, isf_FragNormCoord[1]),0.0,1.0);
-		if (PASSINDEX==3)	{
-			texOffsets[3] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0]-(2.0*blurRadiusInPixels), isf_FragNormCoord[1]),0.0,1.0);
-			texOffsets[4] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0]+(2.0*blurRadiusInPixels), isf_FragNormCoord[1]),0.0,1.0);
-		}
-	}
-	else if (PASSINDEX==4 || PASSINDEX==6 || PASSINDEX==8 || PASSINDEX==10)	{
-		float		pixelHeight = 1.0/RENDERSIZE.y;
-		//	pass 4 is eighth-size (blurLevel 3)
-		if (PASSINDEX==4)	{
-			if (blurLevel==3)
-				blurRadius = blurLevelModulus/2.0;
-			else if (blurLevel>3)
-				blurRadius = 3.0;
-		}
-		//	pass 6 is quarter-size (blurLevel 2)
-		else if (PASSINDEX==6)	{
-			if (blurLevel==2)
-				blurRadius = blurLevelModulus/1.5;
-			else if (blurLevel>2)
-				blurRadius = 4.0;
-		}
-		//	pass 8 is half-size (blurLevel 1)
-		else if (PASSINDEX==8)	{
-			if (blurLevel==1)
-				blurRadius = blurLevelModulus;
-			else if (blurLevel>1)
-				blurRadius = 6.0;
-		}
-		//	pass 10 is normal-size (blurLevel 0)
-		else if (PASSINDEX==10)	{
-			if (blurLevel==0)
-				blurRadius = blurLevelModulus;
-			else if (blurLevel>0)
-				blurRadius = 6.0;
-		}
-		blurRadiusInPixels = pixelHeight * blurRadius;
-		texOffsets[0] = isf_FragNormCoord;
-		texOffsets[1] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]-blurRadiusInPixels),0.0,1.0);
-		texOffsets[2] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]+blurRadiusInPixels),0.0,1.0);
-		if (PASSINDEX==4)	{
-			texOffsets[3] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]-(2.0*blurRadiusInPixels)),0.0,1.0);
-			texOffsets[4] = (blurRadius==0.0) ? isf_FragNormCoord : clamp(vec2(isf_FragNormCoord[0], isf_FragNormCoord[1]+(2.0*blurRadiusInPixels)),0.0,1.0);
-		}
-	}
-	
-}
diff --git a/nannou_isf/test_files/Multi-Pixellate.fs b/nannou_isf/test_files/Multi-Pixellate.fs
deleted file mode 100644
index c9a39dcc9..000000000
--- a/nannou_isf/test_files/Multi-Pixellate.fs
+++ /dev/null
@@ -1,139 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Stylize"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.125,
-            "MAX": 0.5,
-            "MIN": 0.001,
-            "NAME": "cell_size",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.05000000074505806,
-            "MAX": 0.5,
-            "MIN": 0.001,
-            "NAME": "min_cell_size",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.25,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "rSeed",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABELS": [
-                "Square",
-                "Rectangle"
-            ],
-            "NAME": "shape",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1
-            ]
-        },
-        {
-            "DEFAULT": 2,
-            "LABELS": [
-                "Off",
-                "2",
-                "3",
-                "5"
-            ],
-            "NAME": "round_to_divisions",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                2,
-                3,
-                5
-            ]
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-#ifndef GL_ES
-float distance (vec2 center, vec2 pt)
-{
-	float tmp = pow(center.x-pt.x,2.0)+pow(center.y-pt.y,2.0);
-	return pow(tmp,0.5);
-}
-#endif
-
-float rand(vec2 co){
-    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-void main()
-{
-// CALCULATE EDGES OF CURRENT CELL
-	//	At 0.0 just do a pass-thru
-	if (cell_size == 0.0)	{
-		gl_FragColor = IMG_THIS_PIXEL(inputImage);
-	}
-		else	{
-		// Position of current pixel
-		vec2 xy; 
-		xy.x = isf_FragNormCoord[0];
-		xy.y = isf_FragNormCoord[1];
-
-
-		// Left and right of tile
-		float max_cell_size = cell_size + min_cell_size;
-		float CellWidth = max_cell_size;
-		float CellHeight = max_cell_size;
-		if (shape==0)	{
-			CellHeight = max_cell_size * RENDERSIZE.x / RENDERSIZE.y;
-		}
-
-		float x1 = floor(xy.x / CellWidth)*CellWidth;
-		// Top and bottom of tile
-		float y1 = floor(xy.y / CellHeight)*CellHeight;
-		
-		float newCellSize = max_cell_size;
-		
-		if (round_to_divisions > 0)	{
-			float maxCount = (min_cell_size > 0.0) ? max_cell_size / min_cell_size : 10.0;
-			float val = floor(1.0+(maxCount-1.0)*rand(0.1+rSeed+vec2(x1,y1)));
-			newCellSize = newCellSize / pow(float(round_to_divisions),val);
-		}
-		else	{
-			newCellSize = min_cell_size + (cell_size - min_cell_size) * rand(0.1+rSeed+vec2(x1,y1));
-		}
-		
-		CellWidth = newCellSize;
-		CellHeight = newCellSize;
-		if (shape==0)	{
-			CellHeight = newCellSize * RENDERSIZE.x / RENDERSIZE.y;
-		}
-		
-		x1 = floor(xy.x / CellWidth)*CellWidth;
-		float x2 = clamp((ceil(xy.x / CellWidth)*CellWidth), 0.0, 1.0);
-		// Top and bottom of tile
-		y1 = floor(xy.y / CellHeight)*CellHeight;
-		float y2 = clamp((ceil(xy.y / CellHeight)*CellHeight), 0.0, 1.0);
-
-		// GET AVERAGE CELL COLOUR
-		// Average left and right pixels
-		vec4 avgX = (IMG_NORM_PIXEL(inputImage, vec2(x1, y1))+(IMG_NORM_PIXEL(inputImage, vec2(x2, y1)))) / 2.0;
-		// Average top and bottom pixels
-		vec4 avgY = (IMG_NORM_PIXEL(inputImage, vec2(x1, y1))+(IMG_NORM_PIXEL(inputImage, vec2(x1, y2)))) / 2.0;
-		// Centre pixel
-		vec4 avgC = IMG_NORM_PIXEL(inputImage, vec2(x1+(CellWidth/2.0), y2+(CellHeight/2.0)));	// Average the averages + centre
-		vec4 avgClr = (avgX+avgY+avgC) / 3.0;
-
-		gl_FragColor = vec4(avgClr);
-	}
-}
diff --git a/nannou_isf/test_files/MultiFrame 2x2.fs b/nannou_isf/test_files/MultiFrame 2x2.fs
deleted file mode 100644
index 6ebc2564e..000000000
--- a/nannou_isf/test_files/MultiFrame 2x2.fs	
+++ /dev/null
@@ -1,145 +0,0 @@
-/*{
-	"DESCRIPTION": "buffers the last 3 frames and draws a 2x2 grid of the 4 current frames available",
-	"ISFVSN": "2",
-	"CREDIT": "by VIDVOX",
-	"CATEGORIES": [
-		"Tile Effect", "Stylize"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "lag",
-			"TYPE": "bool",
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "hueShift",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.0
-		}
-	],
-	"PASSES": [
-		{
-			"TARGET":"buffer3",
-			"PERSISTENT": true,
-			"WIDTH": "$WIDTH/2.0",
-			"HEIGHT": "$HEIGHT/2.0"
-		},
-		{
-			"TARGET":"buffer2",
-			"PERSISTENT": true,
-			"WIDTH": "$WIDTH/2.0",
-			"HEIGHT": "$HEIGHT/2.0"
-		},
-		{
-			"TARGET":"buffer1",
-			"PERSISTENT": true,
-			"WIDTH": "$WIDTH/2.0",
-			"HEIGHT": "$HEIGHT/2.0"
-		},
-		{
-		
-		}
-	]
-	
-}*/
-
-
-
-vec3 rgb2hsv(vec3 c)	{
-	vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-	//vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
-	//vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
-	vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
-	vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
-	
-	float d = q.x - min(q.w, q.y);
-	float e = 1.0e-10;
-	return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
-}
-
-vec3 hsv2rgb(vec3 c)	{
-	vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
-	vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
-	return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
-}
-
-
-
-void main()
-{
-	//	first pass: read the "buffer2" into "buffer3"
-	//	apply lag on each pass
-	if (PASSINDEX == 0)	{
-		if ((lag == false)||(mod(floor(TIME*60.0+2.0),6.0)<=1.0))	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer2);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer3);
-		}
-	}
-	//	first pass: read the "buffer1" into "buffer2"
-	else if (PASSINDEX == 1)	{
-		if ((lag == false)||(mod(floor(TIME*60.0+2.0),6.0)<=1.0))	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer1);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer2);
-		}
-	}
-	//	third pass: read from "inputImage" into "buffer1"
-	else if (PASSINDEX == 2)	{
-		if ((lag == false)||(mod(floor(TIME*60.0+2.0),6.0)<=1.0))	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(inputImage);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer1);
-		}
-	}
-	else if (PASSINDEX == 3)	{
-		//	Figure out which section I'm in and draw the appropriate buffer there
-		vec2 tex = isf_FragNormCoord;
-		vec4 color = vec4(0.0);
-		//	TL – buffer1
-		if ((tex.x < 0.5) && (tex.y > 0.5))	{
-			tex.x = tex.x * 2.0;
-			tex.y = (tex.y - 0.5) * 2.0;
-			color = IMG_NORM_PIXEL(inputImage, tex);
-		}
-		//	TR – buffer2
-		else if ((tex.x > 0.5) && (tex.y > 0.5))	{
-			tex.x = (tex.x - 0.5) * 2.0;
-			tex.y = (tex.y - 0.5) * 2.0;
-			
-			color = IMG_NORM_PIXEL(buffer1, tex);
-			color.rgb = rgb2hsv(color.rgb);
-			color.r = mod(color.r + hueShift, 1.0);
-			color.rgb = hsv2rgb(color.rgb);
-		}
-		//	BR – buffer2
-		else if ((tex.x < 0.5) && (tex.y < 0.5))	{
-			tex = tex * 2.0;
-			
-			color = IMG_NORM_PIXEL(buffer2, tex);
-			color.rgb = rgb2hsv(color.rgb);
-			color.r = mod(color.r + 2.0 * hueShift, 1.0);
-			color.rgb = hsv2rgb(color.rgb);	
-		}
-		else	{
-			tex.x = (tex.x - 0.5) * 2.0;
-			tex.y = tex.y * 2.0;
-			
-			color = IMG_NORM_PIXEL(buffer3, tex);
-			color.rgb = rgb2hsv(color.rgb);
-			color.r = mod(color.r + 3.0 * hueShift, 1.0);
-			color.rgb = hsv2rgb(color.rgb);		
-		}
-		//	BL - buffer3
-		gl_FragColor = color;
-	}
-}
diff --git a/nannou_isf/test_files/MultiFrame 3x3.fs b/nannou_isf/test_files/MultiFrame 3x3.fs
deleted file mode 100644
index 51212c1ef..000000000
--- a/nannou_isf/test_files/MultiFrame 3x3.fs	
+++ /dev/null
@@ -1,268 +0,0 @@
-/*{
-	"DESCRIPTION": "buffers the last 3 frames and draws a 2x2 grid of the 4 current frames available",
-	"ISFVSN": "2",
-	"CREDIT": "by VIDVOX",
-	"CATEGORIES": [
-		"Tile Effect", "Stylize"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "lag",
-			"TYPE": "bool",
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "hueShift",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.0
-		}
-	],
-	"PASSES": [
-		{
-			"TARGET":"buffer8",
-			"PERSISTENT": true,
-			"WIDTH": "$WIDTH/3.0",
-			"HEIGHT": "$HEIGHT/3.0"
-		},
-		{
-			"TARGET":"buffer7",
-			"PERSISTENT": true,
-			"WIDTH": "$WIDTH/3.0",
-			"HEIGHT": "$HEIGHT/3.0"
-		},
-		{
-			"TARGET":"buffer6",
-			"PERSISTENT": true,
-			"WIDTH": "$WIDTH/3.0",
-			"HEIGHT": "$HEIGHT/3.0"
-		},
-		{
-			"TARGET":"buffer5",
-			"PERSISTENT": true,
-			"WIDTH": "$WIDTH/3.0",
-			"HEIGHT": "$HEIGHT/3.0"
-		},
-		{
-			"TARGET":"buffer4",
-			"PERSISTENT": true,
-			"WIDTH": "$WIDTH/3.0",
-			"HEIGHT": "$HEIGHT/3.0"
-		},
-		{
-			"TARGET":"buffer3",
-			"PERSISTENT": true,
-			"WIDTH": "$WIDTH/3.0",
-			"HEIGHT": "$HEIGHT/3.0"
-		},
-		{
-			"TARGET":"buffer2",
-			"PERSISTENT": true,
-			"WIDTH": "$WIDTH/3.0",
-			"HEIGHT": "$HEIGHT/3.0"
-		},
-		{
-			"TARGET":"buffer1",
-			"PERSISTENT": true,
-			"WIDTH": "$WIDTH/3.0",
-			"HEIGHT": "$HEIGHT/3.0"
-		},
-		{
-		
-		}
-	]
-	
-}*/
-
-
-
-vec3 rgb2hsv(vec3 c)	{
-	vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-	//vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
-	//vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
-	vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
-	vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
-	
-	float d = q.x - min(q.w, q.y);
-	float e = 1.0e-10;
-	return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
-}
-
-vec3 hsv2rgb(vec3 c)	{
-	vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
-	vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
-	return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
-}
-
-
-
-void main()
-{
-	//	first pass: read the "buffer7" into "buffer8"
-	//	apply lag on each pass
-	if (PASSINDEX == 0)	{
-		if ((lag == false)||(mod(floor(TIME*60.0+5.0),6.0)<=1.0))	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer7);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer8);
-		}
-	}
-	else if (PASSINDEX == 1)	{
-		if ((lag == false)||(mod(floor(TIME*60.0+3.0),6.0)<=1.0))	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer6);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer7);
-		}
-	}
-	else if (PASSINDEX == 2)	{
-		if ((lag == false)||(mod(floor(TIME*60.0+2.0),6.0)<=1.0))	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer5);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer6);
-		}
-	}
-	else if (PASSINDEX == 3)	{
-		if ((lag == false)||(mod(floor(TIME*60.0+5.0),6.0)<=1.0))	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer4);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer5);
-		}
-	}
-	else if (PASSINDEX == 4)	{
-		if ((lag == false)||(mod(floor(TIME*60.0+1.0),6.0)<=1.0))	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer3);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer4);
-		}
-	}
-	else if (PASSINDEX == 5)	{
-		if ((lag == false)||(mod(floor(TIME*60.0+3.0),6.0)<=1.0))	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer2);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer3);
-		}
-	}
-	else if (PASSINDEX == 6)	{
-		if ((lag == false)||(mod(floor(TIME*60.0+5.0),6.0)<=1.0))	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer1);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer2);
-		}
-	}
-	else if (PASSINDEX == 7)	{
-		if ((lag == false)||(mod(floor(TIME*60.0+3.0),6.0)<=1.0))	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(inputImage);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer1);
-		}
-	}
-	else if (PASSINDEX == 8)	{
-		//	Figure out which section I'm in and draw the appropriate buffer there
-		vec2 tex = isf_FragNormCoord;
-		vec4 color = vec4(0.0);
-		//	TL – input
-		if (tex.y > 0.667)	{
-			if (tex.x < 0.333)	{
-				tex.x = tex.x * 3.0;
-				tex.y = (tex.y - 0.667) * 3.0;
-				color = IMG_NORM_PIXEL(inputImage, tex);
-			}
-			//	TM – buffer1
-			else if ((tex.x > 0.333) && (tex.x < 0.667))	{
-				tex.x = (tex.x - 0.333) * 3.0;
-				tex.y = (tex.y - 0.667) * 3.0;
-			
-				color = IMG_NORM_PIXEL(buffer1, tex);
-				color.rgb = rgb2hsv(color.rgb);
-				color.r = mod(color.r + 1.0 * hueShift, 1.0);
-				color.rgb = hsv2rgb(color.rgb);
-			}
-			//	TL – buffer2
-			else	{
-				tex.x = (tex.x - 0.667) * 3.0;
-				tex.y = (tex.y - 0.667) * 3.0;
-			
-				color = IMG_NORM_PIXEL(buffer2, tex);
-				color.rgb = rgb2hsv(color.rgb);
-				color.r = mod(color.r + 2.0 * hueShift, 1.0);
-				color.rgb = hsv2rgb(color.rgb);
-			}
-		}
-		//	BL - buffer3
-		else if (tex.y > 0.333)	{
-			if (tex.x < 0.333)	{
-				tex.x = tex.x * 3.0;
-				tex.y = (tex.y - 0.333) * 3.0;
-				color = IMG_NORM_PIXEL(buffer3, tex);
-				color.rgb = rgb2hsv(color.rgb);
-				color.r = mod(color.r + 3.0 * hueShift, 1.0);
-				color.rgb = hsv2rgb(color.rgb);
-			}
-			//	TM – buffer1
-			else if ((tex.x > 0.333) && (tex.x < 0.667))	{
-				tex.x = (tex.x - 0.333) * 3.0;
-				tex.y = (tex.y - 0.333) * 3.0;
-			
-				color = IMG_NORM_PIXEL(buffer4, tex);
-				color.rgb = rgb2hsv(color.rgb);
-				color.r = mod(color.r + 4.0 * hueShift, 1.0);
-				color.rgb = hsv2rgb(color.rgb);
-			}
-			//	TL – buffer2
-			else	{
-				tex.x = (tex.x - 0.667) * 3.0;
-				tex.y = (tex.y - 0.333) * 3.0;
-			
-				color = IMG_NORM_PIXEL(buffer5, tex);
-				color.rgb = rgb2hsv(color.rgb);
-				color.r = mod(color.r + 5.0 * hueShift, 1.0);
-				color.rgb = hsv2rgb(color.rgb);
-			}	
-		}
-		else	{
-			if (tex.x < 0.333)	{
-				tex.x = tex.x * 3.0;
-				tex.y = tex.y * 3.0;
-				color = IMG_NORM_PIXEL(buffer6, tex);
-				color.rgb = rgb2hsv(color.rgb);
-				color.r = mod(color.r + 6.0 * hueShift, 1.0);
-				color.rgb = hsv2rgb(color.rgb);
-			}
-			//	TM – buffer1
-			else if ((tex.x > 0.333) && (tex.x < 0.667))	{
-				tex.x = (tex.x - 0.333) * 3.0;
-				tex.y = tex.y * 3.0;
-			
-				color = IMG_NORM_PIXEL(buffer7, tex);
-				color.rgb = rgb2hsv(color.rgb);
-				color.r = mod(color.r + 7.0 * hueShift, 1.0);
-				color.rgb = hsv2rgb(color.rgb);
-			}
-			//	TL – buffer2
-			else	{
-				tex.x = (tex.x - 0.667) * 3.0;
-				tex.y = tex.y * 3.0;
-			
-				color = IMG_NORM_PIXEL(buffer8, tex);
-				color.rgb = rgb2hsv(color.rgb);
-				color.r = mod(color.r + 8.0 * hueShift, 1.0);
-				color.rgb = hsv2rgb(color.rgb);
-			}			
-		}
-		
-		gl_FragColor = color;
-	}
-}
diff --git a/nannou_isf/test_files/Multiply Blend.fs b/nannou_isf/test_files/Multiply Blend.fs
deleted file mode 100644
index 181ba0396..000000000
--- a/nannou_isf/test_files/Multiply Blend.fs	
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
-{
-  "ISFVSN" : "2",
-  "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/multiply_blend.glsl",
-  "DESCRIPTION": "",
-  "CATEGORIES" : [
-    "Dissolve"
-  ],
-  "INPUTS" : [
-    {
-      "NAME" : "startImage",
-      "TYPE" : "image"
-    },
-    {
-      "NAME" : "endImage",
-      "TYPE" : "image"
-    },
-    {
-      "MAX" : 1,
-      "DEFAULT" : 0,
-      "MIN" : 0,
-      "TYPE" : "float",
-      "NAME" : "progress"
-    }
-  ]
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: Fernando Kuteken
-// License: MIT
-
-vec4 blend(vec4 a, vec4 b) {
-  return a * b;
-}
-
-vec4 transition (vec2 uv) {
-  
-  vec4 blended = blend(getFromColor(uv), getToColor(uv));
-  
-  if (progress < 0.5)
-    return mix(getFromColor(uv), blended, 2.0 * progress);
-  else
-    return mix(blended, getToColor(uv), 2.0 * progress - 1.0);
-}
-
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Neon.fs b/nannou_isf/test_files/Neon.fs
deleted file mode 100644
index 3a564be59..000000000
--- a/nannou_isf/test_files/Neon.fs
+++ /dev/null
@@ -1,134 +0,0 @@
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"DESCRIPTION": "adapted from https://github.com/neilmendoza/ofxPostProcessing/blob/master/src/GodRaysPass.cpp",
-	"CATEGORIES": [
-		"Stylize"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "intensity",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 10.0,
-			"DEFAULT": 5.0
-		},
-		{
-			"NAME": "gain",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "neonColor",
-			"TYPE": "color",
-			"DEFAULT": [
-				1.0,
-				0.4,
-				0.64,
-				1.0
-			]
-		}
-	]
-}*/
-
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-in vec2 left_coord;
-in vec2 right_coord;
-in vec2 above_coord;
-in vec2 below_coord;
-
-in vec2 lefta_coord;
-in vec2 righta_coord;
-in vec2 leftb_coord;
-in vec2 rightb_coord;
-#endif
-
-
-float gray(vec4 n)
-{
-	return (n.r + n.g + n.b)/3.0;
-}
-
-
-void main(void)
-{
-
-	//	edges // rays // color
-	vec4 color = IMG_THIS_PIXEL(inputImage);
-	vec4 colorL = IMG_NORM_PIXEL(inputImage, left_coord);
-	vec4 colorR = IMG_NORM_PIXEL(inputImage, right_coord);
-	vec4 colorA = IMG_NORM_PIXEL(inputImage, above_coord);
-	vec4 colorB = IMG_NORM_PIXEL(inputImage, below_coord);
-
-	vec4 colorLA = IMG_NORM_PIXEL(inputImage, lefta_coord);
-	vec4 colorRA = IMG_NORM_PIXEL(inputImage, righta_coord);
-	vec4 colorLB = IMG_NORM_PIXEL(inputImage, leftb_coord);
-	vec4 colorRB = IMG_NORM_PIXEL(inputImage, rightb_coord);
-
-	float gx = (0.0);
-	float gy = (0.0);
-	gx = (-1.0 * gray(colorLA)) + (-1.0 * gray(colorL)) + (-1.0 * gray(colorLB)) + (1.0 * gray(colorRA)) + (1.0 * gray(colorR)) + (1.0 * gray(colorRB));
-	gy = (1.0 * gray(colorLA)) + (1.0 * gray(colorA)) + (1.0 * gray(colorRA)) + (-1.0 * gray(colorRB)) + (-1.0 * gray(colorB)) + (-1.0 * gray(colorLB));
-
-
-
-	float bright = pow(gx*gx + gy*gy,0.5);
-	vec4 final = color * bright;
-	
-	//	if the brightness is below the threshold draw black
-	if (bright < 0.01)	{
-		final = vec4(0.0);
-	}
-	else	{
-		final = final * intensity;
-	}
-	
-	gl_FragColor = final;
-
-	vec4 origColor = final;
-	vec4 raysColor = color;
-	int NUM_SAMPLES = 30;
-
-	float exposure	= 0.1/float(NUM_SAMPLES);
-	float decay		= 1.0 ;
-	float density	= 0.5;
-	float weight	= 6.0;
-	float illuminationDecay = 1.0;
-	vec2		normSrcCoord;
-
-	normSrcCoord.x = isf_FragNormCoord[0];
-	normSrcCoord.y = isf_FragNormCoord[1];
-
-	vec2 deltaTextCoord = vec2(normSrcCoord.st - 0.5);
-	vec2 textCoo = normSrcCoord;
-	deltaTextCoord *= 1.0 / float(NUM_SAMPLES) * density;
-
-	for(int i=0; i < NUM_SAMPLES ; i++)	{
-		textCoo -= deltaTextCoord;
-		vec4 tsample = IMG_NORM_PIXEL(inputImage, textCoo);
-		tsample *= illuminationDecay * weight;
-		raysColor += tsample;
-		illuminationDecay *= decay;
-	}
-	raysColor *= exposure * gain;
-	float p = 0.3 *raysColor.g + 0.59*raysColor.r + 0.11*raysColor.b;
-	
-	gl_FragColor = gray(origColor + p) * neonColor;
-	
-}
diff --git a/nannou_isf/test_files/Neon.vs b/nannou_isf/test_files/Neon.vs
deleted file mode 100644
index 215dd43d7..000000000
--- a/nannou_isf/test_files/Neon.vs
+++ /dev/null
@@ -1,40 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-out vec2 left_coord;
-out vec2 right_coord;
-out vec2 above_coord;
-out vec2 below_coord;
-
-out vec2 lefta_coord;
-out vec2 righta_coord;
-out vec2 leftb_coord;
-out vec2 rightb_coord;
-#endif
-
-
-void main()
-{
-	isf_vertShaderInit();
-	vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	vec2 d = 1.0/RENDERSIZE;
-	
-	left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
-	right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
-	above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
-	below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
-	
-	d = 1.0/RENDERSIZE;
-	lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
-	righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
-	leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
-	rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Night Vision.fs b/nannou_isf/test_files/Night Vision.fs
deleted file mode 100644
index 826cd2346..000000000
--- a/nannou_isf/test_files/Night Vision.fs	
+++ /dev/null
@@ -1,78 +0,0 @@
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Stylize"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "luminanceThreshold",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.2
-		},
-		{
-			"NAME": "colorAmplification",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 10.0,
-			"DEFAULT": 4.0
-		},
-		{
-			"NAME": "noiseLevel",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.1
-		},
-		{
-			"NAME": "visionColor",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.1,
-				0.95,
-				0.2,
-				1.0
-			]
-		}
-	],
-	"IMPORTED": {
-		"noiseTex": {
-			"PATH": "noise2d.png"
-		}
-	}
-}*/
-
-
-
-void main ()	{
-	vec2		normSrcCoord;
-
-	normSrcCoord.x = isf_FragNormCoord[0];
-	normSrcCoord.y = isf_FragNormCoord[1];
-	
-	vec4 finalColor;
-	
-	// Set effectCoverage to 1.0 for normal use.  
-
-	vec2 uv;           
-	uv.x = 0.4*sin(TIME*50.0);                                 
-	uv.y = 0.4*cos(TIME*50.0);                                 
-	vec3 n = IMG_NORM_PIXEL(noiseTex,mod(normSrcCoord.xy*3.5 + uv,1.0)).rgb;
-	vec3 c = IMG_THIS_PIXEL(inputImage).rgb + n.rgb * noiseLevel;
-	
-	const vec4 	lumacoeff = vec4(0.2126, 0.7152, 0.0722, 0.0);
-	float		lum = dot(vec4(c,1.), lumacoeff);
-	if (lum < luminanceThreshold)	{
-	  c *= colorAmplification; 
-	}
-	finalColor.rgb = (c + (n*0.2)) * visionColor.rgb;
-
-	gl_FragColor.rgb = finalColor.rgb;
-	gl_FragColor.a = 1.0;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Noise Adapt.fs b/nannou_isf/test_files/Noise Adapt.fs
deleted file mode 100644
index b4319c567..000000000
--- a/nannou_isf/test_files/Noise Adapt.fs	
+++ /dev/null
@@ -1,98 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Noise"
-    ],
-    "CREDIT": "by VIDVOX",
-    "DESCRIPTION": "Pixels that change become noise until they match the input again",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "adaptRate",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.05,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "threshold",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "NAME": "useRGBA",
-            "TYPE": "bool"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "PERSISTENT": true,
-            "TARGET": "adaptiveBuffer1"
-        },
-        {
-        }
-    ]
-}
-*/
-
-
-float	minThresh = 3.0/255.0;
-
-
-float rand(vec2 co){
-    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-float steppedRand(vec2 co){
-    return floor(256.0*rand(co))/255.0;
-}
-vec4 randColor(vec2 co){
-	vec4	c = vec4(0.0);
-	c.r = steppedRand(co+0.234);
-	c.g = steppedRand(co+0.193);
-	c.b = steppedRand(co+0.625);
-	c.a = 1.0;
-    return c;
-}
-
-float luma(vec4 c)	{
-	return c.a*(c.r+c.g+c.b)/3.0;	
-}
-
-
-void main()
-{
-	
-	vec4		freshPixel = IMG_PIXEL(inputImage,gl_FragCoord.xy);
-	vec4		stalePixel = IMG_PIXEL(adaptiveBuffer1,gl_FragCoord.xy);
-	if (useRGBA == false)	{
-		float		freshLuma = luma(freshPixel);
-		float		staleLuma = luma(stalePixel);
-		float		thresh = (threshold < minThresh) ? minThresh : threshold;
-		if (abs(freshLuma-staleLuma)>=thresh)	{
-			stalePixel = randColor(gl_FragCoord.xy+TIME);
-		}
-	}
-	else	{
-		float	thresh = (threshold < minThresh) ? minThresh : threshold;
-		if (abs(freshPixel.r-stalePixel.r)>=thresh)	{
-			stalePixel.r = steppedRand(gl_FragCoord.xy+TIME+1.234);
-		}
-		if (abs(freshPixel.g-stalePixel.g)>=thresh)	{
-			stalePixel.g = steppedRand(gl_FragCoord.xy+TIME+2.193);
-		}
-		if (abs(freshPixel.b-stalePixel.b)>=thresh)	{
-			stalePixel.b = steppedRand(gl_FragCoord.xy+TIME+3.625);
-		}
-		if (abs(freshPixel.a-stalePixel.a)>=thresh)	{
-			stalePixel.a = steppedRand(gl_FragCoord.xy+TIME+4.479);
-		}
-	}
-	gl_FragColor = mix(stalePixel,freshPixel,adaptRate);
-
-}
diff --git a/nannou_isf/test_files/Noise Displace.fs b/nannou_isf/test_files/Noise Displace.fs
deleted file mode 100644
index f5351a813..000000000
--- a/nannou_isf/test_files/Noise Displace.fs	
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Distortion Effect", "Noise"
-  ],
-  "DESCRIPTION" : "Displaces image randomly",
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "NAME" : "inputImage",
-      "TYPE" : "image"
-    },
-    {
-      "NAME" : "displaceX",
-      "TYPE" : "float",
-      "MAX" : 0.1,
-      "DEFAULT" : 0.0,
-      "MIN" : 0.0,
-      "LABEL" : "Displace X"
-    },
-    {
-      "NAME" : "displaceY",
-      "TYPE" : "float",
-      "MAX" : 0.1,
-      "DEFAULT" : 0.0,
-      "MIN" : 0.0,
-      "LABEL" : "Displace Y"
-    },
-    {
-      "NAME" : "detailX",
-      "TYPE" : "float",
-      "MAX" : 1.0,
-      "DEFAULT" : 0.1,
-      "MIN" : 0.0,
-      "LABEL" : "Detail X"
-    },
-    {
-      "NAME" : "detailY",
-      "TYPE" : "float",
-      "MAX" : 1.0,
-      "DEFAULT" : 0.1,
-      "MIN" : 0.0,
-      "LABEL" : "Detail Y"
-    },
-    {
-      "NAME" : "updateTime",
-      "TYPE" : "float",
-      "MAX" : 0.1,
-      "DEFAULT" : 0.01,
-      "MIN" : 0.0,
-      "LABEL" : "Frequency"
-    }
-  ],
-  "CREDIT" : "VIDVOX"
-}
-*/
-
-
-float rand(vec2 co){
-    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-void main()	{
-
-	vec4 inputPixelColor;
-	vec2 uv = isf_FragNormCoord.xy;
-	float wobbleTime = (updateTime == 0.0) ? TIME : floor(TIME/updateTime);
-	vec2 waveLoc = fract((uv)*vec2(detailX, detailY));
-	float val1 = rand(vec2(waveLoc.x, wobbleTime));
-	float val2 = rand(vec2(waveLoc.y, wobbleTime+1.0));
-	vec2 wave = vec2(val1, val2)-0.5;
-	wave *= vec2(displaceY, displaceX);
-
-	inputPixelColor = IMG_NORM_PIXEL(inputImage, uv + wave.yx);
-
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/Noise Pixellate.fs b/nannou_isf/test_files/Noise Pixellate.fs
deleted file mode 100644
index 6ad0e68d5..000000000
--- a/nannou_isf/test_files/Noise Pixellate.fs	
+++ /dev/null
@@ -1,120 +0,0 @@
-
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Stylize", "Noise"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "cell_size",
-			"TYPE": "float",
-			"MIN": 0.001,
-			"MAX": 0.5,
-			"DEFAULT": 0.025
-		},
-		{
-			"NAME": "sigGain",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.0
-		},
-		{
-			"NAME": "mode",
-			"VALUES": [
-				0,
-				1
-			],
-			"LABELS": [
-				"Multiply",
-				"Threshold"
-			],
-			"DEFAULT": 1,
-			"TYPE": "long"
-		},
-		{
-			"NAME": "shape",
-			"VALUES": [
-				0,
-				1
-			],
-			"LABELS": [
-				"Square",
-				"Rectangle"
-			],
-			"DEFAULT": 0,
-			"TYPE": "long"
-		}
-	]
-}*/
-
-#ifndef GL_ES
-float distance (vec2 center, vec2 pt)
-{
-	float tmp = pow(center.x-pt.x,2.0)+pow(center.y-pt.y,2.0);
-	return pow(tmp,0.5);
-}
-#endif
-
-float rand(vec2 co){
-    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-void main()
-{
-// CALCULATE EDGES OF CURRENT CELL
-	//	At 0.0 just do a pass-thru
-	if (cell_size == 0.0)	{
-		gl_FragColor = IMG_THIS_PIXEL(inputImage);
-	}
-	else	{
-		// Position of current pixel
-		vec2 xy; 
-		xy.x = isf_FragNormCoord[0];
-		xy.y = isf_FragNormCoord[1];
-
-
-		// Left and right of tile
-		float CellWidth = cell_size;
-		float CellHeight = cell_size;
-		if (shape==0)	{
-			CellHeight = cell_size * RENDERSIZE.x / RENDERSIZE.y;
-		}
-
-		float x1 = floor(xy.x / CellWidth)*CellWidth;
-		float x2 = clamp((ceil(xy.x / CellWidth)*CellWidth), 0.0, 1.0);
-		// Top and bottom of tile
-		float y1 = floor(xy.y / CellHeight)*CellHeight;
-		float y2 = clamp((ceil(xy.y / CellHeight)*CellHeight), 0.0, 1.0);
-
-		// GET AVERAGE CELL COLOUR
-		// Average left and right pixels
-		vec4 original = IMG_THIS_PIXEL(inputImage);
-		vec4 avgX = (IMG_NORM_PIXEL(inputImage, vec2(x1, y1))+(IMG_NORM_PIXEL(inputImage, vec2(x2, y1)))) / 2.0;
-		// Average top and bottom pixels
-		vec4 avgY = (IMG_NORM_PIXEL(inputImage, vec2(x1, y1))+(IMG_NORM_PIXEL(inputImage, vec2(x1, y2)))) / 2.0;
-		// Centre pixel
-		vec4 avgC = IMG_NORM_PIXEL(inputImage, vec2(x1+(CellWidth/2.0), y2+(CellHeight/2.0)));	// Average the averages + centre
-		vec4 avgClr = (avgX+avgY+avgC) / 3.0;
-		avgClr.a = original.a;
-		
-		float thresh = (avgClr.r + avgClr.g + avgClr.b) * avgClr.a / 3.0;
-		
-		if (mode == 0)	{
-			float rVal = (1.0 + sigGain) * rand(xy + thresh);
-			rVal = (rVal > 1.0) ? 1.0 : rVal;
-			avgClr.rgb *= rVal;
-		}
-		else if (mode == 1)	{
-			float rVal = rand(xy + thresh) / (1.0 + sigGain);
-			rVal = (rVal > 1.0) ? 1.0 : rVal;
-			avgClr = (thresh > rVal) ? avgClr : vec4(0.0,0.0,0.0,original.a);
-		}
-		gl_FragColor = avgClr;
-	}
-}
diff --git a/nannou_isf/test_files/Noise.fs b/nannou_isf/test_files/Noise.fs
deleted file mode 100644
index 3a1ffa7bc..000000000
--- a/nannou_isf/test_files/Noise.fs
+++ /dev/null
@@ -1,172 +0,0 @@
-
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Noise"
-	],
-	"INPUTS": [
-		{
-			"NAME": "seed",
-			"LABEL": "Random Seed",
-			"TYPE": "float",
-			"MIN": 0.01,
-			"MAX": 1.0,
-			"DEFAULT": 0.5
-		},
-		{
-			"NAME": "cell_size",
-			"LABEL": "Cell Size",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 0.5,
-			"DEFAULT": 0.125
-		},
-		{
-			"NAME": "threshold",
-			"LABEL": "Threshold",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.0
-		},
-		{
-			"NAME": "use_time",
-			"LABEL": "Animated",
-			"TYPE": "bool",
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "color_mode",
-			"LABEL": "Color Mode",
-			"TYPE": "long",
-			"VALUES": [
-				0,
-				1,
-				2,
-				3
-			],
-			"LABELS": [
-				"B&W",
-				"Alpha",
-				"RGB",
-				"RGBA"
-			],
-			"DEFAULT": 2
-		}
-	]
-}*/
-
-float rand(vec2 co){
-    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-void main()
-{
-// CALCULATE EDGES OF CURRENT CELL
-	float tmpSeed = seed;
-	if (use_time)	{
-		tmpSeed = max(mod(tmpSeed * TIME,1.0),0.01);
-	}
-	
-	//	if the size is 0.0 do this for every pixel
-	if (cell_size == 0.0)	{
-		vec4 outColor = vec4(0.0);
-		float translated = RENDERSIZE.x * isf_FragNormCoord[0] + isf_FragNormCoord[1];
-		float val = rand(vec2(translated, tmpSeed));
-		if (val >= threshold)	{
-			//	b&w
-			if (color_mode == 0)	{
-				outColor = vec4(1.0);
-			}
-			//	grayscale, use the alpha
-			else if (color_mode == 1)	{
-				outColor = vec4(1.0, 1.0, 1.0, val);
-			}
-			//	RGB
-			else if (color_mode == 2)	{
-				float rRand = rand(vec2(translated + 0.1542, tmpSeed));
-				float gRand = rand(vec2(translated + 0.0835, tmpSeed));
-				float bRand = rand(vec2(translated + 0.2547, tmpSeed));
-				outColor = vec4(rRand, gRand, bRand, 1.0);
-			}
-			//	RGBA
-			else if (color_mode == 3)	{
-				float rRand = rand(vec2(translated + 0.1542, tmpSeed));
-				float gRand = rand(vec2(translated + 0.0835, tmpSeed));
-				float bRand = rand(vec2(translated + 0.2547, tmpSeed));
-				outColor = vec4(rRand, gRand, bRand, val);
-			}
-		}
-		gl_FragColor = outColor;
-	}
-	else	{
-		// Position of current pixel
-		vec2 xy; 
-		xy.x = isf_FragNormCoord[0];
-		xy.y = isf_FragNormCoord[1];
-
-
-		// Left and right of tile
-		float CellWidth = cell_size;
-		float CellHeight = cell_size;
-		
-		
-		//	divide 1 by the cell width and cell height to determine the count
-		float rows = floor(1.0/CellHeight);
-		float cols = floor(1.0/CellWidth);
-		float count = floor(rows * cols);
-		
-		//	figure out the ID # of the region
-		float region = cols*floor(xy.x / CellWidth) + floor(xy.y / CellHeight);
-
-		//	use this to draw the gradient of the regions as gray colors..
-		//gl_FragColor = vec4(vec3(region/count),1.0);
-		
-		//	now translate this region to another random region using our seed and region
-		float translated = clamp(rand(vec2(region/count, tmpSeed)),0.0,1.0);
-		//translated = region/count;
-		//gl_FragColor = vec4(vec3(translated),1.0);
-		
-		//	quantize the translated!
-		translated = floor(count * translated);
-		//gl_FragColor = vec4(vec3(translated),1.0);
-		//	now convert the translated region back to an xy location
-		//	get the relative position within the original block and then add on the translated amount
-		xy.x = (xy.x - floor(xy.x / CellWidth)*CellWidth) + CellWidth * floor(translated / rows);
-		//xy.x = (xy.x - floor(xy.x / CellWidth)*CellWidth);
-		xy.y = xy.y - floor(xy.y / CellHeight)*CellHeight + CellHeight * floor(mod(translated , cols));
-		
-		float val = rand(vec2(translated, tmpSeed));
-		
-		vec4 outColor = vec4(0.0);
-		
-		if (val >= threshold)	{
-			//	b&w
-			if (color_mode == 0)	{
-				outColor = vec4(1.0);
-			}
-			//	grayscale, use the alpha
-			else if (color_mode == 1)	{
-				outColor = vec4(1.0, 1.0, 1.0, val);
-			}
-			//	RGB
-			else if (color_mode == 2)	{
-				float rRand = rand(vec2(translated + 0.1542, tmpSeed));
-				float gRand = rand(vec2(translated + 0.0835, tmpSeed));
-				float bRand = rand(vec2(translated + 0.2547, tmpSeed));
-				outColor = vec4(rRand, gRand, bRand, 1.0);
-			}
-			//	RGBA
-			else if (color_mode == 3)	{
-				float rRand = rand(vec2(translated + 0.1542, tmpSeed));
-				float gRand = rand(vec2(translated + 0.0835, tmpSeed));
-				float bRand = rand(vec2(translated + 0.2547, tmpSeed));
-				outColor = vec4(rRand, gRand, bRand, val);
-			}
-		}
-		
-		gl_FragColor = outColor;
-		
-	}
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Optical Flow Distort.fs b/nannou_isf/test_files/Optical Flow Distort.fs
deleted file mode 100644
index 98bc06c4e..000000000
--- a/nannou_isf/test_files/Optical Flow Distort.fs	
+++ /dev/null
@@ -1,209 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion Effect",
-        "Stylize"
-    ],
-    "CREDIT": "by VIDVOX, based on original implementation by Andrew Benson and v002",
-    "DESCRIPTION": "Uses an optical flow mask to create a distortion",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.5,
-            "LABEL": "Distortion Amount",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "amt",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.98,
-            "LABEL": "Flow Persistence",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "maskHold",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 2,
-            "LABEL": "Scale",
-            "MAX": 10,
-            "MIN": 0,
-            "NAME": "inputScale",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.1,
-            "LABEL": "Offset",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "inputOffset",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Noise Removal",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "inputLambda",
-            "TYPE": "float"
-        },
-        {
-            "LABEL": "Restart",
-            "NAME": "resetNow",
-            "TYPE": "event"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "PERSISTENT": true,
-            "TARGET": "maskBuffer"
-        },
-        {
-            "PERSISTENT": true,
-            "TARGET": "delayBuffer"
-        },
-        {
-        }
-    ]
-}
-*/
-
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-in vec2 left_coord;
-in vec2 right_coord;
-in vec2 above_coord;
-in vec2 below_coord;
-
-in vec2 lefta_coord;
-in vec2 righta_coord;
-in vec2 leftb_coord;
-in vec2 rightb_coord;
-#endif
-
-
-//	based on v002 Optical Flow which is itself a port of Andrew Bensons HS Flow implementation on the GPU.
-//	https://github.com/v002/v002-Optical-Flow
-
-
-const vec4 coeffs = vec4(0.2126, 0.7152, 0.0722, 1.0);
-
-float gray(vec4 n)
-{
-	return (n.r + n.g + n.b)/3.0;
-}
-
-void main()
-{
-	//	on the first pass generate the mask using the previous delayBuffer and inputImage
-	//	on the 2nd pass update the delayBuffer to hold inputImage
-	//	on the 3rd pass output the new mask
-	if (PASSINDEX == 0)	{
-		if ((FRAMEINDEX == 0)||(resetNow))	{
-			gl_FragColor = vec4(0.5);
-		}
-		else	{
-			//	convert to grayscale
-			vec4 a = IMG_THIS_PIXEL(inputImage) * coeffs;
-			float brightness = gray(a);
-			a = vec4(brightness);
-			vec4 b = IMG_THIS_PIXEL(delayBuffer) * coeffs;
-			brightness = gray(b);
-			b = vec4(brightness);
-		
-			vec2 x1 = vec2(inputOffset * RENDERSIZE.x, 0.0);
-			vec2 y1 = vec2(0.0,inputOffset * RENDERSIZE.y);
-			vec2 texcoord0 = isf_FragNormCoord.xy * RENDERSIZE;
-			vec2 texcoord1 = isf_FragNormCoord.xy * RENDERSIZE;
-		
-			//get the difference
-			vec4 curdif = b-a;
-	
-			//calculate the gradient
-			vec4 gradx = IMG_PIXEL(delayBuffer, texcoord1+x1)-IMG_PIXEL(delayBuffer, texcoord1-x1);
-			gradx += IMG_PIXEL(inputImage, texcoord0+x1)-IMG_PIXEL(inputImage, texcoord0-x1);
-		
-			vec4 grady = IMG_PIXEL(delayBuffer, texcoord1+y1)-IMG_PIXEL(delayBuffer, texcoord1-y1);
-			grady += IMG_PIXEL(inputImage, texcoord0+y1)-IMG_PIXEL(inputImage, texcoord0-y1);
-	
-			vec4 gradmag = sqrt((gradx*gradx)+(grady*grady)+vec4(inputLambda));
-
-			vec4 vx = curdif*(gradx/gradmag);
-			float vxd = gray(vx);//assumes greyscale
-			//format output for flowrepos, out(-x,+x,-y,+y)
-			vec2 xout = vec2(max(vxd,0.),abs(min(vxd,0.)))*inputScale;
-
-			vec4 vy = curdif*(grady/gradmag);
-			float vyd = gray(vy);//assumes greyscale
-			//format output for flowrepos, out(-x,+x,-y,+y)
-			vec2 yout = vec2(max(vyd,0.),abs(min(vyd,0.)))*inputScale;
-	
-			//gl_FragColor = clamp(vec4(xout.xy,yout.xy), 0.0, 1.0);
-		
-			vec4 mask = clamp(vec4(xout.xy,yout.xy), 0.0, 1.0);
-		
-			vec4 color = IMG_THIS_NORM_PIXEL(maskBuffer);
-			vec4 colorL = IMG_NORM_PIXEL(maskBuffer, left_coord);
-			vec4 colorR = IMG_NORM_PIXEL(maskBuffer, right_coord);
-			vec4 colorA = IMG_NORM_PIXEL(maskBuffer, above_coord);
-			vec4 colorB = IMG_NORM_PIXEL(maskBuffer, below_coord);
-
-			vec4 colorLA = IMG_NORM_PIXEL(maskBuffer, lefta_coord);
-			vec4 colorRA = IMG_NORM_PIXEL(maskBuffer, righta_coord);
-			vec4 colorLB = IMG_NORM_PIXEL(maskBuffer, leftb_coord);
-			vec4 colorRB = IMG_NORM_PIXEL(maskBuffer, rightb_coord);
-
-			//	blur then sharpen the feedback buffer
-			vec4 blurVector = (color + colorL + colorR + colorA + colorB + colorLA + colorRA + colorLB + colorRB) / 9.0;
-			gl_FragColor = mask + maskHold * blurVector;
-		}
-	}
-	else if (PASSINDEX == 1)	{	
-		//	here we just buffer the current frame for next TIME
-		gl_FragColor = IMG_THIS_PIXEL(inputImage);
-	}
-	else	{
-		//	NOW DO SOMETHING WITH THE MASK - BLUR THE IMAGE AND THE MASK IMAGE
-		
-		//	blur the mask image
-		vec2 texcoord0 = isf_FragNormCoord.xy;
-		
-		vec4 color = IMG_THIS_NORM_PIXEL(maskBuffer);
-		vec4 colorL = IMG_NORM_PIXEL(maskBuffer, left_coord);
-		vec4 colorR = IMG_NORM_PIXEL(maskBuffer, right_coord);
-		vec4 colorA = IMG_NORM_PIXEL(maskBuffer, above_coord);
-		vec4 colorB = IMG_NORM_PIXEL(maskBuffer, below_coord);
-
-		vec4 colorLA = IMG_NORM_PIXEL(maskBuffer, lefta_coord);
-		vec4 colorRA = IMG_NORM_PIXEL(maskBuffer, righta_coord);
-		vec4 colorLB = IMG_NORM_PIXEL(maskBuffer, leftb_coord);
-		vec4 colorRB = IMG_NORM_PIXEL(maskBuffer, rightb_coord);
-		
-		vec4 blurVector = (color + colorL + colorR + colorA + colorB + colorLA + colorRA + colorLB + colorRB) / 9.0;
-		//vec4 blurVector = IMG_THIS_PIXEL(maskBuffer);
-		
-		vec2 blurAmount = vec2(blurVector.y-blurVector.x, blurVector.w-blurVector.z);
-		vec2 tmp = texcoord0 + blurAmount * amt;
-		tmp.x = clamp(tmp.x,0.0,1.0);
-		tmp.y = clamp(tmp.y,0.0,1.0);
-		vec4 sample0 = IMG_NORM_PIXEL(inputImage, tmp);
-		tmp = (1.02 + texcoord0) + blurAmount * amt * amt;
-		tmp.x = clamp(tmp.x,0.0,1.0);
-		tmp.y = clamp(tmp.y,0.0,1.0);
-		vec4 sample1 = IMG_NORM_PIXEL(inputImage, tmp);
-		gl_FragColor = (sample0 * 3.0 + sample1) / 4.0;
-	}
-}
diff --git a/nannou_isf/test_files/Optical Flow Distort.vs b/nannou_isf/test_files/Optical Flow Distort.vs
deleted file mode 100644
index 7e661b605..000000000
--- a/nannou_isf/test_files/Optical Flow Distort.vs	
+++ /dev/null
@@ -1,39 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-out vec2 left_coord;
-out vec2 right_coord;
-out vec2 above_coord;
-out vec2 below_coord;
-
-out vec2 lefta_coord;
-out vec2 righta_coord;
-out vec2 leftb_coord;
-out vec2 rightb_coord;
-#endif
-
-
-void main()
-{
-	isf_vertShaderInit();
-	vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	vec2 d = 4.0/RENDERSIZE;
-
-	left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
-	right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
-	above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
-	below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
-
-	lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
-	righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
-	leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
-	rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Optical Flow Generator.fs b/nannou_isf/test_files/Optical Flow Generator.fs
deleted file mode 100644
index e6401b193..000000000
--- a/nannou_isf/test_files/Optical Flow Generator.fs	
+++ /dev/null
@@ -1,125 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Masking",
-        "Utility"
-    ],
-    "CREDIT": "by VIDVOX / v002 / Andrew Benson",
-    "DESCRIPTION": "Creates a raw optical flow mask from the input image",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 10,
-            "LABEL": "Scale",
-            "MAX": 50,
-            "MIN": 0,
-            "NAME": "inputScale",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.01,
-            "LABEL": "Offset",
-            "MAX": 0.5,
-            "MIN": 0,
-            "NAME": "inputOffset",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.2,
-            "LABEL": "Noise Removal",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "inputLambda",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "maskOpacity",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "TARGET": "maskBuffer"
-        },
-        {
-            "PERSISTENT": true,
-            "TARGET": "delayBuffer"
-        },
-        {
-        }
-    ]
-}
-*/
-
-
-//	based on v002 Optical Flow which is itself a port of Andrew Bensons HS Flow implementation on the GPU.
-//	https://github.com/v002/v002-Optical-Flow
-
-const vec4 coeffs = vec4(0.2126, 0.7152, 0.0722, 1.0);
-
-float gray(vec4 n)
-{
-	return (n.r + n.g + n.b)/3.0;
-}
-
-void main()
-{
-	//	on the first pass generate the mask using the previous delayBuffer and inputImage
-	//	on the 2nd pass update the delayBuffer to hold inputImage
-	//	on the 3rd pass output the new mask
-	if (PASSINDEX == 0)	{
-		//	convert to grayscale
-		vec4 a = IMG_THIS_PIXEL(inputImage) * coeffs;
-		float brightness = gray(a);
-		a = vec4(brightness);
-		vec4 b = IMG_THIS_PIXEL(delayBuffer) * coeffs;
-		brightness = gray(b);
-		b = vec4(brightness);
-		
-		vec2 x1 = vec2(inputOffset * RENDERSIZE.x, 0.0);
-		vec2 y1 = vec2(0.0,inputOffset * RENDERSIZE.y / 2.0);
-		vec2 texcoord0 = isf_FragNormCoord.xy * RENDERSIZE;
-		vec2 texcoord1 = isf_FragNormCoord.xy * RENDERSIZE;
-		
-		//get the difference
-		vec4 curdif = b-a;
-	
-		//calculate the gradient
-		vec4 gradx = IMG_PIXEL(delayBuffer, texcoord1+x1)-IMG_PIXEL(delayBuffer, texcoord1-x1);
-		gradx += IMG_PIXEL(inputImage, texcoord0+x1)-IMG_PIXEL(inputImage, texcoord0-x1);
-	
-		vec4 grady = IMG_PIXEL(delayBuffer, texcoord1+y1)-IMG_PIXEL(delayBuffer, texcoord1-y1);
-		grady += IMG_PIXEL(inputImage, texcoord0+y1)-IMG_PIXEL(inputImage, texcoord0-y1);
-	
-		vec4 gradmag = sqrt((gradx*gradx)+(grady*grady)+vec4(inputLambda));
-
-		vec4 vx = curdif*(gradx/gradmag);
-		float vxd = gray(vx);//assumes greyscale
-		//format output for flowrepos, out(-x,+x,-y,+y)
-		vec2 xout = vec2(max(vxd,0.),abs(min(vxd,0.)))*inputScale;
-
-		vec4 vy = curdif*(grady/gradmag);
-		float vyd = gray(vy);//assumes greyscale
-		//format output for flowrepos, out(-x,+x,-y,+y)
-		vec2 yout = vec2(max(vyd,0.),abs(min(vyd,0.)))*inputScale;
-	
-		vec4 mask = clamp(vec4(xout.xy,yout.xy), 0.0, 1.0);
-		gl_FragColor = mask;
-	}
-	else if (PASSINDEX == 1)	{
-		gl_FragColor = IMG_THIS_PIXEL(inputImage);
-	}
-	else	{
-		//	NOW DO SOMETHING WITH THE MASK
-		vec4 mask = IMG_THIS_NORM_PIXEL(maskBuffer);
-		//mask.a = 1.0;
-		mask.a = mix(mask.a, 1.0, maskOpacity);
-		gl_FragColor = mask;
-	}
-}
diff --git a/nannou_isf/test_files/Perlin Transition.fs b/nannou_isf/test_files/Perlin Transition.fs
deleted file mode 100644
index ad2810c70..000000000
--- a/nannou_isf/test_files/Perlin Transition.fs	
+++ /dev/null
@@ -1,126 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Wipe"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/perlin.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 12.9898,
-            "MAX": 100,
-            "MIN": 0,
-            "NAME": "seed",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.01,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "smoothness",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 4,
-            "MAX": 10,
-            "MIN": 0,
-            "NAME": "scale",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: Rich Harris
-// License: MIT
-
-#ifdef GL_ES
-precision mediump float;
-#endif
-
-
-
-// http://byteblacksmith.com/improvements-to-the-canonical-one-liner-glsl-rand-for-opengl-es-2-0/
-float random(vec2 co)
-{
-    highp float a = seed;
-    highp float b = 78.233;
-    highp float c = 43758.5453;
-    highp float dt= dot(co.xy ,vec2(a,b));
-    highp float sn= mod(dt,3.14);
-    return fract(sin(sn) * c);
-}
-
-// 2D Noise based on Morgan McGuire @morgan3d
-// https://www.shadertoy.com/view/4dS3Wd
-float noise (in vec2 st) {
-    vec2 i = floor(st);
-    vec2 f = fract(st);
-
-    // Four corners in 2D of a tile
-    float a = random(i);
-    float b = random(i + vec2(1.0, 0.0));
-    float c = random(i + vec2(0.0, 1.0));
-    float d = random(i + vec2(1.0, 1.0));
-
-    // Smooth Interpolation
-
-    // Cubic Hermine Curve.  Same as SmoothStep()
-    vec2 u = f*f*(3.0-2.0*f);
-    // u = smoothstep(0.,1.,f);
-
-    // Mix 4 coorners porcentages
-    return mix(a, b, u.x) +
-            (c - a)* u.y * (1.0 - u.x) +
-            (d - b) * u.x * u.y;
-}
-
-vec4 transition (vec2 uv) {
-  vec4 from = getFromColor(uv);
-  vec4 to = getToColor(uv);
-  float n = noise(uv * scale);
-  
-  float p = mix(-smoothness, 1.0 + smoothness, progress);
-  float lower = p - smoothness;
-  float higher = p + smoothness;
-  
-  float q = smoothstep(lower, higher, n);
-  
-  return mix(
-    from,
-    to,
-    1.0 - q
-  );
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Pinwheel.fs b/nannou_isf/test_files/Pinwheel.fs
deleted file mode 100644
index 62ea97e89..000000000
--- a/nannou_isf/test_files/Pinwheel.fs
+++ /dev/null
@@ -1,66 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Wipe"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/pinwheel.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 2,
-            "MAX": 10,
-            "MIN": 0,
-            "NAME": "speed",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: Mr Speaker
-// License: MIT
-
-
-vec4 transition(vec2 uv) {
-  
-  vec2 p = uv.xy / vec2(1.0).xy;
-  
-  float circPos = atan(p.y - 0.5, p.x - 0.5) + progress * speed;
-  float modPos = mod(circPos, 3.1415 / 4.);
-  float signed = sign(progress - modPos);
-  
-  return mix(getToColor(p), getFromColor(p), step(signed, 0.5));
-  
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Pixel Shifter.fs b/nannou_isf/test_files/Pixel Shifter.fs
deleted file mode 100644
index 141d129da..000000000
--- a/nannou_isf/test_files/Pixel Shifter.fs	
+++ /dev/null
@@ -1,114 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion Effect"
-    ],
-    "CREDIT": "by VIDVOX",
-    "DESCRIPTION": "Shifts pixels up and down",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Horizontal Phase",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "hPhase",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Horizontal Frequency",
-            "MAX": 16,
-            "MIN": -16,
-            "NAME": "hFrequency",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Horizontal Random",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "hRandom",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Vertical Phase",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "vPhase",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Vertical Frequency",
-            "MAX": 16,
-            "MIN": -16,
-            "NAME": "vFrequency",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Vertical Random",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "vRandom",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Sinusoidal",
-            "NAME": "doSin",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Mirror",
-            "NAME": "mirror",
-            "TYPE": "bool"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-float		PI_CONST = 3.14159265359;
-
-
-float rand(vec2 co){
-    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-
-void main()
-{
-	//	start with the pixel
-	vec2 loc = isf_FragNormCoord;
-	float modVal = 1.0;
-	
-	if (mirror)
-		modVal = 2.0;
-	
-	//	shift the loc.x by the frequency * loc.y + phase
-	if (doSin)
-		loc.x = mod(hRandom * rand(vec2(TIME * 0.127, loc.x)) + loc.x + sign(hFrequency) * 0.5 * (1.0+cos(2.0 * PI_CONST * (hPhase + hFrequency * loc.y))), modVal);
-	else
-		loc.x = mod(hRandom * rand(vec2(TIME * 0.129, loc.x)) + loc.x + hFrequency * loc.y + hPhase, modVal);
-
-	//	shift the loc.y by the frequency * loc.x + phase
-	if (doSin)
-		loc.y = mod(vRandom * rand(vec2(TIME * 0.273, loc.y)) + loc.y + sign(vFrequency) * 0.5 * (1.0+cos(2.0 * PI_CONST * (vPhase + vFrequency * loc.x))), modVal);
-	else
-		loc.y = mod(vRandom * rand(vec2(TIME * 0.341, loc.y)) +loc.y + vFrequency * loc.x + vPhase, modVal);
-		
-	if (loc.x > 1.0)
-		loc.x = 2.0 - loc.x;
-		
-	if (loc.y > 1.0)
-		loc.y = 2.0 - loc.y;
-	
-	gl_FragColor = IMG_NORM_PIXEL(inputImage,loc);
-}
diff --git a/nannou_isf/test_files/Pixelize.fs b/nannou_isf/test_files/Pixelize.fs
deleted file mode 100644
index 3c9233fab..000000000
--- a/nannou_isf/test_files/Pixelize.fs
+++ /dev/null
@@ -1,80 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/pixelize.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 50,
-            "MAX": 100,
-            "MIN": 0,
-            "NAME": "steps",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                20,
-                20
-            ],
-            "MAX": [
-                100,
-                100
-            ],
-            "MIN": [
-                1,
-                1
-            ],
-            "NAME": "squaresMin",
-            "TYPE": "point2D"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: gre
-// License: MIT
-// forked from https://gist.github.com/benraziel/c528607361d90a072e98
-
-
-float d = min(progress, 1.0 - progress);
-float dist = steps>0 ? ceil(d * float(steps)) / float(steps) : d;
-vec2 squareSize = 2.0 * dist / vec2(squaresMin);
-
-vec4 transition(vec2 uv) {
-  vec2 p = dist>0.0 ? (floor(uv / squareSize) + 0.5) * squareSize : uv;
-  return mix(getFromColor(p), getToColor(p), progress);
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Pixellate.fs b/nannou_isf/test_files/Pixellate.fs
deleted file mode 100644
index 039aed6d5..000000000
--- a/nannou_isf/test_files/Pixellate.fs
+++ /dev/null
@@ -1,82 +0,0 @@
-
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Stylize"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "cell_size",
-			"TYPE": "float",
-			"MIN": 0.001,
-			"MAX": 0.5,
-			"DEFAULT": 0.125
-		},
-		{
-			"NAME": "shape",
-			"VALUES": [
-				0,
-				1
-			],
-			"LABELS": [
-				"Square",
-				"Rectangle"
-			],
-			"DEFAULT": 0,
-			"TYPE": "long"
-		}
-	]
-}*/
-
-#ifndef GL_ES
-float distance (vec2 center, vec2 pt)
-{
-	float tmp = pow(center.x-pt.x,2.0)+pow(center.y-pt.y,2.0);
-	return pow(tmp,0.5);
-}
-#endif
-
-void main()
-{
-// CALCULATE EDGES OF CURRENT CELL
-	//	At 0.0 just do a pass-thru
-	if (cell_size == 0.0)	{
-		gl_FragColor = IMG_THIS_PIXEL(inputImage);
-	}
-		else	{
-		// Position of current pixel
-		vec2 xy; 
-		xy.x = isf_FragNormCoord[0];
-		xy.y = isf_FragNormCoord[1];
-
-
-		// Left and right of tile
-		float CellWidth = cell_size;
-		float CellHeight = cell_size;
-		if (shape==0)	{
-			CellHeight = cell_size * RENDERSIZE.x / RENDERSIZE.y;
-		}
-
-		float x1 = floor(xy.x / CellWidth)*CellWidth;
-		float x2 = clamp((ceil(xy.x / CellWidth)*CellWidth), 0.0, 1.0);
-		// Top and bottom of tile
-		float y1 = floor(xy.y / CellHeight)*CellHeight;
-		float y2 = clamp((ceil(xy.y / CellHeight)*CellHeight), 0.0, 1.0);
-
-		// GET AVERAGE CELL COLOUR
-		// Average left and right pixels
-		vec4 avgX = (IMG_NORM_PIXEL(inputImage, vec2(x1, y1))+(IMG_NORM_PIXEL(inputImage, vec2(x2, y1)))) / 2.0;
-		// Average top and bottom pixels
-		vec4 avgY = (IMG_NORM_PIXEL(inputImage, vec2(x1, y1))+(IMG_NORM_PIXEL(inputImage, vec2(x1, y2)))) / 2.0;
-		// Centre pixel
-		vec4 avgC = IMG_NORM_PIXEL(inputImage, vec2(x1+(CellWidth/2.0), y2+(CellHeight/2.0)));	// Average the averages + centre
-		vec4 avgClr = (avgX+avgY+avgC) / 3.0;
-
-		gl_FragColor = vec4(avgClr);
-	}
-}
diff --git a/nannou_isf/test_files/Polar Function.fs b/nannou_isf/test_files/Polar Function.fs
deleted file mode 100644
index d54ed99db..000000000
--- a/nannou_isf/test_files/Polar Function.fs	
+++ /dev/null
@@ -1,70 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Wipe"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/polar_function.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 5,
-            "MAX": 10,
-            "MIN": 0,
-            "NAME": "segments",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: Fernando Kuteken
-// License: MIT
-
-#define PI 3.14159265359
-
-
-vec4 transition (vec2 uv) {
-  
-  float angle = atan(uv.y - 0.5, uv.x - 0.5) - 0.5 * PI;
-  float normalized = (angle + 1.5 * PI) * (2.0 * PI);
-  
-  float radius = (cos(float(segments) * angle) + 4.0) / 4.0;
-  float difference = length(uv - vec2(0.5, 0.5));
-  
-  if (difference > radius * progress)
-    return getFromColor(uv);
-  else
-    return getToColor(uv);
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Polka Dots Curtain.fs b/nannou_isf/test_files/Polka Dots Curtain.fs
deleted file mode 100644
index ebb443cbc..000000000
--- a/nannou_isf/test_files/Polka Dots Curtain.fs	
+++ /dev/null
@@ -1,75 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Wipe"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/PolkaDotsCurtain.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 20,
-            "MAX": 100,
-            "MIN": 0,
-            "NAME": "dots",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "center",
-            "TYPE": "point2D"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// author: bobylito
-// license: MIT
-const float SQRT_2 = 1.414213562373;
-
-vec4 transition(vec2 uv) {
-  bool nextImage = distance(fract(uv * dots), vec2(0.5, 0.5)) < ( progress / distance(uv, center));
-  return nextImage ? getToColor(uv) : getFromColor(uv);
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Poly Glitch.fs b/nannou_isf/test_files/Poly Glitch.fs
deleted file mode 100644
index 7d6040f9b..000000000
--- a/nannou_isf/test_files/Poly Glitch.fs	
+++ /dev/null
@@ -1,169 +0,0 @@
-/*{
-	"CREDIT": "by VIDVOX",
-	"CATEGORIES": [
-		"Stylize", "Glitch"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "randomSeed",
-			"LABEL": "Random Seed",
-			"TYPE": "float",
-			"MIN": 0.01,
-			"MAX": 1.0,
-			"DEFAULT": 0.239
-		},
-		{
-			"NAME": "sizeSpread",
-			"LABEL": "Poly Size",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 0.25,
-			"DEFAULT": 0.025
-		},
-		{
-			"NAME": "sizeGain",
-			"LABEL": "Size Gain",
-			"TYPE": "float",
-			"MIN": 1.0,
-			"MAX": 2.0,
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "sampleMode",
-			"LABEL": "Sample Mode",
-			"VALUES": [
-				0,
-				1
-			],
-			"LABELS": [
-				"Single",
-				"Double"
-			],
-			"DEFAULT": 0,
-			"TYPE": "long"
-		}
-	]
-}*/
-
-
-const float MaxPointCount = 5.0;
-float divisions = 1.0 / sizeSpread;
-
-
-
-float rand(vec2 co){
-    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-float sign(vec2 p1, vec2 p2, vec2 p3)	{
-	return (p1.x - p3.x) * (p2.y - p3.y) - (p2.x - p3.x) * (p1.y - p3.y);
-}
-
-bool PointInTriangle(vec2 pt, vec2 v1, vec2 v2, vec2 v3)	{
-	bool b1, b2, b3;
-
-	b1 = sign(pt, v1, v2) < 0.0;
-	b2 = sign(pt, v2, v3) < 0.0;
-	b3 = sign(pt, v3, v1) < 0.0;
-
-	return ((b1 == b2) && (b2 == b3));
-}
-
-vec2 AvgPointForTriangle(vec2 p1, vec2 p2, vec2 p3)	{
-	return (p1 + p2 + p3) / 3.0;	
-}
-
-float AreaOfTriangle(vec2 p1, vec2 p2, vec2 p3)	{
-	return abs(p1.x*(p2.y-p3.y)+p2.x*(p3.y-p1.y)+p3.x*(p1.y-p2.y))/2.0;	
-}
-
-vec4 ColorForPtIndex(vec2 index1, vec2 index2, float sizeAmount, float theSeed, vec2 pt)	{
-	vec4	returnMe = vec4(0.0);
-	vec2	pt1, pt2, pt3;
-	vec2	offset1 = (index1 + divisions / 2.0) * sizeAmount + sizeAmount / 2.0;
-	vec2	offset2 = (index2 + divisions / 2.0) * sizeAmount + sizeAmount / 2.0;
-	float	adjustedSizeAmount = sizeAmount * sizeGain;
-	vec2	inPoint = pt + vec2(0.5);
-	
-	
-	pt1 = vec2(rand(vec2(theSeed+index1.x,2.187*theSeed+index1.x)),rand(vec2(theSeed+index1.y,0.823*theSeed+index1.y)));
-	pt2 = pt1 + vec2(rand(vec2(theSeed+index1.x,5.326*theSeed+index1.x)),rand(vec2(theSeed+index1.y,1.421*theSeed+index1.y)));
-	pt3 = pt1 - vec2(rand(vec2(theSeed+index2.x,1.935*theSeed+index2.x)),rand(vec2(theSeed+index2.y,3.177*theSeed+index2.y)));
-	
-	float	area = AreaOfTriangle(pt1,pt2,pt3);
-	
-	if (area < 0.5)	{
-		pt1 = 1.0 - pt1;
-		adjustedSizeAmount = adjustedSizeAmount * (2.5-area);
-	}
-	else if (area > 0.5)	{
-		//pt3 = 1.0-pt3;
-	}
-	
-	pt1 = clamp(pt1 * adjustedSizeAmount + offset1 - adjustedSizeAmount / 2.0,0.0,1.0);
-	pt2 = clamp(pt2 * adjustedSizeAmount + offset1 - adjustedSizeAmount / 2.0,0.0,1.0);
-	pt3 = clamp(pt3 * adjustedSizeAmount + offset2 - adjustedSizeAmount / 2.0,0.0,1.0);
-	
-	if(PointInTriangle(inPoint,pt1,pt2,pt3))	{
-		vec2	avgPt = AvgPointForTriangle(pt1,pt2,pt3);
-		returnMe = IMG_NORM_PIXEL(inputImage,avgPt);
-		if (sampleMode==1)	{
-			returnMe.a = 0.5;
-			returnMe.rgb = returnMe.rgb * returnMe.a;
-		}
-		else	{
-			returnMe.a = 1.0;
-		}
-	}
-	
-	return returnMe;
-}
-
-
-
-void main() {	
-	vec4		result = vec4(0.0);
-	vec2		thisPoint = vv_FragNormCoord - vec2(0.5);
-	float		inSpread = sizeSpread;
-	vec2		ptIndex = floor(thisPoint / inSpread);
-	vec4		original = IMG_THIS_NORM_PIXEL(inputImage);
-	float		pointCount = MaxPointCount + float(sampleMode);
-	
-	if (sizeSpread > 0.0)	{		
-		inSpread = sizeSpread * 1.0;
-		for (float i=0.0;i<pointCount;++i)	{
-			if (result.a>0.667)
-				break;
-			float	tmpSpread = inSpread;
-			if (result.a<=0.75)
-				result += ColorForPtIndex(ptIndex,ptIndex+vec2(1.0,0.0),tmpSpread,i+randomSeed,thisPoint);
-			if (result.a<=0.75)
-				result += ColorForPtIndex(ptIndex,ptIndex+vec2(-1.0,0.0),tmpSpread,i+randomSeed,thisPoint);
-			if (result.a<=0.75)
-				result += ColorForPtIndex(ptIndex,ptIndex+vec2(0.0,1.0),tmpSpread,i+randomSeed,thisPoint);
-			if (result.a<=0.75)
-				result += ColorForPtIndex(ptIndex,ptIndex+vec2(0.0,-1.0),tmpSpread,i+randomSeed,thisPoint);	
-			
-			if (result.a<=0.75)
-				result += ColorForPtIndex(ptIndex+vec2(-1.0,0.0),ptIndex,tmpSpread,i+randomSeed,thisPoint);
-			if (result.a<=0.75)
-				result += ColorForPtIndex(ptIndex+vec2(0.0,1.0),ptIndex,tmpSpread,i+randomSeed,thisPoint);
-			if (result.a<=0.75)
-				result += ColorForPtIndex(ptIndex+vec2(0.0,-1.0),ptIndex,tmpSpread,i+randomSeed,thisPoint);
-			if (result.a<=0.75)
-				result += ColorForPtIndex(ptIndex+vec2(1.0,0.0),ptIndex,tmpSpread,i+randomSeed,thisPoint);
-		}
-		if (result.a<1.0)
-			result += (2.0 - result.a) * ColorForPtIndex(ptIndex,ptIndex,inSpread,randomSeed,thisPoint);
-		if (sampleMode==0)
-			result.a = original.a;
-	}
-	else	{
-		result = original;
-	}
-	gl_FragColor = result;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Poly Star.fs b/nannou_isf/test_files/Poly Star.fs
deleted file mode 100644
index 2dea544cf..000000000
--- a/nannou_isf/test_files/Poly Star.fs	
+++ /dev/null
@@ -1,95 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Geometry"
-    ],
-    "CREDIT": "",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "DEFAULT": 5,
-            "LABEL": "Point Count",
-            "MAX": 20,
-            "MIN": 3,
-            "NAME": "pointCount",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 5,
-            "LABEL": "Buldge Amount",
-            "MAX": 10,
-            "MIN": 0,
-            "NAME": "buldge",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.1,
-            "LABEL": "Radius Inside",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "pointRadiusInside",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.1,
-            "LABEL": "Radius Outside",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "pointRadiusOutside",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Rotation",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "pointRotation",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                1,
-                1,
-                1,
-                1
-            ],
-            "LABEL": "Star Color",
-            "NAME": "starColor",
-            "TYPE": "color"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-float rand(vec2 co){
-    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-const float pi = 3.14159265359;
-
-void main()	{
-	vec4 inputPixelColor = vec4(0.0);
-	float angleInc = 1.0 / pointCount;
-	
-	vec2 loc = RENDERSIZE * isf_FragNormCoord;
-	//	'r' is the radius- the distance in pixels from 'loc' to the center of the rendering space
-	float r = distance(RENDERSIZE/2.0, loc);
-	r /= max(RENDERSIZE.x,RENDERSIZE.y);
-	//	'a' is the angle of the line segment from the center to loc is rotated
-	float a = atan ((loc.y-RENDERSIZE.y/2.0),(loc.x-RENDERSIZE.x/2.0));
-	a += pi;
-	a /= 2.0*pi;
-	a += pointRotation;
-	//	'at' is the angle time
-	float at = mod(a,angleInc) / angleInc;
-	//	'rd' is the radius at this angle for the shape 
-	float starness = 10.0 - buldge;
-	float rd = pointRadiusOutside * pow(at,starness) + pointRadiusInside;
-	inputPixelColor = (r < rd) ? starColor : vec4(0.0);
-	at = 1.0 - at;
-	rd = pointRadiusOutside * pow(at,starness) + pointRadiusInside;
-	inputPixelColor = (r < rd) ? starColor : inputPixelColor;
-	
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/Posterize.fs b/nannou_isf/test_files/Posterize.fs
deleted file mode 100644
index 26061595c..000000000
--- a/nannou_isf/test_files/Posterize.fs
+++ /dev/null
@@ -1,46 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Retro",
-        "Stylize",
-        "Color Effect"
-    ],
-    "CREDIT": "VIDVOX",
-    "DESCRIPTION": "Posterizes an image",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 1.25,
-            "LABEL": "Gamma",
-            "MAX": 2,
-            "MIN": 0.5,
-            "NAME": "gamma",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 6,
-            "LABEL": "Quality",
-            "MAX": 32,
-            "MIN": 3,
-            "NAME": "numColors",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-void main()	{
-	
-    vec4	c = IMG_THIS_PIXEL(inputImage);
-
- 	c.rgb = pow(c.rgb, vec3(gamma, gamma, gamma));
- 	c.rgb = c.rgb * numColors;
- 	c.rgb = floor(c.rgb);
- 	c.rgb = c.rgb / numColors;
- 	c.rgb = pow(c.rgb, vec3(1.0/gamma));
-
-	gl_FragColor = c;
-}
diff --git a/nannou_isf/test_files/Power Warp.fs b/nannou_isf/test_files/Power Warp.fs
deleted file mode 100644
index d00b2740f..000000000
--- a/nannou_isf/test_files/Power Warp.fs	
+++ /dev/null
@@ -1,109 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion Effect"
-    ],
-    "CREDIT": "",
-    "DESCRIPTION": "Power curves distortions with shifting",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 4,
-            "MIN": 0.25,
-            "NAME": "power_x",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 4,
-            "MIN": 0.25,
-            "NAME": "power_y",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "shift_x",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "shift_y",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "LABELS": [
-                "Style 1",
-                "Style 2"
-            ],
-            "NAME": "mode_x",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1
-            ]
-        },
-        {
-            "DEFAULT": 1,
-            "LABELS": [
-                "Style 1",
-                "Style 2"
-            ],
-            "NAME": "mode_y",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1
-            ]
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-const float pi = 3.14159265359;
-
-
-
-void main()	{
-	vec4		inputPixelColor;
-	vec2		pos = isf_FragNormCoord.xy;
-	
-	if (mode_x == 0)	{
-		pos.x = pow(pos.x, power_x);
-	}
-	else	{
-		if (pos.x > 0.5)
-			pos.x = 0.5 + pow(2.0*(pos.x - 0.5), power_x) / 2.0;
-		else	{
-			pos.x = pow(1.0 - 2.0*pos.x, power_x) / 2.0;
-			pos.x = 0.5 - pos.x;
-		}
-	}
-	pos.x = mod(pos.x + shift_x, 1.0);
-	
-	if (mode_y == 0)	{
-		pos.y = pow(pos.y, power_y);
-	}
-	else	{
-		if (pos.y > 0.5)
-			pos.y = 0.5 + pow(2.0*(pos.y - 0.5), power_y) / 2.0;
-		else	{
-			pos.y = pow(1.0 - 2.0*pos.y, power_y) / 2.0;
-			pos.y = 0.5 - pos.y;
-		}
-	}
-	pos.y = mod(pos.y + shift_y, 1.0);
-	
-	inputPixelColor = IMG_NORM_PIXEL(inputImage, pos);
-	
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/Quad Mask.fs b/nannou_isf/test_files/Quad Mask.fs
deleted file mode 100644
index f61a94fd8..000000000
--- a/nannou_isf/test_files/Quad Mask.fs	
+++ /dev/null
@@ -1,150 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Masking",
-        "Geometry Adjustment"
-    ],
-    "CREDIT": "",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0
-            ],
-            "LABEL": "Bottom left",
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "pt1",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": [
-                1,
-                0
-            ],
-            "LABEL": "Top left",
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "pt2",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": [
-                1,
-                1
-            ],
-            "LABEL": "Top right",
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "pt3",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": [
-                0,
-                1
-            ],
-            "LABEL": "Bottom right",
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "pt4",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Invert Mask",
-            "NAME": "invertMask",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Apply Mask",
-            "LABELS": [
-                "Apply Mask",
-                "Set Alpha",
-                "Show Mask"
-            ],
-            "NAME": "maskApplyMode",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1,
-                2
-            ]
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-float sign(vec2 p1, vec2 p2, vec2 p3)
-{
-	return (p1.x - p3.x) * (p2.y - p3.y) - (p2.x - p3.x) * (p1.y - p3.y);
-}
-
-bool PointInTriangle(vec2 pt, vec2 v1, vec2 v2, vec2 v3)
-{
-	bool b1, b2, b3;
-
-	b1 = sign(pt, v1, v2) < 0.0;
-	b2 = sign(pt, v2, v3) < 0.0;
-	b3 = sign(pt, v3, v1) < 0.0;
-
-	return ((b1 == b2) && (b2 == b3));
-}
-
-
-void main()	{
-	vec4		inputPixelColor = IMG_THIS_PIXEL(inputImage);
-	vec2		loc = isf_FragNormCoord;
-	bool		drawPixel =  false;
-
-	if ((PointInTriangle(loc,pt1,pt2,pt3))||(PointInTriangle(loc,pt1,pt4,pt3)))	{
-		drawPixel = true;
-	}
-	
-	if (invertMask)
-		drawPixel = !drawPixel;
-	
-	if (maskApplyMode == 0)	{
-		inputPixelColor = (drawPixel) ? inputPixelColor : vec4(0.0);
-	}
-	//	in this mode only the alpha is changed; the rgb remains intact and may still be visible if another filter adjusts the alpha again
-	else if (maskApplyMode == 1)	{
-		inputPixelColor.a = (drawPixel) ? inputPixelColor.a : 0.0;
-	}
-	else if (maskApplyMode == 2)	{
-		inputPixelColor = (drawPixel) ? vec4(1.0) : vec4(0.0);
-	}
-
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/Quad Tile.fs b/nannou_isf/test_files/Quad Tile.fs
deleted file mode 100644
index 655c68b77..000000000
--- a/nannou_isf/test_files/Quad Tile.fs	
+++ /dev/null
@@ -1,136 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Tile Effect"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 2,
-            "MIN": 0,
-            "NAME": "size",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "rotation",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "angle",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "slide1",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "slide2",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "shift",
-            "TYPE": "point2D"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-const float tau = 6.28318530718;
-
-
-vec2 pattern() {
-	float s = sin(tau * rotation);
-	float c = cos(tau * rotation);
-	vec2 tex = isf_FragNormCoord * RENDERSIZE;
-	float scale = 1.0 / max(size,0.001);
-	vec2 point = vec2( c * tex.x - s * tex.y, s * tex.x + c * tex.y ) * scale;
-	point = (point - shift*RENDERSIZE) / RENDERSIZE;
-	//	do this to repeat
-	point = mod(point,1.0);
-	if (point.x < 0.5)	{
-		point.y = mod(point.y + slide1.y, 1.0);
-	}
-	else	{
-		point.y = mod(point.y + slide2.y, 1.0);
-	}
-	if (point.y < 0.5)	{
-		point.x = mod(point.x + slide1.x, 1.0);
-	}
-	else	{
-		point.x = mod(point.x + slide2.x, 1.0);
-	}
-	//	do this for relections
-	point = 1.0-abs(1.0-2.0*point);
-	
-	//	Now let's do a squish based on angle
-	//	convert to polar coordinates
-	vec2 center = vec2(0.5,0.5);
-	float r = distance(center, point);
-	float a = atan ((point.y-center.y),(point.x-center.x));
-	
-	s = sin(a + tau * angle);
-	c = cos(a + tau * angle);
-	
-	float zoom = RENDERSIZE.x / RENDERSIZE.y;
-	
-	point.x = (r * c)/zoom + 0.5;
-	point.y = (r * s)/zoom + 0.5;
-	
-	return point;
-}
-
-
-void main() {
-
-	vec2 pat = pattern();
-
-	gl_FragColor = IMG_NORM_PIXEL(inputImage,pat);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/RE RGB Gradient Generator.fs b/nannou_isf/test_files/RE RGB Gradient Generator.fs
deleted file mode 100644
index 53d2ab2ae..000000000
--- a/nannou_isf/test_files/RE RGB Gradient Generator.fs	
+++ /dev/null
@@ -1,344 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Color",
-        "Utility"
-    ],
-    "CREDIT": "by Carter Rosenberg",
-    "INPUTS": [
-        {
-            "NAME": "lookupImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 16,
-            "MIN": 0.5,
-            "NAME": "frequency1",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "phase1",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 2,
-            "MIN": -2,
-            "NAME": "amplitude1",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": -1,
-            "NAME": "offset1",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "angle1",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABELS": [
-                "Ramp",
-                "Triangle",
-                "Sine",
-                "Exponential",
-                "Look Up Table"
-            ],
-            "NAME": "curve1",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1,
-                2,
-                3,
-                4
-            ]
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 1,
-            "MIN": -1,
-            "NAME": "mixLevel1",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0,
-                0,
-                1
-            ],
-            "NAME": "startColor1",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": [
-                1,
-                0,
-                0,
-                1
-            ],
-            "NAME": "endColor1",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 16,
-            "MIN": 0.5,
-            "NAME": "frequency2",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "phase2",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 2,
-            "MIN": -2,
-            "NAME": "amplitude2",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": -1,
-            "NAME": "offset2",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.75,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "angle2",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABELS": [
-                "Ramp",
-                "Triangle",
-                "Sine",
-                "Exponential",
-                "Look Up Table"
-            ],
-            "NAME": "curve2",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1,
-                2,
-                3,
-                4
-            ]
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 1,
-            "MIN": -1,
-            "NAME": "mixLevel2",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0,
-                0,
-                1
-            ],
-            "NAME": "startColor2",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": [
-                0,
-                1,
-                0,
-                1
-            ],
-            "NAME": "endColor2",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": 2,
-            "MAX": 16,
-            "MIN": 0.5,
-            "NAME": "frequency3",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "phase3",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 2,
-            "MIN": -2,
-            "NAME": "amplitude3",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": -1,
-            "NAME": "offset3",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "angle3",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABELS": [
-                "Ramp",
-                "Triangle",
-                "Sine",
-                "Exponential",
-                "Look Up Table"
-            ],
-            "NAME": "curve3",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1,
-                2,
-                3,
-                4
-            ]
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 1,
-            "MIN": -1,
-            "NAME": "mixLevel3",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0,
-                0,
-                1
-            ],
-            "NAME": "startColor3",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0,
-                1,
-                1
-            ],
-            "NAME": "endColor3",
-            "TYPE": "color"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "FLOAT": true
-        }
-    ]
-}
-*/
-
-
-
-const float pi = 3.14159265359;
-const float e = 2.71828182846;
-
-
-float doMath(int curve, float freq, float phase, float val, vec2 pt)	{
-	float	returnMe = phase + freq * val;
-
-	if (curve == 0)	{
-		returnMe = mod(returnMe,1.0);
-	}
-	else if (curve == 1)	{
-		returnMe = mod(2.0 * returnMe,2.0);
-		returnMe = (returnMe < 1.0) ? returnMe : 1.0 - (returnMe - floor(returnMe));
-	}
-	else if (curve == 2)	{
-		returnMe = sin(returnMe * pi * 2.0 - pi / 2.0) * 0.5 + 0.5;
-	}
-	else if (curve == 3)	{
-		returnMe = mod(2.0 * returnMe, 2.0);
-		returnMe = (returnMe < 1.0) ? returnMe : 1.0 - (returnMe - floor(returnMe));
-		returnMe = pow(returnMe, 2.0);
-	}
-	else if (curve == 4)	{
-		vec2	loc = mod(pt * freq + phase,1.0);
-		vec4	tmp = IMG_NORM_PIXEL(lookupImage,loc);
-		returnMe = (tmp.r+tmp.g+tmp.b)*tmp.a/3.0;
-	}
-	return returnMe;	
-}
-
-//	note that this works on normalized points, but respects aspect ratio
-vec2 rotatePoint(vec2 pt, float angle)	{
-	vec2 returnMe = pt * RENDERSIZE;;
-
-	float r = distance(RENDERSIZE/2.0, returnMe);
-	float a = atan ((returnMe.y-RENDERSIZE.y/2.0),(returnMe.x-RENDERSIZE.x/2.0));
-
-	returnMe.x = r * cos(a + 2.0 * pi * angle - pi) + 0.5;
-	returnMe.y = r * sin(a + 2.0 * pi * angle - pi) + 0.5;
-	
-	returnMe = returnMe / RENDERSIZE + vec2(0.5);
-	
-	return returnMe;
-}
-
-
-void main() {
-	vec4 returnMe = vec4(0.0);
-	vec4 blendColor = vec4(0.0);
-	float mixAmount = 0.0;
-	vec2 loc = isf_FragNormCoord;
-
-	loc = rotatePoint(isf_FragNormCoord,angle1);
-	mixAmount = doMath(curve1,frequency1,phase1,1.0-loc.x,loc);
-	mixAmount = (amplitude1 >= 0.0) ? mixAmount * amplitude1 : (1.0 - mixAmount) * abs(amplitude1);
-	mixAmount += offset1;
-	blendColor = mix(startColor1,endColor1,mixAmount);
-	returnMe.rgb += blendColor.rgb * mixLevel1;
-	returnMe.a += abs(blendColor.a);
-	
-	loc = rotatePoint(isf_FragNormCoord,angle2);
-	mixAmount = doMath(curve2,frequency2,phase2,1.0-loc.x,loc);
-	mixAmount = (amplitude2 >= 0.0) ? mixAmount * amplitude2 : (1.0 - mixAmount) * abs(amplitude2);
-	mixAmount += offset2;
-	blendColor = mix(startColor2,endColor2,mixAmount);
-	returnMe.rgb += blendColor.rgb  * mixLevel2;
-	returnMe.a += abs(blendColor.a);
-	
-	loc = rotatePoint(isf_FragNormCoord,angle3);
-	mixAmount = doMath(curve3,frequency3,phase3,1.0-loc.x,loc);
-	mixAmount = (amplitude3 >= 0.0) ? mixAmount * amplitude3 : (1.0 - mixAmount) * abs(amplitude3);
-	mixAmount += offset3;
-	blendColor = mix(startColor3,endColor3,mixAmount);
-	returnMe.rgb += blendColor.rgb  * mixLevel3;
-	returnMe.a += abs(blendColor.a);
-	
-	gl_FragColor = returnMe;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/README.md b/nannou_isf/test_files/README.md
deleted file mode 100644
index ea4d69f05..000000000
--- a/nannou_isf/test_files/README.md
+++ /dev/null
@@ -1,6 +0,0 @@
-These test files have been sourced from the following site:
-
-https://www.interactiveshaderformat.com/spec
-
-They have been included within this repo with permission from the founders of
-the ISF specification.
diff --git a/nannou_isf/test_files/RGB EQ.fs b/nannou_isf/test_files/RGB EQ.fs
deleted file mode 100644
index 451af11f8..000000000
--- a/nannou_isf/test_files/RGB EQ.fs	
+++ /dev/null
@@ -1,61 +0,0 @@
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Color Adjustment"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "red",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 2.0,
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "green",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 2.0,
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "blue",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 2.0,
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "gain",
-			"TYPE": "float",
-			"MIN": -1.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.0
-		}
-	]
-}*/
-
-
-
-
-void main() {
-	vec4	pixel = IMG_THIS_PIXEL(inputImage);	
-	float	brightness = (pixel.r * red + pixel.g * green + pixel.b * blue) / 3.0;
-	
-	pixel.r = pixel.r * red;
-	pixel.g = pixel.g * green;
-	pixel.b = pixel.b * blue;
-
-	if (gain >= 0.0)	{
-		pixel.a = (brightness >= gain) ? pixel.a : 0.0;
-	}
-	else	{
-		pixel.a = (brightness <= 1.0-abs(gain)) ? pixel.a : 0.0;
-	}
-	gl_FragColor = pixel;
-}
diff --git a/nannou_isf/test_files/RGB Halftone-lookaround.fs b/nannou_isf/test_files/RGB Halftone-lookaround.fs
deleted file mode 100644
index 211bca344..000000000
--- a/nannou_isf/test_files/RGB Halftone-lookaround.fs	
+++ /dev/null
@@ -1,110 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Halftone Effect",
-        "Retro"
-    ],
-    "CREDIT": "by zoidberg",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 45,
-            "MAX": 256,
-            "MIN": 1,
-            "NAME": "gridSize",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.15,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "smoothing",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-vec4		gridRot = vec4(15.0, 45.0, 75.0, 0.0);
-//vec4		gridRot = vec4(15.0, 75.0, 0.0, 45.0);
-//vec4		gridRot = vec4(0.0, 0.0, 0.0, 0.0);
-
-
-
-//	during calculation we find the closest dot to a frag, determine its size, and then determine the size of the four dots above/below/right/left of it. this array of offsets move "one left", "one up", "one right", and "one down"...
-vec2		originOffsets[4];
-
-
-
-void main() {
-	//	a halftone is an overlapping series of grids of dots
-	//	each grid of dots is rotated by a different amount
-	//	the size of the dots determines the colors. the shape of the dot should never change (always be a dot with regular edges)
-	originOffsets[0] = vec2(-1.0, 0.0);
-	originOffsets[1] = vec2(0.0, 1.0);
-	originOffsets[2] = vec2(1.0, 0.0);
-	originOffsets[3] = vec2(0.0, -1.0);
-	
-	vec3		rgbAmounts = vec3(0.0);
-	int i;
-	int j;
-	//	for each of the channels (i) of RGB...
-	for (i=0; i<3; ++i)	{
-		//	figure out the rotation of the grid in radians
-		float		rotRad = radians(gridRot[i]);
-		//	the grids are rotated counter-clockwise- to find the nearest dot, take the fragment pixel loc, 
-		//	rotate it clockwise, and split by the grid to find the center of the dot. then rotate this 
-		//	coord counter-clockwise to yield the location of the center of the dot in pixel coords local to the render space
-		mat2		ccTrans = mat2(vec2(cos(rotRad), sin(rotRad)), vec2(-1.0*sin(rotRad), cos(rotRad)));
-		mat2		cTrans = mat2(vec2(cos(rotRad), -1.0*sin(rotRad)), vec2(sin(rotRad), cos(rotRad)));
-		
-		//	find the location of the frag in the grid (prior to rotating it)
-		vec2		gridFragLoc = cTrans * gl_FragCoord.xy;
-		//	find the center of the dot closest to the frag- there's no "round" in GLSL 1.2, so do a "floor" to find the dot to the bottom-left of the frag, then figure out if the frag would be in the top and right halves of that square to find the closest dot to the frag
-		vec2		gridOriginLoc = vec2(floor(gridFragLoc.x/gridSize), floor(gridFragLoc.y/gridSize));
-		
-		vec2		tmpGridCoords = gridFragLoc/vec2(gridSize);
-		bool		fragAtTopOfGrid = ((tmpGridCoords.y-floor(tmpGridCoords.y)) > (gridSize/2.0)) ? true : false;
-		bool		fragAtRightOfGrid = ((tmpGridCoords.x-floor(tmpGridCoords.x)) > (gridSize/2.0)) ? true : false;
-		if (fragAtTopOfGrid)
-			gridOriginLoc.y = gridOriginLoc.y + 1.0;
-		if (fragAtRightOfGrid)
-			gridOriginLoc.x = gridOriginLoc.x + 1.0;
-		//	...at this point, "gridOriginLoc" contains the grid coords of the nearest dot to the fragment being rendered
-		//	convert the location of the center of the dot from grid coords to pixel coords
-		vec2		gridDotLoc = vec2(gridOriginLoc.x*gridSize, gridOriginLoc.y*gridSize) + vec2(gridSize/2.0);
-		//	rotate the pixel coords of the center of the dot so they become relative to the rendering space
-		vec2		renderDotLoc = ccTrans * gridDotLoc;
-		//	get the color of the pixel of the input image under this dot (the color will ultimately determine the size of the dot)
-		vec4		renderDotImageColorRGB = IMG_PIXEL(inputImage, renderDotLoc);
-		
-		
-		//	the amount of this channel is taken from the same channel of the color of the pixel of the input image under this halftone dot
-		float		imageChannelAmount = renderDotImageColorRGB[i];
-		//	the size of the dot is determined by the value of the channel
-		float		dotRadius = imageChannelAmount * (gridSize*1.50/2.0);
-		float		fragDistanceToDotCenter = distance(gl_FragCoord.xy, renderDotLoc);
-		if (fragDistanceToDotCenter < dotRadius)	{
-			rgbAmounts[i] += smoothstep(dotRadius, dotRadius-(dotRadius*smoothing), fragDistanceToDotCenter);
-		}
-		
-		//	calcluate the size of the dots abov/below/to the left/right to see if they're overlapping
-		for (j=0; j<4; ++j)	{
-			gridDotLoc = vec2((gridOriginLoc.x+originOffsets[j].x)*gridSize, (gridOriginLoc.y+originOffsets[j].y)*gridSize) + vec2(gridSize/2.0);
-			renderDotLoc = ccTrans * gridDotLoc;
-			renderDotImageColorRGB = IMG_PIXEL(inputImage, renderDotLoc);
-			
-			imageChannelAmount = renderDotImageColorRGB[i];
-			dotRadius = imageChannelAmount * (gridSize*1.50/2.0);
-			fragDistanceToDotCenter = distance(gl_FragCoord.xy, renderDotLoc);
-			if (fragDistanceToDotCenter < dotRadius)	{
-				rgbAmounts[i] += smoothstep(dotRadius, dotRadius-(dotRadius*smoothing), fragDistanceToDotCenter);
-			}
-		}
-	}
-	
-	gl_FragColor = vec4(rgbAmounts[0], rgbAmounts[1], rgbAmounts[2], 1.0);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/RGB Halftone.fs b/nannou_isf/test_files/RGB Halftone.fs
deleted file mode 100644
index 2bacf4bb1..000000000
--- a/nannou_isf/test_files/RGB Halftone.fs	
+++ /dev/null
@@ -1,67 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Halftone Effect",
-        "Retro"
-    ],
-    "CREDIT": "by zoidberg",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 45,
-            "MAX": 256,
-            "MIN": 1,
-            "NAME": "gridSize",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.15,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "smoothing",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-vec3		gridRot = vec3(15.0, 45.0, 75.0);
-
-void main() {
-	//	a halftone is an overlapping series of grids of dots
-	//	each grid of dots is rotated by a different amount
-	//	the size of the dots determines the colors. the shape of the dot should never change (always be a dot with regular edges)
-	
-	vec4		rgbaAmounts = vec4(0.0);
-	
-	//	for each of the channels (i) of RGB...
-	for (int i=0; i<3; ++i)	{
-		//	figure out the rotation of the grid in radians
-		float		rotRad = radians(gridRot[i]);
-		//	the grids are rotated counter-clockwise- to find the nearest dot, take the fragment pixel loc, 
-		//	rotate it clockwise, and split by the grid to find the center of the dot. then rotate this 
-		//	coord counter-clockwise to yield the location of the center of the dot in pixel coords local to the render space
-		mat2		ccTrans = mat2(vec2(cos(rotRad), sin(rotRad)), vec2(-1.0*sin(rotRad), cos(rotRad)));
-		mat2		cTrans = mat2(vec2(cos(rotRad), -1.0*sin(rotRad)), vec2(sin(rotRad), cos(rotRad)));
-		
-		//	render loc -> grid loc -> grid dot loc -> grid dot loc in render coords -> pixel color under grid dot loc
-		vec2		gridFragLoc = cTrans * gl_FragCoord.xy;
-		vec2		gridDotLoc = vec2(floor(gridFragLoc.x/gridSize)*gridSize, floor(gridFragLoc.y/gridSize)*gridSize);
-		gridDotLoc = gridDotLoc + vec2(gridSize/2.0);
-		vec2		renderDotLoc = ccTrans * gridDotLoc;
-		vec4		renderDotImageColorRGB = IMG_PIXEL(inputImage, renderDotLoc);
-		
-		float		channelAmount = renderDotImageColorRGB[i];
-		float		dotRadius = channelAmount * (gridSize/2.0);
-		float		fragDistanceToGridCenter = distance(gl_FragCoord.xy, renderDotLoc);
-		//	the amount of the channel depends on the distance to the center of the grid, the size of the dot, and smoothing
-		float		smoothDist = smoothing * (gridSize/6.0);
-		rgbaAmounts[i] += smoothstep(dotRadius, dotRadius-(dotRadius*smoothing), fragDistanceToGridCenter);
-	}
-	
-	rgbaAmounts.a = 1.0;
-	gl_FragColor = rgbaAmounts;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/RGB Invert.fs b/nannou_isf/test_files/RGB Invert.fs
deleted file mode 100644
index b3144c0ce..000000000
--- a/nannou_isf/test_files/RGB Invert.fs	
+++ /dev/null
@@ -1,48 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Color Effect",
-        "Utility"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 1,
-            "NAME": "r",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 1,
-            "NAME": "g",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 1,
-            "NAME": "b",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 0,
-            "NAME": "a",
-            "TYPE": "bool"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-void main() {
-	vec4		srcPixel = IMG_THIS_PIXEL(inputImage);
-	if (r)
-		srcPixel.r = 1.0-srcPixel.r;
-	if (g)
-		srcPixel.g = 1.0-srcPixel.g;
-	if (b)
-		srcPixel.b = 1.0-srcPixel.b;
-	if (a)
-		srcPixel.a = 1.0-srcPixel.a;
-	gl_FragColor = srcPixel;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/RGB Strobe.fs b/nannou_isf/test_files/RGB Strobe.fs
deleted file mode 100644
index aa54c22f8..000000000
--- a/nannou_isf/test_files/RGB Strobe.fs	
+++ /dev/null
@@ -1,108 +0,0 @@
-/*{
-	"DESCRIPTION": "",
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Color Effect"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "r",
-			"TYPE": "bool",
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "g",
-			"TYPE": "bool",
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "b",
-			"TYPE": "bool",
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "a",
-			"TYPE": "bool",
-			"DEFAULT": 0.0
-		},
-		{
-			"NAME": "strobeRates",
-			"LABEL": "Strobe Rates",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.0,
-				0.0,
-				0.0,
-				0.0
-			]
-		}
-	],
-	"PASSES": [
-		{
-			"TARGET":"lastState",
-			"WIDTH": "1",
-			"HEIGHT": "1",
-			"PERSISTENT": true,
-			"DESCRIPTION": "Stores the current strobe state of each of the color channels."
-		},
-		{
-			
-		}
-	]
-	
-}*/
-
-
-
-void main()
-{
-	//	if this is the first pass, i'm going to read the position from the "lastPosition" image, and write a new position based on this and the hold variables
-	if (PASSINDEX == 0)	{
-		vec4		srcPixel = IMG_PIXEL(lastState,vec2(0.5));
-		//	i'm only using the X, which is the last render time we reset
-		if (strobeRates.r == 0.0)	{
-			srcPixel.r = (srcPixel.r == 0.0) ? 1.0 : 0.0;
-		}
-		else	{
-			srcPixel.r = (mod(TIME, strobeRates.r) <= strobeRates.r / 2.0) ? 1.0 : 0.0;
-		}
-		if (strobeRates.g == 0.0)	{
-			srcPixel.g = (srcPixel.g == 0.0) ? 1.0 : 0.0;
-		}
-		else	{
-			srcPixel.g = (mod(TIME, strobeRates.g) <= strobeRates.g / 2.0) ? 1.0 : 0.0;
-		}
-		if (strobeRates.b == 0.0)	{
-			srcPixel.b = (srcPixel.b == 0.0) ? 1.0 : 0.0;
-		}
-		else	{
-			srcPixel.b = (mod(TIME, strobeRates.b) <= strobeRates.b / 2.0) ? 1.0 : 0.0;
-		}
-		if (strobeRates.a == 0.0)	{
-			srcPixel.a = (srcPixel.a == 0.0) ? 1.0 : 0.0;
-		}
-		else	{
-			srcPixel.a = (mod(TIME, strobeRates.a) <= strobeRates.a / 2.0) ? 1.0 : 0.0;
-		}
-		gl_FragColor = srcPixel;
-	}
-	//	else this isn't the first pass- read the position value from the buffer which stores it
-	else	{
-		vec4 lastStateVector = IMG_PIXEL(lastState,vec2(0.5));
-		vec4 srcPixel = IMG_THIS_PIXEL(inputImage);
-		float red = (r == true) ? 1.0 : 0.0;
-		float green = (g == true) ? 1.0 : 0.0;
-		float blue = (b == true) ? 1.0 : 0.0;
-		float alpha = (a == true) ? 1.0 : 0.0;
-		srcPixel.r = (lastStateVector.r == 0.0) ? srcPixel.r : abs(red-srcPixel.r);
-		srcPixel.g = (lastStateVector.g == 0.0) ? srcPixel.g : abs(green-srcPixel.g);
-		srcPixel.b = (lastStateVector.b == 0.0) ? srcPixel.b : abs(blue-srcPixel.b);
-		srcPixel.a = (lastStateVector.a == 0.0) ? srcPixel.a : abs(alpha-srcPixel.a);
-		gl_FragColor = srcPixel;
-	}
-}
diff --git a/nannou_isf/test_files/RGB Trails 3.0.fs b/nannou_isf/test_files/RGB Trails 3.0.fs
deleted file mode 100644
index 57f52c3ba..000000000
--- a/nannou_isf/test_files/RGB Trails 3.0.fs	
+++ /dev/null
@@ -1,53 +0,0 @@
-/*{
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2",
-	"DESCRIPTION": "a persistent buffer is used to maintain an image which is constantly updated.  Similar to VVMotionBlur, but each channel has its own weight",
-	"CATEGORIES": [
-		"Color Effect", "Blur"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "rWeight",
-			"TYPE": "float"
-		},
-		{
-			"NAME": "gWeight",
-			"TYPE": "float"
-		},
-		{
-			"NAME": "bWeight",
-			"TYPE": "float"
-		},
-		{
-			"NAME": "aWeight",
-			"TYPE": "float",
-			"DEFAULT": 0.0
-		}
-	],
-	"PASSES": [
-		{
-			"TARGET":"accum",
-			"PERSISTENT": true,
-			"FLOAT": true
-		},
-		{
-		
-		}
-	]
-	
-}*/
-
-void main()
-{
-	if (PASSINDEX==0)	{
-		vec4		freshPixel = IMG_THIS_PIXEL(inputImage);
-		vec4		stalePixel = IMG_THIS_PIXEL(accum);
-		gl_FragColor = vec4(mix(freshPixel.r,stalePixel.r,rWeight), mix(freshPixel.g,stalePixel.g,gWeight), mix(freshPixel.b,stalePixel.b,bWeight), mix(freshPixel.a,stalePixel.a,aWeight));
-	}
-	else
-		gl_FragColor = IMG_THIS_PIXEL(accum);
-}
diff --git a/nannou_isf/test_files/RGBA Swap.fs b/nannou_isf/test_files/RGBA Swap.fs
deleted file mode 100644
index ae81705be..000000000
--- a/nannou_isf/test_files/RGBA Swap.fs	
+++ /dev/null
@@ -1,166 +0,0 @@
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Color Effect"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"LABEL": "Red",
-			"NAME": "redInput",
-			"TYPE": "long",
-			"VALUES": [
-				0,
-				1,
-				2,
-				3,
-				4
-			],
-			"LABELS": [
-				"R",
-				"G",
-				"B",
-				"A",
-				"Average"
-			],
-			"DEFAULT": 0
-		},
-		{
-			"LABEL": "Green",
-			"NAME": "greenInput",
-			"TYPE": "long",
-			"VALUES": [
-				0,
-				1,
-				2,
-				3,
-				4
-			],
-			"LABELS": [
-				"R",
-				"G",
-				"B",
-				"A",
-				"Average"
-			],
-			"DEFAULT": 1
-		},
-		{
-			"LABEL": "Blue",
-			"NAME": "blueInput",
-			"TYPE": "long",
-			"VALUES": [
-				0,
-				1,
-				2,
-				3,
-				4
-			],
-			"LABELS": [
-				"R",
-				"G",
-				"B",
-				"A",
-				"Average"
-			],
-			"DEFAULT": 2
-		},
-		{
-			"LABEL": "Alpha",
-			"NAME": "alphaInput",
-			"TYPE": "long",
-			"VALUES": [
-				0,
-				1,
-				2,
-				3,
-				4
-			],
-			"LABELS": [
-				"R",
-				"G",
-				"B",
-				"A",
-				"Average"
-			],
-			"DEFAULT": 3
-		}
-	]
-}*/
-
-void main() {
-	vec4		srcPixel = IMG_THIS_PIXEL(inputImage);
-	vec4		outputPixel = srcPixel;
-	float		avgVal = (srcPixel.r + srcPixel.g + srcPixel.b) * srcPixel.a / 3.0;
-	
-	if (redInput == 0)	{
-		outputPixel.r = srcPixel.r;
-	}
-	else if (redInput == 1)	{
-		outputPixel.r = srcPixel.g;
-	}
-	else if (redInput == 2)	{
-		outputPixel.r = srcPixel.b;
-	}
-	else if (redInput == 3)	{
-		outputPixel.r = srcPixel.a;
-	}
-	else if (redInput == 4)	{
-		outputPixel.r = avgVal;
-	}
-	
-	if (greenInput == 0)	{
-		outputPixel.g = srcPixel.r;
-	}
-	else if (greenInput == 1)	{
-		outputPixel.g = srcPixel.g;
-	}
-	else if (greenInput == 2)	{
-		outputPixel.g = srcPixel.b;
-	}
-	else if (greenInput == 3)	{
-		outputPixel.g = srcPixel.a;
-	}
-	else if (greenInput == 4)	{
-		outputPixel.g = avgVal;
-	}
-	
-	if (blueInput == 0)	{
-		outputPixel.b = srcPixel.r;
-	}
-	else if (blueInput == 1)	{
-		outputPixel.b = srcPixel.g;
-	}
-	else if (blueInput == 2)	{
-		outputPixel.b = srcPixel.b;
-	}
-	else if (blueInput == 3)	{
-		outputPixel.b = srcPixel.a;
-	}
-	else if (blueInput == 4)	{
-		outputPixel.b = avgVal;
-	}
-	
-	
-	if (alphaInput == 0)	{
-		outputPixel.a = srcPixel.r;
-	}
-	else if (alphaInput == 1)	{
-		outputPixel.a = srcPixel.g;
-	}
-	else if (alphaInput == 2)	{
-		outputPixel.a = srcPixel.b;
-	}
-	else if (alphaInput == 3)	{
-		outputPixel.a = srcPixel.a;
-	}
-	else if (alphaInput == 4)	{
-		outputPixel.a = avgVal;
-	}
-	
-	gl_FragColor = outputPixel;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/RGBtoHSV.fs b/nannou_isf/test_files/RGBtoHSV.fs
deleted file mode 100644
index 90240d8c3..000000000
--- a/nannou_isf/test_files/RGBtoHSV.fs
+++ /dev/null
@@ -1,46 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Color Effect",
-        "Utility"
-    ],
-    "CREDIT": "by zoidberg",
-    "DESCRIPTION": "swizzles RGBA to BGRA and vice versa",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-
-vec3 rgb2hsv(vec3 c)	{
-	vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-	//vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
-	//vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
-	vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
-	vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
-	
-	float d = q.x - min(q.w, q.y);
-	float e = 1.0e-10;
-	return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
-}
-
-vec3 hsv2rgb(vec3 c)	{
-	vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
-	vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
-	return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
-}
-
-
-
-
-void main()
-{
-	vec4		inColor = IMG_NORM_PIXEL(inputImage, isf_FragNormCoord);
-	gl_FragColor = vec4(rgb2hsv(inColor.rgb), inColor.a);
-}
diff --git a/nannou_isf/test_files/Radial Gradient.fs b/nannou_isf/test_files/Radial Gradient.fs
deleted file mode 100644
index 438cf0e87..000000000
--- a/nannou_isf/test_files/Radial Gradient.fs	
+++ /dev/null
@@ -1,76 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Color"
-    ],
-    "CREDIT": "by Carter Rosenberg",
-    "INPUTS": [
-        {
-            "DEFAULT": 0.1,
-            "NAME": "radius1",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.25,
-            "NAME": "radius2",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                1,
-                0.75,
-                0,
-                1
-            ],
-            "NAME": "startColor",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0.25,
-                0.75,
-                1
-            ],
-            "NAME": "endColor",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": [
-                0.5,
-                0.5
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "location",
-            "TYPE": "point2D"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-void main() {
-	vec2 tmpPt = location;
-	float mixOffset = distance(tmpPt * RENDERSIZE.x / RENDERSIZE.y, isf_FragNormCoord * RENDERSIZE.x / RENDERSIZE.y);
-	float tmpRadius = radius1 + radius2;
-	if (mixOffset <= radius1)	{
-		gl_FragColor = startColor;
-	}
-	else if (mixOffset > tmpRadius)	{
-		gl_FragColor = endColor;
-	}
-	else if (radius1 == tmpRadius)	{
-		gl_FragColor = endColor;
-	}
-	else	{
-		gl_FragColor = mix(startColor,endColor,(mixOffset-radius1)/(tmpRadius-radius1));
-	}
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Radial Replicate.fs b/nannou_isf/test_files/Radial Replicate.fs
deleted file mode 100644
index a6cce2f00..000000000
--- a/nannou_isf/test_files/Radial Replicate.fs	
+++ /dev/null
@@ -1,104 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Kaleidoscope"
-    ],
-    "CREDIT": "VIDVOX",
-    "DESCRIPTION": "Repllcates a radial slice of an image",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Post Rotate Angle",
-            "MAX": 360,
-            "MIN": 0,
-            "NAME": "postRotateAngle",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 12,
-            "LABEL": "Number Of Divisions",
-            "MAX": 360,
-            "MIN": 1,
-            "NAME": "numberOfDivisions",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Pre Rotate Angle",
-            "MAX": 180,
-            "MIN": -180,
-            "NAME": "preRotateAngle",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "IDENTITY": 0,
-            "LABEL": "Radius Start",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "centerRadiusStart",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "IDENTITY": 0,
-            "LABEL": "Radius End",
-            "MAX": 2,
-            "MIN": 0,
-            "NAME": "centerRadiusEnd",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-const float pi = 3.14159265359;
-
-
-
-
-void main()	{
-	
-	vec4		inputPixelColor = vec4(0.0);
-	vec2		loc = _inputImage_imgRect.zw * vec2(isf_FragNormCoord.x,isf_FragNormCoord.y);
-	//	'r' is the radius- the distance in pixels from 'loc' to the center of the rendering space
-	//float		r = distance(IMG_SIZE(inputImage)/2.0, loc);
-	float		r = distance(_inputImage_imgRect.zw/2.0, loc);
-	//	'a' is the angle of the line segment from the center to loc is rotated
-	//float		a = atan ((loc.y-IMG_SIZE(inputImage).y/2.0),(loc.x-IMG_SIZE(inputImage).x/2.0));
-	float		a = atan ((loc.y-_inputImage_imgRect.w/2.0),(loc.x-_inputImage_imgRect.z/2.0));
-	float		modAngle = 2.0 * pi / numberOfDivisions;
-	float		scaledCenterRadiusStart = centerRadiusStart * max(RENDERSIZE.x,RENDERSIZE.y);
-	float		scaledCenterRadiusEnd = centerRadiusEnd * max(RENDERSIZE.x,RENDERSIZE.y);
-	
-	if (scaledCenterRadiusStart > scaledCenterRadiusEnd)	{
-		scaledCenterRadiusStart = scaledCenterRadiusEnd;
-		scaledCenterRadiusEnd = centerRadiusStart * max(RENDERSIZE.x,RENDERSIZE.y);
-	}
-	
-	if ((centerRadiusEnd != centerRadiusStart)&&(r >= scaledCenterRadiusStart)&&(r <= scaledCenterRadiusEnd))	{
-		r = (r - scaledCenterRadiusStart) / (centerRadiusEnd - centerRadiusStart);
-		
-		a = mod(a + pi * postRotateAngle/360.0,modAngle);
-	
-		//	now modify 'a', and convert the modified polar coords (radius/angle) back to cartesian coords (x/y pixels)
-		loc.x = r * cos(a + 2.0 * pi * (preRotateAngle) / 360.0);
-		loc.y = r * sin(a + 2.0 * pi * (preRotateAngle) / 360.0);
-	
-		loc = loc / _inputImage_imgRect.zw + vec2(0.5);
-	
-		if ((loc.x < 0.0)||(loc.y < 0.0)||(loc.x > 1.0)||(loc.y > 1.0))	{
-			inputPixelColor = vec4(0.0);
-		}
-		else	{
-			inputPixelColor = IMG_NORM_PIXEL(inputImage,loc);
-		}
-	}
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/Radial Spectrogram.fs b/nannou_isf/test_files/Radial Spectrogram.fs
deleted file mode 100644
index 3f29678af..000000000
--- a/nannou_isf/test_files/Radial Spectrogram.fs	
+++ /dev/null
@@ -1,84 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Audio Visualizer"
-    ],
-    "CREDIT": "icalvin102 (calvin@icalvin.de)",
-    "DESCRIPTION": "Generates a radial audiospectrogram from fft-input",
-    "INPUTS": [
-        {
-            "LABEL": "AudioFFT",
-            "NAME": "audioFFT",
-            "TYPE": "audioFFT"
-        },
-        {
-            "DEFAULT": 0.001,
-            "LABEL": "Size",
-            "MAX": 0.05,
-            "MIN": 1,
-            "NAME": "size",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.99,
-            "LABEL": "Feedback Opacity",
-            "MAX": 1,
-            "MIN": 0.7,
-            "NAME": "feedbackOpacity",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Lowest Frequency",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "low",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Heighest Frequency",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "high",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "FLOAT": true,
-            "HEIGHT": "1",
-            "PERSISTENT": true,
-            "TARGET": "time",
-            "WIDTH": "1"
-        },
-        {
-            "FLOAT": true,
-            "PERSISTENT": true,
-            "TARGET": "buff"
-        },
-        {
-        }
-    ]
-}
-*/
-
-void main()	{
-	vec4 inputPixelColor = IMG_THIS_PIXEL(buff);
-	float t = IMG_PIXEL(time, vec2(0.0,0.0)).r;
-	if(PASSINDEX == 0){
-		gl_FragColor = vec4(t+size);
-		return;
-	}
-	if(PASSINDEX == 1){
-		vec2 dir = vec2(sin(t), cos(t));
-		vec2 co = (isf_FragNormCoord - vec2(0.5,0.5)) * 2.0;
- 		float radius=length(co);
- 		inputPixelColor *= feedbackOpacity;
- 		if( dot(dir, normalize(co)) >= cos(size) && radius <= 1.0){
-			inputPixelColor = IMG_NORM_PIXEL(audioFFT, vec2((1.0-radius) * abs(high - low) + low, .5));
- 		}
- 		inputPixelColor.a = 1.0;
-	}
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/Radial.fs b/nannou_isf/test_files/Radial.fs
deleted file mode 100644
index f3618fd38..000000000
--- a/nannou_isf/test_files/Radial.fs
+++ /dev/null
@@ -1,66 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Wipe"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/Radial.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "smoothness",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// License: MIT
-// Author: Xaychru
-// ported by gre from https://gist.github.com/Xaychru/ce1d48f0ce00bb379750
-
-
-const float PI = 3.141592653589;
-
-vec4 transition(vec2 p) {
-  vec2 rp = p*2.-1.;
-  return mix(
-    getToColor(p),
-    getFromColor(p),
-    smoothstep(0., smoothness, atan(rp.y,rp.x) - (progress-.5) * PI * 2.5)
-  );
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Random Checkerboard.fs b/nannou_isf/test_files/Random Checkerboard.fs
deleted file mode 100644
index e42f6b327..000000000
--- a/nannou_isf/test_files/Random Checkerboard.fs	
+++ /dev/null
@@ -1,121 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Pattern", "Color"
-    ],
-    "CREDIT": "VIDVOX",
-    "DESCRIPTION": "Creates a checkerboard pattern with randomized colors",
-    "INPUTS": [
-        {
-            "DEFAULT": 0.25,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "width",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "offset",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "hue",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "saturation",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.95,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "brightness",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "NAME": "randHue",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 0,
-            "NAME": "randSaturation",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 0,
-            "NAME": "randBright",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 0,
-            "NAME": "randAlpha",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 0.71,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "rSeed",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-float rand(vec2 co){
-    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-vec4 rand4(vec4 co)	{
-	vec4	returnMe = vec4(0.0);
-	returnMe.r = rand(co.rg);
-	returnMe.g = rand(co.gb);
-	returnMe.b = rand(co.ba);
-	returnMe.a = rand(co.rb);
-	return returnMe;
-}
-
-vec3 hsv2rgb(vec3 c)	{
-	vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
-	vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
-	return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
-}
-
-void main() {
-
-	vec4 out_color = vec4(0.0);
-	vec2 coord = isf_FragNormCoord;
-	vec4 hsv = vec4(hue, saturation, brightness, 1.0);
-	float minW = max(width,1.0/RENDERSIZE.y);
-	vec2 indexes = floor((coord+offset) / minW);
-	float index = indexes.x + indexes.y/minW;
-	
-	hsv.r = (randHue) ? mod(hsv.r + rand(vec2(index, rSeed + 0.34219)),1.0) : hsv.r;
-	hsv.g = (randSaturation) ? mod(hsv.g + rand(vec2(index, rSeed + 0.57731)),1.0) : hsv.g;
-	hsv.b = (randBright) ? mod(hsv.b + rand(vec2(index, rSeed + 0.79436)),1.0) : hsv.b;
-	hsv.a = (randAlpha) ? rand(vec2(hsv.a + index, rSeed + 1.37665)) : hsv.a;
-	
-	out_color.rgb = hsv2rgb(hsv.rgb);
-	out_color.a = hsv.a;
-	
-	gl_FragColor = out_color;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Random Freeze.fs b/nannou_isf/test_files/Random Freeze.fs
deleted file mode 100644
index eb49b0699..000000000
--- a/nannou_isf/test_files/Random Freeze.fs	
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Glitch"
-  ],
-  "DESCRIPTION" : "Causes only part of an image to update",
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "NAME" : "inputImage",
-      "TYPE" : "image"
-    },
-    {
-      "NAME" : "maxUpdateSize",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0.5,
-      "LABEL" : "Size",
-      "MIN" : 0
-    },
-    {
-      "NAME" : "maxBlendAmount",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "resetImage",
-      "TYPE" : "event",
-      "LABEL" : "Reset Image"
-    }
-  ],
-  "PASSES" : [
-    {
-      "TARGET" : "lastState",
-      "PERSISTENT" : true,
-      "DESCRIPTION" : ""
-    }
-  ],
-  "CREDIT" : "VIDVOX"
-}
-*/
-
-float rand(vec2 co){
-    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-vec4 rand4(vec4 co)	{
-	vec4	returnMe = vec4(0.0);
-	returnMe.r = rand(co.rg);
-	returnMe.g = rand(co.gb);
-	returnMe.b = rand(co.ba);
-	returnMe.a = rand(co.rb);
-	return returnMe;
-}
-
-vec3 hsv2rgb(vec3 c)	{
-	vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
-	vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
-	return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
-}
-
-const float pi = 3.14159265359;
-
-
-bool pointInRect(vec2 pt, vec4 r)
-{
-	bool	returnMe = false;
-	if ((pt.x >= r.x)&&(pt.y >= r.y)&&(pt.x <= r.x + r.z)&&(pt.y <= r.y + r.w))
-		returnMe = true;
-	return returnMe;
-}
-
-void main()	{
-	vec2	loc = isf_FragNormCoord.xy;
-	bool	doReset = ((resetImage)||(FRAMEINDEX==0));
-	vec4	returnMe = (doReset) ? IMG_THIS_PIXEL(inputImage) : IMG_THIS_PIXEL(lastState);
-	vec4	seeds1 = TIME * vec4(0.2123,0.34517,0.53428,0.7431);
-	vec4	randCoords = rand4(seeds1);
-	randCoords.zw *= maxUpdateSize;
-	if (randCoords.x + randCoords.z > 1.0)
-		randCoords.z = 1.0 - randCoords.x;
-	if (randCoords.y + randCoords.w > 1.0)
-		randCoords.w = 1.0 - randCoords.y;
-
-	bool	isInShape = pointInRect(loc,randCoords);
-	
-	if (isInShape)	{
-		float		mixAmount = maxBlendAmount * rand(vec2(TIME,0.32234));
-		vec4		newColor = IMG_THIS_PIXEL(inputImage);
-		newColor.a = 1.0;
-		returnMe = mix(newColor,returnMe,mixAmount);
-	}
-	
-	gl_FragColor = returnMe;
-}
diff --git a/nannou_isf/test_files/Random Lines.fs b/nannou_isf/test_files/Random Lines.fs
deleted file mode 100644
index fab9f5d1b..000000000
--- a/nannou_isf/test_files/Random Lines.fs	
+++ /dev/null
@@ -1,300 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Geometry"
-    ],
-    "CREDIT": "VIDVOX",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "DEFAULT": 15,
-            "LABEL": "Line Count",
-            "MAX": 60,
-            "MIN": 1,
-            "NAME": "lineCount",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.025,
-            "LABEL": "Max Line Width",
-            "MAX": 0.25,
-            "MIN": 0,
-            "NAME": "lineWidth",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.25,
-            "LABEL": "Random Seed",
-            "MAX": 1,
-            "MIN": 0.01,
-            "NAME": "randomSeed",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Wobble Amount",
-            "MAX": 0.1,
-            "MIN": 0,
-            "NAME": "wobbleAmount",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.2,
-            "LABEL": "Hue Range",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "hueRange",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Saturation",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "colorSaturation",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": true,
-            "LABEL": "Randomize Brightness",
-            "NAME": "randomizeBrightness",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": false,
-            "LABEL": "Randomize Width",
-            "NAME": "randomizeWidth",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": false,
-            "LABEL": "Randomize Points",
-            "NAME": "randomizeAllPoints",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": false,
-            "LABEL": "Randomize Alpha",
-            "NAME": "randomizeAlpha",
-            "TYPE": "bool"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-vec3 rgb2hsv(vec3 c)	{
-	vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-	//vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
-	//vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
-	vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
-	vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
-	
-	float d = q.x - min(q.w, q.y);
-	float e = 1.0e-10;
-	return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
-}
-
-vec3 hsv2rgb(vec3 c)	{
-	vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
-	vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
-	return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
-}
-
-float rand(vec2 co){
-    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-bool is_point_above_line(vec2 pt, float slope, float intercept)	{
-	bool returnMe = false;
-	float y = slope * pt.x + intercept;
-	if (y < pt.y)
-		returnMe = true;
-	return returnMe;
-}
-
-//	returns two values – distrance from the line and the percentage of the way on the line
-float distance_from_point_to_line(vec2 pt, vec2 l1, vec2 l2){
-	float returnMe = 0.0;
-	float a = (l2.y - l1.y);
-	float b = (l2.x - l1.x);
-	float c = 0.0;
-	
-	//	if b is zero, this is a vertical line!
-	//	in which case distance is based on x distance alone
-	if (b == 0.0)	{
-		float minY = min(l1.y, l2.y);
-		float maxY = max(l1.y, l2.y);
-		
-		//	if we're between the two points distrance is straight up x diff
-		if ((pt.y > minY) && (pt.y < maxY))	{
-			returnMe = abs(pt.x-l1.x);
-		}
-		else	{
-			//returnMe = min(distance(pt, l1), distance(pt, l2));
-			returnMe = -1.0;
-		}
-	}
-	//	if a is zero, this is a horizontal line
-	else if (a == 0.0)	{
-		float minX = min(l1.x, l2.x);
-		float maxX = max(l1.x, l2.x);
-		
-		//	if we're between the two points distrance is straight up y diff
-		if ((pt.x > minX) && (pt.x < maxX))	{
-			returnMe = abs(pt.y - l1.y);
-		}
-		else	{
-			//returnMe = min(distance(pt, l1), distance(pt, l2));
-			returnMe = -1.0;
-		}
-	}
-	//	if b isn't 0, solve for c now that we know a, b, and either l1 or l2
-	else	{		
-		//	here's the tricky bit-
-		//	if pt is beyond l1 and l2, we should switch to distance from those points
-		//	in order to determine this we need to use the perpendicular lines to the segment l1|l2 that pass through l1 & l2
-		//	the slope of the perp line will be -1.0 / slope of original line
-		float m = a / b;
-		float perpm = -b / a;
-		vec2 left_line_pt = l1;
-		vec2 right_line_pt = l2;
-		if (l1.x > l2.x)	{
-			left_line_pt = l2;
-			right_line_pt = l1;
-		}
-		
-		float perp_intercept1 = left_line_pt.y - perpm * left_line_pt.x;
-		float perp_intercept2 = right_line_pt.y - perpm * right_line_pt.x;
-		
-		if (m > 0.0)	{
-			/*
-			if (is_point_above_line(pt, perpm, perp_intercept1)==false)	{
-				//returnMe = distance(pt, left_line_pt);
-				returnMe = -1.0;
-			}
-			else if (is_point_above_line(pt, perpm, perp_intercept2)==true)	{
-				//returnMe = distance(pt, right_line_pt);
-				returnMe = -1.0;
-			}
-			else	{
-				returnMe = abs(a * pt.x - b * pt.y + l2.x * l1.y - l2.y * l1.x) / sqrt(a*a + b*b);
-			}
-			*/
-			returnMe = abs(a * pt.x - b * pt.y + l2.x * l1.y - l2.y * l1.x) / sqrt(a*a + b*b);
-		}
-		else	{
-			/*
-			if (is_point_above_line(pt, perpm, perp_intercept1)==true)	{
-				//returnMe = distance(pt, left_line_pt);
-				returnMe = -1.0;
-			}
-			else if (is_point_above_line(pt, perpm, perp_intercept2)==false)	{
-				//returnMe = distance(pt, right_line_pt);
-				returnMe = -1.0;
-			}
-			else	{
-				returnMe = abs(a * pt.x - b * pt.y + l2.x * l1.y - l2.y * l1.x) / sqrt(a*a + b*b);
-			}
-			*/
-			returnMe = abs(a * pt.x - b * pt.y + l2.x * l1.y - l2.y * l1.x) / sqrt(a*a + b*b);
-		}
-	}
-	 
-    return returnMe;
-}
-
-void main()	{
-	float		maxWidth = lineWidth;
-	float		minWidth = 1.0 / min(RENDERSIZE.x, RENDERSIZE.y);
-	if (maxWidth < minWidth)
-		maxWidth = minWidth;
-	
-	vec4		result = vec4(0.0);
-	vec2		thisPoint = isf_FragNormCoord;
-	vec3		colorHSL;
-	vec2		pt1, pt2;
-	float		baseHue = rand(vec2(floor(lineCount), 1.0));
-	
-	colorHSL.x = baseHue;
-	colorHSL.y = colorSaturation;
-	colorHSL.z = 1.0;
-	if (randomizeBrightness)	{
-		colorHSL.z = rand(vec2(floor(lineCount)+randomSeed * 3.72, randomSeed + lineCount * 0.649));
-	}
-	
-	vec2 wobbleVector = vec2(0.0);
-	
-	pt1 = vec2(rand(vec2(floor(lineCount)+randomSeed*1.123,randomSeed*1.321)),rand(vec2(randomSeed*2.123,randomSeed*3.325)));
-	pt2 = vec2(rand(vec2(floor(lineCount)+randomSeed*0.317,randomSeed*2.591)),rand(vec2(randomSeed*1.833,randomSeed*4.916)));
-	
-	if (wobbleAmount > 0.0)	{
-		wobbleVector = wobbleAmount * vec2(rand(vec2(TIME*1.123,TIME*3.239)),rand(vec2(TIME*3.321,TIME*2.131))) - vec2(wobbleAmount / 2.0);
-		pt1 = pt1 + wobbleVector;
-		
-		wobbleVector = wobbleAmount * vec2(rand(vec2(TIME*6.423,TIME*1.833)),rand(vec2(TIME*2.436,TIME*7.532))) - vec2(wobbleAmount / 2.0);
-		pt2 = pt2 + wobbleVector;
-	}
-	
-	float		randomWidth = maxWidth;
-	
-	if (randomizeWidth)	{
-		randomWidth = clamp(maxWidth * rand(vec2(1.0 + randomSeed * 4.672, randomSeed * lineCount * 2.523)), minWidth, maxWidth);
-	}
-	
-	if (distance_from_point_to_line(thisPoint, pt1, pt2) < randomWidth)	{
-		float newAlpha = 1.0;
-		
-		if (randomizeAlpha)	{
-			newAlpha = 0.25 + 0.5 * rand(vec2(1.0 + floor(lineCount)+randomSeed * 1.938, randomSeed * lineCount * 1.541));
-		}
-		
-		result.rgb = hsv2rgb(colorHSL);
-		result.a = result.a + newAlpha;
-	}
-	
-	for (float i = 0.0; i < 60.0; ++i)	{
-		if (result.a > 0.75)
-			break;
-		if (i >= lineCount - 1.0)
-			break;
-		if (randomizeAllPoints)	{
-			pt1 = vec2(rand(vec2(i+randomSeed*1.123,floor(lineCount)+randomSeed*1.321)),rand(vec2((1.0+i)*floor(lineCount)+randomSeed*2.123,i+randomSeed*1.325)));
-			
-			if (wobbleAmount > 0.0)	{
-				wobbleVector = wobbleAmount * vec2(rand(vec2(i*floor(lineCount)+TIME*3.123,i*floor(lineCount)+TIME*3.239)),rand(vec2(i*floor(lineCount)+TIME*3.321,i*floor(lineCount)+TIME*2.131))) - vec2(wobbleAmount / 2.0);
-				pt1 = pt1 + wobbleVector;
-			}
-		}
-		else	{
-			pt1 = pt2;
-		}
-		pt2 = vec2(rand(vec2(i*floor(lineCount)+randomSeed*3.573,i+randomSeed*6.273)),rand(vec2(i+randomSeed*9.253,i+randomSeed*7.782)));
-		
-		if (wobbleAmount > 0.0)	{
-			wobbleVector = wobbleAmount * vec2(rand(vec2(i*floor(lineCount)+TIME*3.573,i+randomSeed*6.273)),rand(vec2(i+TIME*9.253,i+TIME*7.782))) - vec2(wobbleAmount / 2.0);
-			pt2 = pt2 + wobbleVector;
-		}
-		
-		if (randomizeWidth)	{
-			randomWidth = clamp(maxWidth * rand(vec2(i + randomSeed * 4.672, 1.673 + i * randomSeed * 2.523)), minWidth, maxWidth);
-		}
-		
-		if (distance_from_point_to_line(thisPoint, pt1, pt2) < randomWidth)	{
-			//result = vec4(1.0);
-			float newAlpha = 1.0;
-			
-			if (randomizeAlpha)	{
-				newAlpha = 0.25 + 0.25 * rand(vec2(i + floor(lineCount)+randomSeed * 1.938, randomSeed * lineCount * 1.541));
-			}
-			
-			colorHSL.x = mod(baseHue + hueRange * rand(vec2(floor(lineCount)+randomSeed, i)), 1.0);
-			if (randomizeBrightness)	{
-				colorHSL.z = 0.15 + 0.85 * rand(vec2(i + floor(lineCount)+randomSeed * 2.78, randomSeed + lineCount * 0.249));
-			}
-			result.rgb = result.rgb + hsv2rgb(colorHSL) * newAlpha;
-			result.a = result.a + newAlpha;
-		}
-	}
-	
-	gl_FragColor = result;
-}
diff --git a/nannou_isf/test_files/Random Shape Blast.fs b/nannou_isf/test_files/Random Shape Blast.fs
deleted file mode 100644
index e29a9d0a4..000000000
--- a/nannou_isf/test_files/Random Shape Blast.fs	
+++ /dev/null
@@ -1,224 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Geometry"
-    ],
-    "CREDIT": "VIDVOX",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "DEFAULT": 0.5,
-            "LABEL": "Saturation",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "saturation",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Brightness",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "brightness",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Mix Amount",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "mixAmount",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Mask Shape Mode",
-            "LABELS": [
-                "Random",
-                "Rectangle",
-                "Triangle",
-                "Circle",
-                "Diamond"
-            ],
-            "NAME": "maskShapeMode",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1,
-                2,
-                3,
-                4
-            ]
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Anchor To Bottom",
-            "NAME": "anchorToBottom",
-            "TYPE": "bool"
-        },
-        {
-            "LABEL": "Reset",
-            "NAME": "resetImage",
-            "TYPE": "event"
-        }
-    ],
-    "ISFVSN": "2",
-    "KEYWORDS": [
-        "Abstract",
-        "Geometric"
-    ],
-    "PASSES": [
-        {
-            "DESCRIPTION": "Holds the last render state for drawing over",
-            "PERSISTENT": true,
-            "TARGET": "lastState"
-        }
-    ]
-}
-*/
-
-float rand(vec2 co){
-    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-vec4 rand4(vec4 co)	{
-	vec4	returnMe = vec4(0.0);
-	returnMe.r = rand(co.rg);
-	returnMe.g = rand(co.gb);
-	returnMe.b = rand(co.ba);
-	returnMe.a = rand(co.rb);
-	return returnMe;
-}
-
-vec3 hsv2rgb(vec3 c)	{
-	vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
-	vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
-	return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
-}
-
-const float pi = 3.14159265359;
-
-
-vec2 rotatePoint(vec2 pt, float angle, vec2 center)
-{
-	vec2 returnMe;
-	float s = sin(angle * pi);
-	float c = cos(angle * pi);
-
-	returnMe = pt;
-
-	// translate point back to origin:
-	returnMe.x -= center.x;
-	returnMe.y -= center.y;
-
-	// rotate point
-	float xnew = returnMe.x * c - returnMe.y * s;
-	float ynew = returnMe.x * s + returnMe.y * c;
-
-	// translate point back:
-	returnMe.x = xnew + center.x;
-	returnMe.y = ynew + center.y;
-	return returnMe;
-}
-
-float sign(vec2 p1, vec2 p2, vec2 p3)
-{
-	return (p1.x - p3.x) * (p2.y - p3.y) - (p2.x - p3.x) * (p1.y - p3.y);
-}
-
-bool RotatedPointInTriangle(vec2 pt, vec2 v1, vec2 v2, vec2 v3, vec2 center)
-{
-	bool b1, b2, b3;
-	
-	vec2 v1r = v1;
-	vec2 v2r = v2;
-	vec2 v3r = v3;
-
-	b1 = sign(pt, v1r, v2r) < 0.0;
-	b2 = sign(pt, v2r, v3r) < 0.0;
-	b3 = sign(pt, v3r, v1r) < 0.0;
-
-	return ((b1 == b2) && (b2 == b3));
-}
-
-
-float isPointInShape(vec2 pt, int shape, vec4 shapeCoordinates)	{
-	float returnMe = 0.0;
-	
-	//	rectangle
-	if (shape == 0)	{
-		if (RotatedPointInTriangle(pt, shapeCoordinates.xy, shapeCoordinates.xy + vec2(0.0, shapeCoordinates.w), shapeCoordinates.xy + vec2(shapeCoordinates.z, 0.0), shapeCoordinates.xy + shapeCoordinates.zw / 2.0))	{
-			returnMe = 1.0;
-			// soft edge if needed
-			if ((pt.x > shapeCoordinates.x) && (pt.x < shapeCoordinates.x)) {
-				returnMe = clamp(((pt.x - shapeCoordinates.x) / RENDERSIZE.x), 0.0, 1.0);
-				returnMe = pow(returnMe, 0.5);
-			}
-			else if ((pt.x > shapeCoordinates.x + shapeCoordinates.z) && (pt.x < shapeCoordinates.x + shapeCoordinates.z)) {
-				returnMe = clamp(((shapeCoordinates.x + shapeCoordinates.z - pt.x) / RENDERSIZE.x), 0.0, 1.0);
-				returnMe = pow(returnMe, 0.5);
-			}
-		}
-		else if (RotatedPointInTriangle(pt, shapeCoordinates.xy + shapeCoordinates.zw, shapeCoordinates.xy + vec2(0.0, shapeCoordinates.w), shapeCoordinates.xy + vec2(shapeCoordinates.z, 0.0), shapeCoordinates.xy + shapeCoordinates.zw / 2.0))	{
-			returnMe = 1.0;
-			// soft edge if needed
-			if ((pt.x > shapeCoordinates.x) && (pt.x < shapeCoordinates.x)) {
-				returnMe = clamp(((pt.x - shapeCoordinates.x) / RENDERSIZE.x), 0.0, 1.0);
-				returnMe = pow(returnMe, 0.5);
-			}
-			else if ((pt.x > shapeCoordinates.x + shapeCoordinates.z) && (pt.x < shapeCoordinates.x + shapeCoordinates.z)) {
-				returnMe = clamp(((shapeCoordinates.x + shapeCoordinates.z - pt.x) / RENDERSIZE.x), 0.0, 1.0);
-				returnMe = pow(returnMe, 0.5);
-			}
-		}
-	}
-	//	triangle
-	else if (shape == 1)	{
-		if (RotatedPointInTriangle(pt, shapeCoordinates.xy, shapeCoordinates.xy + vec2(shapeCoordinates.z / 2.0, shapeCoordinates.w), shapeCoordinates.xy + vec2(shapeCoordinates.z, 0.0), shapeCoordinates.xy + shapeCoordinates.zw / 2.0))	{
-			returnMe = 1.0;
-		}
-	}
-	//	oval
-	else if (shape == 2)	{
-		returnMe = distance(pt, vec2(shapeCoordinates.xy + shapeCoordinates.zw / 2.0));
-		if (returnMe < min(shapeCoordinates.z,shapeCoordinates.w) / 2.0)	{
-			returnMe = 1.0;
-		}
-		else	{
-			returnMe = 0.0;
-		}
-	}
-	//	diamond
-	else if (shape == 3)	{
-		if (RotatedPointInTriangle(pt, shapeCoordinates.xy + vec2(0.0, shapeCoordinates.w / 2.0), shapeCoordinates.xy + vec2(shapeCoordinates.z / 2.0, shapeCoordinates.w), shapeCoordinates.xy + vec2(shapeCoordinates.z, shapeCoordinates.w / 2.0), shapeCoordinates.xy + shapeCoordinates.zw / 2.0))	{
-			returnMe = 1.0;
-		}
-		else if (RotatedPointInTriangle(pt, shapeCoordinates.xy + vec2(0.0, shapeCoordinates.w / 2.0), shapeCoordinates.xy + vec2(shapeCoordinates.z / 2.0, 0.0), shapeCoordinates.xy + vec2(shapeCoordinates.z, shapeCoordinates.w / 2.0), shapeCoordinates.xy + shapeCoordinates.zw / 2.0))	{
-			returnMe = 1.0;
-		}
-	}
-
-	return returnMe;	
-}
-
-
-void main()	{
-	vec2	loc = isf_FragNormCoord.xy;
-	vec4	returnMe = (resetImage) ? vec4(0.0) : IMG_NORM_PIXEL(lastState,loc);
-	vec4	seeds1 = TIME * vec4(0.2123,0.34517,0.53428,0.7431);
-	vec4	randCoords = rand4(seeds1);
-	if (anchorToBottom == true)	{
-		randCoords.y = 0.0;
-	}
-	int		shapeMode = (maskShapeMode != 0) ? maskShapeMode - 1 : int(floor(3.99 * rand(vec2(TIME+0.213,0.43*TIME+0.831))));
-	float	isInShape = isPointInShape(loc,shapeMode,randCoords);
-	
-	if (isInShape > 0.0)	{
-		float		randHue = rand(vec2(TIME,0.32234));
-		vec4		newColor = vec4(0.0);
-		newColor.rgb = hsv2rgb(vec3(randHue,saturation,brightness));
-		newColor.a = 1.0;
-		returnMe = mix(returnMe,newColor,mixAmount);
-	}
-	
-	gl_FragColor = returnMe;
-}
diff --git a/nannou_isf/test_files/Random Shape.fs b/nannou_isf/test_files/Random Shape.fs
deleted file mode 100644
index e5efae694..000000000
--- a/nannou_isf/test_files/Random Shape.fs	
+++ /dev/null
@@ -1,290 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Geometry"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "DEFAULT": 15,
-            "LABEL": "Point Count",
-            "MAX": 90,
-            "MIN": 3,
-            "NAME": "pointCount",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.125,
-            "LABEL": "Random Seed",
-            "MAX": 1,
-            "MIN": 0.01,
-            "NAME": "randomSeed",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Wobble Amount",
-            "MAX": 0.25,
-            "MIN": 0,
-            "NAME": "wobbleAmount",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.75,
-            "LABEL": "Zoom Start",
-            "MAX": 4,
-            "MIN": 0.001,
-            "NAME": "zoomStart",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Zoom End",
-            "MAX": 4,
-            "MIN": 0.001,
-            "NAME": "zoomEnd",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Winding Start",
-            "MAX": 4,
-            "MIN": -4,
-            "NAME": "rotationStart",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Winding End",
-            "MAX": 4,
-            "MIN": -4,
-            "NAME": "rotationEnd",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Saturation",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "colorSaturation",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.2,
-            "LABEL": "Hue Base",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "hueBase",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.2,
-            "LABEL": "Hue Range",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "hueRange",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0.5,
-                0.5
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "offsetEnd",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": true,
-            "LABEL": "Randomize Brightness",
-            "NAME": "randomizeBrightness",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": false,
-            "LABEL": "Randomize Alpha",
-            "NAME": "randomizeAlpha",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": false,
-            "LABEL": "Randomize Points",
-            "NAME": "randomizeAllPoints",
-            "TYPE": "bool"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-const float pi = 3.14159265359;
-
-
-
-vec2 rotatePoint(vec2 pt, float angle, vec2 center)
-{
-	vec2 returnMe;
-	float s = sin(angle * pi);
-	float c = cos(angle * pi);
-
-	returnMe = pt;
-
-	// translate point back to origin:
-	returnMe.x -= center.x;
-	returnMe.y -= center.y;
-
-	// rotate point
-	float xnew = returnMe.x * c - returnMe.y * s;
-	float ynew = returnMe.x * s + returnMe.y * c;
-
-	// translate point back:
-	returnMe.x = xnew + center.x;
-	returnMe.y = ynew + center.y;
-	return returnMe;
-}
-
-
-vec3 rgb2hsv(vec3 c)	{
-	vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-	//vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
-	//vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
-	vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
-	vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
-	
-	float d = q.x - min(q.w, q.y);
-	float e = 1.0e-10;
-	return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
-}
-
-vec3 hsv2rgb(vec3 c)	{
-	vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
-	vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
-	return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
-}
-
-float rand(vec2 co){
-    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-
-float sign(vec2 p1, vec2 p2, vec2 p3)	{
-	return (p1.x - p3.x) * (p2.y - p3.y) - (p2.x - p3.x) * (p1.y - p3.y);
-}
-
-bool PointInTriangle(vec2 pt, vec2 v1, vec2 v2, vec2 v3)	{
-	bool b1, b2, b3;
-
-	b1 = sign(pt, v1, v2) < 0.0;
-	b2 = sign(pt, v2, v3) < 0.0;
-	b3 = sign(pt, v3, v1) < 0.0;
-
-	return ((b1 == b2) && (b2 == b3));
-}
-
-
-void main() {
-	vec4		result = vec4(0.0);
-	vec2		thisPoint = isf_FragNormCoord;
-	vec3		colorHSL;
-	vec2		pt1, pt2, pt3;
-	vec2		offsetIncrement = (4.0 * (offsetEnd - vec2(0.5)) / (pointCount - 2.0));
-	float		rotationIncrement = (rotationEnd - rotationStart) / pointCount;
-	float		zoomIncrement = (zoomEnd - zoomStart) / pointCount;
-	
-	thisPoint = rotatePoint(thisPoint, rotationStart, RENDERSIZE/2.0);
-	thisPoint = thisPoint / RENDERSIZE;
-	thisPoint = (thisPoint - vec2(0.5)) / zoomStart + vec2(0.5);
-	
-	colorHSL.x = hueBase;
-	colorHSL.y = colorSaturation;
-	colorHSL.z = 1.0;
-	if (randomizeBrightness)	{
-		colorHSL.z = rand(vec2(floor(pointCount)+randomSeed * 3.72, randomSeed + pointCount * 0.649));
-	}
-	
-	vec2 wobbleVector = vec2(0.0);
-	
-	pt1 = vec2(rand(vec2(floor(pointCount)+randomSeed*1.123,randomSeed*1.321)),rand(vec2(randomSeed*2.123,randomSeed*3.325)));
-	pt2 = vec2(rand(vec2(floor(pointCount)+randomSeed*5.317,randomSeed*2.591)),rand(vec2(randomSeed*1.833,randomSeed*4.916)));
-	pt3 = vec2(rand(vec2(floor(pointCount)+randomSeed*3.573,randomSeed*6.273)),rand(vec2(randomSeed*9.253,randomSeed*7.782)));
-	
-	if (wobbleAmount > 0.0)	{
-		wobbleVector = wobbleAmount * vec2(rand(vec2(TIME*1.123,TIME*3.239)),rand(vec2(TIME*3.321,TIME*2.131))) - vec2(wobbleAmount / 2.0);
-		pt1 = pt1 + wobbleVector;
-		
-		wobbleVector = wobbleAmount * vec2(rand(vec2(TIME*6.423,TIME*1.833)),rand(vec2(TIME*2.436,TIME*7.532))) - vec2(wobbleAmount / 2.0);
-		pt2 = pt2 + wobbleVector;
-		
-		wobbleVector = wobbleAmount * vec2(rand(vec2(TIME*3.951,TIME*3.538)),rand(vec2(TIME*8.513,TIME*6.335))) - vec2(wobbleAmount / 2.0);
-		pt3 = pt3 + wobbleVector;
-	}
-	
-	if (PointInTriangle(thisPoint,pt1,pt2,pt3))	{
-		float newAlpha = 1.0;
-		
-		if (randomizeAlpha)	{
-			newAlpha = 0.5 + 0.5 * rand(vec2(1.0 + floor(pointCount)+randomSeed * 1.938, randomSeed * pointCount * 1.541));
-		}
-		
-		result.rgb = hsv2rgb(colorHSL);
-		result.a = result.a + newAlpha;
-	}
-	
-	for (float i = 0.0; i < 90.0; ++i)	{
-		if (result.a > 0.75)
-			break;
-		if (i > pointCount - 3.0)
-			break;
-		if (randomizeAllPoints)	{
-			pt1 = vec2(rand(vec2(i+randomSeed*1.123,i*floor(pointCount)+randomSeed*1.321)),rand(vec2(i*floor(pointCount)+randomSeed*2.123,i+randomSeed*1.325)));
-			pt2 = vec2(rand(vec2(i*floor(pointCount)+randomSeed*5.317,randomSeed*2.591)),rand(vec2(i+randomSeed*1.833,i*floor(pointCount)+randomSeed*4.916)));
-			
-			if (wobbleAmount > 0.0)	{
-				wobbleVector = wobbleAmount * vec2(rand(vec2(i*floor(pointCount)+TIME*3.123,i*floor(pointCount)+TIME*3.239)),rand(vec2(i*floor(pointCount)+TIME*3.321,i*floor(pointCount)+TIME*2.131))) - vec2(wobbleAmount / 2.0);
-				pt1 = pt1 + wobbleVector;
-			
-				wobbleVector = wobbleAmount * vec2(rand(vec2(i*floor(pointCount)+TIME*6.423,i*floor(pointCount)+TIME*1.833)),rand(vec2(i*floor(pointCount)+TIME*2.436,i*floor(pointCount)+TIME*7.532))) - vec2(wobbleAmount / 2.0);
-				pt2 = pt2 + wobbleVector;
-			}
-		}
-		else	{
-			pt1 = pt2;
-			pt2 = pt3;
-		}
-		pt3 = vec2(rand(vec2(i*floor(pointCount)+randomSeed*3.573,i+randomSeed*6.273)),rand(vec2(i+randomSeed*9.253,i+randomSeed*7.782)));
-		pt3 = (pt3 - vec2(0.5)) * (zoomStart + zoomIncrement * i) + vec2(0.5);
-		pt3 = rotatePoint(pt3, rotationStart + rotationIncrement * i, vec2(0.5));
-		pt3 = pt3 + offsetIncrement * i;
-		
-		if (wobbleAmount > 0.0)	{
-			wobbleVector = wobbleAmount * vec2(rand(vec2(i*floor(pointCount)+TIME*3.573,i+randomSeed*6.273)),rand(vec2(i+TIME*9.253,i+TIME*7.782))) - vec2(wobbleAmount / 2.0);
-			pt3 = pt3 + wobbleVector;
-		}
-		
-		if (PointInTriangle(thisPoint,pt1,pt2,pt3))	{
-			//result = vec4(1.0);
-			float newAlpha = 1.0;
-			
-			if (randomizeAlpha)	{
-				newAlpha = 0.1 + 0.25 * rand(vec2(i + floor(pointCount)+randomSeed * 1.938, randomSeed * pointCount * 1.541));
-			}
-			
-			colorHSL.x = mod(hueBase + hueRange * rand(vec2(floor(pointCount)+randomSeed, i)), 1.0);
-			if (randomizeBrightness)	{
-				colorHSL.z = 0.25 + 0.85 * rand(vec2(i + floor(pointCount)+randomSeed * 2.78, randomSeed + pointCount * 0.249));
-			}
-			result.rgb = result.rgb + hsv2rgb(colorHSL) * newAlpha;
-			result.a = result.a + newAlpha;
-		}
-	}
-	
-	gl_FragColor = result;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Random Squares Mask.fs b/nannou_isf/test_files/Random Squares Mask.fs
deleted file mode 100644
index 49c4c527d..000000000
--- a/nannou_isf/test_files/Random Squares Mask.fs	
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Masking"
-  ],
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "NAME" : "width",
-      "TYPE" : "float",
-      "DEFAULT" : 0.125
-    },
-    {
-      "NAME" : "offset",
-      "TYPE" : "point2D",
-      "DEFAULT" : [
-        0,
-        0
-      ],
-      "MIN": [
-      	0,
-      	0
-      ],
-      "MAX": [
-      	1,
-      	1
-      ]
-    },
-    {
-      "NAME" : "alpha1",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "alpha2",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 1,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "inputImage",
-      "TYPE" : "image"
-    },
-    {
-      "NAME" : "seed1",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0.241,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "randomThreshold",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0.5,
-      "MIN" : 0
-    }
-  ],
-  "CREDIT" : "by VIDVOX"
-}
-*/
-
-
-//	glsl doesn't include random functions
-//	this is a pseudo-random function
-float rand(vec2 co){
-    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-
-void main() {
-	//	determine if we are on an even or odd line
-	//	math goes like..
-	//	mod(((coord+offset) / width),2)
-	
-	
-	vec4 out_color = IMG_THIS_NORM_PIXEL(inputImage);
-	float alphaAdjust = alpha2;
-	vec2 coord = isf_FragNormCoord * RENDERSIZE;
-	vec2 shift = offset * RENDERSIZE;
-	float size = width * RENDERSIZE.x;
-	vec2 gridIndex = vec2(0.0);
-
-	if (size == 0.0)	{
-		alphaAdjust = alpha1;
-	}
-	else {
-		gridIndex = floor((shift + coord) / size);
-		float value = rand(seed1*gridIndex);
-		if (value < randomThreshold)
-			alphaAdjust = alpha1;
-	}
-	
-	out_color.a *= alphaAdjust;
-	
-	gl_FragColor = out_color;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Random Squares.fs b/nannou_isf/test_files/Random Squares.fs
deleted file mode 100644
index 1b962e34e..000000000
--- a/nannou_isf/test_files/Random Squares.fs	
+++ /dev/null
@@ -1,80 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Dissolve"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/randomsquares.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "smoothness",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                10,
-                10
-            ],
-            "MAX": [
-                100,
-                100
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "size",
-            "TYPE": "point2D"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: gre
-// License: MIT
-
- 
-float rand (vec2 co) {
-  return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-vec4 transition(vec2 p) {
-  float r = rand(floor(vec2(size) * p));
-  float m = smoothstep(0.0, -smoothness, r - (progress * (1.0 + smoothness)));
-  return mix(getFromColor(p), getToColor(p), m);
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Random Stripes.fs b/nannou_isf/test_files/Random Stripes.fs
deleted file mode 100644
index f30de2b22..000000000
--- a/nannou_isf/test_files/Random Stripes.fs	
+++ /dev/null
@@ -1,116 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Pattern", "Color"
-    ],
-    "CREDIT": "VIDVOX",
-    "DESCRIPTION": "Creates a stripe pattern with randomized colors",
-    "INPUTS": [
-        {
-            "DEFAULT": 0.25,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "width",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "offset",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "hue",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "saturation",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.95,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "brightness",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "NAME": "vertical",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 1,
-            "NAME": "randHue",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 0,
-            "NAME": "randSaturation",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 0,
-            "NAME": "randBright",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 0,
-            "NAME": "randAlpha",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 0.71,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "rSeed",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-float rand(vec2 co){
-    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-vec4 rand4(vec4 co)	{
-	vec4	returnMe = vec4(0.0);
-	returnMe.r = rand(co.rg);
-	returnMe.g = rand(co.gb);
-	returnMe.b = rand(co.ba);
-	returnMe.a = rand(co.rb);
-	return returnMe;
-}
-
-vec3 hsv2rgb(vec3 c)	{
-	vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
-	vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
-	return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
-}
-
-void main() {
-
-	vec4 out_color = vec4(0.0);
-	float coord = (vertical) ? isf_FragNormCoord.x : isf_FragNormCoord.y;
-	vec4 hsv = vec4(hue, saturation, brightness, 1.0);
-	float minW = (vertical) ? max(width,1.0/RENDERSIZE.x) : max(width,1.0/RENDERSIZE.y);
-	float index = floor((coord+offset) / minW);
-	
-	hsv.r = (randHue) ? mod(hsv.r + rand(vec2(index, rSeed + 0.34219)),1.0) : hsv.r;
-	hsv.g = (randSaturation) ? mod(hsv.g + rand(vec2(index, rSeed + 0.57731)),1.0) : hsv.g;
-	hsv.b = (randBright) ? mod(hsv.b + rand(vec2(index, rSeed + 0.79436)),1.0) : hsv.b;
-	hsv.a = (randAlpha) ? rand(vec2(hsv.a + index, rSeed + 1.37665)) : hsv.a;
-	
-	out_color.rgb = hsv2rgb(hsv.rgb);
-	out_color.a = hsv.a;
-	
-	gl_FragColor = out_color;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Replicate Random.fs b/nannou_isf/test_files/Replicate Random.fs
deleted file mode 100644
index 691deae6f..000000000
--- a/nannou_isf/test_files/Replicate Random.fs	
+++ /dev/null
@@ -1,97 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Tile Effect"
-    ],
-    "CREDIT": "",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "randomSeed",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 5,
-            "MAX": 15,
-            "MIN": 1,
-            "NAME": "repetitions",
-            "TYPE": "float"
-        },
-        {
-            "NAME": "randomizeOpacity",
-            "TYPE": "bool"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-float rand(vec2 co){
-    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-
-vec2 paddedZoomedPosition(vec2 loc, float zl, vec2 c, float p)	{
-	vec2		returnMe = loc;
-	float		zoomMult = (1.0/zl);
-	vec2		modifiedCenter = 2.0*(1.0+p)*c/RENDERSIZE-(1.0+p);
-	float		modifiedPadding = p;
-	
-	returnMe.x = (returnMe.x)*zoomMult + p/2.0 - modifiedCenter.x;
-	returnMe.y = (returnMe.y)*zoomMult + p/2.0 - modifiedCenter.y;
-	returnMe.x = mod(returnMe.x,1.0+modifiedPadding) - p/2.0;
-	returnMe.y = mod(returnMe.y,1.0+modifiedPadding) - p/2.0;
-	
-	return returnMe;
-}
-
-vec2 randomPaddedZoomedPositionWithSeed(vec2 loc, vec2 seed)	{
-	float		minZoomLevel = (4.0/RENDERSIZE.x);
-	vec2		zSeed = seed * vec2(0.128,9.21) + vec2(1.42,2.17);
-	vec2		cSeed1 = seed * vec2(0.436,0.931) + vec2(2.76,3.779);
-	vec2		cSeed2 = seed * vec2(2.831,2.173) + vec2(1.73,6.256);
-	float		modZoom = 0.9*rand(zSeed);
-	vec2		modCenter = RENDERSIZE*vec2(rand(cSeed1),rand(cSeed2));
-	float		modPad = 0.5*rand(seed);
-	modZoom = (modZoom < minZoomLevel) ? minZoomLevel : modZoom;
-	
-	vec2		returnMe = paddedZoomedPosition(loc,modZoom,modCenter,modPad);
-	
-	return returnMe;
-}
-
-
-
-
-void main()	{
-	vec4		inputPixelColor = vec4(0.0);
-
-	int			depth = int(repetitions);
-	vec2		loc = isf_FragNormCoord;
-	
-	for (int i = 0;i < 15;++i)	{
-		if (i >= depth)
-			break;
-		vec2		tmpSeed = vec2((1.12+float(i))*randomSeed+1.37,(1.92+float(i))*randomSeed+1.37);
-		float		modOpacity = (randomizeOpacity) ? 0.25+0.75*rand(tmpSeed) : 1.0;
-		loc = randomPaddedZoomedPositionWithSeed(isf_FragNormCoord,tmpSeed);
-		if ((loc.x < 0.0)||(loc.y < 0.0)||(loc.x > 1.0)||(loc.y > 1.0))	{
-			//inputPixelColor = vec4(0.0);
-		}
-		else	{
-			vec4	tmpColor = IMG_NORM_PIXEL(inputImage,loc);
-			inputPixelColor.rgb = inputPixelColor.rgb + tmpColor.rgb * tmpColor.a * modOpacity;
-			inputPixelColor.a += (tmpColor.a * modOpacity);
-			if (inputPixelColor.a > 0.99)	{
-				break;
-			}
-		}
-		
-	}
-	
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/Replicate.fs b/nannou_isf/test_files/Replicate.fs
deleted file mode 100644
index 7108f70db..000000000
--- a/nannou_isf/test_files/Replicate.fs
+++ /dev/null
@@ -1,127 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Tile Effect"
-    ],
-    "CREDIT": "",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.5,
-            "IDENTITY": 1,
-            "MAX": 2,
-            "MIN": 0,
-            "NAME": "startSize",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "startOpacity",
-            "TYPE": "float"
-        },
-        {
-            "NAME": "startCenter",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": 0.25,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "startPadding",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.25,
-            "MAX": 2,
-            "MIN": 0,
-            "NAME": "endSize",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "endOpacity",
-            "TYPE": "float"
-        },
-        {
-            "NAME": "endCenter",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": 0.1,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "endPadding",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 5,
-            "MAX": 15,
-            "MIN": 1,
-            "NAME": "repetitions",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-vec2 paddedZoomedPosition(vec2 loc, float zl, vec2 c, float p)	{
-	vec2		returnMe = loc;
-	float		zoomMult = (1.0/zl);
-	vec2		modifiedCenter = 2.0*(1.0+p)*c/RENDERSIZE-(1.0+p);
-	float		modifiedPadding = p;
-	
-	returnMe.x = (returnMe.x)*zoomMult + p/2.0 - modifiedCenter.x;
-	returnMe.y = (returnMe.y)*zoomMult + p/2.0 - modifiedCenter.y;
-	returnMe.x = mod(returnMe.x,1.0+modifiedPadding) - p/2.0;
-	returnMe.y = mod(returnMe.y,1.0+modifiedPadding) - p/2.0;
-	
-	return returnMe;
-}
-
-
-void main()	{
-	vec4		inputPixelColor = vec4(0.0);
-
-	int			depth = int(repetitions);
-	vec2		loc = isf_FragNormCoord;
-	float		minZoomLevel = (1.0/RENDERSIZE.x);
-	float		startZoomLevel = (startSize < minZoomLevel) ?  minZoomLevel : startSize;
-	float		endZoomLevel = (endSize < minZoomLevel) ?  minZoomLevel : endSize;
-	float		zoomIncrement = (depth < 2) ? 0.0 : (endZoomLevel - startZoomLevel)/float(depth-1);
-	vec2		centerIncrement = (depth < 2) ? vec2(0.0) : (endCenter - startCenter)/float(depth-1);
-	float		paddingIncrement = (depth < 2) ? 0.0 : (endPadding - startPadding)/float(depth-1);
-	float		opacityIncrement = (depth < 2) ? 0.0 : (endOpacity - startOpacity)/float(depth-1);
-	
-	for (int i = 0;i < 15;++i)	{
-		if (i >= depth)
-			break;
-		float	modZoom = startZoomLevel + zoomIncrement * float(i);
-		vec2	modCenter = startCenter + centerIncrement * float(i);
-		float	modPad = startPadding + paddingIncrement * float(i);
-		float	modOpacity = startOpacity + opacityIncrement * float(i);
-		modOpacity = clamp(modOpacity,0.0,1.0);
-		loc = paddedZoomedPosition(isf_FragNormCoord,modZoom,modCenter,modPad);
-		if ((loc.x < 0.0)||(loc.y < 0.0)||(loc.x > 1.0)||(loc.y > 1.0))	{
-			//inputPixelColor = vec4(0.0);
-		}
-		else	{
-			vec4	tmpColor = IMG_NORM_PIXEL(inputImage,loc);
-			inputPixelColor.rgb = inputPixelColor.rgb + tmpColor.rgb * tmpColor.a * modOpacity;
-			inputPixelColor.a += (tmpColor.a * modOpacity);
-			if (inputPixelColor.a > 0.99)	{
-				break;
-			}
-		}
-	}
-	
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/Resize Glitch.fs b/nannou_isf/test_files/Resize Glitch.fs
deleted file mode 100644
index bec06a5c2..000000000
--- a/nannou_isf/test_files/Resize Glitch.fs	
+++ /dev/null
@@ -1,115 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Glitch",
-        "Geometry Adjustment"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "randomFrequency",
-            "TYPE": "float"
-        },
-        {
-            "NAME": "glitchNow",
-            "TYPE": "event"
-        },
-        {
-            "DEFAULT": 2,
-            "MAX": 10,
-            "MIN": 0.01,
-            "NAME": "levelX",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 2,
-            "MAX": 10,
-            "MIN": 0.01,
-            "NAME": "levelY",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0.5,
-                0.5
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "center",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": true,
-            "NAME": "randomizeWidth",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": true,
-            "NAME": "randomizeHeight",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": true,
-            "NAME": "randomizeCenter",
-            "TYPE": "bool"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-float random (vec2 st) {
-    return fract(sin(dot(st.xy,vec2(12.9898,78.233)))*43758.5453123);
-}
-
-void main() {
-	vec2		loc;
-	vec2		modifiedCenter;
-	
-	loc = isf_FragNormCoord;
-	modifiedCenter = (randomizeCenter) ? vec2(random(vec2(TIME*1.24,0.234)),random(vec2(TIME*2.93,1.234))) : center;
-	
-	float		newWidth = 1.0;
-	float		newHeight = 1.0;
-	
-	bool		doGlitch = false;
-	
-	if (glitchNow)	{
-		doGlitch = true;
-	}
-	else if (randomFrequency == 1.0)	{
-		doGlitch = true;
-	}
-	else	{
-		float	val = random(vec2(TIME,0.2321));
-		if (val <= randomFrequency)	{
-			doGlitch = true;
-		}
-	}
-	
-	if (doGlitch == true)	{
-		newWidth = (randomizeWidth == false) ? levelX : levelX * random(vec2(TIME+0.315,FRAMEINDEX+32));
-		newHeight = (randomizeHeight == false) ? levelY : levelY * random(vec2(TIME+0.942,FRAMEINDEX+43));
-	}
-	
-	loc.x = (loc.x - modifiedCenter.x)*(1.0/newWidth) + modifiedCenter.x;
-	loc.y = (loc.y - modifiedCenter.y)*(1.0/newHeight) + modifiedCenter.y;
-	if ((loc.x < 0.0)||(loc.y < 0.0)||(loc.x > 1.0)||(loc.y > 1.0))	{
-		gl_FragColor = vec4(0.0);
-	}
-	else	{
-		gl_FragColor = IMG_NORM_PIXEL(inputImage,loc);
-	}
-}
diff --git a/nannou_isf/test_files/Ripple Transition.fs b/nannou_isf/test_files/Ripple Transition.fs
deleted file mode 100644
index a08d39a4d..000000000
--- a/nannou_isf/test_files/Ripple Transition.fs	
+++ /dev/null
@@ -1,72 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion",
-        "Dissolve"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/ripple.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 100,
-            "MAX": 100,
-            "MIN": 0,
-            "NAME": "amplitude",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 50,
-            "MAX": 100,
-            "MIN": 0,
-            "NAME": "speed",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: gre
-// License: MIT
-
-vec4 transition (vec2 uv) {
-  vec2 dir = uv - vec2(.5);
-  float dist = length(dir);
-  vec2 offset = dir * (sin(progress * dist * amplitude - progress * speed) + .5) / 30.;
-  return mix(
-    getFromColor(uv + offset),
-    getToColor(uv),
-    smoothstep(0.2, 1.0, progress)
-  );
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Ripples.fs b/nannou_isf/test_files/Ripples.fs
deleted file mode 100644
index fcd2a03c2..000000000
--- a/nannou_isf/test_files/Ripples.fs
+++ /dev/null
@@ -1,118 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion Effect"
-    ],
-    "CREDIT": "by carter rosenberg",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 32,
-            "MIN": 0.1,
-            "NAME": "level",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "offset",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "x_smear",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0.01,
-            "NAME": "y_smear",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0.5,
-                0.5
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "center",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": 0,
-            "LABELS": [
-                "Single",
-                "Double"
-            ],
-            "NAME": "mode",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1
-            ]
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-const float pi = 3.14159265359;
-
-#ifndef GL_ES
-float distance (vec2 inCenter, vec2 pt)
-{
-	float tmp = pow(inCenter.x-pt.x,2.0)+pow(inCenter.y-pt.y,2.0);
-	return pow(tmp,0.5);
-}
-#endif
-
-void main() {
-	vec2 uv = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	vec2 texSize = RENDERSIZE;
-	vec2 tc = uv * texSize;
-	vec2 modifiedCenter = center * RENDERSIZE;
-	float r = distance(modifiedCenter, tc);
-	float a = atan ((tc.y-modifiedCenter.y),(tc.x-modifiedCenter.x));
-	float radius = 1.0;
-	float radius_sized = radius * length(RENDERSIZE);
-	
-	tc -= modifiedCenter;
-
-	if (r < radius_sized) 	{
-		float percent = 1.0-(radius_sized - r) / radius_sized;
-		float adjustedOffset = offset * 2.0 * pi;
-		if (mode == 0)	{
-			tc.x = r*(1.0+sin(percent * level * 2.0 * pi + adjustedOffset))/2.0 * cos(a);
-			tc.y = r*(1.0+sin(percent * level * 2.0 * pi + adjustedOffset))/2.0 * sin(a);
-		}
-		else if (mode == 1)	{
-			tc.x = r*(1.0+sin(percent * level * 2.0 * pi * cos(adjustedOffset + percent * percent * level * 2.0 * pi)))/2.0 * cos(a);
-			tc.y = r*(1.0+sin(percent * level * 2.0 * pi * cos(adjustedOffset + percent * percent * level * 2.0 * pi)))/2.0 * sin(a);
-		}
-		tc.x = mix(uv.x, tc.x, max(1.0-x_smear,0.001));
-		tc.y = mix(uv.y, tc.y, max(1.0-y_smear,0.001));
-	}
-	tc += modifiedCenter;
-	vec2 loc = tc / texSize;
-
-	if ((loc.x < 0.0)||(loc.y < 0.0)||(loc.x > 1.0)||(loc.y > 1.0))	{
-		gl_FragColor = vec4(0.0);
-	}
-	else	{
-		gl_FragColor = IMG_NORM_PIXEL(inputImage, loc);
-	}
-}
diff --git a/nannou_isf/test_files/Rotate Scale Fade.fs b/nannou_isf/test_files/Rotate Scale Fade.fs
deleted file mode 100644
index bf85cbc0a..000000000
--- a/nannou_isf/test_files/Rotate Scale Fade.fs	
+++ /dev/null
@@ -1,112 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/rotate_scale_fade.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 8,
-            "MAX": 10,
-            "MIN": 0,
-            "NAME": "scale",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0.09803921568627451,
-                0.09803921568627451,
-                0.09803921568627451,
-                1
-            ],
-            "NAME": "backColor",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 10,
-            "MIN": 0,
-            "NAME": "rotations",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0.5,
-                0.5
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "center",
-            "TYPE": "point2D"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: Fernando Kuteken
-// License: MIT
-
-#define PI 3.14159265359
-
-
-vec4 transition (vec2 uv) {
-  
-  vec2 difference = uv - center;
-  vec2 dir = normalize(difference);
-  float dist = length(difference);
-  
-  float angle = 2.0 * PI * rotations * progress;
-  
-  float c = cos(angle);
-  float s = sin(angle);
-  
-  float currentScale = mix(scale, 1.0, 2.0 * abs(progress - 0.5));
-  
-  vec2 rotatedDir = vec2(dir.x  * c - dir.y * s, dir.x * s + dir.y * c);
-  vec2 rotatedUv = center + rotatedDir * dist / currentScale;
-  
-  if (rotatedUv.x < 0.0 || rotatedUv.x > 1.0 ||
-      rotatedUv.y < 0.0 || rotatedUv.y > 1.0)
-    return backColor;
-    
-  return mix(getFromColor(rotatedUv), getToColor(rotatedUv), progress);
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Rotate.fs b/nannou_isf/test_files/Rotate.fs
deleted file mode 100644
index 3e7b6f900..000000000
--- a/nannou_isf/test_files/Rotate.fs
+++ /dev/null
@@ -1,39 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Geometry Adjustment",
-        "Utility"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "angle",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-#if __VERSION__ <= 120
-varying vec2 translated_coord;
-#else
-in vec2 translated_coord;
-#endif
-
-void main() {
-	vec2 loc = translated_coord;
-	//	if out of range draw black
-	if ((loc.x < 0.0)||(loc.y < 0.0)||(loc.x > 1.0)||(loc.y > 1.0))	{
-		gl_FragColor = vec4(0.0);
-	}
-	else	{
-		gl_FragColor = IMG_NORM_PIXEL(inputImage,loc);
-	}
-}
diff --git a/nannou_isf/test_files/Rotate.vs b/nannou_isf/test_files/Rotate.vs
deleted file mode 100644
index 6ec668393..000000000
--- a/nannou_isf/test_files/Rotate.vs
+++ /dev/null
@@ -1,21 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2 translated_coord;
-#else
-out vec2 translated_coord;
-#endif
-
-const float pi = 3.14159265359;
-
-void main()	{
-	isf_vertShaderInit();
-
-	vec2 loc = RENDERSIZE * vec2(vv_FragNormCoord[0],vv_FragNormCoord[1]);
-	float r = distance(RENDERSIZE/2.0, loc);
-	float a = atan ((loc.y-RENDERSIZE.y/2.0),(loc.x-RENDERSIZE.x/2.0));
-
-	loc.x = r * cos(a + 2.0 * pi * angle) + 0.5;
-	loc.y = r * sin(a + 2.0 * pi * angle) + 0.5;
-	
-	translated_coord = loc / RENDERSIZE + vec2(0.5);
-
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Saturation Bleed.fs b/nannou_isf/test_files/Saturation Bleed.fs
deleted file mode 100644
index 0ef8bf070..000000000
--- a/nannou_isf/test_files/Saturation Bleed.fs	
+++ /dev/null
@@ -1,143 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Color Effect"
-    ],
-    "CREDIT": "by VIDVOX",
-    "DESCRIPTION": "Applies a blur to the saturation levels of pixels.",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "bleedLevel",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 2,
-            "MAX": 10,
-            "MIN": 1,
-            "NAME": "depth",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 4,
-            "MIN": 0,
-            "NAME": "gainLevel",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "HEIGHT": "max(floor($HEIGHT*0.02),1.0)",
-            "TARGET": "smaller",
-            "WIDTH": "max(floor($WIDTH*0.02),1.0)"
-        },
-        {
-            "HEIGHT": "max(floor($HEIGHT*0.25),1.0)",
-            "TARGET": "small",
-            "WIDTH": "max(floor($WIDTH*0.25),1.0)"
-        },
-        {
-        }
-    ]
-}
-*/
-
-
-//	A simple three pass blur – first reduce the size, then do a weighted blur, then do the same thing 
-//	but  we are only going to blur the saturation
-
-
-//	Inspired by Oversaturation glitches
-//	https://bavc.github.io/avaa/artifacts/oversaturation.html
-
-
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-in vec2 left_coord;
-in vec2 right_coord;
-in vec2 above_coord;
-in vec2 below_coord;
-
-in vec2 lefta_coord;
-in vec2 righta_coord;
-in vec2 leftb_coord;
-in vec2 rightb_coord;
-#endif
-
-
-
-vec4 rgb2hsv(vec4 c)	{
-	vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-	//vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
-	//vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
-	vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
-	vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
-	
-	float d = q.x - min(q.w, q.y);
-	float e = 1.0e-10;
-	return vec4(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x,c.a);
-}
-
-vec4 hsv2rgb(vec4 c)	{
-	vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
-	vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
-	return vec4(c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y),c.a);
-}
-
-
-
-
-void main()
-{
-	
-	vec4 color = rgb2hsv(IMG_THIS_NORM_PIXEL(inputImage));
-	vec4 colorL = rgb2hsv(IMG_NORM_PIXEL(inputImage, left_coord));
-	vec4 colorR = rgb2hsv(IMG_NORM_PIXEL(inputImage, right_coord));
-	vec4 colorA = rgb2hsv(IMG_NORM_PIXEL(inputImage, above_coord));
-	vec4 colorB = rgb2hsv(IMG_NORM_PIXEL(inputImage, below_coord));
-
-	vec4 colorLA = rgb2hsv(IMG_NORM_PIXEL(inputImage, lefta_coord));
-	vec4 colorRA = rgb2hsv(IMG_NORM_PIXEL(inputImage, righta_coord));
-	vec4 colorLB = rgb2hsv(IMG_NORM_PIXEL(inputImage, leftb_coord));
-	vec4 colorRB = rgb2hsv(IMG_NORM_PIXEL(inputImage, rightb_coord));
-
-	vec4 avg = gainLevel * (colorL + colorR + colorA + colorB + colorLA + colorRA + colorLB + colorRB) / 8.0;
-	
-	
-	if (PASSINDEX == 0)	{
-		avg = mix(color, (avg + depth)/(1.0+depth), bleedLevel);
-		color.g = avg.g;
-	}
-	else if (PASSINDEX == 1)	{
-		vec4 blur = rgb2hsv(IMG_THIS_NORM_PIXEL(smaller));
-		avg = mix(color, (avg + depth*blur)/(1.0+depth), bleedLevel);
-		color.g = avg.g;
-	}
-	else if (PASSINDEX == 2)	{
-		vec4 blur = rgb2hsv(IMG_THIS_NORM_PIXEL(small));
-		avg = mix(color, (avg + depth*blur)/(1.0+depth), bleedLevel);
-		color.g = avg.g;
-	}
-	if (color.g < 0.0)
-		color.g = 0.0;
-	else if (color.g > 1.0)
-		color.g = 1.0;
-	color = hsv2rgb(color);
-	gl_FragColor = color;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Saturation Bleed.vs b/nannou_isf/test_files/Saturation Bleed.vs
deleted file mode 100644
index b0ba4b037..000000000
--- a/nannou_isf/test_files/Saturation Bleed.vs	
+++ /dev/null
@@ -1,39 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-out vec2 left_coord;
-out vec2 right_coord;
-out vec2 above_coord;
-out vec2 below_coord;
-
-out vec2 lefta_coord;
-out vec2 righta_coord;
-out vec2 leftb_coord;
-out vec2 rightb_coord;
-#endif
-
-
-void main()
-{
-	isf_vertShaderInit();
-	vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	vec2 d = 1.0/RENDERSIZE;
-
-	left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
-	right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
-	above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
-	below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
-
-	lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
-	righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
-	leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
-	rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Sepia Tone.fs b/nannou_isf/test_files/Sepia Tone.fs
deleted file mode 100644
index 58c9b52a3..000000000
--- a/nannou_isf/test_files/Sepia Tone.fs	
+++ /dev/null
@@ -1,44 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Color Effect",
-        "Retro"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.8,
-            "MAX": 1.2,
-            "MIN": 0.8,
-            "NAME": "contrast",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-//	Adapted from https://www.omniref.com/ruby/gems/essytas/0.0.1/files/lib/glsl/sepia.frag
-
-void main() {
-
-	vec4 rawColor = IMG_THIS_PIXEL(inputImage);
-	vec4 color = rawColor;
-	vec4 sepia1 = vec4( 0.2, 0.05, 0.0, 1.0 );    
-	vec4 sepia2 = vec4( 1.0, 0.9, 0.5, 1.0 );
-	float sepiaMix = dot(vec3(0.3, 0.59, 0.11), color.rgb);
-	color = mix(color, vec4(sepiaMix), 0.5);
-	vec4 sepia = mix(sepia1, sepia2, sepiaMix);
-	sepia = vec4( min( vec3( 1.0 ), sepia.rgb ), color.a );
-	
-	float bright = 0.05;
-	sepia = sepia + vec4(bright, bright, bright, 0.0);
-	sepia.rgb = ((vec3(2.0) * (sepia.rgb - vec3(0.5))) * vec3(contrast) / vec3(2.0)) + vec3(0.5);
-	sepia.a = rawColor.a;
-	gl_FragColor = sepia;
-
-}
diff --git a/nannou_isf/test_files/Set Alpha.fs b/nannou_isf/test_files/Set Alpha.fs
deleted file mode 100644
index 71f94f818..000000000
--- a/nannou_isf/test_files/Set Alpha.fs	
+++ /dev/null
@@ -1,32 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Color Adjustment",
-        "Utility"
-    ],
-    "CREDIT": "VIDVOX",
-    "DESCRIPTION": "Sets the alpha channel of the image",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.5,
-            "LABEL": "New Alpha",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "newAlpha",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-void main()	{
-	vec4		inputPixelColor = IMG_THIS_NORM_PIXEL(inputImage);
-	
-	inputPixelColor.a = newAlpha;
-	
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/Shake.fs b/nannou_isf/test_files/Shake.fs
deleted file mode 100644
index 8e9019cb8..000000000
--- a/nannou_isf/test_files/Shake.fs
+++ /dev/null
@@ -1,54 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Noise",
-        "Geometry Adjustment"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 2,
-            "MIN": 0,
-            "NAME": "magnitude",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 10,
-            "MIN": 0,
-            "NAME": "intensity",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-const float pi = 3.14159265359;
-
-
-float rand(vec2 co) {
-	return fract(sin(dot(co.xy, vec2(12.9898,78.233))) * 43758.5453);
-}
-
-void main(void) {
-	float offset = 0.1 * magnitude;
-	vec2 uv = gl_FragCoord.xy / RENDERSIZE.xy;
-	float rotation = intensity * 2.0 * pi * rand(vec2(magnitude, TIME));
-	float yOffset = offset * sin(TIME * 1.0 * cos(TIME * intensity) + rotation) * rand(vec2(magnitude, TIME));
-	float xOffset = offset * cos(TIME * 1.0 * cos(TIME * intensity) + rotation) * rand(vec2(1.0-magnitude, TIME));;
-	
-	float zoom = 1.0 + offset;
-
-	uv = (uv - 0.5) / zoom + 0.5;
-
-	uv.y += yOffset;
-	uv.x += xOffset;
-
-	gl_FragColor = IMG_NORM_PIXEL(inputImage, uv);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Shape Mask.fs b/nannou_isf/test_files/Shape Mask.fs
deleted file mode 100644
index d7046d110..000000000
--- a/nannou_isf/test_files/Shape Mask.fs	
+++ /dev/null
@@ -1,304 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Masking"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Mask Shape Mode",
-            "LABELS": [
-                "Rectangle",
-                "Triangle",
-                "Circle",
-                "Diamond"
-            ],
-            "NAME": "maskShapeMode",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1,
-                2,
-                3
-            ]
-        },
-        {
-            "DEFAULT": 0.5,
-            "LABEL": "Shape Width",
-            "MAX": 2,
-            "MIN": 0,
-            "NAME": "shapeWidth",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "LABEL": "Shape Height",
-            "MAX": 2,
-            "MIN": 0,
-            "NAME": "shapeHeight",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0.5,
-                0.5
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "center",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": false,
-            "LABEL": "Invert Mask",
-            "NAME": "invertMask",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Horizontal Repeat",
-            "LABELS": [
-                "1",
-                "2",
-                "3",
-                "4",
-                "5",
-                "6",
-                "7",
-                "8",
-                "9"
-            ],
-            "NAME": "horizontalRepeat",
-            "TYPE": "long",
-            "VALUES": [
-                1,
-                2,
-                3,
-                4,
-                5,
-                6,
-                7,
-                8,
-                9
-            ]
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Vertical Repeat",
-            "LABELS": [
-                "1",
-                "2",
-                "3",
-                "4",
-                "5",
-                "6",
-                "7",
-                "8",
-                "9"
-            ],
-            "NAME": "verticalRepeat",
-            "TYPE": "long",
-            "VALUES": [
-                1,
-                2,
-                3,
-                4,
-                5,
-                6,
-                7,
-                8,
-                9
-            ]
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Apply Mask",
-            "LABELS": [
-                "Apply Mask",
-                "Set Alpha",
-                "Show Mask"
-            ],
-            "NAME": "maskApplyMode",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1,
-                2
-            ]
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-const float pi = 3.14159265359;
-
-
-vec2 rotatePoint(vec2 pt, float angle, vec2 center)
-{
-	vec2 returnMe;
-	float s = sin(angle * pi);
-	float c = cos(angle * pi);
-
-	returnMe = pt;
-
-	// translate point back to origin:
-	returnMe.x -= center.x;
-	returnMe.y -= center.y;
-
-	// rotate point
-	float xnew = returnMe.x * c - returnMe.y * s;
-	float ynew = returnMe.x * s + returnMe.y * c;
-
-	// translate point back:
-	returnMe.x = xnew + center.x;
-	returnMe.y = ynew + center.y;
-	return returnMe;
-}
-
-float sign(vec2 p1, vec2 p2, vec2 p3)
-{
-	return (p1.x - p3.x) * (p2.y - p3.y) - (p2.x - p3.x) * (p1.y - p3.y);
-}
-
-bool PointInTriangle(vec2 pt, vec2 v1, vec2 v2, vec2 v3)
-{
-	bool b1, b2, b3;
-
-	b1 = sign(pt, v1, v2) < 0.0;
-	b2 = sign(pt, v2, v3) < 0.0;
-	b3 = sign(pt, v3, v1) < 0.0;
-
-	return ((b1 == b2) && (b2 == b3));
-}
-
-bool RotatedPointInTriangle(vec2 pt, vec2 v1, vec2 v2, vec2 v3, vec2 center)
-{
-	bool b1, b2, b3;
-	
-	vec2 v1r = v1;
-	vec2 v2r = v2;
-	vec2 v3r = v3;
-
-	b1 = sign(pt, v1r, v2r) < 0.0;
-	b2 = sign(pt, v2r, v3r) < 0.0;
-	b3 = sign(pt, v3r, v1r) < 0.0;
-
-	return ((b1 == b2) && (b2 == b3));
-}
-
-
-float isPointInShape(vec2 pt, int shape, vec4 shapeCoordinates)	{
-	float returnMe = 0.0;
-	
-	//	rectangle
-	if (shape == 0)	{
-		if (RotatedPointInTriangle(pt, shapeCoordinates.xy, shapeCoordinates.xy + vec2(0.0, shapeCoordinates.w), shapeCoordinates.xy + vec2(shapeCoordinates.z, 0.0), shapeCoordinates.xy + shapeCoordinates.zw / 2.0))	{
-			returnMe = 1.0;
-			// soft edge if needed
-			if ((pt.x > shapeCoordinates.x) && (pt.x < shapeCoordinates.x)) {
-				returnMe = clamp(((pt.x - shapeCoordinates.x) / RENDERSIZE.x), 0.0, 1.0);
-				returnMe = pow(returnMe, 0.5);
-			}
-			else if ((pt.x > shapeCoordinates.x + shapeCoordinates.z) && (pt.x < shapeCoordinates.x + shapeCoordinates.z)) {
-				returnMe = clamp(((shapeCoordinates.x + shapeCoordinates.z - pt.x) / RENDERSIZE.x), 0.0, 1.0);
-				returnMe = pow(returnMe, 0.5);
-			}
-		}
-		else if (RotatedPointInTriangle(pt, shapeCoordinates.xy + shapeCoordinates.zw, shapeCoordinates.xy + vec2(0.0, shapeCoordinates.w), shapeCoordinates.xy + vec2(shapeCoordinates.z, 0.0), shapeCoordinates.xy + shapeCoordinates.zw / 2.0))	{
-			returnMe = 1.0;
-			// soft edge if needed
-			if ((pt.x > shapeCoordinates.x) && (pt.x < shapeCoordinates.x)) {
-				returnMe = clamp(((pt.x - shapeCoordinates.x) / RENDERSIZE.x), 0.0, 1.0);
-				returnMe = pow(returnMe, 0.5);
-			}
-			else if ((pt.x > shapeCoordinates.x + shapeCoordinates.z) && (pt.x < shapeCoordinates.x + shapeCoordinates.z)) {
-				returnMe = clamp(((shapeCoordinates.x + shapeCoordinates.z - pt.x) / RENDERSIZE.x), 0.0, 1.0);
-				returnMe = pow(returnMe, 0.5);
-			}
-		}
-	}
-	//	triangle
-	else if (shape == 1)	{
-		if (RotatedPointInTriangle(pt, shapeCoordinates.xy, shapeCoordinates.xy + vec2(shapeCoordinates.z / 2.0, shapeCoordinates.w), shapeCoordinates.xy + vec2(shapeCoordinates.z, 0.0), shapeCoordinates.xy + shapeCoordinates.zw / 2.0))	{
-			returnMe = 1.0;
-		}
-	}
-	//	oval
-	else if (shape == 2)	{
-		returnMe = distance(pt, vec2(shapeCoordinates.xy + shapeCoordinates.zw / 2.0));
-		if (returnMe < min(shapeCoordinates.z,shapeCoordinates.w) / 2.0)	{
-			returnMe = 1.0;
-		}
-		else	{
-			returnMe = 0.0;
-		}
-	}
-	//	diamond
-	else if (shape == 3)	{
-		if (RotatedPointInTriangle(pt, shapeCoordinates.xy + vec2(0.0, shapeCoordinates.w / 2.0), shapeCoordinates.xy + vec2(shapeCoordinates.z / 2.0, shapeCoordinates.w), shapeCoordinates.xy + vec2(shapeCoordinates.z, shapeCoordinates.w / 2.0), shapeCoordinates.xy + shapeCoordinates.zw / 2.0))	{
-			returnMe = 1.0;
-		}
-		else if (RotatedPointInTriangle(pt, shapeCoordinates.xy + vec2(0.0, shapeCoordinates.w / 2.0), shapeCoordinates.xy + vec2(shapeCoordinates.z / 2.0, 0.0), shapeCoordinates.xy + vec2(shapeCoordinates.z, shapeCoordinates.w / 2.0), shapeCoordinates.xy + shapeCoordinates.zw / 2.0))	{
-			returnMe = 1.0;
-		}
-	}
-
-	return returnMe;	
-}
-
-
-
-void main() {
-	vec4		srcPixel = IMG_THIS_PIXEL(inputImage);
-	vec2		centerPt = RENDERSIZE * center;
-	vec2		tmpVec = RENDERSIZE * vec2(shapeWidth,shapeHeight) / 2.0;
-	vec4		patternRect = vec4(vec2(centerPt - tmpVec),tmpVec * 2.0);
-	vec2		thisPoint = RENDERSIZE * isf_FragNormCoord;
-	
-	if ((thisPoint.x >= patternRect.x) && (thisPoint.x <= patternRect.x + abs(patternRect.z)))	{
-		patternRect.z = patternRect.z / float(horizontalRepeat);
-		patternRect.x = patternRect.x + abs(patternRect.z) * floor((thisPoint.x - patternRect.x) / abs(patternRect.z));
-	}
-	else	{
-		patternRect.z = patternRect.z / float(horizontalRepeat);	
-	}
-	
-	if ((thisPoint.y >= patternRect.y) && (thisPoint.y <= patternRect.y + abs(patternRect.w)))	{
-		patternRect.w = patternRect.w / float(verticalRepeat);
-		patternRect.y = patternRect.y + abs(patternRect.w) * floor((thisPoint.y - patternRect.y) / abs(patternRect.w));
-	}
-	else	{
-		patternRect.w = patternRect.w / float(verticalRepeat);	
-	}
-	
-	float		luminance = isPointInShape(thisPoint.xy, maskShapeMode, patternRect);
-	
-	if (invertMask)
-		luminance = 1.0 - luminance;
-	
-	if (maskApplyMode == 0)	{
-		srcPixel = srcPixel * luminance;
-	}
-	else if (maskApplyMode == 1)	{
-		srcPixel.a = srcPixel.a * luminance;
-	}
-	else if (maskApplyMode == 2)	{
-		srcPixel.rgb = vec3(luminance);
-	}
-	
-	gl_FragColor = srcPixel;
-}
-
diff --git a/nannou_isf/test_files/Shape Morph Feedback Mask.fs b/nannou_isf/test_files/Shape Morph Feedback Mask.fs
deleted file mode 100644
index 6a43c5999..000000000
--- a/nannou_isf/test_files/Shape Morph Feedback Mask.fs	
+++ /dev/null
@@ -1,321 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Feedback"
-    ],
-    "CREDIT": "VIDVOX",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.25,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "maskRadius",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 16,
-            "MIN": 0,
-            "NAME": "feedbackRate",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "mixPoint",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABELS": [
-                "Circle",
-                "Triangle",
-                "Rect",
-                "Pentagram",
-                "Hexagon",
-                "Star1",
-                "Star2",
-                "Heart",
-                "Rays"
-            ],
-            "NAME": "shape1",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1,
-                2,
-                3,
-                4,
-                5,
-                6,
-                7,
-                8
-            ]
-        },
-        {
-            "DEFAULT": 1,
-            "LABELS": [
-                "Circle",
-                "Triangle",
-                "Rect",
-                "Pentagram",
-                "Hexagon",
-                "Star1",
-                "Star2",
-                "Heart",
-                "Rays"
-            ],
-            "NAME": "shape2",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1,
-                2,
-                3,
-                4,
-                5,
-                6,
-                7,
-                8
-            ]
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 2,
-            "MIN": 0,
-            "NAME": "shapeWobble",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 0.25,
-            "MIN": -0.25,
-            "NAME": "twirlAmount",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "fadeRate",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.1,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "centerFeedback",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0.5,
-                0.5
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "feedbackCenter",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": 2,
-            "LABELS": [
-                "Mask",
-                "CenteredMask",
-                "Scaled",
-                "Wrap",
-                "MirrorWrap",
-                "InvertedMask"
-            ],
-            "NAME": "styleMode",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1,
-                2,
-                3,
-                4,
-                5
-            ]
-        },
-        {
-            "NAME": "clearBuffer",
-            "TYPE": "event"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "PERSISTENT": true,
-            "TARGET": "feedbackBuffer"
-        }
-    ]
-}
-*/
-
-const float pi = 3.1415926535897932384626433832795;
-const float tau =  6.2831853071795864769252867665590;
-
-//	borrowed from pixel spirit deck!
-//	https://github.com/patriciogonzalezvivo/PixelSpiritDeck/tree/master/lib
-
-float triSDF(vec2 st) {
-    st = (st*2.-1.)*2.;
-    return max(abs(st.x) * 0.866025 + st.y * 0.5, -st.y * 0.5);
-}
-float circleSDF(vec2 st) {
-    return length(st-.5)*2.;
-}
-float polySDF(vec2 st, int V) {
-    st = st*2.-1.;
-    float a = atan(st.x,st.y)+pi;
-    float r = length(st);
-    float v = tau/float(V);
-    return cos(floor(.5+a/v)*v-a)*r;
-}
-float pentSDF(vec2 st)	{
-	vec2 pt = st;
-	pt.y /= 0.89217;
-	return polySDF(pt, 5);
-}
-float hexSDF(vec2 st) {
-    st = abs(st*2.-1.);
-    return max(abs(st.y), st.x * 0.866025 + st.y * 0.5);
-}
-float flowerSDF(vec2 st, int N) {
-    st = st*2.-1.;
-    float r = length(st)*2.;
-    float a = atan(st.y,st.x);
-    float v = float(N)*.5;
-    return 1.-(abs(cos(a*v))*.5+.5)/r;
-}
-float heartSDF(vec2 st) {
-    st -= vec2(.5,.8);
-    float r = length(st)*5.5;
-    st = normalize(st);
-    return r - 
-         ((st.y*pow(abs(st.x),0.67))/ 
-         (st.y+1.5)-(2.)*st.y+1.26);
-}
-float starSDF(vec2 st, int V, float s) {
-    st = st*4.-2.;
-    float a = atan(st.y, st.x)/tau;
-    float seg = a * float(V);
-    a = ((floor(seg) + 0.5)/float(V) + 
-        mix(s,-s,step(.5,fract(seg)))) 
-        * tau;
-    return abs(dot(vec2(cos(a),sin(a)),
-                   st));
-}
-float raysSDF(vec2 st, int N) {
-    st -= .5;
-    return fract(atan(st.y,st.x)/tau*float(N));
-}
-
-float shapeForType(vec2 st, int shape)	{
-	if (shape == 0)
-		return circleSDF(st);
-	else if (shape == 1)	
-		return triSDF(st);
-	else if (shape == 2)
-		return polySDF(st,4);
-	else if (shape == 3)
-		return pentSDF(st);
-	else if (shape == 4)
-		return hexSDF(st);
-	else if (shape == 5)
-		return starSDF(st,5,0.07);
-	else if (shape == 6)
-		return starSDF(st,12,0.12);
-	else if (shape == 7)
-		return heartSDF(st);
-	else if (shape == 8)
-		return raysSDF(st,6);
-}
-
-
-void main()	{
-	vec4		inputPixelColor = vec4(0.0);
-	vec2		loc = isf_FragNormCoord.xy;
-	loc -= (feedbackCenter - vec2(0.5));
-	loc = mix(vec2((loc.x*RENDERSIZE.x/RENDERSIZE.y)-(RENDERSIZE.x*.5-RENDERSIZE.y*.5)/RENDERSIZE.y,loc.y), 
-				vec2(loc.x,loc.y*(RENDERSIZE.y/RENDERSIZE.x)-(RENDERSIZE.y*.5-RENDERSIZE.x*.5)/RENDERSIZE.x), 
-				step(RENDERSIZE.x,RENDERSIZE.y));
-	
-	float		val1 = shapeForType(loc,shape1);
-	float		val2 = shapeForType(loc,shape2);
-	vec2		locCenter = feedbackCenter * RENDERSIZE;
-	loc = gl_FragCoord.xy;
-	float		val = mix(val1,val2,mixPoint);
-	float		a1 = (atan(locCenter.y-loc.y,locCenter.x-loc.x) + pi) / (tau);
-	
-	val += (shapeWobble == 0.0) ? 0.0 : shapeWobble * ((sin(TIME+10.0*tau*(a1)))/13.0 + (sin(-TIME*2.1+17.0*tau*(a1)))/17.0 + (sin(19.0*tau*(a1)))/19.0);
-	
-	float		scaledRadius = maskRadius * min(RENDERSIZE.x,RENDERSIZE.y);
-	float		dist = val * min(RENDERSIZE.x,RENDERSIZE.y);
-	bool		invertMask = (styleMode == 5);
-	float		feedbackLevel = 1.0;
-	
-	//	if within the shape, just do the shape
-	if (((dist>scaledRadius)&&(invertMask))||((dist<scaledRadius)&&(invertMask==false)))	{
-		if (styleMode == 1)	{
-			loc -= (locCenter-RENDERSIZE/2.0);
-		}
-		else if (styleMode == 2)	{
-			loc -= (locCenter-RENDERSIZE/2.0);
-			loc -= RENDERSIZE/2.0;
-			loc /= (2.0 * maskRadius);
-			loc += RENDERSIZE/2.0;
-		}
-		else if (styleMode == 3)	{
-			float	r = distance(locCenter,loc);
-			float 	a = atan((loc.y-locCenter.y),(loc.x-locCenter.x));	
-			a = (a + pi)/(tau);
-			a = mod(a+0.75,1.0);
-			r /= scaledRadius;
-			loc = RENDERSIZE * vec2(a,r);
-		}
-		else if (styleMode == 4)	{
-			float	r = distance(locCenter,loc);
-			float 	a = atan((loc.y-locCenter.y),(loc.x-locCenter.x));	
-			a = (a + pi)/(tau);
-			a = mod(a+0.75,1.0);
-			a = (a < 0.5) ? a * 2.0 : 2.0 - a * 2.0;
-			r /= scaledRadius;
-			loc = RENDERSIZE * vec2(a,r);
-		}
-		inputPixelColor = IMG_PIXEL(inputImage,loc);
-		feedbackLevel = centerFeedback;
-		/*
-		if ((centerFeedback > 0.0)&&(clearBuffer == false))	{
-			inputPixelColor = mix(inputPixelColor,IMG_THIS_PIXEL(feedbackBuffer),centerFeedback);	
-		}
-		*/
-		//inputPixelColor = vec4(loc.x,loc.y,0.0,1.0);
-	}
-	if ((clearBuffer == false)&&(feedbackLevel > 0.0))	{
-		//float	r = distance(RENDERSIZE/2.0,loc);
-		float 	a = atan((loc.y-locCenter.y),(loc.x-locCenter.x));
-		//a = tau * (floor(a * 5.0 / tau) / 5.0);
-		float	shiftAmount = -1.0 * feedbackRate;
-		vec2	shift = shiftAmount * vec2(cos(a + twirlAmount * tau), sin(a + twirlAmount * tau));
-		loc = (invertMask) ? loc - shift : loc + shift;
-		inputPixelColor = mix(inputPixelColor,IMG_PIXEL(feedbackBuffer,loc),feedbackLevel);
-		inputPixelColor.a -= fadeRate / 50.0;
-		//inputPixelColor = vec4((a+pi)/(2.0*pi),2.0*r/RENDERSIZE.x,0.0,1.0);
-		//inputPixelColor = vec4(shift.x*2.0-1.0,shift.y*2.0-1.0,0.0,1.0);
-	}
-	
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/Shape Morph Wrap.fs b/nannou_isf/test_files/Shape Morph Wrap.fs
deleted file mode 100644
index 80e406088..000000000
--- a/nannou_isf/test_files/Shape Morph Wrap.fs	
+++ /dev/null
@@ -1,358 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion Effect"
-    ],
-    "CREDIT": "VIDVOX",
-    "DESCRIPTION": "Wraps an image into a shape that is created by morphing two primitive shapes together",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "mixPoint",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABELS": [
-                "Circle",
-                "Triangle",
-                "Rect",
-                "Pentagram",
-                "Hexagon",
-                "Star1",
-                "Star2",
-                "Heart",
-                "Rays"
-            ],
-            "NAME": "shape1",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1,
-                2,
-                3,
-                4,
-                5,
-                6,
-                7,
-                8
-            ]
-        },
-        {
-            "DEFAULT": 1,
-            "LABELS": [
-                "Circle",
-                "Triangle",
-                "Rect",
-                "Pentagram",
-                "Hexagon",
-                "Star1",
-                "Star2",
-                "Heart",
-                "Rays"
-            ],
-            "NAME": "shape2",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1,
-                2,
-                3,
-                4,
-                5,
-                6,
-                7,
-                8
-            ]
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 2,
-            "MIN": 0,
-            "NAME": "shapeWobble",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "preRotateAngle",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.75,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "angleShift",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABELS": [
-                "None",
-                "Extend",
-                "Repeat",
-                "Reflect"
-            ],
-            "NAME": "repeatStyle",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1,
-                2,
-                3
-            ]
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "repeatDecay",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "resultSize",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 2,
-            "MIN": 0,
-            "NAME": "resultWidth",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "resultAngle",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0.5,
-                0.5
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "resultCenter",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": 1,
-            "NAME": "mirrorX",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 0,
-            "NAME": "mirrorY",
-            "TYPE": "bool"
-        }
-    ],
-    "ISFVSN": "2",
-    "VSN": "1"
-}
-*/
-
-
-const float pi = 3.1415926535897932384626433832795;
-const float tau =  6.2831853071795864769252867665590;
-
-vec2 rotatePoint(vec2 pt, float rot)	{
-	vec2 returnMe = pt * RENDERSIZE;
-
-	float r = distance(RENDERSIZE/2.0, returnMe);
-	float a = atan ((returnMe.y-RENDERSIZE.y/2.0),(returnMe.x-RENDERSIZE.x/2.0));
-
-	returnMe.x = r * cos(a + 2.0 * pi * rot - pi) + 0.5;
-	returnMe.y = r * sin(a + 2.0 * pi * rot - pi) + 0.5;
-	
-	returnMe = returnMe / RENDERSIZE + vec2(0.5);
-	
-	return returnMe;
-}
-
-vec2 rotatePointNorm(vec2 pt, float rot)	{
-	vec2 returnMe = pt;
-
-	float r = distance(vec2(0.50), returnMe);
-	float a = atan((returnMe.y-0.5),(returnMe.x-0.5));
-
-	returnMe.x = r * cos(a + 2.0 * pi * rot - pi) + 0.5;
-	returnMe.y = r * sin(a + 2.0 * pi * rot - pi) + 0.5;
-	
-	returnMe = returnMe;
-	
-	return returnMe;
-}
-vec2 rotatePointNormPt(vec2 pt, float rot, vec2 rpt)	{
-	vec2 returnMe = pt;
-
-	float r = distance(vec2(0.50), returnMe);
-	float a = atan((returnMe.y-rpt.y),(returnMe.x-rpt.x));
-
-	returnMe.x = r * cos(a + 2.0 * pi * rot - pi) + rpt.x;
-	returnMe.y = r * sin(a + 2.0 * pi * rot - pi) + rpt.y;
-	
-	returnMe = returnMe;
-	
-	return returnMe;
-}
-
-//	borrowed from pixel spirit deck!
-//	https://github.com/patriciogonzalezvivo/PixelSpiritDeck/tree/master/lib
-
-float triSDF(vec2 st) {
-    st = (st*2.-1.)*2.;
-    return max(abs(st.x) * 0.866025 + st.y * 0.5, -st.y * 0.5);
-}
-float circleSDF(vec2 st) {
-    return length(st-.5)*2.;
-}
-float polySDF(vec2 st, int V) {
-    st = st*2.-1.;
-    float a = atan(st.x,st.y)+pi;
-    float r = length(st);
-    float v = tau/float(V);
-    return cos(floor(.5+a/v)*v-a)*r;
-}
-float pentSDF(vec2 st)	{
-	vec2 pt = st;
-	pt.y /= 0.89217;
-	return polySDF(pt, 5);
-}
-float hexSDF(vec2 st) {
-    st = abs(st*2.-1.);
-    return max(abs(st.y), st.x * 0.866025 + st.y * 0.5);
-}
-float flowerSDF(vec2 st, int N) {
-    st = st*2.-1.;
-    float r = length(st)*2.;
-    float a = atan(st.y,st.x);
-    float v = float(N)*.5;
-    return 1.-(abs(cos(a*v))*.5+.5)/r;
-}
-float heartSDF(vec2 st) {
-    st -= vec2(.5,.8);
-    float r = length(st)*5.5;
-    st = normalize(st);
-    return r - 
-         ((st.y*pow(abs(st.x),0.67))/ 
-         (st.y+1.5)-(2.)*st.y+1.26);
-}
-float starSDF(vec2 st, int V, float s) {
-    st = st*4.-2.;
-    float a = atan(st.y, st.x)/tau;
-    float seg = a * float(V);
-    a = ((floor(seg) + 0.5)/float(V) + 
-        mix(s,-s,step(.5,fract(seg)))) 
-        * tau;
-    return abs(dot(vec2(cos(a),sin(a)),
-                   st));
-}
-float raysSDF(vec2 st, int N) {
-    st -= .5;
-    return fract(atan(st.y,st.x)/tau*float(N));
-}
-
-float shapeForType(vec2 st, int shape)	{
-	if (shape == 0)
-		return circleSDF(st);
-	else if (shape == 1)	
-		return triSDF(st);
-	else if (shape == 2)
-		return polySDF(st,4);
-	else if (shape == 3)
-		return pentSDF(st);
-	else if (shape == 4)
-		return hexSDF(st);
-	else if (shape == 5)
-		return starSDF(st,5,0.07);
-	else if (shape == 6)
-		return starSDF(st,12,0.12);
-	else if (shape == 7)
-		return heartSDF(st);
-	else if (shape == 8)
-		return raysSDF(st,6);
-}
-
-void main()	{
-	vec4		returnMe = vec4(0.0);
-	vec2		st = gl_FragCoord.xy/RENDERSIZE;
-
-	st += (0.5 - resultCenter);
-	st = rotatePoint(st,resultAngle);
-	
-    //	size
-	st -= 0.5;
-	//st += (0.5 - resultCenter);
-	st /= max(0.000001,resultSize);
-	st.x /= resultWidth;
-	st += 0.5;
-   
-	st = mix(vec2((st.x*RENDERSIZE.x/RENDERSIZE.y)-(RENDERSIZE.x*.5-RENDERSIZE.y*.5)/RENDERSIZE.y,st.y), 
-				vec2(st.x,st.y*(RENDERSIZE.y/RENDERSIZE.x)-(RENDERSIZE.y*.5-RENDERSIZE.x*.5)/RENDERSIZE.x), 
-				step(RENDERSIZE.x,RENDERSIZE.y));
-	float		val1 = shapeForType(st,shape1);
-	float		val2 = shapeForType(st,shape2);
-	//val1 = min(max(val1,0.0),1.0);
-	//val2 = min(max(val2,0.0),1.0);
-	
-	float		val = mix(val1,val2,mixPoint);
-	vec2		cnt = vec2(0.5,0.5);
-	float		a = (atan(cnt.y-st.y,cnt.x-st.x) + pi) / (tau);
-	
-	val += (shapeWobble == 0.0) ? 0.0 : shapeWobble * ((sin(TIME+10.0*tau*(a)))/13.0 + (sin(-TIME*2.1+17.0*tau*(a)))/17.0 + (sin(19.0*tau*(a)))/19.0);
-	
-	float		r = val;
-	if (repeatStyle == 1)
-		r = max(0.0,min(r,1.0));
-	else if (repeatStyle == 2)
-		r = mod(r,1.0);
-	else if (repeatStyle == 3)	{
-		r = mod(r,2.0);
-		r = (r > 1.0) ? 2.0 - r : r;	
-	}
-	
-	if (r <= 1.0)	{
-		
-		a = mod(a + angleShift, 1.0);
-		vec2	pt = vec2(a,r);
-		//returnMe = vec4(r,a,0.0,1.0);
-		
-		if (mirrorX)	{
-			pt.x = (pt.x < 0.5) ? pt.x * 2.0 : 2.0 - pt.x * 2.0;
-		}
-		if (mirrorY)	{
-			pt.y = (pt.y < 0.5) ? pt.y * 2.0 : 2.0 - pt.y * 2.0;	
-		}
-		
-		pt = rotatePointNorm(pt,preRotateAngle);
-		returnMe = IMG_NORM_PIXEL(inputImage,pt);
-		
-		if (repeatStyle > 0)	{
-			if (repeatStyle == 1)
-				returnMe.a *= (val > 1.0) ? 1.0 - repeatDecay * (val) : 1.0;
-			else	{
-				float repCount = 1.0 / (1.0+resultSize);
-				returnMe.a *= 1.0 - repeatDecay * floor(val) / repCount;
-			}
-		}
-	}
-	
-	gl_FragColor = returnMe;
-}
diff --git a/nannou_isf/test_files/Sharpen Luminance.fs b/nannou_isf/test_files/Sharpen Luminance.fs
deleted file mode 100644
index 94cf08535..000000000
--- a/nannou_isf/test_files/Sharpen Luminance.fs	
+++ /dev/null
@@ -1,66 +0,0 @@
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Sharpen"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "intensity",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 2.0,
-			"DEFAULT": 1.0
-		}
-	]
-}*/
-
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-in vec2 left_coord;
-in vec2 right_coord;
-in vec2 above_coord;
-in vec2 below_coord;
-
-in vec2 lefta_coord;
-in vec2 righta_coord;
-in vec2 leftb_coord;
-in vec2 rightb_coord;
-#endif
-
-float gray(vec4 n)
-{
-	return (n.r + n.g + n.b)/3.0;
-}
-
-void main()
-{
-
-	vec4 color = IMG_THIS_PIXEL(inputImage);
-	float colorL = gray(IMG_NORM_PIXEL(inputImage, left_coord));
-	float colorR = gray(IMG_NORM_PIXEL(inputImage, right_coord));
-	float colorA = gray(IMG_NORM_PIXEL(inputImage, above_coord));
-	float colorB = gray(IMG_NORM_PIXEL(inputImage, below_coord));
-
-	float colorLA = gray(IMG_NORM_PIXEL(inputImage, lefta_coord));
-	float colorRA = gray(IMG_NORM_PIXEL(inputImage, righta_coord));
-	float colorLB = gray(IMG_NORM_PIXEL(inputImage, leftb_coord));
-	float colorRB = gray(IMG_NORM_PIXEL(inputImage, rightb_coord));
-
-	vec4 final = color + color * intensity * (8.0*gray(color) - colorL - colorR - colorA - colorB - colorLA - colorRA - colorLB - colorRB);
-	
-	gl_FragColor = final;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Sharpen Luminance.vs b/nannou_isf/test_files/Sharpen Luminance.vs
deleted file mode 100644
index 8f2188f5d..000000000
--- a/nannou_isf/test_files/Sharpen Luminance.vs	
+++ /dev/null
@@ -1,39 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-out vec2 left_coord;
-out vec2 right_coord;
-out vec2 above_coord;
-out vec2 below_coord;
-
-out vec2 lefta_coord;
-out vec2 righta_coord;
-out vec2 leftb_coord;
-out vec2 rightb_coord;
-#endif
-
-
-void main()
-{
-	isf_vertShaderInit();
-	vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	vec2 d = 1.0/RENDERSIZE;
-	
-	left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
-	right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
-	above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
-	below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
-
-	lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
-	righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
-	leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
-	rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Sharpen RGB.fs b/nannou_isf/test_files/Sharpen RGB.fs
deleted file mode 100644
index 7c269cd19..000000000
--- a/nannou_isf/test_files/Sharpen RGB.fs	
+++ /dev/null
@@ -1,83 +0,0 @@
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Sharpen"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "intensityR",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 10.0,
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "intensityG",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 10.0,
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "intensityB",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 10.0,
-			"DEFAULT": 1.0
-		}
-	]
-}*/
-
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-in vec2 left_coord;
-in vec2 right_coord;
-in vec2 above_coord;
-in vec2 below_coord;
-
-in vec2 lefta_coord;
-in vec2 righta_coord;
-in vec2 leftb_coord;
-in vec2 rightb_coord;
-#endif
-
-float gray(vec4 n)
-{
-	return (n.r + n.g + n.b)/3.0;
-}
-
-void main()
-{
-
-	vec4 color = IMG_THIS_PIXEL(inputImage);
-	vec4 colorL = IMG_NORM_PIXEL(inputImage, left_coord);
-	vec4 colorR = IMG_NORM_PIXEL(inputImage, right_coord);
-	vec4 colorA = IMG_NORM_PIXEL(inputImage, above_coord);
-	vec4 colorB = IMG_NORM_PIXEL(inputImage, below_coord);
-
-	vec4 colorLA = IMG_NORM_PIXEL(inputImage, lefta_coord);
-	vec4 colorRA = IMG_NORM_PIXEL(inputImage, righta_coord);
-	vec4 colorLB = IMG_NORM_PIXEL(inputImage, leftb_coord);
-	vec4 colorRB = IMG_NORM_PIXEL(inputImage, rightb_coord);
-
-	vec4 final = color;
-	final.r = color.r + intensityR * (8.0*color.r - colorL.r - colorR.r - colorA.r - colorB.r - colorLA.r - colorRA.r - colorLB.r - colorRB.r);
-	final.g = color.g + intensityG * (8.0*color.g - colorL.g - colorR.g - colorA.g - colorB.g - colorLA.g - colorRA.g - colorLB.g - colorRB.g);
-	final.b = color.b + intensityB * (8.0*color.b - colorL.b - colorR.b - colorA.b - colorB.b - colorLA.b - colorRA.b - colorLB.b - colorRB.b);
-	
-	gl_FragColor = final;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Sharpen RGB.vs b/nannou_isf/test_files/Sharpen RGB.vs
deleted file mode 100644
index 8f2188f5d..000000000
--- a/nannou_isf/test_files/Sharpen RGB.vs	
+++ /dev/null
@@ -1,39 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-out vec2 left_coord;
-out vec2 right_coord;
-out vec2 above_coord;
-out vec2 below_coord;
-
-out vec2 lefta_coord;
-out vec2 righta_coord;
-out vec2 leftb_coord;
-out vec2 rightb_coord;
-#endif
-
-
-void main()
-{
-	isf_vertShaderInit();
-	vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	vec2 d = 1.0/RENDERSIZE;
-	
-	left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
-	right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
-	above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
-	below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
-
-	lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
-	righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
-	leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
-	rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Shockwave Pulse.fs b/nannou_isf/test_files/Shockwave Pulse.fs
deleted file mode 100644
index 434bde012..000000000
--- a/nannou_isf/test_files/Shockwave Pulse.fs	
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Distortion Effect"
-  ],
-  "DESCRIPTION" : "",
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "NAME" : "inputImage",
-      "TYPE" : "image"
-    },
-    {
-      "NAME" : "pulse",
-      "TYPE" : "event"
-    },
-    {
-      "NAME" : "rate",
-      "TYPE" : "float",
-      "MAX" : 4,
-      "DEFAULT" : 1,
-      "LABEL" : "rate",
-      "MIN" : 0
-    },
-    {
-      "NAME" : "magnitude",
-      "TYPE" : "float",
-      "MAX" : 0.20000000000000001,
-      "DEFAULT" : 0.080000000000000002,
-      "LABEL" : "magnitude",
-      "MIN" : 0
-    },
-    {
-      "NAME" : "distortion",
-      "TYPE" : "float",
-      "MAX" : 20,
-      "DEFAULT" : 10,
-      "LABEL" : "distortion",
-      "MIN" : 0
-    },
-    {
-      "NAME" : "center",
-      "TYPE" : "point2D",
-      "MAX" : [
-        1,
-        1
-      ],
-      "DEFAULT" : [
-        0.5,
-        0.5
-      ],
-      "MIN" : [
-        0,
-        0
-      ]
-    }
-  ],
-  "PASSES" : [
-    {
-      "PERSISTENT" : true,
-      "WIDTH" : "1",
-      "DESCRIPTION" : "this buffer stores the last frame's time offset in the first component of its only pixel- note that it's requesting a FLOAT target buffer...",
-      "HEIGHT" : "1",
-      "TARGET" : "lastTime",
-      "FLOAT" : true
-    },
-    {
-
-    }
-  ],
-  "CREDIT" : "by VIDVOX"
-}
-*/
-
-
-
-void main()
-{
-	//	if this is the first pass, i'm going to read the position from the "lastPosition" image, and write a new position based on this and the hold variables
-	if (PASSINDEX == 0)	{
-		vec4		srcPixel = IMG_PIXEL(lastTime,vec2(0.5));
-		//	i'm only using the X, which is the last render time we reset
-		srcPixel.r = (pulse && FRAMEINDEX>10) ? 0.0 : clamp(srcPixel.r + rate * 0.01,0.0,1.0);
-		gl_FragColor = srcPixel;
-	}
-	//	else this isn't the first pass- read the position value from the buffer which stores it
-	else	{
-		vec2 uv = isf_FragNormCoord.xy;
-		vec2 texCoord = uv;
-		vec2 mod_center = center;
-		float distance = distance(uv, mod_center);
-		vec4 lastPosVector = IMG_PIXEL(lastTime,vec2(0.5));
-		float adustedTime = lastPosVector.r * (1.0+length(distance));
-
-		if ( (distance <= (adustedTime + magnitude)) && (distance >= (adustedTime - magnitude)) ) 	{
-			float diff = (distance - adustedTime); 
-			float powDiff = 1.0 - pow(abs(diff*distortion), 
-									0.8); 
-			float diffTime = diff  * powDiff; 
-			vec2 diffUV = normalize(uv - mod_center); 
-			texCoord = uv + (diffUV * diffTime);
-		} 
-		gl_FragColor = IMG_NORM_PIXEL(inputImage, texCoord);
-	}
-}
diff --git a/nannou_isf/test_files/Shockwave.fs b/nannou_isf/test_files/Shockwave.fs
deleted file mode 100644
index 928295e73..000000000
--- a/nannou_isf/test_files/Shockwave.fs
+++ /dev/null
@@ -1,82 +0,0 @@
-/*{
-  "DESCRIPTION": "",
-  "CREDIT": "by VIDVOX",
-  "CATEGORIES": [
-    "Distortion Effect"
-  ],
-  "INPUTS": [
-    {
-      "NAME": "inputImage",
-      "TYPE": "image"
-    },
-    {
-      "NAME": "positionVal",
-      "TYPE": "float",
-      "MIN": 0,
-      "MAX": 1,
-      "DEFAULT": 0
-    },
-    {
-      "NAME": "distortion",
-      "TYPE": "float",
-      "MIN": 1,
-      "MAX": 20,
-      "DEFAULT": 10
-    },
-    {
-      "NAME": "magnitude",
-      "TYPE": "float",
-      "MIN": 0,
-      "MAX": 0.2,
-      "DEFAULT": 0.08
-    },
-    {
-      "NAME" : "center",
-      "TYPE" : "point2D",
-      "MAX" : [
-        1,
-        1
-      ],
-      "DEFAULT" : [
-        0.5,
-        0.5
-      ],
-      "MIN" : [
-        0,
-        0
-      ]
-    },
-    {
-      "NAME": "background",
-      "TYPE": "bool",
-      "DEFAULT": 1
-    }
-  ]
-}*/
-
-
-
-void main()
-{
-	//	do this junk so that the ripple starts from nothing
-	vec2 uv = isf_FragNormCoord.xy;
-	vec2 texCoord = uv;
-	vec2 mod_center = center;
-	vec4 color = vec4(0.0);
-	float dist = distance(uv, mod_center);
-	float adjustedTime = (positionVal * RENDERSIZE.x/RENDERSIZE.y - magnitude)/(1.0 - magnitude);
-
-	if ( (dist <= (adjustedTime + magnitude)) && (dist >= (adjustedTime - magnitude)) ) 	{
-		float diff = (dist - adjustedTime); 
-		float powDiff = 1.0 - pow(abs(diff*distortion), 
-								0.8); 
-		float diffTime = diff  * powDiff; 
-		vec2 diffUV = normalize(uv - mod_center); 
-		texCoord = uv + (diffUV * diffTime);
-		color = IMG_NORM_PIXEL(inputImage, texCoord);
-	}
-	else if (background)	{
-		color = IMG_NORM_PIXEL(inputImage, texCoord);
-	}
-	gl_FragColor = color;
-}
diff --git a/nannou_isf/test_files/Show Alpha.fs b/nannou_isf/test_files/Show Alpha.fs
deleted file mode 100644
index 55af35287..000000000
--- a/nannou_isf/test_files/Show Alpha.fs	
+++ /dev/null
@@ -1,22 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Utility"
-    ],
-    "CREDIT": "VIDVOX",
-    "DESCRIPTION": "Maps the alpha to grayscale",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-void main()	{
-	vec4		inputPixelColor = IMG_THIS_PIXEL(inputImage);
-	inputPixelColor.rgb = vec3(inputPixelColor.a);
-	inputPixelColor.a = 1.0;
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/Side Scroller And Flip.fs b/nannou_isf/test_files/Side Scroller And Flip.fs
deleted file mode 100644
index 6a24a47ad..000000000
--- a/nannou_isf/test_files/Side Scroller And Flip.fs	
+++ /dev/null
@@ -1,58 +0,0 @@
-/*{
- "CREDIT": "BrianChasalow",
- "ISFVSN": "2",
- "CATEGORIES": [
- "Geometry Adjustment"
- ],
- "INPUTS": [
- {
- "NAME": "inputImage",
- "TYPE": "image"
- },
- {
- "NAME": "slide",
- "TYPE": "float",
- "MIN": 0.0,
- "MAX": 2.0,
- "DEFAULT": 0.0
- },
- {
- "NAME": "shift",
- "TYPE": "float",
- "MIN": 0.0,
- "MAX": 2.0,
- "DEFAULT": 0.0
- },
- {
- "NAME": "mirrorHorizontal",
- "TYPE": "bool",
- "MIN": false,
- "MAX": true,
- "DEFAULT": true
- },
- {
- "NAME": "mirrorVertical",
- "TYPE": "bool",
- "MIN": false,
- "MAX": true,
- "DEFAULT": true
- }
- 
- ]
- }*/
-
-void main(void)
-{
-	vec2 retard = isf_FragNormCoord;
-	retard.x += slide;
-	retard.y += shift;
-	vec2 moddedRetard = mod(retard,1.0);
-	
-	if(mirrorHorizontal && retard.x >= 1.0 && retard.x <= 2.0)
-		moddedRetard = vec2(1.0-moddedRetard.x, moddedRetard.y);
-	if(mirrorVertical && retard.y >= 1.0 && retard.y <= 2.0)
-		moddedRetard = vec2(moddedRetard.x, 1.0-moddedRetard.y);
-	
-	vec4 pixel = IMG_NORM_PIXEL(inputImage, moddedRetard);
-	gl_FragColor = pixel;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Simple Zoom Transition.fs b/nannou_isf/test_files/Simple Zoom Transition.fs
deleted file mode 100644
index 17a80e989..000000000
--- a/nannou_isf/test_files/Simple Zoom Transition.fs	
+++ /dev/null
@@ -1,68 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion",
-        "Dissolve"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/SimpleZoom.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.8,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "zoom_quickness",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: 0gust1
-// License: MIT
-
-float nQuick = clamp(zoom_quickness,0.2,1.0);
-
-vec2 zoom(vec2 uv, float amount) {
-  return 0.5 + ((uv - 0.5) * (1.0-amount));	
-}
-
-vec4 transition (vec2 uv) {
-  return mix(
-    getFromColor(zoom(uv, smoothstep(0.0, nQuick, progress))),
-    getToColor(uv),
-   smoothstep(nQuick-0.2, 1.0, progress)
-  );
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Sine Warp Gradient.fs b/nannou_isf/test_files/Sine Warp Gradient.fs
deleted file mode 100644
index b52bbdf2a..000000000
--- a/nannou_isf/test_files/Sine Warp Gradient.fs	
+++ /dev/null
@@ -1,119 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Color"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "size",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "rotation",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "angle",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "shift",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": [
-                1,
-                0.5,
-                0,
-                1
-            ],
-            "NAME": "xcolor",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0.5,
-                1,
-                1
-            ],
-            "NAME": "ycolor",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0,
-                0,
-                0
-            ],
-            "NAME": "background",
-            "TYPE": "color"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-//	Basically just uses the same gradient as the Sine Warp Tile but uses the x/y values as the mix amounts for our colors
-
-
-const float tau = 6.28318530718;
-
-
-vec2 pattern() {
-	float s = sin(tau * rotation * 0.5);
-	float c = cos(tau * rotation * 0.5);
-	vec2 tex = isf_FragNormCoord;
-	float scale = 1.0 / max(size,0.001);
-	vec2 point = vec2( c * tex.x - s * tex.y, s * tex.x + c * tex.y ) * scale;
-	point = point - scale * shift;
-	//	do the sine distort
-	point = 0.5 + 0.5 * vec2( sin(scale * point.x), sin(scale * point.y));
-	
-	//	now do a rotation
-	vec2 center = vec2(0.5,0.5);
-	float r = distance(center, point);
-	float a = atan ((point.y-center.y),(point.x-center.x));
-	
-	s = sin(a + tau * angle);
-	c = cos(a + tau * angle);
-	
-	float zoom = max(abs(s),abs(c))*RENDERSIZE.x / RENDERSIZE.y;
-	
-	point.x = (r * c)/zoom + 0.5;
-	point.y = (r * s)/zoom + 0.5;
-
-	return point;
-}
-
-
-void main() {
-
-	vec2 pat = pattern();
-
-	gl_FragColor = background + pat.x * xcolor + pat.y * ycolor;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Sine Warp Tile.fs b/nannou_isf/test_files/Sine Warp Tile.fs
deleted file mode 100644
index 08aabcd90..000000000
--- a/nannou_isf/test_files/Sine Warp Tile.fs	
+++ /dev/null
@@ -1,90 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Kaleidoscope",
-        "Tile Effect"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 0.5,
-            "MIN": 0,
-            "NAME": "size",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "rotation",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "angle",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0.5,
-                0.5
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "shift",
-            "TYPE": "point2D"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-const float tau = 6.28318530718;
-
-
-vec2 pattern() {
-	float s = sin(tau * rotation * 0.5);
-	float c = cos(tau * rotation * 0.5);
-	vec2 tex = isf_FragNormCoord;
-	float scale = 1.0 / max(size,0.001);
-	vec2 point = vec2( c * tex.x - s * tex.y, s * tex.x + c * tex.y ) * scale;
-	point = point - scale * shift;
-	//	do the sine distort
-	point = 0.5 + 0.5 * vec2( sin(scale * point.x), sin(scale * point.y));
-	
-	//	now do a rotation
-	vec2 center = vec2(0.5,0.5);
-	float r = distance(center, point);
-	float a = atan ((point.y-center.y),(point.x-center.x));
-	
-	s = sin(a + tau * angle);
-	c = cos(a + tau * angle);
-	
-	float zoom = max(abs(s),abs(c))*RENDERSIZE.x / RENDERSIZE.y;
-	
-	point.x = (r * c)/zoom + 0.5;
-	point.y = (r * s)/zoom + 0.5;
-
-	return point;
-}
-
-
-void main() {
-
-	vec2 pat = pattern();
-
-	gl_FragColor = IMG_NORM_PIXEL(inputImage,pat);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Sketch.fs b/nannou_isf/test_files/Sketch.fs
deleted file mode 100644
index a9a354b6d..000000000
--- a/nannou_isf/test_files/Sketch.fs
+++ /dev/null
@@ -1,72 +0,0 @@
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Stylize"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "intensity",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 10.0,
-			"DEFAULT": 1.0
-		}
-	]
-}*/
-
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-in vec2 left_coord;
-in vec2 right_coord;
-in vec2 above_coord;
-in vec2 below_coord;
-
-in vec2 lefta_coord;
-in vec2 righta_coord;
-in vec2 leftb_coord;
-in vec2 rightb_coord;
-#endif
-
-float gray(vec4 n)
-{
-	return (n.r + n.g + n.b)/3.0;
-}
-
-void main()
-{
-
-	vec4 color = IMG_THIS_PIXEL(inputImage);
-	vec4 colorL = IMG_NORM_PIXEL(inputImage, left_coord);
-	vec4 colorR = IMG_NORM_PIXEL(inputImage, right_coord);
-	vec4 colorA = IMG_NORM_PIXEL(inputImage, above_coord);
-	vec4 colorB = IMG_NORM_PIXEL(inputImage, below_coord);
-
-	vec4 colorLA = IMG_NORM_PIXEL(inputImage, lefta_coord);
-	vec4 colorRA = IMG_NORM_PIXEL(inputImage, righta_coord);
-	vec4 colorLB = IMG_NORM_PIXEL(inputImage, leftb_coord);
-	vec4 colorRB = IMG_NORM_PIXEL(inputImage, rightb_coord);
-
-	//	blur, do edges, then use the edge as a mask on the blurred
-
-	float gx = (-1.0 * gray(colorLA)) + (-2.0 * gray(colorL)) + (-1.0 * gray(colorLB)) + (1.0 * gray(colorRA)) + (2.0 * gray(colorR)) + (1.0 * gray(colorRB));
-	float gy = (1.0 * gray(colorLA)) + (2.0 * gray(colorA)) + (1.0 * gray(colorRA)) + (-1.0 * gray(colorRB)) + (-2.0 * gray(colorB)) + (-1.0 * gray(colorLB));
-
-	float edge = clamp(pow(gx*gx + gy*gy,0.5) * intensity,0.0,1.0);
-	vec4 blurred = (color + colorL + colorR + colorA + colorB + colorLA + colorRA + colorLB + colorRB) / 9.0;
-	//gl_FragColor = vec4(edge,edge,edge,1.0);
-	gl_FragColor = blurred * (1.0-edge);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Sketch.vs b/nannou_isf/test_files/Sketch.vs
deleted file mode 100644
index 8f2188f5d..000000000
--- a/nannou_isf/test_files/Sketch.vs
+++ /dev/null
@@ -1,39 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-out vec2 left_coord;
-out vec2 right_coord;
-out vec2 above_coord;
-out vec2 below_coord;
-
-out vec2 lefta_coord;
-out vec2 righta_coord;
-out vec2 leftb_coord;
-out vec2 rightb_coord;
-#endif
-
-
-void main()
-{
-	isf_vertShaderInit();
-	vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	vec2 d = 1.0/RENDERSIZE;
-	
-	left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
-	right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
-	above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
-	below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
-
-	lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
-	righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
-	leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
-	rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Sliding Strips.fs b/nannou_isf/test_files/Sliding Strips.fs
deleted file mode 100644
index 56d2cd6e6..000000000
--- a/nannou_isf/test_files/Sliding Strips.fs	
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Geometry Adjustment"
-  ],
-  "DESCRIPTION" : "",
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "NAME" : "inputImage",
-      "TYPE" : "image"
-    },
-    {
-      "NAME" : "xShiftAmount",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "yShiftAmount",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "xTileSize",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0.25,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "yTileSize",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0.25,
-      "MIN" : 0
-    }
-  ],
-  "CREDIT" : ""
-}
-*/
-
-void main()	{
-	vec2		loc = isf_FragNormCoord.xy;
-	vec2		coords = vec2(0.0);
-	coords.x = (xTileSize == 0.0) ? gl_FragCoord.x : floor(loc.x / yTileSize);
-	coords.y = (yTileSize == 0.0) ? gl_FragCoord.y : floor(loc.y / xTileSize);
-	
-	vec2		maxCoords = vec2(0.0);
-	maxCoords.x = (xTileSize == 0.0) ? RENDERSIZE.x : (1.0 / yTileSize);
-	maxCoords.y = (yTileSize == 0.0) ? RENDERSIZE.y : (1.0 / xTileSize);
-	vec2		shiftAmount = vec2(xShiftAmount, yShiftAmount);
-	
-	shiftAmount.x = shiftAmount.x + shiftAmount.x * coords.y / maxCoords.y;
-	
-	if (shiftAmount.x < 0.0)
-		shiftAmount.x = 0.0;
-	else if (shiftAmount.x > 1.0)
-		shiftAmount.x = 1.0;
-	
-	loc.x = mod(loc.x + shiftAmount.x, 1.0);
-	
-	shiftAmount.y = shiftAmount.y + shiftAmount.y * coords.x / maxCoords.x;
-	
-	if (shiftAmount.y < 0.0)
-		shiftAmount.y = 0.0;
-	else if (shiftAmount.y > 1.0)
-		shiftAmount.y = 1.0;
-	
-	loc.y = mod(loc.y + shiftAmount.y, 1.0);
-	
-	gl_FragColor = IMG_NORM_PIXEL(inputImage, loc);
-}
diff --git a/nannou_isf/test_files/Slit Scan Mask.fs b/nannou_isf/test_files/Slit Scan Mask.fs
deleted file mode 100644
index b2b1f55a4..000000000
--- a/nannou_isf/test_files/Slit Scan Mask.fs	
+++ /dev/null
@@ -1,91 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Masking"
-    ],
-    "CREDIT": "by VIDVOX",
-    "DESCRIPTION": "Pixels update only if within range of the specified lines to create a slit scan style",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 1.5,
-            "MIN": 0,
-            "NAME": "spacing",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.33,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "line_width",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.25,
-            "MAX": 1,
-            "MIN": -1,
-            "NAME": "angle",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "shift",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "edgeSharpness",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-const float pi = 3.14159265359;
-
-
-float pattern() {
-	float s = sin(angle * pi);
-	float c = cos(angle * pi);
-	vec2 tex = isf_FragNormCoord * RENDERSIZE;
-	float spaced = length(RENDERSIZE) * spacing;
-	vec2 point = vec2( c * tex.x - s * tex.y, s * tex.x + c * tex.y ) * max(1.0/spaced,0.001);
-	float d = point.y;
-	float w = line_width;
-	if (w > spacing)	{
-		w = 0.99*spacing;	
-	}
-	return ( mod(d + shift*spacing + w * 0.5,spacing) );
-}
-
-void main()
-{
-	vec4	freshPixel = IMG_PIXEL(inputImage,gl_FragCoord.xy);
-	//	If we're on the line, update, otherwise use the stale pixel
-	//vec4 	result = IMG_PIXEL(bufferVariableNameA,gl_FragCoord.xy);
-	vec4 result = vec4(0.0);
-	float pat = pattern();
-	float w = line_width;
-	if (w > spacing)	{
-		w = 0.99*spacing;	
-	}
-
-	if ((pat > 0.0)&&(pat <= w))	{
-		float percent = (1.0-abs(w-2.0*pat)/w);
-		percent = clamp(percent,0.0,1.0);
-		percent = mix(percent, pow(percent,1.0/5.0), edgeSharpness);
-		result = mix(result, freshPixel, percent);
-		//result = vec4(percent,percent,percent,1.0);
-		//result = clamp(result+edgeSharpness, 0.0, 1.0);
-	}
-	gl_FragColor = result;
-}
diff --git a/nannou_isf/test_files/Slit Scan.fs b/nannou_isf/test_files/Slit Scan.fs
deleted file mode 100644
index b1d40f922..000000000
--- a/nannou_isf/test_files/Slit Scan.fs	
+++ /dev/null
@@ -1,87 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Glitch"
-    ],
-    "CREDIT": "by VIDVOX",
-    "DESCRIPTION": "Pixels update only if within range of the specified lines to create a slit scan style",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 1.5,
-            "MIN": 0,
-            "NAME": "spacing",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.33,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "line_width",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.25,
-            "MAX": 1,
-            "MIN": -1,
-            "NAME": "angle",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "shift",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "PERSISTENT": true,
-            "TARGET": "bufferVariableNameA"
-        }
-    ]
-}
-*/
-
-
-const float pi = 3.14159265359;
-
-
-float pattern() {
-	float s = sin(angle * pi);
-	float c = cos(angle * pi);
-	vec2 tex = isf_FragNormCoord * RENDERSIZE;
-	float spaced = length(RENDERSIZE) * spacing;
-	vec2 point = vec2( c * tex.x - s * tex.y, s * tex.x + c * tex.y ) * max(1.0/spaced,0.001);
-	float d = point.y;
-	float w = line_width;
-	if (w > spacing)	{
-		w = 0.99*spacing;	
-	}
-	return ( mod(d + shift*spacing + w * 0.5,spacing) );
-}
-
-void main()
-{
-	vec4	freshPixel = IMG_PIXEL(inputImage,gl_FragCoord.xy);
-	//	If we're on the line, update, otherwise use the stale pixel
-	vec4 	result = IMG_PIXEL(bufferVariableNameA,gl_FragCoord.xy);
-	float pat = pattern();
-	float w = line_width;
-	if (w > spacing)	{
-		w = 0.99*spacing;	
-	}
-
-	if ((pat > 0.0)&&(pat <= w))	{
-		float percent = (1.0-abs(w-2.0*pat)/w);
-		percent = clamp(percent,0.0,1.0);
-		result = mix(result, freshPixel, percent);
-		//result = vec4(percent,percent,percent,1.0);
-	}
-	gl_FragColor = result;
-}
diff --git a/nannou_isf/test_files/Smoke Screen.fs b/nannou_isf/test_files/Smoke Screen.fs
deleted file mode 100644
index 78d91dbc4..000000000
--- a/nannou_isf/test_files/Smoke Screen.fs	
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Stylize"
-  ],
-  "DESCRIPTION" : "A smoke screen overlay effect",
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "NAME" : "inputImage",
-      "TYPE" : "image"
-    },
-    {
-      "NAME" : "smokeColor",
-      "TYPE" : "color",
-      "DEFAULT" : [
-        0.75,
-        0.75,
-        0.75,
-        0.75
-      ]
-    },
-    {
-      "NAME" : "smokeIntensity",
-      "TYPE" : "float",
-      "MAX" : 10,
-      "DEFAULT" : 1,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "smokeDirection",
-      "TYPE" : "point2D",
-      "MAX" : [
-        1,
-        1
-      ],
-      "DEFAULT" : [
-        0.5,
-        0.75
-      ],
-      "MIN" : [
-        0,
-        0
-      ]
-    }
-  ],
-  "CREDIT" : "jackdavenport"
-}
-*/
-
-
-
-//	Converted from https://www.shadertoy.com/view/4t2SRz by jackdavenport
-
-
-
-float random(vec2 co){
-    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-float noise(vec2 p) {
-    
- 	return random(vec2(p.x + p.y * 10000.0,p.y + p.x * 10000.0));
-    
-}
-
-vec2 sw(vec2 p) { return vec2(floor(p.x), floor(p.y)); }
-vec2 se(vec2 p) { return vec2(ceil(p.x), floor(p.y)); }
-vec2 nw(vec2 p) { return vec2(floor(p.x), ceil(p.y)); }
-vec2 ne(vec2 p) { return vec2(ceil(p.x), ceil(p.y)); }
-
-float smoothNoise(vec2 p) {
- 
-    vec2 interp = smoothstep(0., 1., fract(p));
-    float s = mix(noise(sw(p)), noise(se(p)), interp.x);
-    float n = mix(noise(nw(p)), noise(ne(p)), interp.x);
-    return mix(s, n, interp.y);
-    
-}
-
-float fractalNoise(vec2 p) {
- 
-    float n = 0.;
-    n += smoothNoise(p);
-    n += smoothNoise(p * 2.) / 2.;
-    n += smoothNoise(p * 4.) / 4.;
-    n += smoothNoise(p * 8.) / 8.;
-    n += smoothNoise(p * 16.) / 16.;
-    n /= 1. + 1./2. + 1./4. + 1./8. + 1./16.;
-    return n;
-    
-}
-
-void main() {
-	vec2	uv = isf_FragNormCoord;
-	vec2	sd = (smokeDirection - vec2(0.5));
-    vec2	nuv = vec2(uv.x - sd.x * TIME / 3.0, uv.y - sd.y * TIME / 3.0);
-    
-	float	x = fractalNoise(nuv * 6.0);
-	vec4	inputPixel = IMG_NORM_PIXEL(inputImage,uv);
-    vec4	final = mix(vec4(x * smokeColor.rgb,max(x,inputPixel.a)), inputPixel, pow(abs(uv.y),pow(smokeColor.a*smokeIntensity*x,2.0)));
-    
-    gl_FragColor = final;
-}
-
diff --git a/nannou_isf/test_files/Smudged Lens.fs b/nannou_isf/test_files/Smudged Lens.fs
deleted file mode 100644
index f96ab3654..000000000
--- a/nannou_isf/test_files/Smudged Lens.fs	
+++ /dev/null
@@ -1,217 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Film",
-    "Blur"
-  ],
-  "DESCRIPTION" : "Blurs parts of an image as if the lens is smudged",
-  "INPUTS" : [
-    {
-      "NAME" : "inputImage",
-      "TYPE" : "image"
-    },
-    {
-      "NAME" : "scale",
-      "TYPE" : "float",
-      "MAX" : 100,
-      "DEFAULT" : 6,
-      "MIN" : 0,
-      "LABEL" : "Dirt Size"
-    },
-    {
-      "NAME" : "brightness",
-      "TYPE" : "float",
-      "MAX" : 4,
-      "DEFAULT" : 4,
-      "MIN" : 0,
-      "LABEL" : "Dirt Thickness"
-    },
-    {
-      "NAME" : "brightnessCurve",
-      "TYPE" : "float",
-      "MAX" : 4,
-      "DEFAULT" : 4,
-      "LABEL" : "Dirt Shape",
-      "MIN" : 1
-    },
-    {
-      "NAME" : "radius",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0.5,
-      "LABEL" : "Dirt Spread",
-      "MIN" : 0
-    },
-    {
-      "NAME" : "noiseSeed",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0.49379485845565796,
-      "MIN" : 0,
-      "LABEL" : "Dirt Seed"
-    },
-    {
-      "NAME" : "blurLevel",
-      "TYPE" : "float",
-      "MAX" : 0.5,
-      "DEFAULT" : 0.5,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "blurDepth",
-      "TYPE" : "float",
-      "MAX" : 10,
-      "DEFAULT" : 3.75,
-      "MIN" : 1
-    }
-  ],
-  "ISFVSN" : "2",
-  "PASSES" : [
-    {
-      "TARGET" : "smaller",
-      "WIDTH" : "max(floor($WIDTH*0.02),1.0)",
-      "HEIGHT" : "max(floor($HEIGHT*0.02),1.0)"
-    },
-    {
-      "TARGET" : "small",
-      "WIDTH" : "max(floor($WIDTH*0.25),1.0)",
-      "HEIGHT" : "max(floor($HEIGHT*0.25),1.0)"
-    },
-    {
-
-    }
-  ],
-  "CREDIT" : "Inigo Quilez ported by @colin_movecraft and VIDVOX"
-}
-*/
-
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-in vec2 left_coord;
-in vec2 right_coord;
-in vec2 above_coord;
-in vec2 below_coord;
-
-in vec2 lefta_coord;
-in vec2 righta_coord;
-in vec2 leftb_coord;
-in vec2 rightb_coord;
-#endif
-
-
-// Value Noise (http://en.wikipedia.org/wiki/Value_noise), not to be confused with Perlin's
-// Noise, is probably the simplest way to generate noise (a random smooth signal with 
-// mostly all its energy in the low frequencies) suitable for procedural texturing/shading,
-// modeling and animation.
-//
-// It produces lowe quality noise than Gradient Noise (https://www.shadertoy.com/view/XdXGW8)
-// but it is slightly faster to compute. When used in a fractal construction, the blockyness
-// of Value Noise gets qcuikly hidden, making it a very popular alternative to Gradient Noise.
-//
-// The princpiple is to create a virtual grid/latice all over the plane, and assign one
-// random value to every vertex in the grid. When querying/requesting a noise value at
-// an arbitrary point in the plane, the grid cell in which the query is performed is
-// determined (line 30), the four vertices of the grid are determined and their random
-// value fetched (lines 35 to 38) and then bilinearly interpolated (lines 35 to 38 again)
-// with a smooth interpolant (line 31 and 33).
-
-
-// Value    Noise 2D, Derivatives: https://www.shadertoy.com/view/4dXBRH
-// Gradient Noise 2D, Derivatives: https://www.shadertoy.com/view/XdXBRH
-// Value    Noise 3D, Derivatives: https://www.shadertoy.com/view/XsXfRH
-// Gradient Noise 3D, Derivatives: https://www.shadertoy.com/view/4dffRH
-// Value    Noise 2D             : https://www.shadertoy.com/view/lsf3WH
-// Value    Noise 3D             : https://www.shadertoy.com/view/4sfGzS
-// Gradient Noise 2D             : https://www.shadertoy.com/view/XdXGW8
-// Gradient Noise 3D             : https://www.shadertoy.com/view/Xsl3Dl
-// Simplex  Noise 2D             : https://www.shadertoy.com/view/Msf3WH
-
-
-float hash(vec2 p)  // replace this by something better
-{
-    p  = 50.0*fract(noiseSeed + p*0.3183099 + vec2(0.71,0.113));
-    return -1.0+2.0*fract( p.x*p.y*(p.x+p.y) );
-}
-
-float noise( in vec2 p )
-{
-    vec2 i = floor( p );
-    vec2 f = fract( p );
-	
-	vec2 u = f*f*(3.0-2.0*f);
-
-    return mix( mix( hash( i + vec2(0.0,0.0) ), 
-                     hash( i + vec2(1.0,0.0) ), u.x),
-                mix( hash( i + vec2(0.0,1.0) ), 
-                     hash( i + vec2(1.0,1.0) ), u.x), u.y);
-}
-
-float map(float n, float i1, float i2, float o1, float o2){
-	return o1 + (o2-o1) * (n-i1)/(i2-i1);
-	
-}
-
-void main(){
-    vec2 p = gl_FragCoord.xy / RENDERSIZE;
-
-	vec2 uv = p*vec2(RENDERSIZE.x/RENDERSIZE.y,1.0);
-	float f = 0.0;
-
-	//fbm - fractal noise (4 octaves)	
-	{
-		uv *= scale;
-        mat2 m = mat2( 1.6,  1.2, -1.2,  1.6 );
-		f  = 0.5000*noise( uv ); uv = m*uv;
-		f += 0.2500*noise( uv ); uv = m*uv;
-		f += 0.1250*noise( uv ); uv = m*uv;
-		f += 0.0625*noise( uv ); uv = m*uv;
-	}
-	
-	f = 1.0-pow(f,(5.0-brightnessCurve))*brightness;
-	
-	float d = distance(isf_FragNormCoord,vec2(0.5));
-	if (d > radius)	{
-		f = f + (d-radius);
-	}
-	
-	f = (f > 1.0) ? 1.0 : f;
-	
-	vec4 color = IMG_THIS_NORM_PIXEL(inputImage);
-	vec4 colorL = IMG_NORM_PIXEL(inputImage, left_coord);
-	vec4 colorR = IMG_NORM_PIXEL(inputImage, right_coord);
-	vec4 colorA = IMG_NORM_PIXEL(inputImage, above_coord);
-	vec4 colorB = IMG_NORM_PIXEL(inputImage, below_coord);
-
-	vec4 colorLA = IMG_NORM_PIXEL(inputImage, lefta_coord);
-	vec4 colorRA = IMG_NORM_PIXEL(inputImage, righta_coord);
-	vec4 colorLB = IMG_NORM_PIXEL(inputImage, leftb_coord);
-	vec4 colorRB = IMG_NORM_PIXEL(inputImage, rightb_coord);
-
-	vec4 avg = (color + colorL + colorR + colorA + colorB + colorLA + colorRA + colorLB + colorRB) / 9.0;
-	
-	if (PASSINDEX == 1)	{
-		vec4 blur = IMG_THIS_NORM_PIXEL(smaller);
-		avg = mix(color, (avg + blurDepth*blur)/(1.0+blurDepth), (1.0-f)*blurLevel);
-	}
-	else if (PASSINDEX == 2)	{
-		vec4 blur = IMG_THIS_NORM_PIXEL(small);
-		avg = mix(color, (avg + blurDepth*blur)/(1.0+blurDepth), (1.0-f)*blurLevel);
-	}
-
-	gl_FragColor = avg;
-}
-
-
-
-// The MIT License
-// Copyright © 2013 Inigo Quilez
-// 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/nannou_isf/test_files/Smudged Lens.vs b/nannou_isf/test_files/Smudged Lens.vs
deleted file mode 100644
index b0ba4b037..000000000
--- a/nannou_isf/test_files/Smudged Lens.vs	
+++ /dev/null
@@ -1,39 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-out vec2 left_coord;
-out vec2 right_coord;
-out vec2 above_coord;
-out vec2 below_coord;
-
-out vec2 lefta_coord;
-out vec2 righta_coord;
-out vec2 leftb_coord;
-out vec2 rightb_coord;
-#endif
-
-
-void main()
-{
-	isf_vertShaderInit();
-	vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	vec2 d = 1.0/RENDERSIZE;
-
-	left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
-	right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
-	above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
-	below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
-
-	lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
-	righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
-	leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
-	rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Soft Blur.fs b/nannou_isf/test_files/Soft Blur.fs
deleted file mode 100644
index fe6762946..000000000
--- a/nannou_isf/test_files/Soft Blur.fs	
+++ /dev/null
@@ -1,96 +0,0 @@
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Blur"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "softness",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.9
-		},
-		{
-			"NAME": "depth",
-			"TYPE": "float",
-			"MIN": 1.0,
-			"MAX": 10.0,
-			"DEFAULT": 10.0
-		}
-	],
-	"PASSES": [
-		{
-			"TARGET": "smaller",
-			"WIDTH": "max(floor($WIDTH*0.02),1.0)",
-			"HEIGHT": "max(floor($HEIGHT*0.02),1.0)"
-		},
-		{
-			"TARGET": "small",
-			"WIDTH": "max(floor($WIDTH*0.25),1.0)",
-			"HEIGHT": "max(floor($HEIGHT*0.25),1.0)"
-		},
-		{
-		
-		}
-	]
-}*/
-
-
-//	A simple three pass blur – first reduce the size, then do a weighted blur, then do the same thing 
-
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-in vec2 left_coord;
-in vec2 right_coord;
-in vec2 above_coord;
-in vec2 below_coord;
-
-in vec2 lefta_coord;
-in vec2 righta_coord;
-in vec2 leftb_coord;
-in vec2 rightb_coord;
-#endif
-
-
-
-void main()
-{
-	
-	vec4 color = IMG_THIS_NORM_PIXEL(inputImage);
-	vec4 colorL = IMG_NORM_PIXEL(inputImage, left_coord);
-	vec4 colorR = IMG_NORM_PIXEL(inputImage, right_coord);
-	vec4 colorA = IMG_NORM_PIXEL(inputImage, above_coord);
-	vec4 colorB = IMG_NORM_PIXEL(inputImage, below_coord);
-
-	vec4 colorLA = IMG_NORM_PIXEL(inputImage, lefta_coord);
-	vec4 colorRA = IMG_NORM_PIXEL(inputImage, righta_coord);
-	vec4 colorLB = IMG_NORM_PIXEL(inputImage, leftb_coord);
-	vec4 colorRB = IMG_NORM_PIXEL(inputImage, rightb_coord);
-
-	vec4 avg = (color + colorL + colorR + colorA + colorB + colorLA + colorRA + colorLB + colorRB) / 9.0;
-	
-	if (PASSINDEX == 1)	{
-		vec4 blur = IMG_THIS_NORM_PIXEL(smaller);
-		avg = mix(color, (avg + depth*blur)/(1.0+depth), softness);
-	}
-	else if (PASSINDEX == 2)	{
-		vec4 blur = IMG_THIS_NORM_PIXEL(small);
-		avg = mix(color, (avg + depth*blur)/(1.0+depth), softness);
-	}
-	gl_FragColor = avg;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Soft Blur.vs b/nannou_isf/test_files/Soft Blur.vs
deleted file mode 100644
index b0ba4b037..000000000
--- a/nannou_isf/test_files/Soft Blur.vs	
+++ /dev/null
@@ -1,39 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-out vec2 left_coord;
-out vec2 right_coord;
-out vec2 above_coord;
-out vec2 below_coord;
-
-out vec2 lefta_coord;
-out vec2 righta_coord;
-out vec2 leftb_coord;
-out vec2 rightb_coord;
-#endif
-
-
-void main()
-{
-	isf_vertShaderInit();
-	vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	vec2 d = 1.0/RENDERSIZE;
-
-	left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
-	right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
-	above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
-	below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
-
-	lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
-	righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
-	leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
-	rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Soft Flip.fs b/nannou_isf/test_files/Soft Flip.fs
deleted file mode 100644
index d70231a70..000000000
--- a/nannou_isf/test_files/Soft Flip.fs	
+++ /dev/null
@@ -1,109 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Geometry Adjustment"
-    ],
-    "CREDIT": "VIDVOX",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": -0.25,
-            "MAX": 1,
-            "MIN": -1,
-            "NAME": "angle",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0.5,
-                0.5
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "centerPt",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": 0.1,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "lineWidth",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "NAME": "flipH",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 1,
-            "NAME": "flipV",
-            "TYPE": "bool"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-const float pi = 3.14159265359;
-
-
-vec3 rgb2hsv(vec3 c)	{
-	vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-	//vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
-	//vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
-	vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
-	vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
-	
-	float d = q.x - min(q.w, q.y);
-	float e = 1.0e-10;
-	return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
-}
-
-vec3 hsv2rgb(vec3 c)	{
-	vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
-	vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
-	return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
-}
-
-//	returns the distance from pt0 to the line defined by pt1 and pt2
-float distancePtToLine(vec2 pt1, vec2 pt2, vec2 pt0)	{
-	return ((pt2.y-pt1.y)*pt0.x-(pt2.x-pt1.x)*pt0.y+pt2.x*pt1.y-pt2.y*pt1.x)/(sqrt(pow(pt2.y-pt1.y,2.0)+pow(pt2.x-pt1.x,2.0)));
-}
-
-void main()	{
-	vec2		loc = isf_FragNormCoord;
-	vec4		returnMe = vec4(vec3(0.0),1.0);
-	vec2		p1 = centerPt;
-	vec2		p2 = p1 + vec2(cos(angle*pi),sin(angle*pi));
-	float		val = distancePtToLine(p1,p2,loc);
-	vec2		flipLoc = loc;
-	flipLoc.x = (flipH) ? 1.0 - flipLoc.x : flipLoc.x;
-	flipLoc.y = (flipV) ? 1.0 - flipLoc.y : flipLoc.y;
-
-	if (abs(val) < lineWidth)	{
-		vec4	pix1 = IMG_NORM_PIXEL(inputImage,loc);
-		vec4	pix2 = IMG_NORM_PIXEL(inputImage,flipLoc);
-		returnMe = mix(pix1,pix2,((-val+lineWidth)) / (2.0*lineWidth));
-		//returnMe.r = 2.0 * ((val+lineWidth)) / (2.0*lineWidth);
-		//returnMe.g = 2.0 - 2.0 * ((val+lineWidth)) / (2.0*lineWidth);
-	}
-	else if (val > 0.0)	{
-		returnMe = IMG_NORM_PIXEL(inputImage,loc);
-	}
-	else	{
-		returnMe = IMG_NORM_PIXEL(inputImage,flipLoc);
-	}
-	gl_FragColor = returnMe;
-}
diff --git a/nannou_isf/test_files/Solarize.fs b/nannou_isf/test_files/Solarize.fs
deleted file mode 100644
index f0b800214..000000000
--- a/nannou_isf/test_files/Solarize.fs
+++ /dev/null
@@ -1,91 +0,0 @@
-/*{
-	"DESCRIPTION": "Solarizes an image",
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Color Effect"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "centerBrightness",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.5
-		},
-		{
-			"NAME": "powerCurve",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 4.0,
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "colorize",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.0
-		},
-		{
-			"NAME": "inverse",
-			"TYPE": "bool",
-			"DEFAULT": 1.0
-		}
-	]
-}*/
-
-
-
-
-vec3 rgb2hsv(vec3 c)	{
-	vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-	//vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
-	//vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
-	vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
-	vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
-	
-	float d = q.x - min(q.w, q.y);
-	float e = 1.0e-10;
-	return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
-}
-
-vec3 hsv2rgb(vec3 c)	{
-	vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
-	vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
-	return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
-}
-
-
-
-
-void main()
-{
-	vec4		inColor = IMG_NORM_PIXEL(inputImage, isf_FragNormCoord);
-	vec4		hslColor;
-	vec4		outColor;
-	
-	//	convert to HSV
-	hslColor.rgb = rgb2hsv(inColor.rgb);
-	outColor.rgb = hslColor.rgb;
-	outColor.a = inColor.a;
-	
-	//	drop the saturation
-	//outColor.g = 0.0;
-	
-	//	adjust the brightness curve
-	outColor.b = (outColor.b < centerBrightness) ? (1.0 - outColor.b / centerBrightness) : (outColor.b - centerBrightness) / centerBrightness;
-	outColor.b = pow(outColor.b, powerCurve);
-	outColor.b = (inverse) ? 1.0 - outColor.b : outColor.b;
-	
-	outColor.g = (inverse) ? outColor.g * (1.0-hslColor.b) * colorize : outColor.g * hslColor.b * colorize;
-	
-	//	convert back to rgb
-	outColor.rgb = hsv2rgb(outColor.rgb);
-	
-	gl_FragColor = outColor;
-}
diff --git a/nannou_isf/test_files/Solid Color.fs b/nannou_isf/test_files/Solid Color.fs
deleted file mode 100644
index 0cb8819ca..000000000
--- a/nannou_isf/test_files/Solid Color.fs	
+++ /dev/null
@@ -1,27 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Color",
-        "Utility"
-    ],
-    "CREDIT": "by Carter Rosenberg",
-    "DESCRIPTION": "demonstrates the use of color-type image inputs",
-    "INPUTS": [
-        {
-            "DEFAULT": [
-                1,
-                0,
-                0,
-                1
-            ],
-            "NAME": "Color",
-            "TYPE": "color"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-void main()
-{
-	gl_FragColor = Color;
-}
diff --git a/nannou_isf/test_files/Sorting Smear.fs b/nannou_isf/test_files/Sorting Smear.fs
deleted file mode 100644
index 7e37ea5f5..000000000
--- a/nannou_isf/test_files/Sorting Smear.fs	
+++ /dev/null
@@ -1,119 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Glitch",
-        "Feedback"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "LABEL": "Flush Buffer",
-            "NAME": "resetInput",
-            "TYPE": "event"
-        },
-        {
-            "DEFAULT": 0.25,
-            "LABEL": "Adapt Rate",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "adaptLevel",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Sort Rate",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "sortRate",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "H Sort",
-            "NAME": "horizontalSort",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "V Sort",
-            "NAME": "verticalSort",
-            "TYPE": "bool"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "PERSISTENT": true,
-            "TARGET": "lastRender"
-        }
-    ]
-}
-*/
-
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-#else
-in vec2 left_coord;
-in vec2 right_coord;
-in vec2 above_coord;
-in vec2 below_coord;
-#endif
-
-
-
-void main()
-{
-	vec4 result = vec4(0.0);
-	vec4 color = IMG_THIS_NORM_PIXEL(inputImage);
-	//float localAdaptRate = 1.0 - pow(adaptLevel,2.0);
-	float localAdaptRate = adaptLevel;
-	//	if the frame index is 0, or the reset event was triggered, use the original color
-	if ((FRAMEINDEX <= 1)||(resetInput))	{
-		result = color;
-	}
-	else	{
-		vec4 oldColor = IMG_THIS_NORM_PIXEL(lastRender);
-		color = mix(color, oldColor, localAdaptRate);
-		result = color;
-		float	b0 = (color.r + color.b + color.g) / 3.0;
-
-		if (verticalSort)	{
-			vec4 colorA = IMG_NORM_PIXEL(lastRender, above_coord);
-			vec4 colorB = IMG_NORM_PIXEL(lastRender, below_coord);
-			float	bA = (colorA.r + colorA.b + colorA.g) / 3.0;
-			float	bB = (colorB.r + colorB.b + colorB.g) / 3.0;
-			float	localSortRate = sortRate;
-			//	if this pixel is brighter to the one on the left, we are swapping with it
-			if (b0 < bA)	{
-				result = mix(result, colorA, localSortRate);
-			}
-			//	if this pixel is not as bright as the one to the right, we are swapping with it
-			if (b0 > bB)	{
-				result = mix(result, colorB, localSortRate);
-			}
-		}
-		if (horizontalSort)	{
-			vec4	colorL = IMG_NORM_PIXEL(lastRender, left_coord);
-			vec4	colorR = IMG_NORM_PIXEL(lastRender, right_coord);
-			float	bL = (colorL.r + colorL.b + colorL.g) / 3.0;
-			float	bR = (colorR.r + colorR.b + colorR.g) / 3.0;
-			float	localSortRate = (verticalSort) ? 0.5 : 1.0;
-			localSortRate = localSortRate * sortRate;
-			//	if this pixel is brighter to the one on the left, we are swapping with it
-			if (b0 > bL)	{
-				result = mix(result, colorL, localSortRate);
-			}
-			//	if this pixel is not as bright as the one to the right, we are swapping with it
-			if (b0 < bR)	{
-				result = mix(result, colorR, localSortRate);
-			}
-		}
-	}	
-	gl_FragColor = result;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Sorting Smear.vs b/nannou_isf/test_files/Sorting Smear.vs
deleted file mode 100644
index 4f5982db3..000000000
--- a/nannou_isf/test_files/Sorting Smear.vs	
+++ /dev/null
@@ -1,24 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-#else
-out vec2 left_coord;
-out vec2 right_coord;
-out vec2 above_coord;
-out vec2 below_coord;
-#endif
-
-
-void main()
-{
-	isf_vertShaderInit();
-	vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	vec2 d = 1.0/RENDERSIZE;
-
-	left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
-	right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
-	above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
-	below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Sphere Map.fs b/nannou_isf/test_files/Sphere Map.fs
deleted file mode 100644
index f0daa863c..000000000
--- a/nannou_isf/test_files/Sphere Map.fs	
+++ /dev/null
@@ -1,76 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion Effect"
-    ],
-    "CREDIT": "VIDVOX",
-    "DESCRIPTION": "Maps video onto a sphere",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.5,
-            "LABEL": "Image Scale",
-            "MAX": 1,
-            "MIN": 0.125,
-            "NAME": "imageScale",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Radius Scale",
-            "MAX": 1.999,
-            "MIN": 0,
-            "NAME": "radiusScale",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0
-            ],
-            "LABEL": "Rotate",
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "pointInput",
-            "TYPE": "point2D"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-const float pi = 3.14159265359;
-
-
-void main()	{
-	vec4		inputPixelColor = vec4(0.0);
-	vec2		rotate = pointInput;
- 	vec2 		p = 2.0 * isf_FragNormCoord.xy - 1.0;
- 	float		aspect = RENDERSIZE.x / RENDERSIZE.y;
- 	p.x = p.x * aspect;
- 	
- 	float		r = sqrt(dot(p,p)) * (2.0-radiusScale);
- 	if (r < 1.0)	{
-		vec2 uv;
-    	float f = imageScale * (1.0-sqrt(1.0-r))/(r);
-    	uv.x = mod(p.x*f + rotate.x,1.0);
-    	uv.y = mod(p.y*f + rotate.y,1.0);
-    	inputPixelColor = IMG_NORM_PIXEL(inputImage, uv);
-	}
-
-
-	//	both of these are also the same
-	//inputPixelColor = IMG_NORM_PIXEL(inputImage, loc);
-	
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/Spiral.fs b/nannou_isf/test_files/Spiral.fs
deleted file mode 100644
index f5ff9733d..000000000
--- a/nannou_isf/test_files/Spiral.fs
+++ /dev/null
@@ -1,107 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Geometry"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "rotation",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 2,
-            "MAX": 50,
-            "MIN": 0.1,
-            "NAME": "count",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.125,
-            "MAX": 0.25,
-            "MIN": 0,
-            "NAME": "width",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.25,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "softness",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0,
-                0,
-                0
-            ],
-            "NAME": "color1",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": [
-                1,
-                1,
-                1,
-                1
-            ],
-            "NAME": "color2",
-            "TYPE": "color"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-const float pi = 3.14159265359;
-
-
-void main() {
-	//	determine if we are on an even or odd line
-	//	math goes like..
-	//	r = a + b*theta
-	//	Changing the parameter 'a' will turn the spiral, while 'b' controls the distance between successive turnings.
-	
-	
-	vec4 out_color = color1;
-	
-	//	convert to polar coordinates
-	vec2 loc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	loc.y = (loc.y - 0.5) * RENDERSIZE.y / RENDERSIZE.x + 0.5;
-	float r = 2.0 * count * distance(vec2(0.5,0.5), loc) + width;
-	float theta = atan ((loc.y-0.5),(loc.x-0.5));
-
-	loc.y = r * sin(theta + 2.0 * pi * rotation) + 0.5;
-
-	if (loc.y < 0.5)	{
-		theta = theta + 2.0 * pi;
-		theta = mod(theta + rotation * 2.0 * pi, 2.0 * pi);
-		theta = (theta + 2.0 * pi * floor(r - width));
-	}
-	else	{
-		theta = mod(theta + rotation * 2.0 * pi, 2.0 * pi);
-		theta = (theta + 2.0 * pi * floor(r + width));
-	}
-	
-	if (width == 0.0)	{
-		out_color = color1;
-	}
-	else 	{
-		float dist = abs(r - theta/(2.0*pi));
-		if (dist < width)	{
-			if (dist > width * (1.0-softness))	{
-				out_color = mix(color2, color1, (dist - width * (1.0-softness))/(width - width * (1.0-softness)));
-			}
-			else	{
-				out_color = color2;
-			}
-		}
-	}
-	
-	gl_FragColor = out_color;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Squares Wire.fs b/nannou_isf/test_files/Squares Wire.fs
deleted file mode 100644
index 2132e3564..000000000
--- a/nannou_isf/test_files/Squares Wire.fs	
+++ /dev/null
@@ -1,100 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Wipe"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/squareswire.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1.6,
-            "MAX": 10,
-            "MIN": 0,
-            "NAME": "smoothness",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                1,
-                -0.5
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                -1,
-                -1
-            ],
-            "NAME": "direction",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": [
-                10,
-                10
-            ],
-            "MAX": [
-                100,
-                100
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "squares",
-            "TYPE": "point2D"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: gre
-// License: MIT
- 
-
-const vec2 center = vec2(0.5, 0.5);
-vec4 transition (vec2 p) {
-  vec2 v = normalize(direction);
-  v /= abs(v.x)+abs(v.y);
-  float d = v.x * center.x + v.y * center.y;
-  float offset = smoothness;
-  float pr = smoothstep(-offset, 0.0, v.x * p.x + v.y * p.y - (d-0.5+progress*(1.+offset)));
-  vec2 squarep = fract(p*vec2(squares));
-  vec2 squaremin = vec2(pr/2.0);
-  vec2 squaremax = vec2(1.0 - pr/2.0);
-  float a = (1.0 - step(progress, 0.0)) * step(squaremin.x, squarep.x) * step(squaremin.y, squarep.y) * step(squarep.x, squaremax.x) * step(squarep.y, squaremax.y);
-  return mix(getFromColor(p), getToColor(p), a);
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Squeeze.fs b/nannou_isf/test_files/Squeeze.fs
deleted file mode 100644
index adeb39dc3..000000000
--- a/nannou_isf/test_files/Squeeze.fs
+++ /dev/null
@@ -1,69 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Wipe"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/squeeze.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.04,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "colorSeparation",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: gre
-// License: MIT
- 
- 
-vec4 transition (vec2 uv) {
-  float y = 0.5 + (uv.y-0.5) / (1.0-progress);
-  if (y < 0.0 || y > 1.0) {
-     return getToColor(uv);
-  }
-  else {
-    vec2 fp = vec2(uv.x, y);
-    vec2 off = progress * vec2(0.0, colorSeparation);
-    vec4 c = getFromColor(fp);
-    vec4 cn = getFromColor(fp - off);
-    vec4 cp = getFromColor(fp + off);
-    return vec4(cn.r, c.g, cp.b, c.a);
-  }
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Star.fs b/nannou_isf/test_files/Star.fs
deleted file mode 100644
index 489f8a11e..000000000
--- a/nannou_isf/test_files/Star.fs
+++ /dev/null
@@ -1,109 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Geometry"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "DEFAULT": 0.25,
-            "LABEL": "Size",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "size",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.01,
-            "LABEL": "Stroke Width",
-            "MAX": 0.1,
-            "MIN": 0,
-            "NAME": "bordersize",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                1,
-                0.6,
-                0.75,
-                1
-            ],
-            "LABEL": "Fill Color",
-            "NAME": "color1",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0,
-                0,
-                1
-            ],
-            "LABEL": "Stroke Color",
-            "NAME": "color2",
-            "TYPE": "color"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-//	Adapted from https://glsl.io/transition/d1f891c5585fc40b55ea
-
- 
-vec2 circlePoint( float ang )
-{
-	ang += 6.28318 * 0.15;
-	return vec2( cos(ang), sin(ang) );  
-}
-
-float cross2d( vec2 a, vec2 b )
-{
-	return ( a.x * b.y - a.y * b.x );
-}
-
-// quickly knocked together with some math from http://www.pixeleuphoria.com/node/30
-float star( vec2 p, float size )
-{
-	if( size <= 0.0 )
-	{
-		return 0.0;
-	}
-	p /= size;
-
-	vec2 p0 = circlePoint( 0.0 );
-	vec2 p1 = circlePoint( 6.28318 * 1.0 / 5.0 );
-	vec2 p2 = circlePoint( 6.28318 * 2.0 / 5.0 );
-	vec2 p3 = circlePoint( 6.28318 * 3.0 / 5.0 );
-	vec2 p4 = circlePoint( 6.28318 * 4.0 / 5.0 );
-
-	// are we on this side of the line
-	float s0 = ( cross2d( p1 - p0, p - p0 ) );
-	float s1 = ( cross2d( p2 - p1, p - p1 ) );
-	float s2 = ( cross2d( p3 - p2, p - p2 ) );
-	float s3 = ( cross2d( p4 - p3, p - p3 ) );
-	float s4 = ( cross2d( p0 - p4, p - p4 ) );
-
-	// some trial and error math to get the star shape.  I'm sure there's some elegance I'm missing.
-	float s5 = min( min( min( s0, s1 ), min( s2, s3 ) ), s4 );
-	float s = max( 1.0 - sign( s0 * s1 * s2 * s3 * s4 ) + sign(s5), 0.0 );
-	s = sign( 2.6 - length(p) ) * s;
-
-	return max( s, 0.0 );
-}
-
-void main() 
-{
-	vec2 p = isf_FragNormCoord;
-	vec2 o = p * 2.0 - 1.0;
-
-	float t = size * 1.4;
-
-	float c1 = star( o, t );
-	float c2 = star( o, t - bordersize );
-
-	float border = max( c1 - c2, 0.0 );
-
-	gl_FragColor = mix(mix(vec4(0.0), color1, c1), color2, border);
-}
- 
diff --git a/nannou_isf/test_files/Stereo Viewer.fs b/nannou_isf/test_files/Stereo Viewer.fs
deleted file mode 100644
index 78c3965cc..000000000
--- a/nannou_isf/test_files/Stereo Viewer.fs	
+++ /dev/null
@@ -1,269 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Wipe",
-        "Retro"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/StereoViewer.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.88,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "zoom",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.22,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "corner_radius",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-float ratio = RENDERSIZE.x/RENDERSIZE.y;
-
-
-
-// Tunable parameters
-// How much to zoom (out) for the effect ~ 0.5 - 1.0
-// Corner radius as a fraction of the image height
-
-// author: Ted Schundler
-// license: BSD 2 Clause
-// Free for use and modification by anyone with credit
-
-// Copyright (c) 2016, Theodore K Schundler
-// All rights reserved.
-
-// Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
-
-// 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
-
-// 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
-
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-///////////////////////////////////////////////////////////////////////////////
-// Stereo Viewer Toy Transition                                              //
-//                                                                           //
-// Inspired by ViewMaster / Image3D image viewer devices.                    //
-// This effect is similar to what you see when you press the device's lever. //
-// There is a quick zoom in / out to make the transition 'valid' for GLSL.io //
-///////////////////////////////////////////////////////////////////////////////
-
-const vec4 black = vec4(0.0, 0.0, 0.0, 1.0);
-const vec2 c00 = vec2(0.0, 0.0); // the four corner points
-const vec2 c01 = vec2(0.0, 1.0);
-const vec2 c11 = vec2(1.0, 1.0);
-const vec2 c10 = vec2(1.0, 0.0);
-
-// Check if a point is within a given corner
-bool in_corner(vec2 p, vec2 corner, vec2 radius) {
-  // determine the direction we want to be filled
-  vec2 axis = (c11 - corner) - corner;
-
-  // warp the point so we are always testing the bottom left point with the
-  // circle centered on the origin
-  p = p - (corner + axis * radius);
-  p *= axis / radius;
-  return (p.x > 0.0 && p.y > -1.0) || (p.y > 0.0 && p.x > -1.0) || dot(p, p) < 1.0;
-}
-
-// Check all four corners
-// return a float for v2 for anti-aliasing?
-bool test_rounded_mask(vec2 p, vec2 corner_size) {
-  return
-      in_corner(p, c00, corner_size) &&
-      in_corner(p, c01, corner_size) &&
-      in_corner(p, c10, corner_size) &&
-      in_corner(p, c11, corner_size);
-}
-
-// Screen blend mode - https://en.wikipedia.org/wiki/Blend_modes
-// This more closely approximates what you see than linear blending
-vec4 screen(vec4 a, vec4 b) {
-  return 1.0 - (1.0 - a) * (1.0 -b);
-}
-
-// Given RGBA, find a value that when screened with itself
-// will yield the original value.
-vec4 unscreen(vec4 c) {
-  return 1.0 - sqrt(1.0 - c);
-}
-
-// Grab a pixel, only if it isn't masked out by the rounded corners
-vec4 sample_with_corners_from(vec2 p, vec2 corner_size) {
-  p = (p - 0.5) / zoom + 0.5;
-  if (!test_rounded_mask(p, corner_size)) {
-    return black;
-  }
-  return unscreen(getFromColor(p));
-}
-
-vec4 sample_with_corners_to(vec2 p, vec2 corner_size) {
-  p = (p - 0.5) / zoom + 0.5;
-  if (!test_rounded_mask(p, corner_size)) {
-    return black;
-  }
-  return unscreen(getToColor(p));
-}
-
-// special sampling used when zooming - extra zoom parameter and don't unscreen
-vec4 simple_sample_with_corners_from(vec2 p, vec2 corner_size, float zoom_amt) {
-  p = (p - 0.5) / (1.0 - zoom_amt + zoom * zoom_amt) + 0.5;
-  if (!test_rounded_mask(p, corner_size)) {
-    return black;
-  }
-  return getFromColor(p);
-}
-
-vec4 simple_sample_with_corners_to(vec2 p, vec2 corner_size, float zoom_amt) {
-  p = (p - 0.5) / (1.0 - zoom_amt + zoom * zoom_amt) + 0.5;
-  if (!test_rounded_mask(p, corner_size)) {
-    return black;
-  }
-  return getToColor(p);
-}
-
-// Basic 2D affine transform matrix helpers
-// These really shouldn't be used in a fragment shader - I should work out the
-// the math for a translate & rotate function as a pair of dot products instead
-
-mat3 rotate2d(float angle, float ratio) {
-  float s = sin(angle);
-  float c = cos(angle);
-  return mat3(
-    c, s ,0.0,
-    -s, c, 0.0,
-    0.0, 0.0, 1.0);
-}
-
-mat3 translate2d(float x, float y) {
-  return mat3(
-    1.0, 0.0, 0,
-    0.0, 1.0, 0,
-    -x, -y, 1.0);
-}
-
-mat3 scale2d(float x, float y) {
-  return mat3(
-    x, 0.0, 0,
-    0.0, y, 0,
-    0, 0, 1.0);
-}
-
-// Split an image and rotate one up and one down along off screen pivot points
-vec4 get_cross_rotated(vec3 p3, float angle, vec2 corner_size, float ratio) {
-  angle = angle * angle; // easing
-  angle /= 2.4; // works out to be a good number of radians
-
-  mat3 center_and_scale = translate2d(-0.5, -0.5) * scale2d(1.0, ratio);
-  mat3 unscale_and_uncenter = scale2d(1.0, 1.0/ratio) * translate2d(0.5,0.5);
-  mat3 slide_left = translate2d(-2.0,0.0);
-  mat3 slide_right = translate2d(2.0,0.0);
-  mat3 rotate = rotate2d(angle, ratio);
-
-  mat3 op_a = center_and_scale * slide_right * rotate * slide_left * unscale_and_uncenter;
-  mat3 op_b = center_and_scale * slide_left * rotate * slide_right * unscale_and_uncenter;
-
-  vec4 a = sample_with_corners_from((op_a * p3).xy, corner_size);
-  vec4 b = sample_with_corners_from((op_b * p3).xy, corner_size);
-
-  return screen(a, b);
-}
-
-// Image stays put, but this time move two masks
-vec4 get_cross_masked(vec3 p3, float angle, vec2 corner_size, float ratio) {
-  angle = 1.0 - angle;
-  angle = angle * angle; // easing
-  angle /= 2.4;
-
-  vec4 img;
-
-  mat3 center_and_scale = translate2d(-0.5, -0.5) * scale2d(1.0, ratio);
-  mat3 unscale_and_uncenter = scale2d(1.0 / zoom, 1.0 / (zoom * ratio)) * translate2d(0.5,0.5);
-  mat3 slide_left = translate2d(-2.0,0.0);
-  mat3 slide_right = translate2d(2.0,0.0);
-  mat3 rotate = rotate2d(angle, ratio);
-
-  mat3 op_a = center_and_scale * slide_right * rotate * slide_left * unscale_and_uncenter;
-  mat3 op_b = center_and_scale * slide_left * rotate * slide_right * unscale_and_uncenter;
-
-  bool mask_a = test_rounded_mask((op_a * p3).xy, corner_size);
-  bool mask_b = test_rounded_mask((op_b * p3).xy, corner_size);
-
-  if (mask_a || mask_b) {
-    img = sample_with_corners_to(p3.xy, corner_size);
-    return screen(mask_a ? img : black, mask_b ? img : black);
-  } else {
-    return black;
-  }
-}
-
-vec4 transition(vec2 uv) {
-  float a;
-  vec2 p=uv.xy/vec2(1.0).xy;
-  vec3 p3 = vec3(p.xy, 1.0); // for 2D matrix transforms
-
-  // corner is warped to represent to size after mapping to 1.0, 1.0
-  vec2 corner_size = vec2(corner_radius / ratio, corner_radius);
-
-  if (progress <= 0.0) {
-    // 0.0: start with the base frame always
-    return getFromColor(p);
-  } else if (progress < 0.1) {
-    // 0.0-0.1: zoom out and add rounded corners
-    a = progress / 0.1;
-    return  simple_sample_with_corners_from(p, corner_size * a, a);
-  } else if (progress < 0.48) {
-    // 0.1-0.48: Split original image apart
-    a = (progress - 0.1)/0.38;
-    return get_cross_rotated(p3, a, corner_size, ratio);
-  } else if (progress < 0.9) {
-    // 0.48-0.52: black
-    // 0.52 - 0.9: unmask new image
-    return get_cross_masked(p3, (progress - 0.52)/0.38, corner_size, ratio);
-  } else if (progress < 1.0) {
-    // zoom out and add rounded corners
-    a = (1.0 - progress) / 0.1;
-    return simple_sample_with_corners_to(p, corner_size * a, a);
-  } else {
-    // 1.0 end with base frame
-    return getToColor(p);
-  }
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Stripes.fs b/nannou_isf/test_files/Stripes.fs
deleted file mode 100644
index aa56cc489..000000000
--- a/nannou_isf/test_files/Stripes.fs
+++ /dev/null
@@ -1,76 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Geometry"
-    ],
-    "CREDIT": "VIDVOX",
-    "INPUTS": [
-        {
-            "DEFAULT": 0.25,
-            "NAME": "width",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "NAME": "offset",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "NAME": "vertical",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": [
-                1,
-                1,
-                1,
-                1
-            ],
-            "NAME": "color1",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0,
-                0,
-                1
-            ],
-            "NAME": "color2",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "splitPos",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-void main() {
-	//	determine if we are on an even or odd line
-	//	math goes like..
-	//	mod(((coord+offset) / width),2)
-	
-	
-	vec4 out_color = color2;
-	float coord = isf_FragNormCoord[0];
-
-	if (vertical)	{
-		coord = isf_FragNormCoord[1];
-	}
-	if (width == 0.0)	{
-		out_color = color1;
-	}
-	else if(mod(((coord+offset) / width),2.0) < 2.0 * splitPos)	{
-		out_color = color1;
-	}
-	
-	gl_FragColor = out_color;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Strobe.fs b/nannou_isf/test_files/Strobe.fs
deleted file mode 100644
index b0a154129..000000000
--- a/nannou_isf/test_files/Strobe.fs
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Color Effect"
-  ],
-  "DESCRIPTION" : "",
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "NAME" : "inputImage",
-      "TYPE" : "image"
-    },
-    {
-      "NAME" : "strobeRate",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0,
-      "LABEL" : "Strobe Rate",
-      "MIN" : 0
-    },
-    {
-      "LABELS" : [
-        "Invert",
-        "Color"
-      ],
-      "NAME" : "strobeMode",
-      "TYPE" : "long",
-      "LABEL" : "Strobe Mode",
-      "VALUES" : [
-        0,
-        1
-      ]
-    },
-    {
-      "NAME" : "strobeColor",
-      "TYPE" : "color",
-      "DEFAULT" : [
-        1,
-        1,
-        1,
-        1
-      ],
-      "LABEL" : "Strobe Color"
-    }
-  ],
-  "PASSES" : [
-    {
-      "WIDTH" : "1",
-      "DESCRIPTION" : "this buffer stores the last frame's time offset in the first component of its only pixel- note that it's requesting a FLOAT target buffer...",
-      "HEIGHT" : "1",
-      "TARGET" : "lastState",
-      "PERSISTENT" : true
-    },
-    {
-
-    }
-  ],
-  "CREDIT" : "by VIDVOX"
-}
-*/
-
-
-
-void main()
-{
-	//	if this is the first pass, i'm going to read the position from the "lastPosition" image, and write a new position based on this and the hold variables
-	if (PASSINDEX == 0)	{
-		vec4		srcPixel = IMG_PIXEL(lastState,vec2(0.5));
-		//	i'm only using the X, which is the last render time we reset
-		if (strobeRate == 0.0)	{
-			srcPixel.r = (srcPixel.r == 0.0) ? 1.0 : 0.0;
-		}
-		else	{
-			srcPixel.r = (mod(TIME, strobeRate) <= strobeRate / 2.0) ? 1.0 : 0.0;
-		}
-		gl_FragColor = srcPixel;
-	}
-	//	else this isn't the first pass- read the position value from the buffer which stores it
-	else	{
-		vec4 lastStateVector = IMG_PIXEL(lastState,vec2(0.5));
-		vec4 srcPixel = IMG_THIS_PIXEL(inputImage);
-		//	invert or flash a color?
-		if (strobeMode == 0)	{
-			srcPixel = (lastStateVector.r == 0.0) ? srcPixel : vec4(1.0-srcPixel.r, 1.0-srcPixel.g, 1.0-srcPixel.b, srcPixel.a);
-		}
-		else if (strobeMode == 1)	{
-			srcPixel = (lastStateVector.r == 0.0) ? srcPixel : strobeColor;
-		}
-		gl_FragColor = srcPixel;
-	}
-}
diff --git a/nannou_isf/test_files/Swap Transition.fs b/nannou_isf/test_files/Swap Transition.fs
deleted file mode 100644
index 137566a68..000000000
--- a/nannou_isf/test_files/Swap Transition.fs	
+++ /dev/null
@@ -1,122 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Wipe",
-        "Retro"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/swap.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.2,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "perspective",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 3,
-            "MAX": 10,
-            "MIN": 0,
-            "NAME": "depth",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.4,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "reflection",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: gre
-// License: MIT
-// General parameters
- 
-const vec4 black = vec4(0.0, 0.0, 0.0, 1.0);
-const vec2 boundMin = vec2(0.0, 0.0);
-const vec2 boundMax = vec2(1.0, 1.0);
- 
-bool inBounds (vec2 p) {
-  return all(lessThan(boundMin, p)) && all(lessThan(p, boundMax));
-}
- 
-vec2 project (vec2 p) {
-  return p * vec2(1.0, -1.2) + vec2(0.0, -0.02);
-}
- 
-vec4 bgColor (vec2 p, vec2 pfr, vec2 pto) {
-  vec4 c = black;
-  pfr = project(pfr);
-  if (inBounds(pfr)) {
-    c += mix(black, getFromColor(pfr), reflection * mix(1.0, 0.0, pfr.y));
-  }
-  pto = project(pto);
-  if (inBounds(pto)) {
-    c += mix(black, getToColor(pto), reflection * mix(1.0, 0.0, pto.y));
-  }
-  return c;
-}
- 
-vec4 transition(vec2 p) {
-  vec2 pfr, pto = vec2(-1.);
- 
-  float size = mix(1.0, depth, progress);
-  float persp = perspective * progress;
-  pfr = (p + vec2(-0.0, -0.5)) * vec2(size/(1.0-perspective*progress), size/(1.0-size*persp*p.x)) + vec2(0.0, 0.5);
- 
-  size = mix(1.0, depth, 1.-progress);
-  persp = perspective * (1.-progress);
-  pto = (p + vec2(-1.0, -0.5)) * vec2(size/(1.0-perspective*(1.0-progress)), size/(1.0-size*persp*(0.5-p.x))) + vec2(1.0, 0.5);
-
-  if (progress < 0.5) {
-    if (inBounds(pfr)) {
-      return getFromColor(pfr);
-    }
-    if (inBounds(pto)) {
-      return getToColor(pto);
-    }  
-  }
-  if (inBounds(pto)) {
-    return getToColor(pto);
-  }
-  if (inBounds(pfr)) {
-    return getFromColor(pfr);
-  }
-  return bgColor(p, pfr, pto);
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Swirl.fs b/nannou_isf/test_files/Swirl.fs
deleted file mode 100644
index 925884e63..000000000
--- a/nannou_isf/test_files/Swirl.fs
+++ /dev/null
@@ -1,75 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/Swirl.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// License: MIT
-// Author: Sergey Kosarevsky
-// ( http://www.linderdaum.com )
-// ported by gre from https://gist.github.com/corporateshark/cacfedb8cca0f5ce3f7c
-
-vec4 transition(vec2 UV)
-{
-	float Radius = 1.0;
-
-	float T = progress;
-
-	UV -= vec2( 0.5, 0.5 );
-
-	float Dist = length(UV);
-
-	if ( Dist < Radius )
-	{
-		float Percent = (Radius - Dist) / Radius;
-		float A = ( T <= 0.5 ) ? mix( 0.0, 1.0, T/0.5 ) : mix( 1.0, 0.0, (T-0.5)/0.5 );
-		float Theta = Percent * Percent * A * 8.0 * 3.14159;
-		float S = sin( Theta );
-		float C = cos( Theta );
-		UV = vec2( dot(UV, vec2(C, -S)), dot(UV, vec2(S, C)) );
-	}
-	UV += vec2( 0.5, 0.5 );
-
-	vec4 C0 = getFromColor(UV);
-	vec4 C1 = getToColor(UV);
-
-	return mix( C0, C1, T );
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/TV Static.fs b/nannou_isf/test_files/TV Static.fs
deleted file mode 100644
index d1257b3da..000000000
--- a/nannou_isf/test_files/TV Static.fs	
+++ /dev/null
@@ -1,75 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Wipe"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/TVStatic.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.05,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "offset",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// author: Brandon Anzaldi
-// license: MIT
-
-// Pseudo-random noise function
-// http://byteblacksmith.com/improvements-to-the-canonical-one-liner-glsl-rand-for-opengl-es-2-0/
-highp float noise(vec2 co)
-{
-    highp float a = 12.9898;
-    highp float b = 78.233;
-    highp float c = 43758.5453;
-    highp float dt= dot(co.xy * progress, vec2(a, b));
-    highp float sn= mod(dt,3.14);
-    return fract(sin(sn) * c);
-}
-
-vec4 transition(vec2 p) {
-  if (progress < offset) {
-    return getFromColor(p);
-  } else if (progress > (1.0 - offset)) {
-    return getToColor(p);
-  } else {
-    return vec4(vec3(noise(p)), 1.0);
-  }
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Test-Audio.fs b/nannou_isf/test_files/Test-Audio.fs
deleted file mode 100644
index 388ddcc6a..000000000
--- a/nannou_isf/test_files/Test-Audio.fs
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Generator"
-  ],
-  "DESCRIPTION" : "Visualizes an FFT analysis image with custom set colors for frequency domain",
-  "INPUTS" : [
-    {
-      "NAME" : "waveImage",
-      "TYPE" : "audio"
-    },
-    {
-      "NAME" : "waveSize",
-      "TYPE" : "float",
-      "MAX" : 0.5,
-      "DEFAULT" : 0.05,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "stereo",
-      "TYPE" : "bool",
-      "DEFAULT" : 1
-    }
-  ],
-  "CREDIT" : "by VIDVOX"
-}
-*/
-
-
-
-void main() {
-	
-	vec2		loc = vec2(vv_FragNormCoord[1], vv_FragNormCoord[0]);
-	
-	vec2		rawSize = IMG_SIZE(waveImage);
-	float		channel = 0.5;
-	float		offset = 0.0;
-	if (stereo == true)	{
-		channel = (loc.x > 0.5) ? 0.0 : 1.0;
-		offset = (loc.x > 0.5) ? 0.25 : -0.25;
-	}
-	
-	vec2		waveLoc = vec2(loc.y,channel);
-	vec4		wave = IMG_NORM_PIXEL(waveImage, waveLoc)+offset;
-	vec4		waveAdd = (1.0 - smoothstep(0.0, waveSize, abs(wave - loc.x)));
-	waveAdd.a = 1.0;
-	gl_FragColor = waveAdd;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Test-AudioFFT.fs b/nannou_isf/test_files/Test-AudioFFT.fs
deleted file mode 100644
index 8e543f421..000000000
--- a/nannou_isf/test_files/Test-AudioFFT.fs
+++ /dev/null
@@ -1,95 +0,0 @@
-/*{
-	"DESCRIPTION": "Visualizes an FFT analysis image with custom set colors for frequency domain",
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Generator"
-	],
-	"INPUTS": [
-		{
-			"NAME": "fftImage",
-			"TYPE": "audioFFT"
-		},
-		{
-			"NAME": "strokeSize",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 0.25,
-			"DEFAULT": 0.01
-		},
-		{
-			"NAME": "gain",
-			"TYPE": "float",
-			"MIN": 1.0,
-			"MAX": 5.0,
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "minRange",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.0
-		},
-		{
-			"NAME": "maxRange",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.9
-		},
-		{
-			"NAME": "topColor",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.0,
-				0.0,
-				0.0,
-				0.0
-			]
-		},
-		{
-			"NAME": "bottomColor",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.0,
-				0.5,
-				0.9,
-				1.0
-			]
-		},
-		{
-			"NAME": "strokeColor",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.25,
-				0.25,
-				0.25,
-				1.0
-			]
-		}
-	]
-}*/
-
-
-
-void main() {
-	
-	vec2 loc = isf_FragNormCoord;
-	
-	//	the fftImage is 256 steps
-	loc.x = loc.x * abs(maxRange - minRange) + minRange;
-	
-	vec4 fft = IMG_NORM_PIXEL(fftImage, vec2(loc.x,0.5));
-	float fftVal = gain * (fft.r + fft.g + fft.b) / 3.0;
-	if (loc.y > fftVal)
-		fft = topColor;
-	else
-		fft = bottomColor;
-	if ((strokeSize > 0.0) && (abs(fftVal - loc.y) < strokeSize))	{
-		fft = mix(strokeColor, fft, abs(fftVal - loc.y) / strokeSize);
-	}
-	
-	//(smoothstep(0.0, stroke, abs(fftVal - loc.y))) * strokeColor);
-	gl_FragColor = fft;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Test-Bool.fs b/nannou_isf/test_files/Test-Bool.fs
deleted file mode 100644
index 2a5869239..000000000
--- a/nannou_isf/test_files/Test-Bool.fs
+++ /dev/null
@@ -1,25 +0,0 @@
-/*{
-	"DESCRIPTION": "demonstrates a BOOL-type input on an image filter",
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2.0",
-	"CATEGORIES": [
-		"TEST-GLSL FX"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "flashToggle",
-			"TYPE": "bool",
-			"DEFAULT": 1.0
-		}
-	]
-}*/
-
-void main()
-{
-	vec4		srcPixel = IMG_THIS_PIXEL(inputImage);
-	gl_FragColor = (flashToggle==true) ? vec4(1.0,1.0,1.0,1.0) : srcPixel;
-}
diff --git a/nannou_isf/test_files/Test-Color.fs b/nannou_isf/test_files/Test-Color.fs
deleted file mode 100644
index af5525727..000000000
--- a/nannou_isf/test_files/Test-Color.fs
+++ /dev/null
@@ -1,48 +0,0 @@
-/*{
-	"DESCRIPTION": "demonstrates the use of color-type image inputs",
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2.0",
-	"CATEGORIES": [
-		"TEST-GLSL FX"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "level",
-			"TYPE": "float",
-			"DEFAULT": 0.5,
-			"MIN": 0.0,
-			"MAX": 1.0
-		},
-		{
-			"NAME": "lowColor",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.0,
-				0.0,
-				1.0,
-				1.0
-			]
-		},
-		{
-			"NAME": "highColor",
-			"TYPE": "color",
-			"DEFAULT": [
-				1.0,
-				1.0,
-				1.0,
-				1.0
-			]
-		}
-	]
-}*/
-
-void main()
-{
-	vec4		srcPixel = IMG_THIS_PIXEL(inputImage);
-	vec4		dstPixel = ((srcPixel.r+srcPixel.g+srcPixel.b)/3.0>level) ? lowColor : highColor;
-	gl_FragColor = dstPixel;
-}
diff --git a/nannou_isf/test_files/Test-Event.fs b/nannou_isf/test_files/Test-Event.fs
deleted file mode 100644
index 2037a5d0b..000000000
--- a/nannou_isf/test_files/Test-Event.fs
+++ /dev/null
@@ -1,24 +0,0 @@
-/*{
-	"DESCRIPTION": "demonstrates the use of an event-type input",
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2.0",
-	"CATEGORIES": [
-		"TEST-GLSL FX"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "flashEvent",
-			"TYPE": "event"
-		}
-	]
-}*/
-
-void main()
-{
-	vec4		srcPixel = IMG_THIS_PIXEL(inputImage);
-	gl_FragColor = (flashEvent==true) ? vec4(1.0,1.0,1.0,1.0) : srcPixel;
-}
diff --git a/nannou_isf/test_files/Test-Float.fs b/nannou_isf/test_files/Test-Float.fs
deleted file mode 100644
index b83c74ac7..000000000
--- a/nannou_isf/test_files/Test-Float.fs
+++ /dev/null
@@ -1,29 +0,0 @@
-/*{
-	"DESCRIPTION": "demonstrates the use of float-type inputs",
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2.0",
-	"CATEGORIES": [
-		"TEST-GLSL FX"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "level",
-			"TYPE": "float",
-			"DEFAULT": 0.5,
-			"MIN": 0.0,
-			"MAX": 1.0
-		}
-	]
-}*/
-
-void main()
-{
-	vec4		srcPixel = IMG_THIS_PIXEL(inputImage);
-	float		luma = (srcPixel.r+srcPixel.g+srcPixel.b)/3.0;
-	vec4		dstPixel = (luma>level) ? srcPixel : vec4(0,0,0,1);
-	gl_FragColor = dstPixel;
-}
diff --git a/nannou_isf/test_files/Test-Functionality.fs b/nannou_isf/test_files/Test-Functionality.fs
deleted file mode 100644
index d7e5ffecd..000000000
--- a/nannou_isf/test_files/Test-Functionality.fs
+++ /dev/null
@@ -1,19 +0,0 @@
-/*{
-	"DESCRIPTION": "just colors the passed image opaque red, tests basic rendering functionality",
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2.0",
-	"CATEGORIES": [
-		"TEST-GLSL FX"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		}
-	]
-}*/
-
-void main()
-{
-	gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Test-IMG_NORM_PIXEL.fs b/nannou_isf/test_files/Test-IMG_NORM_PIXEL.fs
deleted file mode 100644
index 7e5f79e99..000000000
--- a/nannou_isf/test_files/Test-IMG_NORM_PIXEL.fs
+++ /dev/null
@@ -1,20 +0,0 @@
-/*{
-	"DESCRIPTION": "demonstrates the use of IMG_NORM_PIXEL to fetch a pixel color from an input",
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2.0",
-	"CATEGORIES": [
-		"TEST-GLSL FX"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		}
-	]
-}*/
-
-void main()
-{
-	vec4		test = IMG_NORM_PIXEL(inputImage, isf_FragNormCoord);
-	gl_FragColor = test;
-}
diff --git a/nannou_isf/test_files/Test-IMG_PIXEL.fs b/nannou_isf/test_files/Test-IMG_PIXEL.fs
deleted file mode 100644
index 9d293d7c5..000000000
--- a/nannou_isf/test_files/Test-IMG_PIXEL.fs
+++ /dev/null
@@ -1,20 +0,0 @@
-/*{
-	"DESCRIPTION": "demonstrates the use of IMG_PIXEL to fetch a pixel color from an input",
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2.0",
-	"CATEGORIES": [
-		"TEST-GLSL FX"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		}
-	]
-}*/
-
-void main()
-{
-	vec4		test = IMG_PIXEL(inputImage, gl_FragCoord.xy);
-	gl_FragColor = test;
-}
diff --git a/nannou_isf/test_files/Test-IMG_THIS_NORM_PIXEL.fs b/nannou_isf/test_files/Test-IMG_THIS_NORM_PIXEL.fs
deleted file mode 100644
index f8d52f1fa..000000000
--- a/nannou_isf/test_files/Test-IMG_THIS_NORM_PIXEL.fs
+++ /dev/null
@@ -1,20 +0,0 @@
-/*{
-	"DESCRIPTION": "demonstrates the use of IMG_THIS_NORM_PIXEL to fetch a pixel color from an input",
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2.0",
-	"CATEGORIES": [
-		"TEST-GLSL FX"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		}
-	]
-}*/
-
-void main()
-{
-	vec4		test = IMG_THIS_NORM_PIXEL(inputImage);
-	gl_FragColor = test;
-}
diff --git a/nannou_isf/test_files/Test-IMG_THIS_PIXEL.fs b/nannou_isf/test_files/Test-IMG_THIS_PIXEL.fs
deleted file mode 100644
index e2e511e97..000000000
--- a/nannou_isf/test_files/Test-IMG_THIS_PIXEL.fs
+++ /dev/null
@@ -1,20 +0,0 @@
-/*{
-	"DESCRIPTION": "demonstrates the use of IMG_THIS_PIXEL to fetch a pixel color from an input",
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2.0",
-	"CATEGORIES": [
-		"TEST-GLSL FX"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		}
-	]
-}*/
-
-void main()
-{
-	vec4		test = IMG_THIS_PIXEL(inputImage);
-	gl_FragColor = test;
-}
diff --git a/nannou_isf/test_files/Test-ImportedImage.fs b/nannou_isf/test_files/Test-ImportedImage.fs
deleted file mode 100644
index 8c935adba..000000000
--- a/nannou_isf/test_files/Test-ImportedImage.fs
+++ /dev/null
@@ -1,27 +0,0 @@
-/*{
-	"DESCRIPTION": "demonstrates the use of multiple image-type inputs",
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2.0",
-	"CATEGORIES": [
-		"TEST-GLSL FX"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		}
-	],
-	"IMPORTED": {
-		"blendImage": {
-			"PATH": "Hexagon.tiff"
-		}
-	}
-}*/
-
-void main()
-{
-	vec4		srcPixel = IMG_NORM_PIXEL(inputImage, isf_FragNormCoord);
-	vec4		blendPixel = IMG_NORM_PIXEL(blendImage, isf_FragNormCoord);
-	
-	gl_FragColor = (srcPixel + blendPixel)/2.0;
-}
diff --git a/nannou_isf/test_files/Test-Long.fs b/nannou_isf/test_files/Test-Long.fs
deleted file mode 100644
index 973cb58ec..000000000
--- a/nannou_isf/test_files/Test-Long.fs
+++ /dev/null
@@ -1,40 +0,0 @@
-/*{
-	"DESCRIPTION": "demonstrates the use of long-type inputs as pop-up buttons to display either the red, green, or blue channel of an image",
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2.0",
-	"CATEGORIES": [
-		"TEST-GLSL FX"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "longInputIsPopUpButton",
-			"VALUES": [
-				0,
-				1,
-				2
-			],
-			"LABELS": [
-				"red",
-				"green",
-				"blue"
-			],
-			"DEFAULT": 1,
-			"TYPE": "long"
-		}
-	]
-}*/
-
-void main()
-{
-	vec4		srcPixel = IMG_THIS_PIXEL(inputImage);
-	if (longInputIsPopUpButton == 0)
-		gl_FragColor = srcPixel.rrra;
-	else if (longInputIsPopUpButton == 1)
-		gl_FragColor = srcPixel.ggga;
-	else if (longInputIsPopUpButton == 2)
-		gl_FragColor = srcPixel.bbba;
-}
diff --git a/nannou_isf/test_files/Test-MultiPassRendering.fs b/nannou_isf/test_files/Test-MultiPassRendering.fs
deleted file mode 100644
index 8aae97ca5..000000000
--- a/nannou_isf/test_files/Test-MultiPassRendering.fs
+++ /dev/null
@@ -1,38 +0,0 @@
-/*{
-	"DESCRIPTION": "demonstrates the use of two-pass rendering- the first pass renders to a persistent buffer which is substantially smaller than the res of the image being drawn.  the second pass renders at the default requested size and scales up the image from the first pass",
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2.0",
-	"CATEGORIES": [
-		"TEST-GLSL FX"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		}
-	],
-	"PASSES": [
-		{
-			"TARGET":"bufferVariableNameA",
-			"PERSISTENT": true,
-			"WIDTH": "$WIDTH/16.0",
-			"HEIGHT": "$HEIGHT/16.0"
-		},
-		{
-		
-		}
-	]
-	
-}*/
-
-void main()
-{
-	//	first pass: read the "inputImage"- remember, we're drawing to the persistent buffer "bufferVariableNameA" on the first pass
-	if (PASSINDEX == 0)	{
-		gl_FragColor = IMG_THIS_NORM_PIXEL(inputImage);
-	}
-	//	second pass: read from "bufferVariableNameA".  output looks chunky and low-res.
-	else if (PASSINDEX == 1)	{
-		gl_FragColor = IMG_THIS_NORM_PIXEL(bufferVariableNameA);
-	}
-}
diff --git a/nannou_isf/test_files/Test-PersistentBuffer.fs b/nannou_isf/test_files/Test-PersistentBuffer.fs
deleted file mode 100644
index 4e6e4d3c5..000000000
--- a/nannou_isf/test_files/Test-PersistentBuffer.fs
+++ /dev/null
@@ -1,33 +0,0 @@
-/*{
-	"DESCRIPTION": "demonstrates the use of a persistent buffer to create a motion-blur type effect. also demonstrates the simplest use of steps: a one-step rendering pass",
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2.0",
-	"CATEGORIES": [
-		"TEST-GLSL FX"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "blurAmount",
-			"TYPE": "float"
-		}
-	],
-	"PASSES": [
-		{
-			"TARGET": "bufferVariableNameA",
-			"PERSISTENT": true,
-			"FLOAT": true
-		}
-	]
-	
-}*/
-
-void main()
-{
-	vec4		freshPixel = IMG_THIS_PIXEL(inputImage);
-	vec4		stalePixel = IMG_THIS_PIXEL(bufferVariableNameA);
-	gl_FragColor = mix(freshPixel,stalePixel,blurAmount);
-}
diff --git a/nannou_isf/test_files/Test-PersistentBufferDifferingSizes.fs b/nannou_isf/test_files/Test-PersistentBufferDifferingSizes.fs
deleted file mode 100644
index e90da129a..000000000
--- a/nannou_isf/test_files/Test-PersistentBufferDifferingSizes.fs
+++ /dev/null
@@ -1,39 +0,0 @@
-/*{
-	"DESCRIPTION": "demonstrates the use of two-pass rendering- the first pass renders to a persistent buffer which is substantially smaller than the res of the image being drawn.  the second pass renders at the default requested size and scales up the image from the first pass",
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2.0",
-	"CATEGORIES": [
-		"TEST-GLSL FX"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		}
-	],
-	"PASSES": [
-		{
-			"TARGET":"bufferVariableNameA",
-			"PERSISTENT": true,
-			"FLOAT": true,
-			"WIDTH": "$WIDTH/16.0",
-			"HEIGHT": "$HEIGHT/16.0"
-		},
-		{
-		
-		}
-	]
-	
-}*/
-
-void main()
-{
-	//	first pass: read the "inputImage"- remember, we're drawing to the persistent buffer "bufferVariableNameA" on the first pass
-	if (PASSINDEX == 0)	{
-		gl_FragColor = IMG_THIS_NORM_PIXEL(inputImage);
-	}
-	//	second pass: read from "bufferVariableNameA".  output looks chunky and low-res.
-	else if (PASSINDEX == 1)	{
-		gl_FragColor = IMG_THIS_NORM_PIXEL(bufferVariableNameA);
-	}
-}
diff --git a/nannou_isf/test_files/Test-Point.fs b/nannou_isf/test_files/Test-Point.fs
deleted file mode 100644
index 029cc0677..000000000
--- a/nannou_isf/test_files/Test-Point.fs
+++ /dev/null
@@ -1,47 +0,0 @@
-/*{
-	"DESCRIPTION": "demonstrates the use of a 2d point-type input",
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2.0",
-	"CATEGORIES": [
-		"TEST-GLSL FX"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "location",
-			"TYPE": "point2D",
-			"DEFAULT": [
-				0,
-				0
-			]
-		},
-		{
-			"NAME": "locationB",
-			"TYPE": "point2D",
-			"DEFAULT": [
-				0,
-				0
-			],
-			"MIN": [
-				0,
-				0
-			],
-			"MAX": [
-				1920,
-				1080
-			]
-		}
-	]
-}*/
-
-void main()
-{
-	vec4		srcPixel = IMG_THIS_PIXEL(inputImage);
-	if (abs(gl_FragCoord.xy.x-location.x)<10.0 && abs(gl_FragCoord.xy.y-location.y)<10.0)
-		gl_FragColor = vec4(1,1,1,1);
-	else
-		gl_FragColor = srcPixel;
-}
diff --git a/nannou_isf/test_files/Test-Sampler.fs b/nannou_isf/test_files/Test-Sampler.fs
deleted file mode 100644
index e6f7955f2..000000000
--- a/nannou_isf/test_files/Test-Sampler.fs
+++ /dev/null
@@ -1,32 +0,0 @@
-/*{
-	"DESCRIPTION": "demonstrates the use of multiple image-type inputs",
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2.0",
-	"CATEGORIES": [
-		"TEST-GLSL FX"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "blendImage",
-			"TYPE": "image"
-		}
-	]
-}*/
-
-void main()
-{
-	//	these two variable declarations are functionally identical (the only difference is that THIS_PIXEL is a non-dependent texture lookup)
-	//vec4		srcPixel = IMG_PIXEL(inputImage, gl_FragCoord.xy);	//	returns a vec4 with the colors of the pixel in sampler "inputImage" at (non-normalized) texture coordinates "srcCoord"
-	//vec4		srcPixel = IMG_THIS_PIXEL(inputImage);
-	
-	//	these two variable declarations are also identical.  though they behave similarly to the above declarations in this specific filter, NORM and non-NORM pixel lookups are fundamentally different and behave differently under other circumstances.
-	//vec4		srcPixel = IMG_NORM_PIXEL(inputImage, isf_FragNormCoord);
-	vec4		srcPixel = IMG_THIS_NORM_PIXEL(inputImage);
-	
-	vec4		blendPixel = IMG_THIS_NORM_PIXEL(blendImage);	//	returns a vec4 with the colors of the pixel in sampler "inputImage" at (normalized) texture coordinates "blendCoord".
-	gl_FragColor = srcPixel/2.0 + blendPixel/2.0;
-}
diff --git a/nannou_isf/test_files/Test-TempBufferDifferingSizes.fs b/nannou_isf/test_files/Test-TempBufferDifferingSizes.fs
deleted file mode 100644
index 4967abc58..000000000
--- a/nannou_isf/test_files/Test-TempBufferDifferingSizes.fs
+++ /dev/null
@@ -1,37 +0,0 @@
-/*{
-	"DESCRIPTION": "same as TestPersistentBufferDifferingSizes, but uses a temp buffer instead of a persistent buffer",
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2.0",
-	"CATEGORIES": [
-		"TEST-GLSL FX"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		}
-	],
-	"PASSES": [
-		{
-			"TARGET":"bufferVariableNameA",
-			"WIDTH": "$WIDTH/16.0",
-			"HEIGHT": "$HEIGHT/16.0"
-		},
-		{
-			"DESCRIPTION": "this empty pass is rendered at the same rez as whatever you are running the ISF filter at- the previous step rendered an image at one-sixteenth the res, so this step ensures that the output is full-size"
-		}
-	]
-	
-}*/
-
-void main()
-{
-	//	first pass: read the "inputImage"- remember, we're drawing to the persistent buffer "bufferVariableNameA" on the first pass
-	if (PASSINDEX == 0)	{
-		gl_FragColor = IMG_THIS_NORM_PIXEL(inputImage);
-	}
-	//	second pass: read from "bufferVariableNameA".  output looks chunky and low-res.
-	else if (PASSINDEX == 1)	{
-		gl_FragColor = IMG_THIS_NORM_PIXEL(bufferVariableNameA);
-	}
-}
diff --git a/nannou_isf/test_files/Thermal Camera.fs b/nannou_isf/test_files/Thermal Camera.fs
deleted file mode 100644
index 9c64c7c83..000000000
--- a/nannou_isf/test_files/Thermal Camera.fs	
+++ /dev/null
@@ -1,111 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Stylize",
-        "Color Effect"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-//	partly adapted from http://coding-experiments.blogspot.com/2010/10/thermal-vision-pixel-shader.html
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-in vec2 left_coord;
-in vec2 right_coord;
-in vec2 above_coord;
-in vec2 below_coord;
-
-in vec2 lefta_coord;
-in vec2 righta_coord;
-in vec2 leftb_coord;
-in vec2 rightb_coord;
-#endif
-
-
-void main ()	{
-	//vec4 pixcol = IMG_THIS_PIXEL(inputImage);
-	vec4 colors[9];
-	//	8 color stages with variable ranges to get this to look right
-	//	black, purple, blue, cyan, green, yellow, orange, red, red
-	colors[0] = vec4(0.0,0.0,0.0,1.0);
-	colors[1] = vec4(0.272,0.0,0.4,1.0);	//	dark deep purple, (RGB: 139, 0, 204)
-	colors[2] = vec4(0.0,0.0,1.0,1.0);		//	full blue
-	colors[3] = vec4(0.0,1.0,1.0,1.0);		//	cyan
-	colors[4] = vec4(0.0,1.0,0.0,1.0);		//	green
-	colors[5] = vec4(0.0,1.0,0.0,1.0);		//	green
-	colors[6] = vec4(1.0,1.0,0.0,1.0);		//	yellow
-	colors[7] = vec4(1.0,0.5,0.0,1.0);		//	orange
-	colors[8] = vec4(1.0,0.0,0.0,1.0);		//	red
-	
-	vec4 color = IMG_THIS_NORM_PIXEL(inputImage);
-	vec4 colorL = IMG_NORM_PIXEL(inputImage, left_coord);
-	vec4 colorR = IMG_NORM_PIXEL(inputImage, right_coord);
-	vec4 colorA = IMG_NORM_PIXEL(inputImage, above_coord);
-	vec4 colorB = IMG_NORM_PIXEL(inputImage, below_coord);
-
-	vec4 colorLA = IMG_NORM_PIXEL(inputImage, lefta_coord);
-	vec4 colorRA = IMG_NORM_PIXEL(inputImage, righta_coord);
-	vec4 colorLB = IMG_NORM_PIXEL(inputImage, leftb_coord);
-	vec4 colorRB = IMG_NORM_PIXEL(inputImage, rightb_coord);
-
-	vec4 avg = (color + colorL + colorR + colorA + colorB + colorLA + colorRA + colorLB + colorRB) / 9.0;
-	
-	const vec4 	lumacoeff = vec4(0.2126, 0.7152, 0.0722, 0.0);
-	float		lum = dot(avg, lumacoeff);
-	//float lum = (avg.r+avg.g+avg.b)/3.0;
-	//float lum = dot(vec3(0.30, 0.59, 0.11), avg.rgb);
-	lum = pow(lum,1.4);
-
-	int ix = 0;
-	float range = 1.0 / 8.0;
-	
-	//	orange to red
-	if (lum > range * 7.0)	{
-		ix = 7;
-	}
-	//	yellow to orange
-	else if (lum > range * 6.0)	{
-		ix = 6;
-	}
-	//	green to yellow
-	else if (lum > range * 5.0)	{
-		ix = 5;
-	}
-	//	green to green
-	else if (lum > range * 4.0)	{
-		ix = 4;
-	}
-	//	cyan to green
-	else if (lum > range * 3.0)	{
-		ix = 3;
-	}
-	//	blue to cyan
-	else if (lum > range * 2.0)	{
-		ix = 2;
-	}
-	// purple to blue
-	else if (lum > range)	{
-		ix = 1;
-	}
-	
-	vec4 thermal = mix(colors[ix],colors[ix+1],(lum-float(ix)*range)/range);
-	gl_FragColor = thermal;
-
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Thermal Camera.vs b/nannou_isf/test_files/Thermal Camera.vs
deleted file mode 100644
index b0ba4b037..000000000
--- a/nannou_isf/test_files/Thermal Camera.vs	
+++ /dev/null
@@ -1,39 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-out vec2 left_coord;
-out vec2 right_coord;
-out vec2 above_coord;
-out vec2 below_coord;
-
-out vec2 lefta_coord;
-out vec2 righta_coord;
-out vec2 leftb_coord;
-out vec2 rightb_coord;
-#endif
-
-
-void main()
-{
-	isf_vertShaderInit();
-	vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	vec2 d = 1.0/RENDERSIZE;
-
-	left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
-	right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
-	above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
-	below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
-
-	lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
-	righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
-	leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
-	rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Time Glitch RGB.fs b/nannou_isf/test_files/Time Glitch RGB.fs
deleted file mode 100644
index cbb1be1eb..000000000
--- a/nannou_isf/test_files/Time Glitch RGB.fs	
+++ /dev/null
@@ -1,461 +0,0 @@
-/*{
-	"DESCRIPTION": "Buffers 8 recent frames",
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Glitch"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "inputDelay",
-			"LABEL": "Buffer",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.25,
-				0.5,
-				0.75,
-				0.5
-			]
-		},
-		{
-			"NAME": "inputRate",
-			"LABEL": "Buffer Lag",
-			"TYPE": "float",
-			"MIN": 1.0,
-			"MAX": 20.0,
-			"DEFAULT": 4.0
-		},
-		{
-			"NAME": "glitch_size",
-			"LABEL": "Size",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 0.5,
-			"DEFAULT": 0.1
-		},
-		{
-			"NAME": "glitch_horizontal",
-			"LABEL": "Horizontal Amount",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.2
-		},
-		{
-			"NAME": "glitch_vertical",
-			"LABEL": "Vertical Amount",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.0
-		},
-		{
-			"NAME": "randomize_size",
-			"LABEL": "Randomize Size",
-			"TYPE": "bool",
-			"DEFAULT": 1.0
-		},
-		{
-			"NAME": "randomize_position",
-			"LABEL": "Randomize Position",
-			"TYPE": "bool",
-			"DEFAULT": 0.0
-		},
-		{
-			"NAME": "randomize_zoom",
-			"LABEL": "Randomize Zoom",
-			"TYPE": "bool",
-			"DEFAULT": 0.0
-		}
-	],
-	"PASSES": [
-		{
-			"TARGET":"lastRow",
-			"WIDTH": "1",
-			"HEIGHT": "1",
-			"PERSISTENT": true,
-			"DESCRIPTION": "this buffer stores the last frame's odd / even state"
-		},
-		{
-			"TARGET":"buffer8",
-			"PERSISTENT": true
-		},
-		{
-			"TARGET":"buffer7",
-			"PERSISTENT": true
-		},
-		{
-			"TARGET":"buffer6",
-			"PERSISTENT": true
-		},
-		{
-			"TARGET":"buffer5",
-			"PERSISTENT": true
-		},
-		{
-			"TARGET":"buffer4",
-			"PERSISTENT": true
-		},
-		{
-			"TARGET":"buffer3",
-			"PERSISTENT": true
-		},
-		{
-			"TARGET":"buffer2",
-			"PERSISTENT": true
-		},
-		{
-			"TARGET":"buffer1",
-			"PERSISTENT": true
-		},
-		{
-		
-		}
-	]
-	
-}*/
-
-
-float rand(vec2 co){
-    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-
-void main()
-{
-	//	first pass: read the "buffer7" into "buffer8"
-	//	apply lag on each pass
-	//	if this is the first pass, i'm going to read the position from the "lastRow" image, and write a new position based on this and the hold variables
-	if (PASSINDEX == 0)	{
-		vec4		srcPixel = IMG_PIXEL(lastRow,vec2(0.5));
-		//	i'm only using the X and Y components, which are the X and Y offset (normalized) for the frame
-		if (inputRate == 0.0)	{
-			srcPixel.x = 0.0;
-			srcPixel.y = 0.0;
-		}
-		else if (inputRate <= 1.0)	{
-			srcPixel.x = (srcPixel.x) > 0.5 ? 0.0 : 1.0;
-			srcPixel.y = 0.0;
-		}
-		else {
-			srcPixel.x = srcPixel.x + 1.0 / inputRate + srcPixel.y;
-			if (srcPixel.x > 1.0)	{
-				srcPixel.y = mod(srcPixel.x, 1.0);
-				srcPixel.x = 0.0;
-			}
-		}
-		gl_FragColor = srcPixel;
-	}
-	if (PASSINDEX == 1)	{
-		vec4		lastRow = IMG_PIXEL(lastRow,vec2(0.5));
-		if (lastRow.x == 0.0)	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer7);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer8);
-		}
-	}
-	else if (PASSINDEX == 2)	{
-		vec4		lastRow = IMG_PIXEL(lastRow,vec2(0.5));
-		if (lastRow.x == 0.0)	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer6);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer7);
-		}
-	}
-	else if (PASSINDEX == 3)	{
-		vec4		lastRow = IMG_PIXEL(lastRow,vec2(0.5));
-		if (lastRow.x == 0.0)	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer5);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer6);
-		}
-	}
-	else if (PASSINDEX == 4)	{
-		vec4		lastRow = IMG_PIXEL(lastRow,vec2(0.5));
-		if (lastRow.x == 0.0)	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer4);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer5);
-		}
-	}
-	else if (PASSINDEX == 5)	{
-		vec4		lastRow = IMG_PIXEL(lastRow,vec2(0.5));
-		if (lastRow.x == 0.0)	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer3);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer4);
-		}
-	}
-	else if (PASSINDEX == 6)	{
-		vec4		lastRow = IMG_PIXEL(lastRow,vec2(0.5));
-		if (lastRow.x == 0.0)	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer2);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer3);
-		}
-	}
-	else if (PASSINDEX == 7)	{
-		vec4		lastRow = IMG_PIXEL(lastRow,vec2(0.5));
-		if (lastRow.x == 0.0)	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer1);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer2);
-		}
-	}
-	else if (PASSINDEX == 8)	{
-		vec4		lastRow = IMG_PIXEL(lastRow,vec2(0.5));
-		if (lastRow.x == 0.0)	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(inputImage);
-		}
-		else	{
-			gl_FragColor = IMG_THIS_NORM_PIXEL(buffer1);
-		}
-	}
-	else if (PASSINDEX == 9)	{
-		//	Figure out which section I'm in and draw the appropriate buffer there
-		vec2 tex = isf_FragNormCoord;
-		vec4 color = vec4(0.0);		
-		//	figure out the "input delay shift" for this pixel...
-		float randomDelayShift = 0.0;
-		
-		vec2 xy; 
-		xy.x = isf_FragNormCoord[0];
-		xy.y = isf_FragNormCoord[1];
-	
-		//	quantize the xy to the glitch_amount size
-		//xy = floor(xy / glitch_size) * glitch_size;
-		vec2 random;
-
-		float local_glitch_size = glitch_size;
-		float random_offset = 0.0;
-	
-		if (randomize_size)	{
-			random_offset = mod(rand(vec2(TIME,TIME)), 1.0);
-			local_glitch_size = random_offset * glitch_size;
-		}
-	
-		if (local_glitch_size > 0.0)	{
-			random.x = rand(vec2(floor(random_offset + xy.y / local_glitch_size) * local_glitch_size, TIME));
-			random.y = rand(vec2(floor(random_offset + xy.x / local_glitch_size) * local_glitch_size, TIME));
-		}
-		else	{
-			random.x = rand(vec2(xy.x, TIME));
-			random.y = rand(vec2(xy.y, TIME));
-		}
-	
-		//	if doing a horizontal glitch do a random shift
-		if ((random.x < glitch_horizontal)&&(random.y < glitch_vertical))	{
-			randomDelayShift = clamp(random.x + random.y, 0.0, 2.0);
-		}
-		else if (random.x < glitch_horizontal)	{
-			randomDelayShift = clamp(random.x + random.y, 0.0, 2.0);
-		}
-		else if (random.y < glitch_vertical)	{
-			randomDelayShift = clamp(random.x + random.y, 0.0, 2.0);
-		}
-		
-		vec4 pixelBuffer = randomDelayShift * inputDelay * 9.0;
-		
-		if (randomize_zoom)	{
-			if ((random.x < glitch_horizontal)&&(random.y < glitch_vertical))	{
-				float level = (random.x + random.y) / 3.0 + 0.90;
-				tex = (tex - vec2(0.5))*(1.0/level) + vec2(0.5);
-			}
-			else if (random.x < glitch_horizontal)	{
-				float level = (random.x) / 2.0 + 0.95;
-				tex = (tex - vec2(0.5))*(1.0/level) + vec2(0.5);
-			}
-			else if (random.y < glitch_vertical)	{
-				float level = (random.y) / 2.0 + 0.95;
-				tex = (tex - vec2(0.5))*(1.0/level) + vec2(0.5);
-			}
-		}
-		
-		if (randomize_position)	{
-			if ((random.x < glitch_horizontal)&&(random.y < glitch_vertical))	{
-				tex.x = mod(tex.x + inputDelay.r * random.x, 1.0);
-				tex.y = mod(tex.y + inputDelay.r * random.y, 1.0);
-			}
-			else if (random.x < glitch_horizontal)	{
-				tex.y = mod(tex.y + inputDelay.r * random.x, 1.0);
-			}
-			else if (random.y < glitch_vertical)	{
-				tex.x = mod(tex.x + inputDelay.r * random.y, 1.0);
-			}
-			//	apply small random zoom too
-		}
-		
-		if (pixelBuffer.r < 1.0)	{
-			color.r = IMG_NORM_PIXEL(inputImage, tex).r;
-		}
-		else if (pixelBuffer.r < 2.0)	{
-			color.r = IMG_NORM_PIXEL(buffer1, tex).r;
-		}
-		else if (pixelBuffer.r < 3.0)	{
-			color.r = IMG_NORM_PIXEL(buffer2, tex).r;
-		}
-		else if (pixelBuffer.r < 4.0)	{
-			color.r = IMG_NORM_PIXEL(buffer3, tex).r;
-		}
-		else if (pixelBuffer.r < 5.0)	{
-			color.r = IMG_NORM_PIXEL(buffer4, tex).r;
-		}
-		else if (pixelBuffer.r < 6.0)	{
-			color.r = IMG_NORM_PIXEL(buffer5, tex).r;
-		}
-		else if (pixelBuffer.r < 7.0)	{
-			color.r = IMG_NORM_PIXEL(buffer6, tex).r;
-		}
-		else if (pixelBuffer.r < 8.0)	{
-			color.r = IMG_NORM_PIXEL(buffer7, tex).r;
-		}
-		else	{
-			color.r = IMG_NORM_PIXEL(buffer8, tex).r;
-		}
-		
-		if (randomize_position)	{
-			if ((random.x < glitch_horizontal)&&(random.y < glitch_vertical))	{
-				tex.x = mod(tex.x + random.x * inputDelay.g, 1.0);
-				tex.y = mod(tex.y + random.y * inputDelay.g, 1.0);
-			}
-			else if (random.x < glitch_horizontal)	{
-				tex.y = mod(tex.y + random.x * inputDelay.g, 1.0);
-			}
-			else if (random.y < glitch_vertical)	{
-				tex.x = mod(tex.x + random.y * inputDelay.g, 1.0);
-			}
-			//	apply small random zoom too
-			//float level = inputDelay.g * random.x / 5.0 + 0.9;
-			//tex = (tex - vec2(0.5))*(1.0/level) + vec2(0.5);
-		}
-		
-		if (pixelBuffer.g < 1.0)	{
-			color.g = IMG_NORM_PIXEL(inputImage, tex).g;
-		}
-		else if (pixelBuffer.g < 2.0)	{
-			color.g = IMG_NORM_PIXEL(buffer1, tex).g;
-		}
-		else if (pixelBuffer.g < 3.0)	{
-			color.g = IMG_NORM_PIXEL(buffer2, tex).g;
-		}
-		else if (pixelBuffer.g < 4.0)	{
-			color.g = IMG_NORM_PIXEL(buffer3, tex).g;
-		}
-		else if (pixelBuffer.g < 5.0)	{
-			color.g = IMG_NORM_PIXEL(buffer4, tex).g;
-		}
-		else if (pixelBuffer.g < 6.0)	{
-			color.g = IMG_NORM_PIXEL(buffer5, tex).g;
-		}
-		else if (pixelBuffer.g < 7.0)	{
-			color.g = IMG_NORM_PIXEL(buffer6, tex).g;
-		}
-		else if (pixelBuffer.g < 8.0)	{
-			color.g = IMG_NORM_PIXEL(buffer7, tex).g;
-		}
-		else	{
-			color.g = IMG_NORM_PIXEL(buffer8, tex).g;
-		}
-		
-		if (randomize_position)	{
-			if ((random.x < glitch_horizontal)&&(random.y < glitch_vertical))	{
-				tex.x = mod(tex.x + random.x * inputDelay.b, 1.0);
-				tex.y = mod(tex.y + random.y * inputDelay.b, 1.0);
-			}
-			else if (random.x < glitch_horizontal)	{
-				tex.y = mod(tex.y + random.x * inputDelay.b, 1.0);
-			}
-			else if (random.y < glitch_vertical)	{
-				tex.x = mod(tex.x + random.y * inputDelay.b, 1.0);
-			}
-			//	apply small random zoom too
-			//float level = inputDelay.b * random.x / 5.0 + 0.9;
-			//tex = (tex - vec2(0.5))*(1.0/level) + vec2(0.5);
-		}
-		
-		if (pixelBuffer.b < 1.0)	{
-			color.b = IMG_NORM_PIXEL(inputImage, tex).b;
-		}
-		else if (pixelBuffer.b < 2.0)	{
-			color.b = IMG_NORM_PIXEL(buffer1, tex).b;
-		}
-		else if (pixelBuffer.b < 3.0)	{
-			color.b = IMG_NORM_PIXEL(buffer2, tex).b;
-		}
-		else if (pixelBuffer.b < 4.0)	{
-			color.b = IMG_NORM_PIXEL(buffer3, tex).b;
-		}
-		else if (pixelBuffer.b < 5.0)	{
-			color.b = IMG_NORM_PIXEL(buffer4, tex).b;
-		}
-		else if (pixelBuffer.b < 6.0)	{
-			color.b = IMG_NORM_PIXEL(buffer5, tex).b;
-		}
-		else if (pixelBuffer.b < 7.0)	{
-			color.b = IMG_NORM_PIXEL(buffer6, tex).b;
-		}
-		else if (pixelBuffer.b < 8.0)	{
-			color.b = IMG_NORM_PIXEL(buffer7, tex).b;
-		}
-		else	{
-			color.b = IMG_NORM_PIXEL(buffer8, tex).b;
-		}
-		
-		if (randomize_position)	{
-			if ((random.x < glitch_horizontal)&&(random.y < glitch_vertical))	{
-				tex.x = mod(tex.x + random.x * inputDelay.a, 1.0);
-				tex.y = mod(tex.y + random.y * inputDelay.a, 1.0);
-			}
-			else if (random.x < glitch_horizontal)	{
-				tex.y = mod(tex.y + random.x * inputDelay.a, 1.0);
-			}
-			else if (random.y < glitch_vertical)	{
-				tex.x = mod(tex.x + random.y * inputDelay.a, 1.0);
-			}
-			//	apply small random zoom too
-			//float level = inputDelay.a * random.x / 5.0 + 0.9;
-			//tex = (tex - vec2(0.5))*(1.0/level) + vec2(0.5);
-		}
-		
-		if (pixelBuffer.a < 1.0)	{
-			color.a = IMG_NORM_PIXEL(inputImage, tex).a;
-		}
-		else if (pixelBuffer.a < 2.0)	{
-			color.a = IMG_NORM_PIXEL(buffer1, tex).a;
-		}
-		else if (pixelBuffer.a < 3.0)	{
-			color.a = IMG_NORM_PIXEL(buffer2, tex).a;
-		}
-		else if (pixelBuffer.a < 4.0)	{
-			color.a = IMG_NORM_PIXEL(buffer3, tex).a;
-		}
-		else if (pixelBuffer.a < 5.0)	{
-			color.a = IMG_NORM_PIXEL(buffer4, tex).a;
-		}
-		else if (pixelBuffer.a < 6.0)	{
-			color.a = IMG_NORM_PIXEL(buffer5, tex).a;
-		}
-		else if (pixelBuffer.a < 7.0)	{
-			color.a = IMG_NORM_PIXEL(buffer6, tex).a;
-		}
-		else if (pixelBuffer.a < 8.0)	{
-			color.a = IMG_NORM_PIXEL(buffer7, tex).a;
-		}
-		else	{
-			color.a = IMG_NORM_PIXEL(buffer8, tex).a;
-		}
-
-		gl_FragColor = color;
-	}
-}
diff --git a/nannou_isf/test_files/Toon.fs b/nannou_isf/test_files/Toon.fs
deleted file mode 100644
index bb436641d..000000000
--- a/nannou_isf/test_files/Toon.fs
+++ /dev/null
@@ -1,77 +0,0 @@
-
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Stylize"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "normalEdgeThreshold",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 0.1,
-			"DEFAULT": 0.03
-		},
-		{
-			"NAME": "qLevel",
-			"TYPE": "float",
-			"MIN": 2.0,
-			"MAX": 64.0,
-			"DEFAULT": 32.0
-		}
-	]
-}*/
-
-//	with help from https://github.com/neilmendoza/ofxPostProcessing/blob/master/src/ToonPass.cpp
-
-
-vec3 getNormal(vec2 st){
-	vec2 texcoord = clamp(st, 0.001, 0.999);
-	return IMG_NORM_PIXEL(inputImage,texcoord).rgb;
-}
-
-void main(void){
-	float dxtex = 1.0 / RENDERSIZE.x;
-	float dytex = 1.0 / RENDERSIZE.y;
-
-	vec2 st = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	// access center pixel and 4 surrounded pixel
-	vec3 center = getNormal(st).rgb;
-	vec3 left = getNormal(st + vec2(dxtex, 0.0)).rgb;
-	vec3 right = getNormal(st + vec2(-dxtex, 0.0)).rgb;
-	vec3 up = getNormal(st + vec2(0.0, -dytex)).rgb;
-	vec3 down = getNormal(st + vec2(0.0, dytex)).rgb;
-
-	// discrete Laplace operator
-	vec3 laplace = abs(-4.0*center + left + right + up + down);
-	// if one rgb-component of convolution result is over threshold => edge
-	vec4 line = IMG_NORM_PIXEL(inputImage, st);
-	if(laplace.r > normalEdgeThreshold
-	|| laplace.g > normalEdgeThreshold
-	|| laplace.b > normalEdgeThreshold){
-		line = vec4(0.0, 0.0, 0.0, 1.0); // => color the pixel green
-	} else {
-		line = vec4(1.0, 1.0, 1.0, 1.0); // black
-	}
-
-	//end Line;
-	//gl_FragColor = line;
-	
-	vec4 color = IMG_THIS_PIXEL(inputImage);
-
-	// store previous alpha value
-	float alpha = color.a;
-	// quantize process: multiply by factor, round and divde by factor
-	color = floor((qLevel * color)) / qLevel;
-	// set fragment/pixel color
-	color.a = alpha;
-
-	gl_FragColor = color * line;
-	
-}
-
diff --git a/nannou_isf/test_files/Trail Mask.fs b/nannou_isf/test_files/Trail Mask.fs
deleted file mode 100644
index a48c817f9..000000000
--- a/nannou_isf/test_files/Trail Mask.fs	
+++ /dev/null
@@ -1,173 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Glitch"
-    ],
-    "CREDIT": "by VIDVOX",
-    "DESCRIPTION": "Pixels update only based on the masking image",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "LABEL": "mask image",
-            "NAME": "maskImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "mask size mode",
-            "LABELS": [
-                "Fit",
-                "Fill",
-                "Stretch",
-                "Copy"
-            ],
-            "NAME": "maskSizingMode",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1,
-                2,
-                3
-            ]
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": -1,
-            "NAME": "bright",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 4,
-            "MIN": -4,
-            "NAME": "contrast",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "NAME": "RGB_mode",
-            "TYPE": "bool"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "PERSISTENT": true,
-            "TARGET": "bufferVariableNameA"
-        }
-    ]
-}
-*/
-
-
-
-//const vec4		lumcoeff = vec4(0.299, 0.587, 0.114, 0.0);
-const vec4 		lumcoeff = vec4(0.2126, 0.7152, 0.0722, 0.0);
-
-//	'a' and 'b' are rects (x and y are the originx, z and w are the width and height)
-//	'm' is the sizing mode as described above (fit/fill/stretch/copy)
-vec4 RectThatFitsRectInRect(vec4 a, vec4 b, int m);
-
-
-void main()
-{
-	vec4	freshPixel = IMG_PIXEL(inputImage,gl_FragCoord.xy);
-	//	If we're on the line, update, otherwise use the stale pixel
-	vec4 	stalePixel = IMG_PIXEL(bufferVariableNameA,gl_FragCoord.xy);
-
-	
-	//	get the rect of the mask image after it's been resized according to the passed sizing mode.  this is in pixel coords relative to the rendering space!
-	vec4		rectOfResizedMaskImage = RectThatFitsRectInRect(vec4(0.0, 0.0, _maskImage_imgRect.z, _maskImage_imgRect.w), vec4(0,0,RENDERSIZE.x,RENDERSIZE.y), maskSizingMode);
-	//vec4		rectOfResizedMaskImage = RectThatFitsRectInRect(vec4(0.0, 0.0, IMG_SIZE(maskImage).x, IMG_SIZE(maskImage).y), vec4(0,0,RENDERSIZE.x,RENDERSIZE.y), maskSizingMode);
-	//	i know the pixel coords of this frag in the render space- convert this to NORMALIZED texture coords for the resized mask image
-	vec2		normMaskSrcCoord;
-	normMaskSrcCoord.x = (gl_FragCoord.x-rectOfResizedMaskImage.x)/rectOfResizedMaskImage.z;
-	normMaskSrcCoord.y = (gl_FragCoord.y-rectOfResizedMaskImage.y)/rectOfResizedMaskImage.w;
-	
-	//	get the color of the pixel from the mask image for these normalized coords
-	vec4		tmpColorA = IMG_NORM_PIXEL(maskImage, normMaskSrcCoord);
-	
-	//	apply bright/contrast to this pixel value
-	vec4		tmpColorB = tmpColorA + vec4(bright, bright, bright, 0.0);
-	tmpColorA.rgb = ((vec3(2.0) * (tmpColorB.rgb - vec3(0.5))) * vec3(contrast) / vec3(2.0)) + vec3(0.5);
-	tmpColorA.a = ((2.0 * (tmpColorB.a - 0.5)) * abs(contrast) / 2.0) + 0.5;
-	
-	
-	vec4		result;
-	if (RGB_mode)	{
-		result.a = freshPixel.a;
-		result.rgb = mix(freshPixel.rgb, stalePixel.rgb, clamp(tmpColorA.rgb,0.0,1.0));
-	}
-	//	get the luminance of this pixel value: this will be the new alpha for the source pixel
-	//	use the luminance to mix between the fresh pixel and the stale one
-	else	{
-		float		luminance = dot(tmpColorA,lumcoeff);
-		result = mix(freshPixel, stalePixel, clamp(luminance,0.0,1.0));
-	}
-
-	gl_FragColor = result;
-}
-
-
-//	rect that fits 'a' in 'b' using sizing mode 'm'
-vec4 RectThatFitsRectInRect(vec4 a, vec4 b, int m)	{
-	float		bAspect = b.z/b.w;
-	float		aAspect = a.z/a.w;
-	if (aAspect==bAspect)	{
-		return b;
-	}
-	vec4		returnMe = vec4(0.0);
-	//	fit
-	if (m==0)	{
-		//	if the rect i'm trying to fit stuff *into* is wider than the rect i'm resizing
-		if (bAspect > aAspect)	{
-			returnMe.w = b.w;
-			returnMe.z = returnMe.w * aAspect;
-		}
-		//	else if the rect i'm resizing is wider than the rect it's going into
-		else if (bAspect < aAspect)	{
-			returnMe.z = b.z;
-			returnMe.w = returnMe.z / aAspect;
-		}
-		else	{
-			returnMe.z = b.z;
-			returnMe.w = b.w;
-		}
-		returnMe.x = (b.z-returnMe.z)/2.0+b.x;
-		returnMe.y = (b.w-returnMe.w)/2.0+b.y;
-	}
-	//	fill
-	else if (m==1)	{
-		//	if the rect i'm trying to fit stuff *into* is wider than the rect i'm resizing
-		if (bAspect > aAspect)	{
-			returnMe.z = b.z;
-			returnMe.w = returnMe.z / aAspect;
-		}
-		//	else if the rect i'm resizing is wider than the rect it's going into
-		else if (bAspect < aAspect)	{
-			returnMe.w = b.w;
-			returnMe.z = returnMe.w * aAspect;
-		}
-		else	{
-			returnMe.z = b.z;
-			returnMe.w = b.w;
-		}
-		returnMe.x = (b.z-returnMe.z)/2.0+b.x;
-		returnMe.y = (b.w-returnMe.w)/2.0+b.y;
-	}
-	//	stretch
-	else if (m==2)	{
-		returnMe = vec4(b.x, b.y, b.z, b.w);
-	}
-	//	copy
-	else if (m==3)	{
-		returnMe.z = float(int(a.z));
-		returnMe.w = float(int(a.w));
-		returnMe.x = float(int((b.z-returnMe.z)/2.0+b.x));
-		returnMe.y = float(int((b.w-returnMe.w)/2.0+b.y));
-	}
-	return returnMe;
-}
diff --git a/nannou_isf/test_files/Trapezoid Distortion.fs b/nannou_isf/test_files/Trapezoid Distortion.fs
deleted file mode 100644
index f62d0d871..000000000
--- a/nannou_isf/test_files/Trapezoid Distortion.fs	
+++ /dev/null
@@ -1,58 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion Effect"
-    ],
-    "CREDIT": "VIDVOX",
-    "DESCRIPTION": "Warps the video into a trapezoid shape",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Top Width",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "topWidth",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Bottom Width",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "bottomWidth",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "LABEL": "Height",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "heightScale",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-void main()	{
-	vec4		inputPixelColor = vec4(0.0);
-	vec2		loc = isf_FragNormCoord.xy;
-	if (heightScale > 0.0)	{
-		float	heightDivisor = 1.0 / heightScale;
-		loc.y = loc.y * heightDivisor + (1.0 - heightDivisor) / 2.0;
-		float		currentLineWidth = mix(bottomWidth,topWidth,loc.y);
-		if (currentLineWidth > 0.0)	{
-			float		lwDivisor = 1.0 / currentLineWidth;
-			loc.x = loc.x * lwDivisor + (1.0 - lwDivisor) / 2.0;
-	
-			if ((loc.x >= 0.0)&&(loc.x <= 1.0)&&(loc.y >= 0.0)&&(loc.y <= 1.0))	{
-				inputPixelColor = IMG_NORM_PIXEL(inputImage,loc);	
-			}
-		}
-	}
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/Triangle Warp.fs b/nannou_isf/test_files/Triangle Warp.fs
deleted file mode 100644
index 855c03e58..000000000
--- a/nannou_isf/test_files/Triangle Warp.fs	
+++ /dev/null
@@ -1,60 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion Effect"
-    ],
-    "CREDIT": "VIDVOX",
-    "DESCRIPTION": "Warps an image to fit in a triangle by fitting the height of the image to the height of a triangle",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": [
-                0.5,
-                1
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "peakPoint",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "distortX",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-void main()	{
-	vec4		inputPixelColor = vec4(0.0);
-	vec2		pt = isf_FragNormCoord;
-	float		val = 0.0;
-	
-	if (pt.x < peakPoint.x)	{
-		pt.x = pt.x * 0.5 / peakPoint.x;
-		val = 2.0 * pt.x * peakPoint.y;
-	}
-	else	{
-		pt.x = 0.5 + 0.5 * (pt.x - peakPoint.x) / (1.0 - peakPoint.x);
-		val = (2.0 - 2.0 * pt.x) * peakPoint.y;
-	}
-	if (pt.y <= val)	{
-		pt.x = mix(isf_FragNormCoord.x,pt.x,distortX);
-		pt.y /= val;
-		inputPixelColor = IMG_NORM_PIXEL(inputImage, pt);
-	}
-	
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/Triangle.fs b/nannou_isf/test_files/Triangle.fs
deleted file mode 100644
index 9e905f007..000000000
--- a/nannou_isf/test_files/Triangle.fs
+++ /dev/null
@@ -1,110 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Geometry"
-    ],
-    "CREDIT": "by Carter Rosenberg",
-    "INPUTS": [
-        {
-            "DEFAULT": [
-                0,
-                0
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "pt1",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": [
-                0.5,
-                1
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "pt2",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": [
-                1,
-                0
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "pt3",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": [
-                1,
-                1,
-                1,
-                1
-            ],
-            "NAME": "fillColor",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0,
-                0,
-                0
-            ],
-            "NAME": "bgColor",
-            "TYPE": "color"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-//	functions via http://stackoverflow.com/questions/2049582/how-to-determine-a-point-in-a-triangle
-
-float sign(vec2 p1, vec2 p2, vec2 p3)
-{
-	return (p1.x - p3.x) * (p2.y - p3.y) - (p2.x - p3.x) * (p1.y - p3.y);
-}
-
-bool PointInTriangle(vec2 pt, vec2 v1, vec2 v2, vec2 v3)
-{
-	bool b1, b2, b3;
-
-	b1 = sign(pt, v1, v2) < 0.0;
-	b2 = sign(pt, v2, v3) < 0.0;
-	b3 = sign(pt, v3, v1) < 0.0;
-
-	return ((b1 == b2) && (b2 == b3));
-}
-
-
-void main() {
-	vec2 loc = isf_FragNormCoord;
-	vec4 outColor = vec4(0.0);
-	vec2 point1 = pt1;
-	vec2 point2 = pt2;
-	vec2 point3 = pt3;
-	
-	//	determine if we are inside or outside of the triangle
-	
-	gl_FragColor = mix(bgColor, fillColor, float(PointInTriangle(loc, point1,point2,point3)));;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Triangles.fs b/nannou_isf/test_files/Triangles.fs
deleted file mode 100644
index 0f0bd101e..000000000
--- a/nannou_isf/test_files/Triangles.fs
+++ /dev/null
@@ -1,130 +0,0 @@
-
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Stylize"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "cell_size",
-			"TYPE": "float",
-			"MIN": 0.001,
-			"MAX": 0.5,
-			"DEFAULT": 0.125
-		},
-		{
-			"NAME": "style",
-			"VALUES": [
-				0,
-				1
-			],
-			"LABELS": [
-				"Squared",
-				"Diamond"
-			],
-			"DEFAULT": 0,
-			"TYPE": "long"
-		}
-	]
-}*/
-
-#ifndef GL_ES
-float distance (vec2 center, vec2 pt)
-{
-	float tmp = pow(center.x-pt.x,2.0)+pow(center.y-pt.y,2.0);
-	return pow(tmp,0.5);
-}
-#endif
-
-void main()
-{
-// CALCULATE EDGES OF CURRENT CELL
-	//	At 0.0 just do a pass-thru
-	if (cell_size == 0.0)	{
-		gl_FragColor = IMG_THIS_PIXEL(inputImage);
-	}
-	else	{
-		// Position of current pixel
-		vec2 xy; 
-		xy.x = isf_FragNormCoord[0];
-		xy.y = isf_FragNormCoord[1];
-
-
-		// Left and right of tile
-		float CellWidth = cell_size;
-		float CellHeight = cell_size;
-		
-		CellHeight = cell_size * RENDERSIZE.x / RENDERSIZE.y;
-
-		float x1 = floor(xy.x / CellWidth)*CellWidth;
-		float x2 = clamp((ceil(xy.x / CellWidth)*CellWidth), 0.0, 1.0);
-		// Top and bottom of tile
-		float y1 = floor(xy.y / CellHeight)*CellHeight;
-		float y2 = clamp((ceil(xy.y / CellHeight)*CellHeight), 0.0, 1.0);
-		
-		//	get the normalized local coords in the cell
-		float x = (xy.x-x1) / CellWidth;
-		float y = (xy.y-y1) / CellHeight;
-		vec4 avgClr = vec4(0.0);
-		
-		//	style 0, two right triangles making a square
-		if (style == 0)	{
-			//	if above the center line...
-			if (x < y)	{
-				// Average bottom left, top left, center and top right pixels
-				vec4 avgL = (IMG_NORM_PIXEL(inputImage, vec2(x1, y1))+(IMG_NORM_PIXEL(inputImage, vec2(x1, y2)))) / 2.0;
-				vec4 avgR = IMG_NORM_PIXEL(inputImage, vec2(x2, y2));
-				vec4 avgC = IMG_NORM_PIXEL(inputImage, vec2(x1+(CellWidth/2.0), y2+(CellHeight/2.0)));	// Average the averages + centre
-				avgClr = (avgL+avgR+avgC) / 3.0;
-			}
-			else	{
-				// Average bottom right, bottom left, center and top right pixels
-				vec4 avgR = (IMG_NORM_PIXEL(inputImage, vec2(x2, y1))+(IMG_NORM_PIXEL(inputImage, vec2(x2, y2)))) / 2.0;
-				vec4 avgL = IMG_NORM_PIXEL(inputImage, vec2(x1, y1));
-				vec4 avgC = IMG_NORM_PIXEL(inputImage, vec2(x1+(CellWidth/2.0), y2+(CellHeight/2.0)));	// Average the averages + centre
-				avgClr = (avgL+avgR+avgC) / 3.0;
-			}
-		}
-		//	style 1, four triangles making a square
-		else {
-			//	if above the B2T center line and below the T2B center line...
-			if ((x > y)&&(x < 1.0 - y))	{
-				// Average bottom left, bottom right, center
-				vec4 avgL = IMG_NORM_PIXEL(inputImage, vec2(x1, y1));
-				vec4 avgR = IMG_NORM_PIXEL(inputImage, vec2(x2, y1));
-				vec4 avgC = IMG_NORM_PIXEL(inputImage, vec2(x1+(CellWidth/2.0), y2+(CellHeight/2.0)));	// Average the averages + centre
-				avgClr = (avgL+avgR+avgC) / 3.0;				
-			}
-			else if ((x < y)&&(x < 1.0 - y))	{
-				// Average bottom left, top left, center
-				vec4 avgL = IMG_NORM_PIXEL(inputImage, vec2(x1, y1));
-				vec4 avgR = IMG_NORM_PIXEL(inputImage, vec2(x1, y2));
-				vec4 avgC = IMG_NORM_PIXEL(inputImage, vec2(x1+(CellWidth/2.0), y2+(CellHeight/2.0)));	// Average the averages + centre
-				avgClr = (avgL+avgR+avgC) / 3.0;
-			}
-			else if ((x > 1.0 - y)&&(x < y))	{
-				// Average top left, top right, center
-				vec4 avgL = IMG_NORM_PIXEL(inputImage, vec2(x1, y2));
-				vec4 avgR = IMG_NORM_PIXEL(inputImage, vec2(x2, y2));
-				vec4 avgC = IMG_NORM_PIXEL(inputImage, vec2(x1+(CellWidth/2.0), y2+(CellHeight/2.0)));	// Average the averages + centre
-				avgClr = (avgL+avgR+avgC) / 3.0;
-				//avgClr = vec4(0.0,1.0,0.0,1.0);
-			}
-			else	{
-				// Average top right, bottom right, center
-				vec4 avgL = IMG_NORM_PIXEL(inputImage, vec2(x2, y1));
-				vec4 avgR = IMG_NORM_PIXEL(inputImage, vec2(x2, y2));
-				vec4 avgC = IMG_NORM_PIXEL(inputImage, vec2(x1+(CellWidth/2.0), y2+(CellHeight/2.0)));	// Average the averages + centre
-				avgClr = (avgL+avgR+avgC) / 3.0;
-				//avgClr = vec4(0.0,0.0,1.0,1.0);
-			}
-		}
-		
-		gl_FragColor = avgClr;
-	}
-}
diff --git a/nannou_isf/test_files/Trio Tone.fs b/nannou_isf/test_files/Trio Tone.fs
deleted file mode 100644
index 14ad0ea28..000000000
--- a/nannou_isf/test_files/Trio Tone.fs	
+++ /dev/null
@@ -1,95 +0,0 @@
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Color Effect"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "darkColor",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.00,
-				0.164,
-				1.0,
-				1.0
-			]
-		},
-		{
-			"NAME": "midColor",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.00,
-				1.00,
-				0.00,
-				1.0
-			]
-		},
-		{
-			"NAME": "brightColor",
-			"TYPE": "color",
-			"DEFAULT": [
-				1.0,
-				0.00,
-				0.00,
-				1.0
-			]
-		}
-	]
-}*/
-
-
-//	partly adapted from http://coding-experiments.blogspot.com/2010/10/thermal-vision-pixel-shader.html
-
-
-void main ()	{
-	vec4 pixcol = IMG_THIS_PIXEL(inputImage);
-	/*
-	//	this method doesn't work nicely on certain gpu / os releases due to arrays?
-	vec4 colors[4];
-	colors[0] = vec4(0.0,0.0,0.0,1.0);
-	colors[1] = darkColor;
-	colors[2] = midColor;
-	colors[3] = brightColor;
-	const vec4 	lumacoeff = vec4(0.2126, 0.7152, 0.0722, 0.0);
-	float		lum = dot(pixcol, lumacoeff);
-	//float lum = (pixcol.r+pixcol.g+pixcol.b)/3.;
-	int ix = 0; 
-
-	if (lum > 0.66)	{
-		ix = 2;
-	}
-	else if (lum > 0.33)	{
-		ix = 1;
-	}
-	
-	vec4 thermal = mix(colors[ix],colors[ix+1],(lum-float(ix)*0.33)/0.33);
-	*/
-	vec4 color1 = vec4(0.0,0.0,0.0,1.0);
-	vec4 color2 = darkColor;
-	int ix = 0;
-	
-	const vec4 	lumacoeff = vec4(0.2126, 0.7152, 0.0722, 0.0);
-	float		lum = dot(pixcol, lumacoeff);
-
-
-	if (lum > 0.66)	{
-		color1 = midColor;
-		color2 = brightColor;
-		ix = 2;
-	}
-	else if (lum > 0.33)	{
-		color1 = darkColor;
-		color2 = midColor;
-		ix = 1;
-	}
-	
-	vec4 thermal = mix(color1,color2,(lum-float(ix)*0.33)/0.33);
-	
-	gl_FragColor = vec4(thermal.rgb, pixcol.a);
-
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Triple Rotate.fs b/nannou_isf/test_files/Triple Rotate.fs
deleted file mode 100644
index 33306d434..000000000
--- a/nannou_isf/test_files/Triple Rotate.fs	
+++ /dev/null
@@ -1,96 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Geometry Adjustment"
-    ],
-    "CREDIT": "by VIDVOX",
-    "DESCRIPTION": "Performs three different rotations",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "angle1",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "angle2",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "angle3",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "angle4",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.15,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "radius1",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.15,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "radius2",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.15,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "radius3",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-const float pi = 3.14159265359;
-
-void main()	{
-	//	'loc' is the location in pixels of this vertex.  we're going to convert this to polar coordinates (radius/angle)
-	vec2		loc = RENDERSIZE * vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	//	'r' is the radius- the distance in pixels from 'loc' to the center of the rendering space
-	float		r = distance(RENDERSIZE/2.0, loc);
-	//	'a' is the angle of the line segment from the center to loc is rotated
-	float		a = atan ((loc.y-RENDERSIZE.y/2.0),(loc.x-RENDERSIZE.x/2.0));
-	
-	//	now modify 'a', and convert the modified polar coords (radius/angle) back to cartesian coords (x/y pixels)
-	float	angle = angle1;
-	float	minSide = min(RENDERSIZE.x,RENDERSIZE.y);
-	if (r > (radius1 + radius2 + radius3)*minSide)
-		angle = angle4;
-	else if (r > (radius1 + radius2)*minSide)
-		angle = angle3;
-	else if (r > radius1 * minSide)
-		angle = angle2;
-	loc.x = r * cos(a + 2.0 * pi * angle);
-	loc.y = r * sin(a + 2.0 * pi * angle);
-	
-	loc = loc / RENDERSIZE + vec2(0.5);
-	
-	if ((loc.x < 0.0)||(loc.y < 0.0)||(loc.x > 1.0)||(loc.y > 1.0))	{
-		gl_FragColor = vec4(0.0);
-	}
-	else	{
-		gl_FragColor = IMG_NORM_PIXEL(inputImage,loc);
-	}
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Truchet Tile.fs b/nannou_isf/test_files/Truchet Tile.fs
deleted file mode 100644
index 3c972764d..000000000
--- a/nannou_isf/test_files/Truchet Tile.fs	
+++ /dev/null
@@ -1,110 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Geometry"
-    ],
-    "CREDIT": "pjkarlik",
-    "DESCRIPTION": "Creates a Truchet Tile pattern",
-    "INPUTS": [
-        {
-            "DEFAULT": 0.1,
-            "LABEL": "Size",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "tSize",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.35,
-            "LABEL": "Noise Seed",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "nSeed",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                1,
-                1,
-                1,
-                1
-            ],
-            "LABEL": "Color 1",
-            "NAME": "color1",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0,
-                0,
-                1
-            ],
-            "LABEL": "Color 2",
-            "NAME": "color2",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": 0,
-            "NAME": "lineMode",
-            "TYPE": "bool"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-//	adapted from https://github.com/pjkarlik/TruchetTiles/blob/master/src/shader/truchet/fragmentShader.js
-
-
-#define PI 3.14159265358979323846264
-
-vec2 hash2(vec2 p) {
-  vec2 o = (p+0.5)/256.0;
-  return o;
-}
-float goldNoise(vec2 coord, float seed){
-  float phi = 1.61803398874989484820459 * 00000.1;
-  float pi2 = PI * 00000.1;
-  float sq2 = 1.41421356237309504880169 * 10000.0;
-  float temp = fract(
-    sin(
-      dot(
-        coord*(seed+phi), vec2(phi, pi2)
-      )
-    ) * sq2
-  );
-  return temp;
-}
-vec3 pattern(vec2 uv) {
-  vec2 grid = floor(uv);
-  vec2 subuv = fract(uv);
-  float mult = 0.5;
-  float dnoise = goldNoise(grid, nSeed);
-  vec2 rand = hash2(grid);
-  float shade = 0.;
-  float df;
-  float check = dnoise;
-  if( check <= .25 ) {
-    df = subuv.x - subuv.y; // tl
-  } else if( check <= .5 ) {
-    df = 1. - subuv.y - subuv.x;
-  } else if( check <= .75 ) {
-    df = subuv.y - subuv.x;
-  } else if( check <= 1. ) {
-    df = subuv.y - 1. + subuv.x;
-  }
-  shade = smoothstep(.0, -.02, df);
-  if (lineMode)
-	shade += smoothstep(.02, .04, df);
-  return vec3( shade );
-}
-void main() {
-  float fScale = (tSize == 0.0) ? max(RENDERSIZE.x,RENDERSIZE.y) : 1.0 / tSize;
-  vec2 uv = (gl_FragCoord.xy - 0.5 * RENDERSIZE.xy) / min(RENDERSIZE.y, RENDERSIZE.x);
-  uv *= fScale;
-  vec3 colour = pattern(uv);
-  vec4 returnMe = (colour.r == 1.0) ? color1 : color2;
-  gl_FragColor = returnMe;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Twirl.fs b/nannou_isf/test_files/Twirl.fs
deleted file mode 100644
index 79115a2cc..000000000
--- a/nannou_isf/test_files/Twirl.fs
+++ /dev/null
@@ -1,75 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion Effect"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "radius",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 10,
-            "MIN": -10,
-            "NAME": "amount",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0.5,
-                0.5
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "center",
-            "TYPE": "point2D"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-const float pi = 3.14159265359;
-
-
-void main (void)
-{
-	vec2 uv = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	vec2 texSize = RENDERSIZE;
-	vec2 tc = uv * texSize;
-	float radius_sized = radius * max(RENDERSIZE.x,RENDERSIZE.y);
-	tc -= (center * RENDERSIZE);
-	float dist = length(tc);
-	if (dist < radius_sized) 	{
-		float percent = (radius_sized - dist) / radius_sized;
-		float theta = percent * percent * amount * 2.0 * pi;
-		float s = sin(theta);
-		float c = cos(theta);
-		tc = vec2(dot(tc, vec2(c, -s)), dot(tc, vec2(s, c)));
-	}
-	tc += (center * RENDERSIZE);
-	vec2 loc = tc / texSize;
-	vec4 color = IMG_NORM_PIXEL(inputImage, loc);
-
-	if ((loc.x < 0.0)||(loc.y < 0.0)||(loc.x > 1.0)||(loc.y > 1.0))	{
-		gl_FragColor = vec4(0.0);
-	}
-	else	{
-		gl_FragColor = color;
-	}
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Undulating Burn Out.fs b/nannou_isf/test_files/Undulating Burn Out.fs
deleted file mode 100644
index 9e664a24f..000000000
--- a/nannou_isf/test_files/Undulating Burn Out.fs	
+++ /dev/null
@@ -1,121 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Wipe"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/undulatingBurnOut.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0.5,
-                0.5
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "center",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0,
-                0,
-                1
-            ],
-            "NAME": "color",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": 0.03,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "smoothness",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// License: MIT
-// Author: pthrasher
-// adapted by gre from https://gist.github.com/pthrasher/8e6226b215548ba12734
-
-
-const float M_PI = 3.14159265358979323846;
-
-float quadraticInOut(float t) {
-  float p = 2.0 * t * t;
-  return t < 0.5 ? p : -p + (4.0 * t) - 1.0;
-}
-
-float getGradient(float r, float dist) {
-  float d = r - dist;
-  return mix(
-    smoothstep(-smoothness, 0.0, r - dist * (1.0 + smoothness)),
-    -1.0 - step(0.005, d),
-    step(-0.005, d) * step(d, 0.01)
-  );
-}
-
-float getWave(vec2 p){
-  vec2 _p = p - center; // offset from center
-  float rads = atan(_p.y, _p.x);
-  float degs = degrees(rads) + 180.0;
-  vec2 range = vec2(0.0, M_PI * 30.0);
-  vec2 domain = vec2(0.0, 360.0);
-  float ratio = (M_PI * 30.0) / 360.0;
-  degs = degs * ratio;
-  float x = progress;
-  float magnitude = mix(0.02, 0.09, smoothstep(0.0, 1.0, x));
-  float offset = mix(40.0, 30.0, smoothstep(0.0, 1.0, x));
-  float ease_degs = quadraticInOut(sin(degs));
-  float deg_wave_pos = (ease_degs * magnitude) * sin(x * offset);
-  return x + deg_wave_pos;
-}
-
-vec4 transition(vec2 p) {
-  float dist = distance(center, p);
-  float m = getGradient(getWave(p), dist);
-  vec4 cfrom = getFromColor(p);
-  vec4 cto = getToColor(p);
-  return mix(mix(cfrom, cto, m), mix(cfrom, color, 0.75), step(m, -2.0));
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Unsharp Mask.fs b/nannou_isf/test_files/Unsharp Mask.fs
deleted file mode 100644
index 743d935b8..000000000
--- a/nannou_isf/test_files/Unsharp Mask.fs	
+++ /dev/null
@@ -1,66 +0,0 @@
-/*{
-	"CREDIT": "by VIDVOX",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Sharpen"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "intensity",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 10.0,
-			"DEFAULT": 1.0
-		}
-	]
-}*/
-
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-in vec2 left_coord;
-in vec2 right_coord;
-in vec2 above_coord;
-in vec2 below_coord;
-
-in vec2 lefta_coord;
-in vec2 righta_coord;
-in vec2 leftb_coord;
-in vec2 rightb_coord;
-#endif
-
-float gray(vec4 n)
-{
-	return (n.r + n.g + n.b)/3.0;
-}
-
-void main()
-{
-
-	vec4 color = IMG_THIS_PIXEL(inputImage);
-	vec4 colorL = IMG_NORM_PIXEL(inputImage, left_coord);
-	vec4 colorR = IMG_NORM_PIXEL(inputImage, right_coord);
-	vec4 colorA = IMG_NORM_PIXEL(inputImage, above_coord);
-	vec4 colorB = IMG_NORM_PIXEL(inputImage, below_coord);
-
-	vec4 colorLA = IMG_NORM_PIXEL(inputImage, lefta_coord);
-	vec4 colorRA = IMG_NORM_PIXEL(inputImage, righta_coord);
-	vec4 colorLB = IMG_NORM_PIXEL(inputImage, leftb_coord);
-	vec4 colorRB = IMG_NORM_PIXEL(inputImage, rightb_coord);
-
-	vec4 final = color + intensity * (8.0*color - colorL - colorR - colorA - colorB - colorLA - colorRA - colorLB - colorRB);
-	
-	gl_FragColor = final;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Unsharp Mask.vs b/nannou_isf/test_files/Unsharp Mask.vs
deleted file mode 100644
index 8f2188f5d..000000000
--- a/nannou_isf/test_files/Unsharp Mask.vs	
+++ /dev/null
@@ -1,39 +0,0 @@
-#if __VERSION__ <= 120
-varying vec2 left_coord;
-varying vec2 right_coord;
-varying vec2 above_coord;
-varying vec2 below_coord;
-
-varying vec2 lefta_coord;
-varying vec2 righta_coord;
-varying vec2 leftb_coord;
-varying vec2 rightb_coord;
-#else
-out vec2 left_coord;
-out vec2 right_coord;
-out vec2 above_coord;
-out vec2 below_coord;
-
-out vec2 lefta_coord;
-out vec2 righta_coord;
-out vec2 leftb_coord;
-out vec2 rightb_coord;
-#endif
-
-
-void main()
-{
-	isf_vertShaderInit();
-	vec2 texc = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-	vec2 d = 1.0/RENDERSIZE;
-	
-	left_coord = clamp(vec2(texc.xy + vec2(-d.x , 0)),0.0,1.0);
-	right_coord = clamp(vec2(texc.xy + vec2(d.x , 0)),0.0,1.0);
-	above_coord = clamp(vec2(texc.xy + vec2(0,d.y)),0.0,1.0);
-	below_coord = clamp(vec2(texc.xy + vec2(0,-d.y)),0.0,1.0);
-
-	lefta_coord = clamp(vec2(texc.xy + vec2(-d.x , d.x)),0.0,1.0);
-	righta_coord = clamp(vec2(texc.xy + vec2(d.x , d.x)),0.0,1.0);
-	leftb_coord = clamp(vec2(texc.xy + vec2(-d.x , -d.x)),0.0,1.0);
-	rightb_coord = clamp(vec2(texc.xy + vec2(d.x , -d.x)),0.0,1.0);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/VHS Glitch.fs b/nannou_isf/test_files/VHS Glitch.fs
deleted file mode 100644
index 501c587c1..000000000
--- a/nannou_isf/test_files/VHS Glitch.fs	
+++ /dev/null
@@ -1,214 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Glitch",
-        "Retro"
-    ],
-    "CREDIT": "David Lublin, original by Staffan Widegarn Åhlvik",
-    "DESCRIPTION": "VHS Glitch Style",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 1,
-            "NAME": "autoScan",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "xScanline",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "xScanline2",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "yScanline",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "xScanlineSize",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.25,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "xScanlineSize2",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.25,
-            "MAX": 1,
-            "MIN": -1,
-            "NAME": "yScanlineAmount",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 3,
-            "MIN": 0,
-            "NAME": "grainLevel",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "NAME": "scanFollow",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 10,
-            "MIN": 0,
-            "NAME": "analogDistort",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 3,
-            "MIN": 0,
-            "NAME": "bleedAmount",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "bleedDistort",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 2,
-            "MIN": 0,
-            "NAME": "bleedRange",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0.8,
-                0,
-                0.4,
-                1
-            ],
-            "NAME": "colorBleedL",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0.5,
-                0.75,
-                1
-            ],
-            "NAME": "colorBleedC",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": [
-                0.8,
-                0,
-                0.4,
-                1
-            ],
-            "NAME": "colorBleedR",
-            "TYPE": "color"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-
-//	Based on https://github.com/staffantan/unity-vhsglitch
-//	Converted by David Lublin / VIDVOX
-
-
-const float tau = 6.28318530718;
-
-
-float rand(vec3 co){
-	return abs(mod(sin( dot(co.xyz ,vec3(12.9898,78.233,45.5432) )) * 43758.5453, 1.0));
-}
-
-void main()	{
-	float	actualXLine = (!autoScan) ? xScanline : mod(xScanline + ((1.0+sin(0.34*TIME))/2.0 + (1.0+sin(TIME))/3.0 + (1.0+cos(2.1*TIME))/3.0 + (1.0+cos(0.027*TIME))/2.0)/3.5,1.0);
-	float	actualXLineWidth = (!autoScan) ? xScanlineSize : xScanlineSize + ((1.0+sin(1.2*TIME))/2.0 + (1.0+cos(3.91*TIME))/3.0 + (1.0+cos(0.014*TIME))/2.0)/3.5;
-	vec2	loc = isf_FragNormCoord;
-	vec4	vhs = IMG_NORM_PIXEL(inputImage, loc);
-	float	dx = 1.0+actualXLineWidth/25.0-abs(distance(loc.y, actualXLine));
-	float	dx2 = 1.0+xScanlineSize2/10.0-abs(distance(loc.y, xScanline2));
-	float	dy = (1.0-abs(distance(loc.y, yScanline)));
-	if (autoScan)
-		dy = (1.0-abs(distance(loc.y, mod(yScanline+TIME,1.0))));
-	
-	dy = (dy > 0.5) ? 2.0 * dy : 2.0 * (1.0 - dy);
-	
-	float	rX = (scanFollow) ? rand(vec3(dy,actualXLine,analogDistort)) : rand(vec3(dy,bleedAmount,analogDistort));
-	float	xTime = (actualXLine > 0.5) ? 2.0 * actualXLine : 2.0 * (1.0 - actualXLine);
-	
-	loc.x += yScanlineAmount * dy * 0.025 + analogDistort * rX/(RENDERSIZE.x/2.0);
-	
-	if(dx2 > 1.0 - xScanlineSize2 / 10.0)	{
-		float	rX2 = (dy * rand(vec3(dy,dx2,dx+TIME)) + dx2) / 4.0;
-		float	distortAmount = analogDistort * (sin(rX * tau / dx2) + cos(rX * tau * 0.78 / dx2)) / 10.0;
-		//loc.y = xScanline2;
-		//loc.x += (1.0 + distortAmount * sin(tau * (loc.x) / rX2 ) - 1.0) / 15.0;
-		loc.x += (1.0 + distortAmount * sin(tau * (loc.x) / rX2 ) - 1.0) / 15.0;
-	}
-	if(dx > 1.0 - actualXLineWidth / 25.0)
-		loc.y = actualXLine;
-
-	loc.x = mod(loc.x,1.0);
-	loc.y = mod(loc.y,1.0);
-	
-	vec4	c = IMG_NORM_PIXEL(inputImage, loc);
-	float	x = (loc.x*320.0)/320.0;
-	float	y = (loc.y*240.0)/240.0;
-	float	bleed = 0.0;
-	
-	if (scanFollow)
-		c -= rand(vec3(x, y, xTime)) * xTime / (5.0-grainLevel);
-	else
-		c -= rand(vec3(x, y, bleedAmount)) * (bleedAmount/20.0) / (5.0-grainLevel);
-	
-	if (bleedAmount > 0.0)	{
-		IMG_NORM_PIXEL(inputImage, loc + vec2(0.01, 0)).r;
-		bleed += IMG_NORM_PIXEL(inputImage, loc + bleedRange * vec2(0.02, 0)).r;
-		bleed += IMG_NORM_PIXEL(inputImage, loc + bleedRange * vec2(0.01, 0.01)).r;
-		bleed += IMG_NORM_PIXEL(inputImage, loc + bleedRange * vec2(-0.02, 0.02)).r;
-		bleed += IMG_NORM_PIXEL(inputImage, loc + bleedRange * vec2(0.0, -0.03)).r;
-		bleed /= 6.0;
-		bleed *= bleedAmount;
-	}
-
-	if (bleed > 0.1){
-		float	bleedFreq = 1.0;
-		float	bleedX = 0.0;
-		if (autoScan)
-			bleedX = x + bleedDistort * (yScanlineAmount + (1.5 + cos(TIME / 13.0 + tau*(bleedDistort+(1.0-loc.y))))/2.0) * sin((TIME / 9.0 + bleedDistort) * tau + loc.y * loc.y * tau * bleedFreq) / 8.0;
-		else
-			bleedX = x + (yScanlineAmount + (1.0 + sin(tau*(bleedDistort+loc.y)))/2.0) * sin(bleedDistort * tau + loc.y * loc.y * tau * bleedFreq) / 10.0;
-		vec4	colorBleed = (bleedX < 0.5) ? mix(colorBleedL, colorBleedC, 2.0 * bleedX) : mix(colorBleedR, colorBleedC, 2.0 - 2.0 * bleedX);
-		if (scanFollow)
-			c += bleed * max(xScanlineSize,xTime) * colorBleed;
-		else
-			c += bleed * colorBleed;
-	}
-	gl_FragColor = c;
-}
diff --git a/nannou_isf/test_files/VU Meter.fs b/nannou_isf/test_files/VU Meter.fs
deleted file mode 100644
index a0d4f8db1..000000000
--- a/nannou_isf/test_files/VU Meter.fs	
+++ /dev/null
@@ -1,78 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Geometry"
-    ],
-    "CREDIT": "VIDVOX",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "DEFAULT": 1,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "audioLevel",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0,
-                1,
-                0,
-                1
-            ],
-            "NAME": "color1",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": [
-                1,
-                1,
-                0,
-                1
-            ],
-            "NAME": "color2",
-            "TYPE": "color"
-        },
-        {
-            "DEFAULT": [
-                1,
-                0,
-                0,
-                1
-            ],
-            "NAME": "color3",
-            "TYPE": "color"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-const float divisionCount = 5.0;
-
-float round(float val)	{
-	if (fract(val) <= 0.5)
-		return floor(val);
-	else
-		return ceil(val);	
-}
-
-void main()	{
-	vec4		inputPixelColor = vec4(0.0);
-	vec2		loc = isf_FragNormCoord;
-	
-	float		div = floor(divisionCount * audioLevel);
-	float		thisDiv = floor(loc.x * divisionCount);
-	float		nearestDiv = round(loc.x * divisionCount);
-	
-	if (loc.x < div / divisionCount)	{
-		if (thisDiv <= divisionCount * 0.5)
-			inputPixelColor = color1;
-		else if (thisDiv <= divisionCount - 2.0)
-			inputPixelColor = color2;
-		else
-			inputPixelColor = color3;
-	}
-	
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/VVMotionBlur 3.0.fs b/nannou_isf/test_files/VVMotionBlur 3.0.fs
deleted file mode 100644
index 489b7d74b..000000000
--- a/nannou_isf/test_files/VVMotionBlur 3.0.fs	
+++ /dev/null
@@ -1,37 +0,0 @@
-/*{
-	"DESCRIPTION": "this is basically identical to the demonstration of a persistent buffer",
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Blur"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "blurAmount",
-			"TYPE": "float",
-			"DEFAULT": 0.0
-		}
-	],
-	"PASSES": [
-		{
-			"TARGET":"bufferVariableNameA",
-			"PERSISTENT": true,
-			"FLOAT": true
-		},
-		{
-		
-		}
-	]
-	
-}*/
-
-void main()
-{
-	vec4		freshPixel = IMG_PIXEL(inputImage,gl_FragCoord.xy);
-	vec4		stalePixel = IMG_PIXEL(bufferVariableNameA,gl_FragCoord.xy);
-	gl_FragColor = mix(freshPixel,stalePixel,blurAmount);
-}
diff --git a/nannou_isf/test_files/Vertex Manipulator.fs b/nannou_isf/test_files/Vertex Manipulator.fs
deleted file mode 100644
index 66acebb98..000000000
--- a/nannou_isf/test_files/Vertex Manipulator.fs	
+++ /dev/null
@@ -1,58 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Geometry Adjustment"
-    ],
-    "CREDIT": "VIDVOX",
-    "DESCRIPTION": "Moves the vertex points to the specified locations without correction",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": [
-                0,
-                1
-            ],
-            "LABEL": "Top Left",
-            "NAME": "topleft",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0
-            ],
-            "LABEL": "Bottom Left",
-            "NAME": "bottomleft",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": [
-                1,
-                1
-            ],
-            "LABEL": "Top Right",
-            "NAME": "topright",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": [
-                1,
-                0
-            ],
-            "LABEL": "Bottom Right",
-            "NAME": "bottomright",
-            "TYPE": "point2D"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-void main()
-{
-	vec4		test = IMG_THIS_PIXEL(inputImage);
-	gl_FragColor = test;
-}
diff --git a/nannou_isf/test_files/Vertex Manipulator.vs b/nannou_isf/test_files/Vertex Manipulator.vs
deleted file mode 100644
index 599fdfc18..000000000
--- a/nannou_isf/test_files/Vertex Manipulator.vs	
+++ /dev/null
@@ -1,31 +0,0 @@
-
-
-void main()
-{
-	isf_vertShaderInit();
-	
-	vec4 position = gl_Position;
-	vec4 coord;
-	if ((position.x<0.0)&&(position.y<0.0))	{
-	    coord.xy = bottomleft / RENDERSIZE;
-	    coord.x = coord.x * 2.0;
-	    coord.y = coord.y * 2.0;
-	}
-	else if ((position.x>0.0)&&(position.y<0.0))	{
-	    coord.xy = bottomright / RENDERSIZE;
-	    coord.x = (1.0-coord.x) * -2.0;
-	    coord.y = coord.y * 2.0;
-	}
-	else if (position.x<0.0)	{
-		coord.xy = topleft / RENDERSIZE;
-	    coord.x = coord.x * 2.0;
-	    coord.y = (1.0-coord.y) * -2.0;
-	}
-	else	{
-		coord.xy = topright / RENDERSIZE;
-	    coord.x = (1.0-coord.x) * -2.0;
-	    coord.y = (1.0-coord.y) * -2.0;
-	}
-	gl_Position.xy = position.xy + coord.xy;
-
-}
diff --git a/nannou_isf/test_files/Vertical Tearing.fs b/nannou_isf/test_files/Vertical Tearing.fs
deleted file mode 100644
index 954e8646c..000000000
--- a/nannou_isf/test_files/Vertical Tearing.fs	
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Glitch"
-  ],
-  "DESCRIPTION" : "This introduces a vertical tearing effect similar to when GL VBL sync is off.",
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "NAME" : "inputImage",
-      "TYPE" : "image"
-    },
-    {
-      "NAME" : "tearPosition",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0.5,
-      "MIN" : 0
-    }
-  ],
-  "PASSES" : [
-    {
-      "TARGET" : "oldImage"
-    },
-    {
-      "TARGET" : "newImage",
-      "PERSISTENT" : true
-    },
-    {
-
-    }
-  ],
-  "CREDIT" : "by VIDVOX"
-}
-*/
-
-void main()
-{
-	//	write the previous buffer into here
-	if (PASSINDEX == 0)	{
-		gl_FragColor = IMG_NORM_PIXEL(newImage,isf_FragNormCoord.xy);
-	}
-	else if (PASSINDEX == 1)	{
-		gl_FragColor = IMG_NORM_PIXEL(inputImage,isf_FragNormCoord.xy);
-	}
-	else if (PASSINDEX == 2)	{
-		vec4		freshPixel = IMG_NORM_PIXEL(inputImage,isf_FragNormCoord.xy);
-		vec4		stalePixel = IMG_NORM_PIXEL(oldImage,isf_FragNormCoord.xy);
-		gl_FragColor = (isf_FragNormCoord.y > tearPosition) ? freshPixel : stalePixel;
-	}
-}
diff --git a/nannou_isf/test_files/Vibrance.fs b/nannou_isf/test_files/Vibrance.fs
deleted file mode 100644
index ed8788ca2..000000000
--- a/nannou_isf/test_files/Vibrance.fs
+++ /dev/null
@@ -1,54 +0,0 @@
-/*{
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Color Adjustment"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "vibrance",
-			"TYPE": "float",
-			"MIN": -0.25,
-			"MAX": 0.6,
-			"DEFAULT": 0.0
-		}
-	]
-}*/
-
-
-vec3 rgb2hsv(vec3 c);
-vec3 hsv2rgb(vec3 c);
-
-void main() {
-	vec4		tmpColorA = IMG_THIS_PIXEL(inputImage);
-	vec3		tmpColorB = rgb2hsv(tmpColorA.rgb);
-	float		maxDelta = sqrt(tmpColorB.y) - tmpColorB.y;
-	tmpColorB.y = (maxDelta * vibrance) + tmpColorB.y;
-	tmpColorA.rgb = hsv2rgb(tmpColorB.rgb);
-	gl_FragColor = tmpColorA;
-}
-
-
-
-
-vec3 rgb2hsv(vec3 c)	{
-	vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-	//vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
-	//vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
-	vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
-	vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
-	
-	float d = q.x - min(q.w, q.y);
-	float e = 1.0e-10;
-	return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
-}
-
-vec3 hsv2rgb(vec3 c)	{
-	vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
-	vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
-	return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Water Drop.fs b/nannou_isf/test_files/Water Drop.fs
deleted file mode 100644
index c634f7c5e..000000000
--- a/nannou_isf/test_files/Water Drop.fs	
+++ /dev/null
@@ -1,72 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/WaterDrop.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 30,
-            "MAX": 100,
-            "MIN": 0,
-            "NAME": "speed",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 30,
-            "MAX": 100,
-            "MIN": 0,
-            "NAME": "amplitude",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// author: Paweł Płóciennik
-// license: MIT
-
-vec4 transition(vec2 p) {
-  vec2 dir = p - vec2(.5);
-  float dist = length(dir);
-
-  if (dist > progress) {
-    return mix(getFromColor( p), getToColor( p), progress);
-  } else {
-    vec2 offset = dir * sin(dist * amplitude - progress * speed);
-    return mix(getFromColor( p + offset), getToColor( p), progress);
-  }
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Waveform Displace.fs b/nannou_isf/test_files/Waveform Displace.fs
deleted file mode 100644
index 8a31105c4..000000000
--- a/nannou_isf/test_files/Waveform Displace.fs	
+++ /dev/null
@@ -1,72 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Audio Visualizer",
-        "Distortion Effect"
-    ],
-    "CREDIT": "icalvin102 (calvin@icalvin.de)",
-    "DESCRIPTION": "Displaces image with audio waveform",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "LABEL": "Audio Waveform",
-            "NAME": "audio",
-            "TYPE": "audio"
-        },
-        {
-            "DEFAULT": 0.1,
-            "LABEL": "Displace X",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "displaceX",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.1,
-            "LABEL": "Displace Y",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "displaceY",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "LABEL": "Detail X",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "detailX",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "LABEL": "Detail Y",
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "detailY",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "DESCRIPTION": "Renderpass 0"
-        }
-    ]
-}
-*/
-
-void main()	{
-
-	vec4 inputPixelColor;
-	vec2 uv = isf_FragNormCoord.xy;
-	vec2 waveLoc = fract((uv)*vec2(detailX, detailY));
-
-	vec2 wave = vec2(IMG_NORM_PIXEL(audio, vec2(waveLoc.x, 0.0)).r, IMG_NORM_PIXEL(audio, vec2(waveLoc.y, 1.0)).r)-.5;
-	wave *= vec2(displaceY, displaceX);
-
-	inputPixelColor = IMG_NORM_PIXEL(inputImage, uv + wave.yx);
-
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/White Point Adjust.fs b/nannou_isf/test_files/White Point Adjust.fs
deleted file mode 100644
index ffdd564af..000000000
--- a/nannou_isf/test_files/White Point Adjust.fs	
+++ /dev/null
@@ -1,31 +0,0 @@
-/*{
-	"CREDIT": "by zoidberg",
-	"ISFVSN": "2",
-	"DESCRIPTION": "Modifies the white point by multiplying the src pixel by the color value",
-	"CATEGORIES": [
-		"Color Adjustment"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "newWhite",
-			"TYPE": "color",
-			"DEFAULT": [
-				1.0,
-				1.0,
-				1.0,
-				1.0
-			]
-		}
-	]
-}*/
-
-
-
-void main() {
-	vec4		tmpColorA = IMG_THIS_PIXEL(inputImage);
-	gl_FragColor = tmpColorA * newWhite;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Wind.fs b/nannou_isf/test_files/Wind.fs
deleted file mode 100644
index 7081d9f15..000000000
--- a/nannou_isf/test_files/Wind.fs
+++ /dev/null
@@ -1,69 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Wipe"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/wind.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.2,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "size",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: gre
-// License: MIT
-
-// Custom parameters
-
-float rand (vec2 co) {
-  return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
-}
-
-vec4 transition (vec2 uv) {
-  float r = rand(vec2(0, uv.y));
-  float m = smoothstep(0.0, -size, uv.x*(1.0-size) + size*r - (progress * (1.0 + size)));
-  return mix(
-    getFromColor(uv),
-    getToColor(uv),
-    m
-  );
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Window Blinds.fs b/nannou_isf/test_files/Window Blinds.fs
deleted file mode 100644
index ce935060e..000000000
--- a/nannou_isf/test_files/Window Blinds.fs	
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Dissolve"
-  ],
-  "INPUTS" : [
-    {
-      "TYPE" : "image",
-      "NAME" : "startImage"
-    },
-    {
-      "NAME" : "endImage",
-      "TYPE" : "image"
-    },
-    {
-      "NAME" : "progress",
-      "MIN" : 0,
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0
-    }
-  ],
-  "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/windowblinds.glsl",
-  "DESCRIPTION": "",
-  "ISFVSN" : "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: Fabien Benetou
-// License: MIT
-
-vec4 transition (vec2 uv) {
-  float t = progress;
-  
-  if (mod(floor(uv.y*100.*progress),2.)==0.)
-    t*=2.-.5;
-  
-  return mix(
-    getFromColor(uv),
-    getToColor(uv),
-    mix(t, progress, smoothstep(0.8, 1.0, progress))
-  );
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Window Slice.fs b/nannou_isf/test_files/Window Slice.fs
deleted file mode 100644
index b21d5fa1b..000000000
--- a/nannou_isf/test_files/Window Slice.fs	
+++ /dev/null
@@ -1,67 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Wipe"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/windowslice.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 10,
-            "MAX": 100,
-            "MIN": 0,
-            "NAME": "count",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "smoothness",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: gre
-// License: MIT
-
-
-vec4 transition (vec2 p) {
-  float pr = smoothstep(-smoothness, 0.0, p.x - progress * (1.0 + smoothness));
-  float s = step(pr, fract(count * p.x));
-  return mix(getFromColor(p), getToColor(p), s);
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Wipe Down.fs b/nannou_isf/test_files/Wipe Down.fs
deleted file mode 100644
index c709b3dde..000000000
--- a/nannou_isf/test_files/Wipe Down.fs	
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
-{
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "TYPE" : "image",
-      "NAME" : "startImage"
-    },
-    {
-      "TYPE" : "image",
-      "NAME" : "endImage"
-    },
-    {
-      "TYPE" : "float",
-      "NAME" : "progress",
-      "MIN" : 0,
-      "MAX" : 1,
-      "DEFAULT" : 0
-    }
-  ],
-  "CATEGORIES" : [
-    "Wipe"
-  ],
-  "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/wipeDown.glsl",
-  "DESCRIPTION" : "Automatically converted from https://gl-transitions.com/"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: Jake Nelson
-// License: MIT
-
-vec4 transition(vec2 uv) {
-  vec2 p=uv.xy/vec2(1.0).xy;
-  vec4 a=getFromColor(p);
-  vec4 b=getToColor(p);
-  return mix(a, b, step(1.0-p.y,progress));
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Wipe Left.fs b/nannou_isf/test_files/Wipe Left.fs
deleted file mode 100644
index 7ac43c618..000000000
--- a/nannou_isf/test_files/Wipe Left.fs	
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
-{
-  "INPUTS" : [
-    {
-      "TYPE" : "image",
-      "NAME" : "startImage"
-    },
-    {
-      "TYPE" : "image",
-      "NAME" : "endImage"
-    },
-    {
-      "TYPE" : "float",
-      "MAX" : 1,
-      "NAME" : "progress",
-      "MIN" : 0,
-      "DEFAULT" : 0
-    }
-  ],
-  "CATEGORIES" : [
-    "Wipe"
-  ],
-  "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/wipeLeft.glsl",
-  "DESCRIPTION": "",
-  "ISFVSN" : "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: Jake Nelson
-// License: MIT
-
-vec4 transition(vec2 uv) {
-  vec2 p=uv.xy/vec2(1.0).xy;
-  vec4 a=getFromColor(p);
-  vec4 b=getToColor(p);
-  return mix(a, b, step(1.0-p.x,progress));
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Wipe Right.fs b/nannou_isf/test_files/Wipe Right.fs
deleted file mode 100644
index e8782b667..000000000
--- a/nannou_isf/test_files/Wipe Right.fs	
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
-{
-  "INPUTS" : [
-    {
-      "TYPE" : "image",
-      "NAME" : "startImage"
-    },
-    {
-      "TYPE" : "image",
-      "NAME" : "endImage"
-    },
-    {
-      "TYPE" : "float",
-      "MAX" : 1,
-      "NAME" : "progress",
-      "MIN" : 0,
-      "DEFAULT" : 0
-    }
-  ],
-  "CATEGORIES" : [
-    "Wipe"
-  ],
-  "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/wipeRight.glsl",
-  "DESCRIPTION": "",
-  "ISFVSN" : "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: Jake Nelson
-// License: MIT
-
-vec4 transition(vec2 uv) {
-  vec2 p=uv.xy/vec2(1.0).xy;
-  vec4 a=getFromColor(p);
-  vec4 b=getToColor(p);
-  return mix(a, b, step(0.0+p.x,progress));
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Wipe Up.fs b/nannou_isf/test_files/Wipe Up.fs
deleted file mode 100644
index 3e1f62636..000000000
--- a/nannou_isf/test_files/Wipe Up.fs	
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Wipe"
-  ],
-  "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/wipeUp.glsl",
-  "DESCRIPTION": "",
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "TYPE" : "image",
-      "NAME" : "startImage"
-    },
-    {
-      "NAME" : "endImage",
-      "TYPE" : "image"
-    },
-    {
-      "MIN" : 0,
-      "TYPE" : "float",
-      "NAME" : "progress",
-      "MAX" : 1,
-      "DEFAULT" : 0
-    }
-  ]
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: Jake Nelson
-// License: MIT
-
-vec4 transition(vec2 uv) {
-  vec2 p=uv.xy/vec2(1.0).xy;
-  vec4 a=getFromColor(p);
-  vec4 b=getToColor(p);
-  return mix(a, b, step(0.0+p.y,progress));
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/XYZoom.fs b/nannou_isf/test_files/XYZoom.fs
deleted file mode 100644
index d679f5b19..000000000
--- a/nannou_isf/test_files/XYZoom.fs
+++ /dev/null
@@ -1,60 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Geometry Adjustment"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 10,
-            "MIN": 0.01,
-            "NAME": "levelX",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 10,
-            "MIN": 0.01,
-            "NAME": "levelY",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "center",
-            "TYPE": "point2D"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-void main() {
-	vec2		loc;
-	vec2		modifiedCenter;
-	
-	loc = isf_FragNormCoord;
-	modifiedCenter = center;
-	loc.x = (loc.x - modifiedCenter.x)*(1.0/levelX) + modifiedCenter.x;
-	loc.y = (loc.y - modifiedCenter.y)*(1.0/levelY) + modifiedCenter.y;
-	if ((loc.x < 0.0)||(loc.y < 0.0)||(loc.x > 1.0)||(loc.y > 1.0))	{
-		gl_FragColor = vec4(0.0);
-	}
-	else	{
-		gl_FragColor = IMG_NORM_PIXEL(inputImage,loc);
-	}
-}
diff --git a/nannou_isf/test_files/Y-C Time Blur.fs b/nannou_isf/test_files/Y-C Time Blur.fs
deleted file mode 100644
index f6224a22a..000000000
--- a/nannou_isf/test_files/Y-C Time Blur.fs	
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Blur",
-    "Glitch"
-  ],
-  "DESCRIPTION" : "This converts to YIQ and does separate feedback blur on the Y and C channels",
-  "ISFVSN" : "2",
-  "INPUTS" : [
-    {
-      "NAME" : "inputImage",
-      "TYPE" : "image"
-    },
-    {
-      "NAME" : "yFeedbackLevel",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0,
-      "MIN" : 0
-    },
-    {
-      "NAME" : "cFeedbackLevel",
-      "TYPE" : "float",
-      "MAX" : 1,
-      "DEFAULT" : 0,
-      "MIN" : 0
-    }
-  ],
-  "PASSES" : [
-    {
-      "TARGET" : "lastFrame",
-      "PERSISTENT" : true,
-      "FLOAT" : true
-    }
-  ],
-  "CREDIT" : "VIDVOX"
-}
-*/
-
-
-//	inspired by (but not exactly the same thing as) y/c delay error
-//	https://bavc.github.io/avaa/artifacts/yc_delay_error.html
-
-//	shout out to this stackoverflow
-//	https://stackoverflow.com/questions/9234724/how-to-change-hue-of-a-texture-with-glsl/9234854#9234854
-//	(though I'd have gone to HSV for that particular effect, it covers our use case of yiq nicely!)
-
-
-const vec4  kRGBToYPrime = vec4 (0.299, 0.587, 0.114, 0.0);
-const vec4  kRGBToI     = vec4 (0.596, -0.275, -0.321, 0.0);
-const vec4  kRGBToQ     = vec4 (0.212, -0.523, 0.311, 0.0);
-
-const vec4  kYIQToR   = vec4 (1.0, 0.956, 0.621, 0.0);
-const vec4  kYIQToG   = vec4 (1.0, -0.272, -0.647, 0.0);
-const vec4  kYIQToB   = vec4 (1.0, -1.107, 1.704, 0.0);
-
-
-vec3 rgb2yiq(vec3 c)	{
-    float   YPrime = dot (c, kRGBToYPrime.rgb);
-    float   I = dot (c, kRGBToI.rgb);
-    float   Q = dot (c, kRGBToQ.rgb);
-    return vec3(YPrime,I,Q);
-}
-
-vec3 yiq2rgb(vec3 c)	{
-    vec3    yIQ   = vec3 (c.r, c.g, c.b);
-    return vec3(dot (yIQ, kYIQToR.rgb),dot (yIQ, kYIQToG.rgb),dot (yIQ, kYIQToB.rgb));
-}
-
-
-void main()	{
-	//	this is a pass-thru1
-	vec4		inputPixelColor = IMG_THIS_PIXEL(inputImage);
-	vec4		lastPixel = IMG_THIS_PIXEL(lastFrame);
-	inputPixelColor.rgb = rgb2yiq(inputPixelColor.rgb);
-	lastPixel.rgb = rgb2yiq(lastPixel.rgb);
-	
-	inputPixelColor.r = mix(inputPixelColor.r,lastPixel.r,yFeedbackLevel);
-	inputPixelColor.gb = mix(inputPixelColor.gb,lastPixel.gb,cFeedbackLevel);
-	
-	inputPixelColor.rgb = yiq2rgb(inputPixelColor.rgb);
-	
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/Zoom In Circles.fs b/nannou_isf/test_files/Zoom In Circles.fs
deleted file mode 100644
index 8605cb525..000000000
--- a/nannou_isf/test_files/Zoom In Circles.fs	
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
-{
-  "CATEGORIES" : [
-    "Wipe"
-  ],
-  "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/ZoomInCircles.glsl",
-  "DESCRIPTION": "",
-  "INPUTS" : [
-    {
-      "TYPE" : "image",
-      "NAME" : "startImage"
-    },
-    {
-      "TYPE" : "image",
-      "NAME" : "endImage"
-    },
-    {
-      "DEFAULT" : 0,
-      "TYPE" : "float",
-      "NAME" : "progress",
-      "MIN" : 0,
-      "MAX" : 1
-    }
-  ],
-  "ISFVSN" : "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-float ratio = RENDERSIZE.x/RENDERSIZE.y;
-
-// License: MIT
-// Author: dycm8009
-// ported by gre from https://gist.github.com/dycm8009/948e99b1800e81ad909a
-
-vec2 zoom(vec2 uv, float amount) {
-  return 0.5 + ((uv - 0.5) * amount);	
-}
-
-vec2 ratio2 = vec2(1.0, 1.0 / ratio);
-
-vec4 transition(vec2 uv) {
-  // TODO: some timing are hardcoded but should be one or many parameters
-  // TODO: should also be able to configure how much circles
-  // TODO: if() branching should be avoided when possible, prefer use of step() & other functions
-  vec2 r = 2.0 * ((vec2(uv.xy) - 0.5) * ratio2);
-  float pro = progress / 0.8;
-  float z = pro * 0.2;
-  float t = 0.0;
-  if (pro > 1.0) {
-    z = 0.2 + (pro - 1.0) * 5.;
-    t = clamp((progress - 0.8) / 0.07, 0.0, 1.0);
-  }
-  if (length(r) < 0.5+z) {
-    // uv = zoom(uv, 0.9 - 0.1 * pro);
-  }
-  else if (length(r) < 0.8+z*1.5) {
-    uv = zoom(uv, 1.0 - 0.15 * pro);
-    t = t * 0.5;
-  }
-  else if (length(r) < 1.2+z*2.5) {
-    uv = zoom(uv, 1.0 - 0.2 * pro);
-    t = t * 0.2;
-  }
-  else {
-    uv = zoom(uv, 1.0 - 0.25 * pro);
-  }
-  return mix(getFromColor(uv), getToColor(uv), t);
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/Zoom.fs b/nannou_isf/test_files/Zoom.fs
deleted file mode 100644
index 8e8fd3b45..000000000
--- a/nannou_isf/test_files/Zoom.fs
+++ /dev/null
@@ -1,53 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Geometry Adjustment"
-    ],
-    "CREDIT": "by VIDVOX",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 10,
-            "MIN": 0.01,
-            "NAME": "level",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0,
-                0
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "center",
-            "TYPE": "point2D"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-void main() {
-	vec2		loc;
-	vec2		modifiedCenter;
-	
-	loc = isf_FragNormCoord;
-	modifiedCenter = center;
-	loc.x = (loc.x - modifiedCenter.x)*(1.0/level) + modifiedCenter.x;
-	loc.y = (loc.y - modifiedCenter.y)*(1.0/level) + modifiedCenter.y;
-	if ((loc.x < 0.0)||(loc.y < 0.0)||(loc.x > 1.0)||(loc.y > 1.0))	{
-		gl_FragColor = vec4(0.0);
-	}
-	else	{
-		gl_FragColor = IMG_NORM_PIXEL(inputImage,loc);
-	}
-}
diff --git a/nannou_isf/test_files/Zooming Feedback.fs b/nannou_isf/test_files/Zooming Feedback.fs
deleted file mode 100644
index 755bdd543..000000000
--- a/nannou_isf/test_files/Zooming Feedback.fs	
+++ /dev/null
@@ -1,230 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Retro",
-        "Feedback"
-    ],
-    "CREDIT": "",
-    "DESCRIPTION": "Creates a simple zooming feedback loop",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": [
-                0.5,
-                0.5
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "preShift",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": 0.9,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "feedbackLevel",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "rotateAngle",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1.2,
-            "MAX": 2,
-            "MIN": 0.25,
-            "NAME": "zoomLevel",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": [
-                0.5,
-                0.5
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "zoomCenter",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": [
-                0.5,
-                0.5
-            ],
-            "MAX": [
-                1,
-                1
-            ],
-            "MIN": [
-                0,
-                0
-            ],
-            "NAME": "feedbackShift",
-            "TYPE": "point2D"
-        },
-        {
-            "DEFAULT": 0,
-            "NAME": "invert",
-            "TYPE": "bool"
-        },
-        {
-            "DEFAULT": 3,
-            "LABELS": [
-                "Add",
-                "Over Black",
-                "Over Alpha",
-                "Max",
-                "Under Black",
-                "Under Alpha"
-            ],
-            "NAME": "blendMode",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1,
-                2,
-                3,
-                4,
-                5
-            ]
-        },
-        {
-            "DEFAULT": 0.1,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "blackThresh",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 1,
-            "MAX": 2,
-            "MIN": 0,
-            "NAME": "satLevel",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "colorShift",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2",
-    "PASSES": [
-        {
-            "PERSISTENT": true,
-            "TARGET": "feedbackBuffer"
-        }
-    ]
-}
-*/
-
-
-const float pi = 3.14159265359;
-
-
-vec3 rgb2hsv(vec3 c)	{
-	vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
-	//vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
-	//vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
-	vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
-	vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
-	
-	float d = q.x - min(q.w, q.y);
-	float e = 1.0e-10;
-	return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
-}
-
-vec3 hsv2rgb(vec3 c)	{
-	vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
-	vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
-	return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
-}
-
-
-
-void main()	{
-	vec2		loc = isf_FragNormCoord;
-	vec4		inputPixelColor = IMG_NORM_PIXEL(inputImage,loc + (0.5 - (preShift)));
-	
-	vec4		feedbackPixelColor = vec4(0.0);
-	
-	//	rotate here if needed
-	loc = loc * RENDERSIZE;
-	float		r = distance(RENDERSIZE/2.0, loc);
-	float		a = atan ((loc.y-RENDERSIZE.y/2.0),(loc.x-RENDERSIZE.x/2.0));
-
-	loc.x = r * cos(a + 2.0 * pi * rotateAngle - pi) + 0.5;
-	loc.y = r * sin(a + 2.0 * pi * rotateAngle - pi) + 0.5;
-	
-	loc = loc / RENDERSIZE + vec2(0.5);
-	
-	vec2		modifiedCenter = zoomCenter;
-	loc.x = (loc.x - modifiedCenter.x)*(1.0/zoomLevel) + modifiedCenter.x;
-	loc.y = (loc.y - modifiedCenter.y)*(1.0/zoomLevel) + modifiedCenter.y;
-	loc += (0.5 - (feedbackShift));
-	
-	if ((loc.x < 0.0)||(loc.y < 0.0)||(loc.x > 1.0)||(loc.y > 1.0))	{
-		feedbackPixelColor = vec4(0.0);
-	}
-	else	{
-		feedbackPixelColor = IMG_NORM_PIXEL(feedbackBuffer,loc);
-	}
-	
-	feedbackPixelColor.rgb = rgb2hsv(feedbackPixelColor.rgb);
-	feedbackPixelColor.r = mod(feedbackPixelColor.r+colorShift,1.0);
-	feedbackPixelColor.g *= satLevel;
-	
-	feedbackPixelColor.rgb = hsv2rgb(feedbackPixelColor.rgb);
-	
-	if (invert)
-		feedbackPixelColor.rgb = 1.0 - feedbackPixelColor.rgb;
-	
-	if (blendMode == 0)	{
-		inputPixelColor = inputPixelColor + feedbackLevel * feedbackPixelColor;
-	}
-	else if (blendMode == 1)	{
-		float		val = inputPixelColor.a * (inputPixelColor.r + inputPixelColor.g + inputPixelColor.b) / 3.0;
-		inputPixelColor = (val >= blackThresh) ? inputPixelColor : feedbackLevel * feedbackPixelColor;
-		inputPixelColor.a = inputPixelColor.a + feedbackPixelColor.a * feedbackLevel;
-	}
-	else if (blendMode == 2)	{
-		//	apply the alpha to the input pixel as this happens
-		inputPixelColor.rgb = inputPixelColor.a * inputPixelColor.rgb + (1.0 - inputPixelColor.a) * feedbackLevel * feedbackPixelColor.rgb;
-		inputPixelColor.a = inputPixelColor.a + feedbackPixelColor.a * feedbackLevel;
-	}
-	else if (blendMode == 3)	{
-		inputPixelColor.rgb = max(inputPixelColor.a * inputPixelColor.rgb, feedbackLevel * feedbackPixelColor.rgb);
-		inputPixelColor.a = inputPixelColor.a + feedbackPixelColor.a * feedbackLevel;
-	}
-	else if (blendMode == 4)	{
-		float		val = feedbackPixelColor.a * (feedbackPixelColor.r + feedbackPixelColor.g + feedbackPixelColor.b) / 3.0;
-		inputPixelColor = (val < blackThresh) ? inputPixelColor.a * inputPixelColor : feedbackLevel * feedbackPixelColor;
-		inputPixelColor.a = inputPixelColor.a + feedbackPixelColor.a * feedbackLevel;
-	}
-	else if (blendMode == 5)	{
-		//	apply the alpha to the input pixel as this happens
-		inputPixelColor.rgb = (1.0-feedbackPixelColor.a) * inputPixelColor.a * inputPixelColor.rgb + feedbackLevel * feedbackPixelColor.rgb;
-		inputPixelColor.a = inputPixelColor.a + feedbackPixelColor.a * feedbackLevel;
-	}
-	
-	gl_FragColor = inputPixelColor;
-}
diff --git a/nannou_isf/test_files/cube.fs b/nannou_isf/test_files/cube.fs
deleted file mode 100644
index 84015a582..000000000
--- a/nannou_isf/test_files/cube.fs
+++ /dev/null
@@ -1,135 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Wipe",
-        "Distortion"
-    ],
-    "CREDIT": "Automatically converted from https://www.github.com/gl-transitions/gl-transitions/tree/master/cube.glsl",
-    "DESCRIPTION": "",
-    "INPUTS": [
-        {
-            "NAME": "startImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "endImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "progress",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.4,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "reflection",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.7,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "persp",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.3,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "unzoom",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 3,
-            "MAX": 10,
-            "MIN": 0,
-            "NAME": "floating",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-
-vec4 getFromColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(startImage, inUV);
-}
-vec4 getToColor(vec2 inUV)	{
-	return IMG_NORM_PIXEL(endImage, inUV);
-}
-
-
-
-// Author: gre
-// License: MIT
-
-vec2 project (vec2 p) {
-  return p * vec2(1.0, -1.2) + vec2(0.0, -floating/100.);
-}
-
-bool inBounds (vec2 p) {
-  return all(lessThan(vec2(0.0), p)) && all(lessThan(p, vec2(1.0)));
-}
-
-vec4 bgColor (vec2 p, vec2 pfr, vec2 pto) {
-  vec4 c = vec4(0.0, 0.0, 0.0, 1.0);
-  pfr = project(pfr);
-  // FIXME avoid branching might help perf!
-  if (inBounds(pfr)) {
-    c += mix(vec4(0.0), getFromColor(pfr), reflection * mix(1.0, 0.0, pfr.y));
-  }
-  pto = project(pto);
-  if (inBounds(pto)) {
-    c += mix(vec4(0.0), getToColor(pto), reflection * mix(1.0, 0.0, pto.y));
-  }
-  return c;
-}
-
-// p : the position
-// persp : the perspective in [ 0, 1 ]
-// center : the xcenter in [0, 1] \ 0.5 excluded
-vec2 xskew (vec2 p, float persp, float center) {
-  float x = mix(p.x, 1.0-p.x, center);
-  return (
-    (
-      vec2( x, (p.y - 0.5*(1.0-persp) * x) / (1.0+(persp-1.0)*x) )
-      - vec2(0.5-distance(center, 0.5), 0.0)
-    )
-    * vec2(0.5 / distance(center, 0.5) * (center<0.5 ? 1.0 : -1.0), 1.0)
-    + vec2(center<0.5 ? 0.0 : 1.0, 0.0)
-  );
-}
-
-vec4 transition(vec2 op) {
-  float uz = unzoom * 2.0*(0.5-distance(0.5, progress));
-  vec2 p = -uz*0.5+(1.0+uz) * op;
-  vec2 fromP = xskew(
-    (p - vec2(progress, 0.0)) / vec2(1.0-progress, 1.0),
-    1.0-mix(progress, 0.0, persp),
-    0.0
-  );
-  vec2 toP = xskew(
-    p / vec2(progress, 1.0),
-    mix(pow(progress, 2.0), 1.0, persp),
-    1.0
-  );
-  // FIXME avoid branching might help perf!
-  if (inBounds(fromP)) {
-    return getFromColor(fromP);
-  }
-  else if (inBounds(toP)) {
-    return getToColor(toP);
-  }
-  return bgColor(op, fromP, toP);
-}
-
-
-
-void main()	{
-	gl_FragColor = transition(isf_FragNormCoord.xy);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/noise2d.png b/nannou_isf/test_files/noise2d.png
deleted file mode 100644
index 79168c9dd..000000000
Binary files a/nannou_isf/test_files/noise2d.png and /dev/null differ
diff --git a/nannou_isf/test_files/v002 Bleach Bypass.fs b/nannou_isf/test_files/v002 Bleach Bypass.fs
deleted file mode 100644
index 4063ef569..000000000
--- a/nannou_isf/test_files/v002 Bleach Bypass.fs	
+++ /dev/null
@@ -1,55 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Color Adjustment",
-        "Film",
-        "v002"
-    ],
-    "CREDIT": "by v002",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "amount",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-//	Based on v002 bleach bypass – https://github.com/v002/v002-Film-Effects/
-
-//constant variables.
-const vec4 one = vec4(1.0);	
-const vec4 two = vec4(2.0);
-//const vec4 lumcoeff = vec4(0.2125,0.7154,0.0721,0.0);
-const vec4 lumcoeff = vec4(0.2126, 0.7152, 0.0722, 0.0);
-
-
-vec4 overlay(vec4 myInput, vec4 previousmix, vec4 amount)
-{
-	float luminance = dot(previousmix,lumcoeff);
-	float mixamount = clamp((luminance - 0.45) * 10., 0., 1.);
-
-	vec4 branch1 = two * previousmix * myInput;
-	vec4 branch2 = one - (two * (one - previousmix) * (one - myInput));
-
-	vec4 result = mix(branch1, branch2, vec4(mixamount) );
-
-	return mix(previousmix, result, amount);
-}
-
-void main (void) 
-{ 		
-	vec4 input0 = IMG_THIS_PIXEL(inputImage);
-
-	vec4 luma = vec4(dot(input0,lumcoeff));
-
-	gl_FragColor = overlay(luma, input0, vec4(amount));
-
-} 
\ No newline at end of file
diff --git a/nannou_isf/test_files/v002 Crosshatch.fs b/nannou_isf/test_files/v002 Crosshatch.fs
deleted file mode 100644
index 46909abf8..000000000
--- a/nannou_isf/test_files/v002 Crosshatch.fs	
+++ /dev/null
@@ -1,114 +0,0 @@
-/*{
-	"CREDIT": "by v002",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Halftone Effect", "v002"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "invert",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.0
-		},
-		{
-			"NAME": "separation",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 0.5,
-			"DEFAULT": 0.25
-		},
-		{
-			"NAME": "greyscale",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 1.0,
-			"DEFAULT": 0.75
-		},
-		{
-			"NAME": "thickness",
-			"TYPE": "float",
-			"MIN": 0.5,
-			"MAX": 1.0,
-			"DEFAULT": 0.75
-		},
-		{
-			"NAME": "front",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.5,
-				0.0,
-				0.25,
-				1.0
-			]
-		},
-		{
-			"NAME": "back",
-			"TYPE": "color",
-			"DEFAULT": [
-				0.2,
-				0.75,
-				0.5,
-				1.0
-			]
-		}
-	]
-}*/
-
-
-//Original Source
-//http://learningwebgl.com/blog/?p=2858
-
-//	Based on https://github.com/v002/v002-Half-Tones/
-
-
-
-
-const vec4 lumacoeff = vec4(0.2126, 0.7152, 0.0722, 0.0);
-
-
-void main()
-{
-    vec4 color = IMG_THIS_PIXEL(inputImage);
-    float lum = dot(color, lumacoeff);
-    vec2 coord = gl_FragCoord.xy;
-    
-    vec4 colora = mix(front, back, invert);
-    vec4 colorb = mix(back, front, invert);
-    
-    colora.a *= color.a;
-    colorb.a *= color.a;
-    
-    vec4 cout = mix(color,colora, greyscale);
-
-    gl_FragColor = colorb;
-    
-    if (lum > 1.00)
-    {
-        if (mod(coord.x + coord.y, thickness) >= separation)
-            gl_FragColor = cout;
-    }
-    
-    if (lum > 0.75)
-    {
-        if (mod(coord.x - coord.y, thickness) >= separation )
-            gl_FragColor = cout;
-    }
-    
-    if (lum > 0.50)
-    {
-        if (mod(coord.x + coord.y - (thickness * 0.5), thickness) >= separation)
-            gl_FragColor = cout;
-    }
-    
-    if (lum > 0.3)
-    {
-        if (mod(coord.x - coord.y - (thickness * 0.5), thickness) >= separation)
-            gl_FragColor = cout;
-    }
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/v002 Dilate.fs b/nannou_isf/test_files/v002 Dilate.fs
deleted file mode 100644
index ff24183ea..000000000
--- a/nannou_isf/test_files/v002 Dilate.fs	
+++ /dev/null
@@ -1,58 +0,0 @@
-/*{
-	"DESCRIPTION": "messed up version of v002 dilate",
-	"CREDIT": "by carter rosenberg",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Blur", "v002"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "amount",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 0.1,
-			"DEFAULT": 0.01
-		}
-	]
-}*/
-
-#if __VERSION__ <= 120
-varying vec2 texcoord0;
-varying vec2 texcoord1;
-varying vec2 texcoord2;
-varying vec2 texcoord3;
-varying vec2 texcoord4;
-varying vec2 texcoord5;
-varying vec2 texcoord6;
-varying vec2 texcoord7;
-#else
-in vec2 texcoord0;
-in vec2 texcoord1;
-in vec2 texcoord2;
-in vec2 texcoord3;
-in vec2 texcoord4;
-in vec2 texcoord5;
-in vec2 texcoord6;
-in vec2 texcoord7;
-#endif
-
-void main()
-{
-
-	vec4 dilate = IMG_NORM_PIXEL(inputImage, 0.5 * (texcoord3 + texcoord4));
-	
-	dilate = max(dilate, IMG_NORM_PIXEL(inputImage, texcoord0));
-	dilate = max(dilate, IMG_NORM_PIXEL(inputImage, texcoord1));
-	dilate = max(dilate, IMG_NORM_PIXEL(inputImage, texcoord2));
-	dilate = max(dilate, IMG_NORM_PIXEL(inputImage, texcoord3));
-	dilate = max(dilate, IMG_NORM_PIXEL(inputImage, texcoord4));
-	dilate = max(dilate, IMG_NORM_PIXEL(inputImage, texcoord5));
-	dilate = max(dilate, IMG_NORM_PIXEL(inputImage, texcoord6));
-	dilate = max(dilate, IMG_NORM_PIXEL(inputImage, texcoord7));
-
-	gl_FragColor = dilate;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/v002 Dilate.vs b/nannou_isf/test_files/v002 Dilate.vs
deleted file mode 100644
index d47984dea..000000000
--- a/nannou_isf/test_files/v002 Dilate.vs	
+++ /dev/null
@@ -1,40 +0,0 @@
-
-#if __VERSION__ <= 120
-varying vec2 texcoord0;
-varying vec2 texcoord1;
-varying vec2 texcoord2;
-varying vec2 texcoord3;
-varying vec2 texcoord4;
-varying vec2 texcoord5;
-varying vec2 texcoord6;
-varying vec2 texcoord7;
-#else
-out vec2 texcoord0;
-out vec2 texcoord1;
-out vec2 texcoord2;
-out vec2 texcoord3;
-out vec2 texcoord4;
-out vec2 texcoord5;
-out vec2 texcoord6;
-out vec2 texcoord7;
-#endif
-
-void main()
-{
-	isf_vertShaderInit();
-	// perform standard transform on vertex
-	//gl_Position = ftransform();
-
-	// transform texcoord        
-	vec2 texcoord = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-
-	// get sample positions
-	texcoord0 = texcoord + vec2(-amount, -amount);
-	texcoord1 = texcoord + vec2( 0,      -amount);
-	texcoord2 = texcoord + vec2( amount, -amount);
-	texcoord3 = texcoord + vec2(-amount,  0);
-	texcoord4 = texcoord + vec2( amount,  0);
-	texcoord5 = texcoord + vec2(-amount,  amount);
-	texcoord6 = texcoord + vec2( 0,       amount);
-	texcoord7 = texcoord + vec2( amount,  amount);
-}
diff --git a/nannou_isf/test_files/v002 Erode.fs b/nannou_isf/test_files/v002 Erode.fs
deleted file mode 100644
index b25228cef..000000000
--- a/nannou_isf/test_files/v002 Erode.fs	
+++ /dev/null
@@ -1,57 +0,0 @@
-/*{
-	"DESCRIPTION": "messed up version of v002 erode",
-	"CREDIT": "by carter rosenberg",
-	"ISFVSN": "2",
-	"CATEGORIES": [
-		"Blur", "v002"
-	],
-	"INPUTS": [
-		{
-			"NAME": "inputImage",
-			"TYPE": "image"
-		},
-		{
-			"NAME": "amount",
-			"TYPE": "float",
-			"MIN": 0.0,
-			"MAX": 0.1,
-			"DEFAULT": 0.01
-		}
-	]
-}*/
-
-#if __VERSION__ <= 120
-varying vec2 texcoord0;
-varying vec2 texcoord1;
-varying vec2 texcoord2;
-varying vec2 texcoord3;
-varying vec2 texcoord4;
-varying vec2 texcoord5;
-varying vec2 texcoord6;
-varying vec2 texcoord7;
-#else
-in vec2 texcoord0;
-in vec2 texcoord1;
-in vec2 texcoord2;
-in vec2 texcoord3;
-in vec2 texcoord4;
-in vec2 texcoord5;
-in vec2 texcoord6;
-in vec2 texcoord7;
-#endif
-
-void main()
-{
-	vec4 erode = IMG_NORM_PIXEL(inputImage, 0.5 * (texcoord3 + texcoord4));
-	
-	erode = min(erode, IMG_NORM_PIXEL(inputImage, texcoord0));
-	erode = min(erode, IMG_NORM_PIXEL(inputImage, texcoord1));
-	erode = min(erode, IMG_NORM_PIXEL(inputImage, texcoord2));
-	erode = min(erode, IMG_NORM_PIXEL(inputImage, texcoord3));
-	erode = min(erode, IMG_NORM_PIXEL(inputImage, texcoord4));
-	erode = min(erode, IMG_NORM_PIXEL(inputImage, texcoord5));
-	erode = min(erode, IMG_NORM_PIXEL(inputImage, texcoord6));
-	erode = min(erode, IMG_NORM_PIXEL(inputImage, texcoord7));
-
-	gl_FragColor = erode;
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/v002 Erode.vs b/nannou_isf/test_files/v002 Erode.vs
deleted file mode 100644
index d3fe13ea5..000000000
--- a/nannou_isf/test_files/v002 Erode.vs	
+++ /dev/null
@@ -1,40 +0,0 @@
-
-#if __VERSION__ <= 120
-varying vec2 texcoord0;
-varying vec2 texcoord1;
-varying vec2 texcoord2;
-varying vec2 texcoord3;
-varying vec2 texcoord4;
-varying vec2 texcoord5;
-varying vec2 texcoord6;
-varying vec2 texcoord7;
-#else
-out vec2 texcoord0;
-out vec2 texcoord1;
-out vec2 texcoord2;
-out vec2 texcoord3;
-out vec2 texcoord4;
-out vec2 texcoord5;
-out vec2 texcoord6;
-out vec2 texcoord7;
-#endif
-
-void main()
-{
-	isf_vertShaderInit();
-	// perform standard transform on vertex
-	//gl_Position = ftransform();
-	
-	// transform texcoord        
-	vec2 texcoord = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-
-	// get sample positions
-	texcoord0 = texcoord + vec2(-amount, -amount);
-	texcoord1 = texcoord + vec2( 0,      -amount);
-	texcoord2 = texcoord + vec2( amount, -amount);
-	texcoord3 = texcoord + vec2(-amount,  0);
-	texcoord4 = texcoord + vec2( amount,  0);
-	texcoord5 = texcoord + vec2(-amount,  amount);
-	texcoord6 = texcoord + vec2( 0,       amount);
-	texcoord7 = texcoord + vec2( amount,  amount);
-}
diff --git a/nannou_isf/test_files/v002 Light Leak.fs b/nannou_isf/test_files/v002 Light Leak.fs
deleted file mode 100644
index 4818d9d26..000000000
--- a/nannou_isf/test_files/v002 Light Leak.fs	
+++ /dev/null
@@ -1,83 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Film",
-        "Stylize",
-        "v002"
-    ],
-    "CREDIT": "by v002",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "NAME": "leakImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1.5,
-            "MIN": 0,
-            "NAME": "amount",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "length",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 360,
-            "MIN": 0,
-            "NAME": "angle",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-// rotation matrix
-#if __VERSION__ <= 120
-varying mat2 rotmat;
-#else
-in mat2 rotmat;
-#endif
-
-
-
-void main (void) 
-{
-	// normalized point 0 - 1 texcoords
-	vec2 point = isf_FragNormCoord;
-	// our normal image.
-	vec4 input0 = IMG_NORM_PIXEL(inputImage, point);
-	// rotate sampling point
-	point = ((point - 0.5) * rotmat) + 0.5;
-	//point = clamp(point, 0.0, 1.0);
-
-	// this adjusts the length of the leak
-	float leakIntensity = pow(point.y, 1.0 + ((1.0 - length) * 19.0));
-
-	// this adjusts the gamma/brightness of the overall effect.
-	leakIntensity =  pow(leakIntensity, 1.0 / amount);
-
-	// sample the leak // how do we want to handle edge texcoords during rotation? 
-	if (point.x < 0.0)	{
-		point.x = abs(point.x);
-	}
-	if (point.x > 1.0)	{
-		point.x = 2.0 - point.x;
-	}
-
-	vec4 leak = IMG_NORM_PIXEL(leakImage, vec2(mod(point.x,1.0),0.0));
-
-	leak = pow(leak * leakIntensity, vec4(1.0/(leakIntensity))); // - vec2(0.5, 0.0);
-	leak += input0;
-
-	gl_FragColor = mix(input0, leak, amount);
-} 
\ No newline at end of file
diff --git a/nannou_isf/test_files/v002 Light Leak.vs b/nannou_isf/test_files/v002 Light Leak.vs
deleted file mode 100644
index c78098f63..000000000
--- a/nannou_isf/test_files/v002 Light Leak.vs	
+++ /dev/null
@@ -1,21 +0,0 @@
-
-#if __VERSION__ <= 120
-varying mat2 rotmat;
-#else
-out mat2 rotmat;
-#endif
-
-void main()
-{
-	isf_vertShaderInit();
-
-	// setup basic rotation matrix here
-	float theta = radians(angle); 
-
-	// dont need to compute this more than once..
-	float c = cos(theta);
-	float s = sin(theta);
-
-	// rotation matrix
-	rotmat = mat2(c,s,-s,c);
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/v002 Technicolor.fs b/nannou_isf/test_files/v002 Technicolor.fs
deleted file mode 100644
index 7c693b429..000000000
--- a/nannou_isf/test_files/v002 Technicolor.fs	
+++ /dev/null
@@ -1,109 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Stylize",
-        "Film",
-        "Color Effect",
-        "v002"
-    ],
-    "CREDIT": "by v002",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "amount",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABELS": [
-                "Strip additive",
-                "Strip subtractive",
-                "Strip matte"
-            ],
-            "NAME": "style",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1,
-                2
-            ]
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-//	Based on v002 technicolor – https://github.com/v002/v002-Film-Effects/
-
-const vec4 redfilter1 		= vec4(1.0, 0.0, 0.0, 1.0);
-const vec4 bluegreenfilter1 	= vec4(0.0, 1.0, 0.7, 1.0);
-
-const vec4 redfilter2 		= vec4(1.0, 0.0, 0.0, 0.0);
-const vec4 bluegreenfilter2 	= vec4(0.0, 1.0, 1.0, 0.0);
-
-const vec4 cyanfilter		= vec4(0.0, 1.0, 0.5, 0.0);
-const vec4 magentafilter	= vec4(1.0, 0.0, 0.25, 0.0);
-
-
-
-void main (void) 
-{
-	vec4 input0 = IMG_THIS_PIXEL(inputImage);
-	vec4 result;
-
-	if (style == 0)	{
-		vec4 redrecord = input0 * redfilter1;
-		vec4 bluegreenrecord = input0 * bluegreenfilter1;
-		vec4 rednegative = vec4(redrecord.r);
-		vec4 bluegreennegative = vec4((bluegreenrecord.g + bluegreenrecord.b)/2.0);
-
-		vec4 redoutput = rednegative * redfilter1;
-		vec4 bluegreenoutput = bluegreennegative * bluegreenfilter1;
-
-		// additive 'projection"
-		result = redoutput + bluegreenoutput;
-
-		result = mix(input0, result, amount);
-		result.a = input0.a;
-	}
-	else if (style == 1)	{
-		vec4 redrecord = input0 * redfilter2;
-		vec4 bluegreenrecord = input0 * bluegreenfilter2;
-
-		vec4 rednegative = vec4(redrecord.r);
-		vec4 bluegreennegative = vec4((bluegreenrecord.g + bluegreenrecord.b)/2.0);
-
-		vec4 redoutput = rednegative + cyanfilter;
-		vec4 bluegreenoutput = bluegreennegative + magentafilter;
-
-		result = redoutput * bluegreenoutput;
-
-		result = mix(input0, result, amount);
-		result.a = input0.a;	
-	}
-	else if (style == 2)	{
-		vec3 redmatte = vec3(input0.r - ((input0.g + input0.b)/2.0));
-		vec3 greenmatte = vec3(input0.g - ((input0.r + input0.b)/2.0));
-		vec3 bluematte = vec3(input0.b - ((input0.r + input0.g)/2.0));
-
-		redmatte = 1.0 - redmatte;
-		greenmatte = 1.0 - greenmatte;
-		bluematte = 1.0 - bluematte;
-
-		vec3 red =  greenmatte * bluematte * input0.r;
-		vec3 green = redmatte * bluematte * input0.g;
-		vec3 blue = redmatte * greenmatte * input0.b;
-
-		result = vec4(red.r, green.g, blue.b, input0.a);
-
-		result = mix(input0, result, amount);
-		result.a = input0.a;	
-	}
-	gl_FragColor = result;		
-} 
\ No newline at end of file
diff --git a/nannou_isf/test_files/v002 Vignette.fs b/nannou_isf/test_files/v002 Vignette.fs
deleted file mode 100644
index 9b3a61c4f..000000000
--- a/nannou_isf/test_files/v002 Vignette.fs	
+++ /dev/null
@@ -1,66 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Film",
-        "v002"
-    ],
-    "CREDIT": "by v002",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "vignette",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "vignetteEdge",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "vignetteMix",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-
-//	Based on v002 vignette – https://github.com/v002/v002-Film-Effects/
-
-
-
-// create a black and white oval about the center of our image for our vignette
-vec4 vignetteFucntion(vec2 normalizedTexcoord, float vignetteedge, float vignetteMix)
-{
-	normalizedTexcoord = 2.0 * normalizedTexcoord - 1.0; // - 1.0 to 1.0
-	float r = length(normalizedTexcoord);
-	vec4 vignette = (vec4(smoothstep(0.0, 1.0, pow(clamp(r - vignetteMix, 0.0, 1.0), 1.0 + vignetteedge * 10.0))));
-	return clamp(1.0 - vignette, 0.0, 1.0);
-}
-
-
-
-void main (void) 
-{ 		
-	vec2 normcoord = vec2(isf_FragNormCoord[0],isf_FragNormCoord[1]);
-
-
-	// make a vignette around our borders.
-	vec4 vignetteResult = vignetteFucntion(normcoord, vignetteEdge, vignetteMix);
-
-	// sharpen via unsharp mask (subtract image from blured image)
-	vec4 input0 = IMG_THIS_PIXEL(inputImage);
-
-	gl_FragColor = mix(input0,vignetteResult * input0, vignette);		
-} 
\ No newline at end of file
diff --git a/nannou_isf/test_files/v002-CRT-Displacement.fs b/nannou_isf/test_files/v002-CRT-Displacement.fs
deleted file mode 100755
index f877c8e20..000000000
--- a/nannou_isf/test_files/v002-CRT-Displacement.fs
+++ /dev/null
@@ -1,55 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Distortion Effect",
-        "Retro",
-        "v002"
-    ],
-    "CREDIT": "by vade",
-    "DESCRIPTION": "CRT Displacement, emulating the look of curved CRT Displays",
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "Amount",
-            "TYPE": "float"
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-void main (void) 
-{ 
-	vec2 t1, t2;
-	vec2 ctr = RENDERSIZE / 2.0;
-	
-	t1 = gl_FragCoord.xy;
-	
-	float a = -0.0;
-	float b = -.1 * Amount;
-	float c = -.0;
-	float d = 1.0  - 1.1 * ( a + b + c );
-	float r1, r2;
-	float unit = length(ctr) / 2.0;
-	
-	r1 = distance( t1, ctr )/unit;
-	r2 =  r1 *( r1*( r1 * (a*r1 + b) + c) + d );
-	float sc = step( 0.0 , r1) * ( r1/(r2 + .000001)) + (1.0 - step( 0.0 , r1));
-
-	t2  = ctr + ( t1 - ctr) * sc;
-	
-	gl_FragColor = IMG_PIXEL(inputImage, t2);
-			
-	if ((t2.x < 0.0)
-		||(t2.y < 0.0)
-		||(t2.x > RENDERSIZE.x)
-		||(t2.y > RENDERSIZE.y)) 
-	{
-		gl_FragColor = vec4(0.0);
-	}
-}
\ No newline at end of file
diff --git a/nannou_isf/test_files/v002-CRT-Mask-RGB-Shadow.png b/nannou_isf/test_files/v002-CRT-Mask-RGB-Shadow.png
deleted file mode 100755
index 5dbf30c34..000000000
Binary files a/nannou_isf/test_files/v002-CRT-Mask-RGB-Shadow.png and /dev/null differ
diff --git a/nannou_isf/test_files/v002-CRT-Mask-RGB-Staggered.png b/nannou_isf/test_files/v002-CRT-Mask-RGB-Staggered.png
deleted file mode 100755
index c2b42d066..000000000
Binary files a/nannou_isf/test_files/v002-CRT-Mask-RGB-Staggered.png and /dev/null differ
diff --git a/nannou_isf/test_files/v002-CRT-Mask-RGB-Straight.png b/nannou_isf/test_files/v002-CRT-Mask-RGB-Straight.png
deleted file mode 100755
index 230fd84c5..000000000
Binary files a/nannou_isf/test_files/v002-CRT-Mask-RGB-Straight.png and /dev/null differ
diff --git a/nannou_isf/test_files/v002-CRT-Mask-Scanline-Staggered.png b/nannou_isf/test_files/v002-CRT-Mask-Scanline-Staggered.png
deleted file mode 100755
index 2e9c4a377..000000000
Binary files a/nannou_isf/test_files/v002-CRT-Mask-Scanline-Staggered.png and /dev/null differ
diff --git a/nannou_isf/test_files/v002-CRT-Mask.fs b/nannou_isf/test_files/v002-CRT-Mask.fs
deleted file mode 100755
index 1f09663b6..000000000
--- a/nannou_isf/test_files/v002-CRT-Mask.fs
+++ /dev/null
@@ -1,77 +0,0 @@
-/*{
-    "CATEGORIES": [
-        "Retro",
-        "v002"
-    ],
-    "CREDIT": "by vade",
-    "DESCRIPTION": "CRT Mask, emulating the look of curved CRT Displays",
-    "IMPORTED": {
-        "CRTMask0": {
-            "PATH": "v002-CRT-Mask-RGB-Staggered.png"
-        },
-        "CRTMask1": {
-            "PATH": "v002-CRT-Mask-RGB-Shadow.png"
-        },
-        "CRTMask2": {
-            "PATH": "v002-CRT-Mask-RGB-Straight.png"
-        },
-        "CRTMask3": {
-            "PATH": "v002-CRT-Mask-Scanline-Staggered.png"
-        }
-    },
-    "INPUTS": [
-        {
-            "NAME": "inputImage",
-            "TYPE": "image"
-        },
-        {
-            "DEFAULT": 0.5,
-            "MAX": 1,
-            "MIN": 0,
-            "NAME": "Amount",
-            "TYPE": "float"
-        },
-        {
-            "DEFAULT": 0,
-            "LABEL": "Style",
-            "LABELS": [
-                "Staggered",
-                "Shadow",
-                "Straight",
-                "Scanline Staggered"
-            ],
-            "NAME": "style",
-            "TYPE": "long",
-            "VALUES": [
-                0,
-                1,
-                2,
-                3
-            ]
-        }
-    ],
-    "ISFVSN": "2"
-}
-*/
-
-void main (void) 
-{ 
-	vec2 crtcoord = mod(gl_FragCoord.xy, 12.0);
-	vec4 crt;
-	
-	if (style == 0)
-		crt = IMG_PIXEL(CRTMask0, crtcoord);
-	else if (style == 1)
-		crt = IMG_PIXEL(CRTMask1, crtcoord);
-	else if (style == 2)
-		crt = IMG_PIXEL(CRTMask2, crtcoord);
-	else if (style == 3)
-		crt = IMG_PIXEL(CRTMask3, crtcoord);
-
-	vec4 image = IMG_THIS_PIXEL(inputImage);
-	vec4 result = mix(image, image * crt, Amount);
-	
-	result.a = image.a;
-	
-	gl_FragColor = result;
-}
\ No newline at end of file
diff --git a/nannou_isf/tests/gen_glsl.rs b/nannou_isf/tests/gen_glsl.rs
deleted file mode 100644
index 18ad62d38..000000000
--- a/nannou_isf/tests/gen_glsl.rs
+++ /dev/null
@@ -1,159 +0,0 @@
-/// Tests the following for each test file:
-///
-/// - Reads file to string.
-/// - Parse file for `Isf`.
-/// - Generate GLSL for `Isf`.
-/// - Merge generated GLSL with original GLSL.
-/// - Attempt to compile merged GLSL to SPIR-V.
-///
-/// Run with `cargo test -- --nocapture` to print result to command line.
-#[test]
-fn test_gen_glsl() {
-    let test_files_path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("test_files");
-    assert!(test_files_path.exists());
-    assert!(test_files_path.is_dir());
-    let mut successes = vec![];
-    let mut failures = vec![];
-    for entry in std::fs::read_dir(test_files_path).unwrap() {
-        let entry = entry.unwrap();
-        let path = entry.path();
-        let ext = path.extension().and_then(|s| s.to_str()).unwrap_or("");
-        let shader_ty = match hotglsl::ext_to_shader_ty(ext) {
-            None => continue,
-            Some(ty) => ty,
-        };
-        if should_ignore(&path) {
-            continue;
-        }
-        let old_glsl_string = std::fs::read_to_string(&path).unwrap();
-        println!("Parsing {} for `Isf`...", path.display());
-        let isf = match isf::parse(&old_glsl_string) {
-            // Ignore non-ISF vertex shaders.
-            Err(isf::ParseError::MissingTopComment) if ext == "vs" => continue,
-            Err(err) => panic!("err while parsing {}: {}", path.display(), err),
-            Ok(isf) => isf,
-        };
-
-        println!("  Generating GLSL string...");
-        let isf_glsl_string = nannou_isf::glsl_string_from_isf(&isf);
-        println!("  Merging GLSL strings...");
-        let new_glsl_string = nannou_isf::prefix_isf_glsl_str(&isf_glsl_string, old_glsl_string);
-
-        println!("  Compiling GLSL to SPIR-V...");
-        match hotglsl::compile_str(&new_glsl_string, shader_ty) {
-            Ok(_) => successes.push(path),
-            Err(err) => {
-                eprintln!("{}", err);
-                failures.push((path, err, new_glsl_string));
-            }
-        }
-    }
-
-    successes.sort();
-    failures.sort_by_key(|elem| elem.0.clone());
-
-    if !successes.is_empty() {
-        println!("Successes:");
-        for path in &successes {
-            println!("  {}", path.display());
-        }
-    }
-
-    if !failures.is_empty() {
-        println!("Failures:");
-        for (path, err, _src) in &failures {
-            println!("  {}\n{}\n", path.display(), err);
-        }
-    }
-
-    println!("{} succeeded, {} failed", successes.len(), failures.len());
-    assert!(failures.is_empty());
-}
-
-// Shaders known to trigger bugs in `glsl` parser crate.
-const GLSL_PARSER_BUGS: &[&str] = &["Film Burn.fs"];
-
-// We only support GLSL 450 shaders.
-const GLSL_450_INCOMPATIBLE: &[&str] = &[
-    // The following don't define the `location` for inputs from vertex shader.
-    "Lens Flare.fs",
-    "Color Blowout.fs",
-    "FastMosh.fs",
-    "Optical Flow Distort.fs",
-    "Circular Screen.fs",
-    "Edge Trace.fs",
-    "Rotate.fs",
-    "Neon.fs",
-    "Smudged Lens.fs",
-    "Glow-Fast.fs",
-    "Line Screen.fs",
-    "Fast Blur.fs",
-    "Bloom.fs",
-    "Life.fs",
-    "Dot Screen.fs",
-    "Sketch.fs",
-    "Gloom.fs",
-    "Mirror Edge.fs",
-    "Saturation Bleed.fs",
-    "v002 Dilate.fs",
-    "Sharpen Luminance.fs",
-    "Unsharp Mask.fs",
-    "Edge Blur.fs",
-    "Sorting Smear.fs",
-    "Edges.fs",
-    "Emboss.fs",
-    "Auto Levels.fs",
-    "v002 Erode.fs",
-    "v002 Light Leak.fs",
-    "Sharpen RGB.fs",
-    "Glow.fs",
-    "Edge Distort.fs",
-    "City Lights.fs",
-    "Multi Pass Gaussian Blur.fs",
-    "Soft Blur.fs",
-    "Thermal Camera.fs",
-    // Unable to parse the `#ENDIF` on these.
-    "Multi-Pixellate.fs",
-    "Circle Splash Distortion.fs",
-    "Triangles.fs",
-    "Cubic Warp.fs",
-    "Pixellate.fs",
-    "Grid Warp.fs",
-    "Ripples.fs",
-    "Noise Pixellate.fs",
-    "Bump Distortion.fs",
-    // Forward declarations. These don't seem to be supported in glsl 450?
-    "Chroma Desaturation Mask.fs",
-    "Chroma Mask.fs",
-    "Color Replacement.fs",
-    // These unnecessarily re-declare the `round` function.
-    "VU Meter.fs",
-    "Etch-a-Sketch.fs",
-    // These have what seems to be invalid for loop syntax?
-    // e.g. `for (i = 0(i)<(3); ++(i)) {`
-    // Error: `function call, method, or subroutine call expected`
-    "RGB Halftone-lookaround.fs",
-    "CMYK Halftone-Lookaround.fs",
-    // Don't work after switching to `naga`
-    "Pixelize.fs",
-];
-
-// Tests that are known to fail but there's no clear solution explained by the spec.
-const KNOWN_BUGS: &[&str] = &[
-    // NOTE: Seems like the following two are using some implicitly declared uniforms associated
-    // with their input images? Is this meant to be a more efficient alternative to `IMG_SIZE`?
-    // This uses undeclared `_inputImage_imgRect`.
-    "Radial Replicate.fs",
-    // This uses undeclared `_maskImage_imgRect`.
-    "Trail Mask.fs",
-];
-
-fn should_ignore(path: &std::path::Path) -> bool {
-    let file_name = match path.file_name().and_then(|s| s.to_str()) {
-        Some(name) => name,
-        None => return true,
-    };
-    GLSL_PARSER_BUGS.contains(&file_name)
-        || GLSL_450_INCOMPATIBLE.contains(&file_name)
-        || KNOWN_BUGS.contains(&file_name)
-}
diff --git a/nannou_laser/.dropboxignore b/nannou_laser/.dropboxignore
new file mode 100644
index 000000000..308cac8b1
--- /dev/null
+++ b/nannou_laser/.dropboxignore
@@ -0,0 +1,7 @@
+# ----
+# Automatically Generated .dropboxignore file at Tue Apr 23 13:35:38 PDT 2024
+# ----
+/target
+**/*.rs.bk
+Cargo.lock
+# ----
diff --git a/nannou_laser/src/dac.rs b/nannou_laser/src/dac.rs
index 72ee4c6e9..10a030c5e 100644
--- a/nannou_laser/src/dac.rs
+++ b/nannou_laser/src/dac.rs
@@ -174,7 +174,7 @@ fn detect_dacs_async_inner(
                     is_closed.store(true, atomic::Ordering::Relaxed);
                     break;
                 }
-                while let Some(res) = detect_dacs.next() {
+                for res in detect_dacs.by_ref() {
                     if let Err(ref e) = res {
                         match e.kind() {
                             io::ErrorKind::TimedOut | io::ErrorKind::WouldBlock => continue 'msgs,
diff --git a/nannou_laser/src/ffi.rs b/nannou_laser/src/ffi.rs
index e87398e4b..6d16e8be6 100644
--- a/nannou_laser/src/ffi.rs
+++ b/nannou_laser/src/ffi.rs
@@ -296,7 +296,7 @@ pub unsafe extern "C" fn available_dacs(
         if !dacs.is_empty() {
             let mut dacs: Box<[_]> = dacs
                 .values()
-                .map(|&(_, ref dac)| detected_dac_to_ffi(dac.clone()))
+                .map(|(_, dac)| detected_dac_to_ffi(dac.clone()))
                 .collect();
             *len = dacs.len() as _;
             *first_dac = dacs.as_mut_ptr();
@@ -317,15 +317,15 @@ pub unsafe extern "C" fn detect_dac(api: *mut Api, detected_dac: *mut DetectedDa
         Ok(iter) => iter,
     };
     match iter.next() {
-        None => return Result::DetectDacFailed,
+        None => Result::DetectDacFailed,
         Some(res) => match res {
             Ok(dac) => {
                 *detected_dac = detected_dac_to_ffi(dac);
-                return Result::Success;
+                Result::Success
             }
             Err(err) => {
                 api.last_error = Some(err_to_cstring(&err));
-                return Result::DetectDacFailed;
+                Result::DetectDacFailed
             }
         },
     }
@@ -433,7 +433,7 @@ pub unsafe extern "C" fn new_frame_stream(
         .stream_error(stream_error_fn);
 
     if (*config).stream_conf.detected_dac != std::ptr::null() {
-        let ffi_dac = (*(*config).stream_conf.detected_dac).clone();
+        let ffi_dac = *(*config).stream_conf.detected_dac;
         let detected_dac = detected_dac_from_ffi(ffi_dac);
         builder = builder.detected_dac(detected_dac);
     }
@@ -501,7 +501,7 @@ pub unsafe extern "C" fn new_raw_stream(
         .stream_error(stream_error_fn);
 
     if (*config).detected_dac != std::ptr::null() {
-        let ffi_dac = (*(*config).detected_dac).clone();
+        let ffi_dac = *(*config).detected_dac;
         let detected_dac = detected_dac_from_ffi(ffi_dac);
         builder = builder.detected_dac(detected_dac);
     }
@@ -693,12 +693,12 @@ pub unsafe extern "C" fn frame_stream_close(api: *mut Api, stream: FrameStream)
             Some(Ok(Ok(()))) => Result::Success,
             Some(Ok(Err(err))) => {
                 (*(*api).inner).last_error = Some(err_to_cstring(&err));
-                return Result::CloseStreamFailed;
+                Result::CloseStreamFailed
             }
             Some(Err(_err)) => {
-                let string = format!("failed to join stream thread");
+                let string = "failed to join stream thread".to_string();
                 (*(*api).inner).last_error = Some(string_to_cstring(string));
-                return Result::CloseStreamFailed;
+                Result::CloseStreamFailed
             }
             None => Result::Success,
         }
@@ -763,12 +763,12 @@ pub unsafe extern "C" fn raw_stream_close(api: *mut Api, stream: RawStream) -> R
             Some(Ok(Ok(()))) => Result::Success,
             Some(Ok(Err(err))) => {
                 (*(*api).inner).last_error = Some(err_to_cstring(&err));
-                return Result::CloseStreamFailed;
+                Result::CloseStreamFailed
             }
             Some(Err(_err)) => {
-                let string = format!("failed to join stream thread");
+                let string = "failed to join stream thread".to_string();
                 (*(*api).inner).last_error = Some(string_to_cstring(string));
-                return Result::CloseStreamFailed;
+                Result::CloseStreamFailed
             }
             None => Result::Success,
         }
@@ -1026,7 +1026,7 @@ unsafe fn stream_error_action_set(
 }
 
 fn raw_string_from_str(s: &str) -> RawString {
-    let cstring = CString::new(&s[..]).unwrap();
+    let cstring = CString::new(s).unwrap();
     let inner = cstring.into_raw();
     RawString { inner }
 }
@@ -1110,7 +1110,7 @@ fn detected_dac_to_ffi(dac: crate::DetectedDac) -> DetectedDac {
 
 fn detected_dac_from_ffi(ffi_dac: DetectedDac) -> crate::DetectedDac {
     unsafe {
-        let broadcast = ffi_dac.kind.ether_dream.broadcast.clone();
+        let broadcast = ffi_dac.kind.ether_dream.broadcast;
         let source_addr = socket_addr_from_ffi(ffi_dac.kind.ether_dream.source_addr);
         crate::DetectedDac::EtherDream {
             broadcast,
diff --git a/nannou_laser/src/ilda_idtf.rs b/nannou_laser/src/ilda_idtf.rs
index 4875cdf4b..96b781f84 100644
--- a/nannou_laser/src/ilda_idtf.rs
+++ b/nannou_laser/src/ilda_idtf.rs
@@ -4,13 +4,14 @@
 //!
 //! See the extensive, top-level `ilda-idtf` API docs [here](https://docs.rs/ilda-idtf).
 
-use crate::{point, Point};
 use std::io;
 use std::path::Path;
 
 #[doc(inline)]
 pub use ilda_idtf::*;
 
+use crate::{point, Point};
+
 /// A type that simplifies the process of reading laser frames from the ILDA IDTF format in a
 /// manner that is compatible with the `nannou_laser` stream APIs.
 pub struct FrameReader<R> {
@@ -122,12 +123,12 @@ where
     }
 }
 
-impl<R> Into<SectionReader<R>> for FrameReader<R>
+impl<R> From<FrameReader<R>> for SectionReader<R>
 where
     R: io::Read,
 {
-    fn into(self) -> SectionReader<R> {
-        self.into_section_reader()
+    fn from(val: FrameReader<R>) -> Self {
+        val.into_section_reader()
     }
 }
 
diff --git a/nannou_laser/src/lib.rs b/nannou_laser/src/lib.rs
index a17461490..8df9ec2fd 100644
--- a/nannou_laser/src/lib.rs
+++ b/nannou_laser/src/lib.rs
@@ -2,14 +2,9 @@
 
 pub extern crate ether_dream;
 
-pub mod dac;
-#[cfg(feature = "ffi")]
-pub mod ffi;
-#[cfg(feature = "ilda-idtf")]
-pub mod ilda_idtf;
-pub mod point;
-pub mod stream;
-pub mod util;
+use std::io;
+use std::sync::Arc;
+use std::time::Duration;
 
 pub use dac::{DetectDacs, DetectDacsAsync, DetectedDac, DetectedDacCallback, Id as DacId};
 pub use point::{Point, RawPoint};
@@ -18,9 +13,14 @@ pub use stream::frame::Stream as FrameStream;
 pub use stream::raw::Stream as RawStream;
 pub use stream::raw::{Buffer, StreamError, StreamErrorAction};
 
-use std::io;
-use std::sync::Arc;
-use std::time::Duration;
+pub mod dac;
+#[cfg(feature = "ffi")]
+pub mod ffi;
+#[cfg(feature = "ilda-idtf")]
+pub mod ilda_idtf;
+pub mod point;
+pub mod stream;
+pub mod util;
 
 /// A general API that allows for detecting and enumerating laser DACs on a network and
 /// establishing new streams of communication with them.
@@ -34,6 +34,12 @@ pub struct Api {
 // drops out for some reason.
 pub(crate) struct Inner;
 
+impl Default for Api {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Api {
     /// Instantiate the laser API.
     pub fn new() -> Self {
diff --git a/nannou_laser/src/stream/frame.rs b/nannou_laser/src/stream/frame.rs
index ec461d43b..0f078e84b 100644
--- a/nannou_laser/src/stream/frame.rs
+++ b/nannou_laser/src/stream/frame.rs
@@ -1,6 +1,3 @@
-use crate::stream;
-use crate::stream::raw::{self, Buffer, StreamError};
-use crate::{Point, RawPoint};
 use std::io;
 use std::ops::{Deref, DerefMut};
 use std::sync::{mpsc, Arc, Mutex};
@@ -8,6 +5,10 @@ use std::time::Duration;
 
 pub use lasy::InterpolationConfig;
 
+use crate::stream;
+use crate::stream::raw::{self, Buffer, StreamError};
+use crate::{Point, RawPoint};
+
 /// The function that will be called each time a new `Frame` is requested.
 pub trait RenderFn<M>: Fn(&mut M, &mut Frame) {}
 impl<M, F> RenderFn<M> for F where F: Fn(&mut M, &mut Frame) {}
@@ -465,7 +466,7 @@ impl Frame {
                 self.points.push(*next);
             }
         }
-        self.points.extend(points.map(|p| p.as_ref().clone()));
+        self.points.extend(points.map(|p| *p.as_ref()));
     }
 }
 
@@ -597,13 +598,13 @@ impl Requester {
                         let blank_point = self
                             .blank_points
                             .last()
-                            .map(|&p| p)
+                            .copied()
                             .or_else(|| last_frame_point.map(|p| p.blanked()))
                             .unwrap_or_else(RawPoint::centered_blank);
                         interpolated.extend((0..target_points).map(|_| blank_point));
                     }
 
-                    self.raw_points.extend(self.blank_points.drain(..));
+                    self.raw_points.append(&mut self.blank_points);
                     self.raw_points.extend(interpolated);
                 }
 
@@ -626,12 +627,12 @@ impl Requester {
                     .iter()
                     .flat_map(|pt| Some(pt.to_raw()).into_iter().chain(pt.to_raw_weighted()));
 
-                self.raw_points.extend(self.blank_points.drain(..));
+                self.raw_points.append(&mut self.blank_points);
                 self.raw_points.extend(frame_points);
             }
 
             // Update the last frame point.
-            self.last_frame_point = self.raw_points.last().map(|&p| p);
+            self.last_frame_point = self.raw_points.last().copied();
 
             // Write the points to buffer.
             let end = start + std::cmp::min(num_points_to_fill, self.raw_points.len());
diff --git a/nannou_laser/src/stream/raw.rs b/nannou_laser/src/stream/raw.rs
index cef5fc3a0..8d4437b4c 100644
--- a/nannou_laser/src/stream/raw.rs
+++ b/nannou_laser/src/stream/raw.rs
@@ -1,13 +1,15 @@
-use crate::util::{clamp, map_range};
-use crate::Inner as ApiInner;
-use crate::{DetectedDac, RawPoint};
 use std::io;
 use std::ops::{Deref, DerefMut};
 use std::sync::atomic::{self, AtomicBool};
 use std::sync::{mpsc, Arc, Mutex};
 use std::time::Duration;
+
 use thiserror::Error;
 
+use crate::util::{clamp, map_range};
+use crate::Inner as ApiInner;
+use crate::{DetectedDac, RawPoint};
+
 /// The function that will be called when a `Buffer` of points is requested.
 pub trait RenderFn<M>: Fn(&mut M, &mut Buffer) {}
 impl<M, F> RenderFn<M> for F where F: Fn(&mut M, &mut Buffer) {}
@@ -138,7 +140,7 @@ pub enum EtherDreamStreamError {
 }
 
 /// An action to perform in response to a `StreamError` occurring.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Default)]
 pub enum StreamErrorAction {
     /// Attempts to reconnect to the specified DAC in the case that one was provided, or any DAC in
     /// the case that `None` was provided.
@@ -153,6 +155,7 @@ pub enum StreamErrorAction {
         timeout: Option<Duration>,
     },
     /// Close the TCP communication thread and return the error responsible.
+    #[default]
     CloseThread,
 }
 
@@ -459,12 +462,6 @@ impl<M, F, E> Builder<M, F, E> {
     }
 }
 
-impl Default for StreamErrorAction {
-    fn default() -> Self {
-        StreamErrorAction::CloseThread
-    }
-}
-
 impl Deref for Buffer {
     type Target = [RawPoint];
     fn deref(&self) -> &Self::Target {
@@ -606,12 +603,12 @@ where
         match run_laser_stream_tcp_loop(
             &dac,
             tcp_timeout,
-            &state,
-            &model,
+            state,
+            model,
             &render,
-            &state_update_rx,
-            &model_update_rx,
-            &is_closed,
+            state_update_rx,
+            model_update_rx,
+            is_closed,
             &mut connect_attempts,
         ) {
             Ok(()) => break,
@@ -663,10 +660,10 @@ where
     let mut pending_model_updates: Vec<ModelUpdate<M>> = Vec::new();
 
     // Establish the TCP connection.
-    let ip = src_addr.ip().clone();
+    let ip = src_addr.ip();
     let result = match tcp_timeout {
-        None => ether_dream::dac::stream::connect(&broadcast, ip),
-        Some(timeout) => ether_dream::dac::stream::connect_timeout(&broadcast, ip, timeout)
+        None => ether_dream::dac::stream::connect(broadcast, ip),
+        Some(timeout) => ether_dream::dac::stream::connect_timeout(broadcast, ip, timeout)
             .and_then(|stream| {
                 stream.set_timeout(Some(timeout))?;
                 Ok(stream)
diff --git a/nannou_mesh/.gitignore b/nannou_mesh/.gitignore
deleted file mode 100644
index 96ef6c0b9..000000000
--- a/nannou_mesh/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-/target
-Cargo.lock
diff --git a/nannou_mesh/Cargo.toml b/nannou_mesh/Cargo.toml
deleted file mode 100644
index 3f83c7809..000000000
--- a/nannou_mesh/Cargo.toml
+++ /dev/null
@@ -1,17 +0,0 @@
-[package]
-name = "nannou_mesh"
-version ="0.19.0"
-authors = ["mitchmindtree <mail@mitchellnordine.com>"]
-description = "The mesh abstraction shared between nannou's `Draw` and `Ui` abstractions."
-readme = "README.md"
-license = "MIT"
-repository = "https://github.com/nannou-org/nannou.git"
-homepage = "https://nannou.cc"
-edition = "2018"
-
-[dependencies]
-nannou_core = { version ="0.19.0", path = "../nannou_core" }
-serde = { version = "1", optional = true, features = ["derive"] }
-
-[features]
-serde1 = ["nannou_core/serde", "serde"]
diff --git a/nannou_mesh/README.md b/nannou_mesh/README.md
deleted file mode 100644
index 17ceaf648..000000000
--- a/nannou_mesh/README.md
+++ /dev/null
@@ -1,8 +0,0 @@
-# nannou_mesh
-
-An API for composing **Mesh**s shared between `nannou` crates.
-
-**Mesh**s may be composed of different sets of channels including position,
-color, texture-coordinate and normals. Note that this is quite a low-level
-representation. For a higher-level, graphics-related mesh API, see the
-`nannou::draw` module and the `draw.mesh()` API.
diff --git a/nannou_mesh/src/channel.rs b/nannou_mesh/src/channel.rs
deleted file mode 100644
index e459c5d74..000000000
--- a/nannou_mesh/src/channel.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-use std::borrow::{Borrow, Cow};
-
-/// Types that may be used as a data channel within a mesh.
-pub trait Channel {
-    /// The type contained within the channel.
-    type Element;
-    /// Borrow the data channel.
-    fn channel(&self) -> &[Self::Element];
-}
-
-/// Types that may be used as a data channel within a mesh.
-pub trait ChannelMut: Channel {
-    /// Mutably borrow the data channel.
-    fn channel_mut(&mut self) -> &mut [Self::Element];
-}
-
-impl<'a, T> Channel for &'a [T] {
-    type Element = T;
-    #[inline]
-    fn channel(&self) -> &[Self::Element] {
-        self
-    }
-}
-
-impl<'a, T> Channel for &'a mut [T] {
-    type Element = T;
-    #[inline]
-    fn channel(&self) -> &[Self::Element] {
-        self
-    }
-}
-
-impl<'a, T> ChannelMut for &'a mut [T] {
-    #[inline]
-    fn channel_mut(&mut self) -> &mut [Self::Element] {
-        self
-    }
-}
-
-impl<T> Channel for Box<[T]> {
-    type Element = T;
-    #[inline]
-    fn channel(&self) -> &[Self::Element] {
-        &self[..]
-    }
-}
-
-impl<T> ChannelMut for Box<[T]> {
-    #[inline]
-    fn channel_mut(&mut self) -> &mut [Self::Element] {
-        &mut self[..]
-    }
-}
-
-impl<T> Channel for Vec<T> {
-    type Element = T;
-    #[inline]
-    fn channel(&self) -> &[Self::Element] {
-        &self[..]
-    }
-}
-
-impl<T> ChannelMut for Vec<T> {
-    #[inline]
-    fn channel_mut(&mut self) -> &mut [Self::Element] {
-        &mut self[..]
-    }
-}
-
-impl<'a, T> Channel for Cow<'a, [T]>
-where
-    [T]: ToOwned,
-{
-    type Element = T;
-    #[inline]
-    fn channel(&self) -> &[Self::Element] {
-        self.borrow()
-    }
-}
-
-macro_rules! impl_channel_for_arrays {
-    ($($N:expr)*) => {
-        $(
-            impl<T> Channel for [T; $N] {
-                type Element = T;
-                #[inline]
-                fn channel(&self) -> &[Self::Element] {
-                    &self[..]
-                }
-            }
-            impl<T> ChannelMut for [T; $N] {
-                #[inline]
-                fn channel_mut(&mut self) -> &mut [Self::Element] {
-                    &mut self[..]
-                }
-            }
-            // impl<T> FixedSizeArray for [T; $N] {
-            //     const LEN: usize = $N;
-            // }
-        )*
-    };
-}
-
-impl_channel_for_arrays! {
-    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
-    35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65
-    66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96
-    97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120
-    121 122 123 124 125 126 127 128 256 512 1024 2048 4096 8192
-}
diff --git a/nannou_mesh/src/lib.rs b/nannou_mesh/src/lib.rs
deleted file mode 100644
index 3003defba..000000000
--- a/nannou_mesh/src/lib.rs
+++ /dev/null
@@ -1,1573 +0,0 @@
-//! An API for composing **Mesh**s. **Mesh**s may be composed of different sets of channels
-//! including position, color, texture-coordinate and normals. Note that this is quite a low-level
-//! representation. For a higher-level, graphics-related mesh API, see the `draw` module.
-
-use core::cell::{Ref, RefMut};
-use core::cmp;
-use core::convert::{TryFrom, TryInto};
-use core::ops::{self, Deref, DerefMut};
-use nannou_core::geom;
-
-pub mod channel;
-pub mod vertex;
-
-pub use self::channel::{Channel, ChannelMut};
-
-// Traits describing meshes with access to certain channels.
-
-/// Mesh types that can be indexed to produce a vertex.
-pub trait GetVertex<I> {
-    /// The vertex type representing all channels of data within the mesh at a single index.
-    type Vertex;
-    /// Create a vertex containing all channel properties for the given index.
-    fn get_vertex(&self, index: I) -> Option<Self::Vertex>;
-}
-
-/// All meshes must contain at least one vertex channel.
-pub trait Points {
-    /// The vertex type used to represent the location of a vertex.
-    type Point;
-    /// The channel type containing points.
-    type Points: Channel<Element = Self::Point>;
-    /// Borrow the vertex channel from the mesh.
-    fn points(&self) -> &Self::Points;
-}
-
-/// Meshes that contain a channel of indices that describe the edges between points.
-pub trait Indices {
-    /// The type used to index into the vertex buffer.
-    type Index;
-    /// The channel type containing indices.
-    type Indices: Channel<Element = Self::Index>;
-    /// Borrow the index channel from the mesh.
-    fn indices(&self) -> &Self::Indices;
-}
-
-/// Meshes that contain a channel of colors.
-pub trait Colors {
-    /// The color type stored within the channel.
-    type Color;
-    /// The channel type containing colors.
-    type Colors: Channel<Element = Self::Color>;
-    /// Borrow the color channel from the mesh.
-    fn colors(&self) -> &Self::Colors;
-}
-
-/// Meshes that contain a channel of texture coordinates.
-pub trait TexCoords {
-    /// The point type used to represent texture coordinates.
-    type TexCoord;
-    /// The channel type containing texture coordinates.
-    type TexCoords: Channel<Element = Self::TexCoord>;
-    /// Borrow the texture coordinate channel from the mesh.
-    fn tex_coords(&self) -> &Self::TexCoords;
-}
-
-/// Meshes that contain a channel of vertex normals.
-pub trait Normals {
-    /// The vector type used to represent the normal.
-    type Normal;
-    /// The channel type containing vertex normals.
-    type Normals: Channel<Element = Self::Normal>;
-    /// Borrow the normal channel from the mesh.
-    fn normals(&self) -> &Self::Normals;
-}
-
-/// Meshes that can push vertices of type **V** while keeping all non-index channels the same
-/// length before and after the push.
-pub trait PushVertex<V> {
-    /// Push the given vertex onto the mesh.
-    ///
-    /// Implementation requires that all non-index channels maintain the same length before and
-    /// after a call to this method.
-    fn push_vertex(&mut self, vertex: V);
-}
-
-/// Meshes that contain an **Indices** channel and can push new indices to it.
-pub trait PushIndex {
-    /// The inner index type.
-    type Index;
-    /// Push a new index onto the indices channel.
-    fn push_index(&mut self, index: Self::Index);
-    /// Extend the **Mesh**'s **Indices** channel with the given indices.
-    fn extend_indices<I>(&mut self, indices: I)
-    where
-        I: IntoIterator<Item = Self::Index>,
-    {
-        for i in indices {
-            self.push_index(i);
-        }
-    }
-}
-
-/// Meshes whose **Indices** channel can be cleared.
-pub trait ClearIndices {
-    /// Clear all indices from the mesh.
-    fn clear_indices(&mut self);
-}
-
-/// Meshes whose vertices channels can be cleared.
-pub trait ClearVertices {
-    /// Clear all vertices from the mesh.
-    fn clear_vertices(&mut self);
-}
-
-/// Meshes whose indices and vertices buffers may be cleared for re-use.
-pub trait Clear: ClearIndices + ClearVertices {
-    fn clear(&mut self) {
-        self.clear_indices();
-        self.clear_vertices();
-    }
-}
-
-/// Meshes that may be extended from a slice of data.
-pub trait ExtendFromSlice<'a> {
-    /// The slice type expected via the mesh.
-    ///
-    /// Note: This may be multiple combined slices if the mesh contains multiple channels of data.
-    type Slice: 'a;
-    /// Extend the mesh.
-    fn extend_from_slice(&mut self, slice: Self::Slice);
-}
-
-// Mesh types.
-
-/// The base mesh type with only a single vertex channel.
-///
-/// Extra channels can be added to the mesh via the `WithIndices`, `WithColors`, `WithTexCoords`
-/// and `WithNormals` adaptor types.
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub struct MeshPoints<P> {
-    points: P,
-}
-
-/// A mesh type with an added channel containing indices describing the edges between vertices.
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub struct WithIndices<M, I> {
-    mesh: M,
-    indices: I,
-}
-
-/// A `Mesh` type with an added channel containing colors.
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub struct WithColors<M, C> {
-    mesh: M,
-    colors: C,
-}
-
-/// A `Mesh` type with an added channel containing texture coordinates.
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub struct WithTexCoords<M, T> {
-    mesh: M,
-    tex_coords: T,
-}
-
-/// A `Mesh` type with an added channel containing vertex normals.
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub struct WithNormals<M, N> {
-    mesh: M,
-    normals: N,
-}
-
-// **GetVertex** implementations.
-
-impl<'a, M, I> GetVertex<I> for &'a M
-where
-    M: GetVertex<I>,
-{
-    type Vertex = M::Vertex;
-    fn get_vertex(&self, index: I) -> Option<Self::Vertex> {
-        (**self).get_vertex(index)
-    }
-}
-
-impl<'a, M, I> GetVertex<I> for &'a mut M
-where
-    M: GetVertex<I>,
-{
-    type Vertex = M::Vertex;
-    fn get_vertex(&self, index: I) -> Option<Self::Vertex> {
-        (**self).get_vertex(index)
-    }
-}
-
-impl<'a, M, I> GetVertex<I> for Ref<'a, M>
-where
-    M: GetVertex<I>,
-{
-    type Vertex = M::Vertex;
-    fn get_vertex(&self, index: I) -> Option<Self::Vertex> {
-        (**self).get_vertex(index)
-    }
-}
-
-impl<'a, M, I> GetVertex<I> for RefMut<'a, M>
-where
-    M: GetVertex<I>,
-{
-    type Vertex = M::Vertex;
-    fn get_vertex(&self, index: I) -> Option<Self::Vertex> {
-        (**self).get_vertex(index)
-    }
-}
-
-impl<P, I> GetVertex<I> for MeshPoints<P>
-where
-    P: Channel,
-    P::Element: Clone,
-    I: TryInto<usize>,
-{
-    type Vertex = P::Element;
-    fn get_vertex(&self, index: I) -> Option<Self::Vertex> {
-        let index = index
-            .try_into()
-            .unwrap_or_else(|_err| panic!("index out of range of valid `usize` values"));
-        self.points.channel().get(index).map(|p| p.clone())
-    }
-}
-
-impl<M, I, Ix> GetVertex<Ix> for WithIndices<M, I>
-where
-    M: GetVertex<Ix>,
-{
-    type Vertex = M::Vertex;
-    fn get_vertex(&self, index: Ix) -> Option<Self::Vertex> {
-        self.mesh.get_vertex(index)
-    }
-}
-
-impl<M, C, I> GetVertex<I> for WithColors<M, C>
-where
-    M: GetVertex<I>,
-    C: Channel,
-    C::Element: Clone,
-    I: Copy + TryInto<usize>,
-{
-    type Vertex = vertex::WithColor<M::Vertex, C::Element>;
-    fn get_vertex(&self, index: I) -> Option<Self::Vertex> {
-        self.mesh.get_vertex(index).and_then(|vertex| {
-            let index: usize = index
-                .try_into()
-                .unwrap_or_else(|_err| panic!("index out of range of valid usize values"));
-            self.colors.channel().get(index).map(|color: &C::Element| {
-                let color = color.clone();
-                vertex::WithColor { vertex, color }
-            })
-        })
-    }
-}
-
-impl<M, T, I> GetVertex<I> for WithTexCoords<M, T>
-where
-    M: GetVertex<I>,
-    T: Channel,
-    T::Element: Clone,
-    I: Copy + TryInto<usize>,
-{
-    type Vertex = vertex::WithTexCoords<M::Vertex, T::Element>;
-    fn get_vertex(&self, index: I) -> Option<Self::Vertex> {
-        self.mesh.get_vertex(index).and_then(|vertex| {
-            let index: usize = index
-                .try_into()
-                .unwrap_or_else(|_err| panic!("index out of range of valid usize values"));
-            self.tex_coords.channel().get(index).map(|tex_coords| {
-                let tex_coords = tex_coords.clone();
-                vertex::WithTexCoords { vertex, tex_coords }
-            })
-        })
-    }
-}
-
-impl<M, N, I> GetVertex<I> for WithNormals<M, N>
-where
-    M: GetVertex<I>,
-    N: Channel,
-    N::Element: Clone,
-    I: Copy + TryInto<usize>,
-{
-    type Vertex = vertex::WithNormal<M::Vertex, N::Element>;
-    fn get_vertex(&self, index: I) -> Option<Self::Vertex> {
-        self.mesh.get_vertex(index).and_then(|vertex| {
-            let index: usize = index
-                .try_into()
-                .unwrap_or_else(|_err| panic!("index out of range of valid usize values"));
-            self.normals.channel().get(index).map(|normal| {
-                let normal = normal.clone();
-                vertex::WithNormal { vertex, normal }
-            })
-        })
-    }
-}
-
-// **Points** implementations.
-
-impl<P> Points for MeshPoints<P>
-where
-    P: Channel,
-{
-    type Point = P::Element;
-    type Points = P;
-    fn points(&self) -> &Self::Points {
-        &self.points
-    }
-}
-
-impl<'a, M> Points for &'a M
-where
-    M: Points,
-{
-    type Point = M::Point;
-    type Points = M::Points;
-    fn points(&self) -> &Self::Points {
-        (**self).points()
-    }
-}
-
-impl<'a, M> Points for &'a mut M
-where
-    M: Points,
-{
-    type Point = M::Point;
-    type Points = M::Points;
-    fn points(&self) -> &Self::Points {
-        (**self).points()
-    }
-}
-
-impl<'a, M> Points for Ref<'a, M>
-where
-    M: Points,
-{
-    type Point = M::Point;
-    type Points = M::Points;
-    fn points(&self) -> &Self::Points {
-        (**self).points()
-    }
-}
-
-impl<'a, M> Points for RefMut<'a, M>
-where
-    M: Points,
-{
-    type Point = M::Point;
-    type Points = M::Points;
-    fn points(&self) -> &Self::Points {
-        (**self).points()
-    }
-}
-
-impl<M, I> Points for WithIndices<M, I>
-where
-    M: Points,
-{
-    type Point = M::Point;
-    type Points = M::Points;
-    fn points(&self) -> &Self::Points {
-        self.mesh.points()
-    }
-}
-
-impl<M, C> Points for WithColors<M, C>
-where
-    M: Points,
-{
-    type Point = M::Point;
-    type Points = M::Points;
-    fn points(&self) -> &Self::Points {
-        self.mesh.points()
-    }
-}
-
-impl<M, T> Points for WithTexCoords<M, T>
-where
-    M: Points,
-{
-    type Point = M::Point;
-    type Points = M::Points;
-    fn points(&self) -> &Self::Points {
-        self.mesh.points()
-    }
-}
-
-impl<M, N> Points for WithNormals<M, N>
-where
-    M: Points,
-{
-    type Point = M::Point;
-    type Points = M::Points;
-    fn points(&self) -> &Self::Points {
-        self.mesh.points()
-    }
-}
-
-// **Indices** implementations.
-
-impl<M, I> Indices for WithIndices<M, I>
-where
-    I: Channel,
-{
-    type Index = I::Element;
-    type Indices = I;
-    fn indices(&self) -> &Self::Indices {
-        &self.indices
-    }
-}
-
-impl<'a, M> Indices for &'a M
-where
-    M: Indices,
-{
-    type Index = M::Index;
-    type Indices = M::Indices;
-    fn indices(&self) -> &Self::Indices {
-        (**self).indices()
-    }
-}
-
-impl<'a, M> Indices for &'a mut M
-where
-    M: Indices,
-{
-    type Index = M::Index;
-    type Indices = M::Indices;
-    fn indices(&self) -> &Self::Indices {
-        (**self).indices()
-    }
-}
-
-impl<'a, M> Indices for Ref<'a, M>
-where
-    M: Indices,
-{
-    type Index = M::Index;
-    type Indices = M::Indices;
-    fn indices(&self) -> &Self::Indices {
-        (**self).indices()
-    }
-}
-
-impl<'a, M> Indices for RefMut<'a, M>
-where
-    M: Indices,
-{
-    type Index = M::Index;
-    type Indices = M::Indices;
-    fn indices(&self) -> &Self::Indices {
-        (**self).indices()
-    }
-}
-
-impl<M, C> Indices for WithColors<M, C>
-where
-    M: Indices,
-{
-    type Index = M::Index;
-    type Indices = M::Indices;
-    fn indices(&self) -> &Self::Indices {
-        self.mesh.indices()
-    }
-}
-
-impl<M, T> Indices for WithTexCoords<M, T>
-where
-    M: Indices,
-{
-    type Index = M::Index;
-    type Indices = M::Indices;
-    fn indices(&self) -> &Self::Indices {
-        self.mesh.indices()
-    }
-}
-
-impl<M, N> Indices for WithNormals<M, N>
-where
-    M: Indices,
-{
-    type Index = M::Index;
-    type Indices = M::Indices;
-    fn indices(&self) -> &Self::Indices {
-        self.mesh.indices()
-    }
-}
-
-// **Colors** implementations.
-
-impl<M, C> Colors for WithColors<M, C>
-where
-    C: Channel,
-{
-    type Color = C::Element;
-    type Colors = C;
-    fn colors(&self) -> &Self::Colors {
-        &self.colors
-    }
-}
-
-impl<'a, M> Colors for &'a M
-where
-    M: Colors,
-{
-    type Color = M::Color;
-    type Colors = M::Colors;
-    fn colors(&self) -> &Self::Colors {
-        (**self).colors()
-    }
-}
-
-impl<'a, M> Colors for &'a mut M
-where
-    M: Colors,
-{
-    type Color = M::Color;
-    type Colors = M::Colors;
-    fn colors(&self) -> &Self::Colors {
-        (**self).colors()
-    }
-}
-
-impl<'a, M> Colors for Ref<'a, M>
-where
-    M: Colors,
-{
-    type Color = M::Color;
-    type Colors = M::Colors;
-    fn colors(&self) -> &Self::Colors {
-        (**self).colors()
-    }
-}
-
-impl<'a, M> Colors for RefMut<'a, M>
-where
-    M: Colors,
-{
-    type Color = M::Color;
-    type Colors = M::Colors;
-    fn colors(&self) -> &Self::Colors {
-        (**self).colors()
-    }
-}
-
-impl<M, I> Colors for WithIndices<M, I>
-where
-    M: Colors,
-{
-    type Color = M::Color;
-    type Colors = M::Colors;
-    fn colors(&self) -> &Self::Colors {
-        self.mesh.colors()
-    }
-}
-
-impl<M, T> Colors for WithTexCoords<M, T>
-where
-    M: Colors,
-{
-    type Color = M::Color;
-    type Colors = M::Colors;
-    fn colors(&self) -> &Self::Colors {
-        self.mesh.colors()
-    }
-}
-
-impl<M, N> Colors for WithNormals<M, N>
-where
-    M: Colors,
-{
-    type Color = M::Color;
-    type Colors = M::Colors;
-    fn colors(&self) -> &Self::Colors {
-        self.mesh.colors()
-    }
-}
-
-// **TexCoords** implementations.
-
-impl<M, T> TexCoords for WithTexCoords<M, T>
-where
-    T: Channel,
-{
-    type TexCoord = T::Element;
-    type TexCoords = T;
-    fn tex_coords(&self) -> &Self::TexCoords {
-        &self.tex_coords
-    }
-}
-
-impl<'a, M> TexCoords for &'a M
-where
-    M: TexCoords,
-{
-    type TexCoord = M::TexCoord;
-    type TexCoords = M::TexCoords;
-    fn tex_coords(&self) -> &Self::TexCoords {
-        (**self).tex_coords()
-    }
-}
-
-impl<'a, M> TexCoords for &'a mut M
-where
-    M: TexCoords,
-{
-    type TexCoord = M::TexCoord;
-    type TexCoords = M::TexCoords;
-    fn tex_coords(&self) -> &Self::TexCoords {
-        (**self).tex_coords()
-    }
-}
-
-impl<'a, M> TexCoords for Ref<'a, M>
-where
-    M: TexCoords,
-{
-    type TexCoord = M::TexCoord;
-    type TexCoords = M::TexCoords;
-    fn tex_coords(&self) -> &Self::TexCoords {
-        (**self).tex_coords()
-    }
-}
-
-impl<'a, M> TexCoords for RefMut<'a, M>
-where
-    M: TexCoords,
-{
-    type TexCoord = M::TexCoord;
-    type TexCoords = M::TexCoords;
-    fn tex_coords(&self) -> &Self::TexCoords {
-        (**self).tex_coords()
-    }
-}
-
-impl<M, I> TexCoords for WithIndices<M, I>
-where
-    M: TexCoords,
-{
-    type TexCoord = M::TexCoord;
-    type TexCoords = M::TexCoords;
-    fn tex_coords(&self) -> &Self::TexCoords {
-        self.mesh.tex_coords()
-    }
-}
-
-impl<M, C> TexCoords for WithColors<M, C>
-where
-    M: TexCoords,
-{
-    type TexCoord = M::TexCoord;
-    type TexCoords = M::TexCoords;
-    fn tex_coords(&self) -> &Self::TexCoords {
-        self.mesh.tex_coords()
-    }
-}
-
-impl<M, N> TexCoords for WithNormals<M, N>
-where
-    M: TexCoords,
-{
-    type TexCoord = M::TexCoord;
-    type TexCoords = M::TexCoords;
-    fn tex_coords(&self) -> &Self::TexCoords {
-        self.mesh.tex_coords()
-    }
-}
-
-// **Normals** implementations.
-
-impl<M, N> Normals for WithNormals<M, N>
-where
-    M: Points,
-    N: Channel,
-{
-    type Normal = N::Element;
-    type Normals = N;
-    fn normals(&self) -> &Self::Normals {
-        &self.normals
-    }
-}
-
-impl<'a, M> Normals for &'a M
-where
-    M: Normals,
-{
-    type Normal = M::Normal;
-    type Normals = M::Normals;
-    fn normals(&self) -> &Self::Normals {
-        (**self).normals()
-    }
-}
-
-impl<'a, M> Normals for &'a mut M
-where
-    M: Normals,
-{
-    type Normal = M::Normal;
-    type Normals = M::Normals;
-    fn normals(&self) -> &Self::Normals {
-        (**self).normals()
-    }
-}
-
-impl<'a, M> Normals for Ref<'a, M>
-where
-    M: Normals,
-{
-    type Normal = M::Normal;
-    type Normals = M::Normals;
-    fn normals(&self) -> &Self::Normals {
-        (**self).normals()
-    }
-}
-
-impl<'a, M> Normals for RefMut<'a, M>
-where
-    M: Normals,
-{
-    type Normal = M::Normal;
-    type Normals = M::Normals;
-    fn normals(&self) -> &Self::Normals {
-        (**self).normals()
-    }
-}
-
-impl<M, I> Normals for WithIndices<M, I>
-where
-    M: Normals,
-{
-    type Normal = M::Normal;
-    type Normals = M::Normals;
-    fn normals(&self) -> &Self::Normals {
-        self.mesh.normals()
-    }
-}
-
-impl<M, C> Normals for WithColors<M, C>
-where
-    M: Normals,
-{
-    type Normal = M::Normal;
-    type Normals = M::Normals;
-    fn normals(&self) -> &Self::Normals {
-        self.mesh.normals()
-    }
-}
-
-impl<M, T> Normals for WithTexCoords<M, T>
-where
-    M: Normals,
-{
-    type Normal = M::Normal;
-    type Normals = M::Normals;
-    fn normals(&self) -> &Self::Normals {
-        self.mesh.normals()
-    }
-}
-
-// PushVertex implementations for each mesh type where the channels are **Vec**s.
-
-impl<'a, M, V> PushVertex<V> for &'a mut M
-where
-    M: PushVertex<V>,
-{
-    fn push_vertex(&mut self, v: V) {
-        (**self).push_vertex(v)
-    }
-}
-
-impl<'a, M, V> PushVertex<V> for RefMut<'a, M>
-where
-    M: PushVertex<V>,
-{
-    fn push_vertex(&mut self, v: V) {
-        (**self).push_vertex(v)
-    }
-}
-
-impl<V> PushVertex<V> for MeshPoints<Vec<V>> {
-    fn push_vertex(&mut self, v: V) {
-        self.points.push(v);
-    }
-}
-
-impl<M, I, V> PushVertex<V> for WithIndices<M, Vec<I>>
-where
-    M: PushVertex<V>,
-{
-    fn push_vertex(&mut self, v: V) {
-        self.mesh.push_vertex(v);
-    }
-}
-
-impl<M, V, C> PushVertex<vertex::WithColor<V, C>> for WithColors<M, Vec<C>>
-where
-    M: PushVertex<V>,
-{
-    fn push_vertex(&mut self, v: vertex::WithColor<V, C>) {
-        let vertex::WithColor { vertex, color } = v;
-        self.colors.push(color);
-        self.mesh.push_vertex(vertex);
-    }
-}
-
-impl<M, V, T> PushVertex<vertex::WithTexCoords<V, T>> for WithTexCoords<M, Vec<T>>
-where
-    M: PushVertex<V>,
-{
-    fn push_vertex(&mut self, v: vertex::WithTexCoords<V, T>) {
-        let vertex::WithTexCoords { vertex, tex_coords } = v;
-        self.tex_coords.push(tex_coords);
-        self.mesh.push_vertex(vertex);
-    }
-}
-
-impl<M, V, N> PushVertex<vertex::WithNormal<V, N>> for WithNormals<M, Vec<N>>
-where
-    M: PushVertex<V>,
-{
-    fn push_vertex(&mut self, v: vertex::WithNormal<V, N>) {
-        let vertex::WithNormal { vertex, normal } = v;
-        self.normals.push(normal);
-        self.mesh.push_vertex(vertex);
-    }
-}
-
-// PushIndex implementations for meshes.
-
-impl<'a, M> PushIndex for &'a mut M
-where
-    M: PushIndex,
-{
-    type Index = M::Index;
-    fn push_index(&mut self, index: Self::Index) {
-        (**self).push_index(index);
-    }
-    fn extend_indices<I>(&mut self, indices: I)
-    where
-        I: IntoIterator<Item = Self::Index>,
-    {
-        (**self).extend_indices(indices);
-    }
-}
-
-impl<'a, M> PushIndex for RefMut<'a, M>
-where
-    M: PushIndex,
-{
-    type Index = M::Index;
-    fn push_index(&mut self, index: Self::Index) {
-        (**self).push_index(index);
-    }
-    fn extend_indices<I>(&mut self, indices: I)
-    where
-        I: IntoIterator<Item = Self::Index>,
-    {
-        (**self).extend_indices(indices);
-    }
-}
-
-impl<M, I> PushIndex for WithIndices<M, Vec<I>> {
-    type Index = I;
-
-    fn push_index(&mut self, index: Self::Index) {
-        self.indices.push(index);
-    }
-
-    fn extend_indices<It>(&mut self, indices: It)
-    where
-        It: IntoIterator<Item = Self::Index>,
-    {
-        self.indices.extend(indices);
-    }
-}
-
-impl<M, C> PushIndex for WithColors<M, C>
-where
-    M: PushIndex,
-{
-    type Index = M::Index;
-
-    fn push_index(&mut self, index: Self::Index) {
-        self.mesh.push_index(index);
-    }
-
-    fn extend_indices<I>(&mut self, indices: I)
-    where
-        I: IntoIterator<Item = Self::Index>,
-    {
-        self.mesh.extend_indices(indices);
-    }
-}
-
-impl<M, T> PushIndex for WithTexCoords<M, T>
-where
-    M: PushIndex,
-{
-    type Index = M::Index;
-
-    fn push_index(&mut self, index: Self::Index) {
-        self.mesh.push_index(index);
-    }
-
-    fn extend_indices<I>(&mut self, indices: I)
-    where
-        I: IntoIterator<Item = Self::Index>,
-    {
-        self.mesh.extend_indices(indices);
-    }
-}
-
-impl<M, N> PushIndex for WithNormals<M, N>
-where
-    M: PushIndex,
-{
-    type Index = M::Index;
-
-    fn push_index(&mut self, index: M::Index) {
-        self.mesh.push_index(index);
-    }
-
-    fn extend_indices<I>(&mut self, indices: I)
-    where
-        I: IntoIterator<Item = M::Index>,
-    {
-        self.mesh.extend_indices(indices);
-    }
-}
-
-// **ClearIndices** implementations
-
-impl<'a, M> ClearIndices for &'a mut M
-where
-    M: ClearIndices,
-{
-    fn clear_indices(&mut self) {
-        (**self).clear_indices();
-    }
-}
-
-impl<'a, M> ClearIndices for RefMut<'a, M>
-where
-    M: ClearIndices,
-{
-    fn clear_indices(&mut self) {
-        (**self).clear_indices();
-    }
-}
-
-impl<M, I> ClearIndices for WithIndices<M, Vec<I>> {
-    fn clear_indices(&mut self) {
-        self.indices.clear();
-    }
-}
-
-impl<M, C> ClearIndices for WithColors<M, C>
-where
-    M: ClearIndices,
-{
-    fn clear_indices(&mut self) {
-        self.mesh.clear_indices();
-    }
-}
-
-impl<M, T> ClearIndices for WithTexCoords<M, T>
-where
-    M: ClearIndices,
-{
-    fn clear_indices(&mut self) {
-        self.mesh.clear_indices();
-    }
-}
-
-impl<M, N> ClearIndices for WithNormals<M, N>
-where
-    M: ClearIndices,
-{
-    fn clear_indices(&mut self) {
-        self.mesh.clear_indices();
-    }
-}
-
-// **ClearVertices** implementations
-
-impl<'a, M> ClearVertices for &'a mut M
-where
-    M: ClearVertices,
-{
-    fn clear_vertices(&mut self) {
-        (**self).clear_vertices()
-    }
-}
-
-impl<'a, M> ClearVertices for RefMut<'a, M>
-where
-    M: ClearVertices,
-{
-    fn clear_vertices(&mut self) {
-        (**self).clear_vertices()
-    }
-}
-
-impl<V> ClearVertices for MeshPoints<Vec<V>> {
-    fn clear_vertices(&mut self) {
-        self.points.clear();
-    }
-}
-
-impl<M, I> ClearVertices for WithIndices<M, Vec<I>>
-where
-    M: ClearVertices,
-{
-    fn clear_vertices(&mut self) {
-        self.mesh.clear_vertices();
-        self.indices.clear();
-    }
-}
-
-impl<M, C> ClearVertices for WithColors<M, Vec<C>>
-where
-    M: ClearVertices,
-{
-    fn clear_vertices(&mut self) {
-        self.mesh.clear_vertices();
-        self.colors.clear();
-    }
-}
-
-impl<M, T> ClearVertices for WithTexCoords<M, Vec<T>>
-where
-    M: ClearVertices,
-{
-    fn clear_vertices(&mut self) {
-        self.mesh.clear_vertices();
-        self.tex_coords.clear();
-    }
-}
-
-impl<M, N> ClearVertices for WithNormals<M, Vec<N>>
-where
-    M: ClearVertices,
-{
-    fn clear_vertices(&mut self) {
-        self.mesh.clear_vertices();
-        self.normals.clear();
-    }
-}
-
-// **ExtendFromSlice** implementations
-
-impl<'a, P> ExtendFromSlice<'a> for MeshPoints<Vec<P>>
-where
-    P: 'a + Clone,
-{
-    type Slice = &'a [P];
-    fn extend_from_slice(&mut self, slice: Self::Slice) {
-        self.points.extend_from_slice(slice);
-    }
-}
-
-impl<'a, M, I> ExtendFromSlice<'a> for WithIndices<M, Vec<I>>
-where
-    M: ExtendFromSlice<'a>,
-    I: 'a + Clone,
-{
-    type Slice = (&'a [I], M::Slice);
-    fn extend_from_slice(&mut self, slice: Self::Slice) {
-        let (slice, inner) = slice;
-        self.mesh.extend_from_slice(inner);
-        self.indices.extend_from_slice(slice);
-    }
-}
-
-impl<'a, M, C> ExtendFromSlice<'a> for WithColors<M, Vec<C>>
-where
-    M: ExtendFromSlice<'a>,
-    C: 'a + Clone,
-{
-    type Slice = (&'a [C], M::Slice);
-    fn extend_from_slice(&mut self, slice: Self::Slice) {
-        let (slice, inner) = slice;
-        self.mesh.extend_from_slice(inner);
-        self.colors.extend_from_slice(slice);
-    }
-}
-
-impl<'a, M, T> ExtendFromSlice<'a> for WithTexCoords<M, Vec<T>>
-where
-    M: ExtendFromSlice<'a>,
-    T: 'a + Clone,
-{
-    type Slice = (&'a [T], M::Slice);
-    fn extend_from_slice(&mut self, slice: Self::Slice) {
-        let (slice, inner) = slice;
-        self.mesh.extend_from_slice(inner);
-        self.tex_coords.extend_from_slice(slice);
-    }
-}
-
-impl<'a, M, N> ExtendFromSlice<'a> for WithNormals<M, Vec<N>>
-where
-    M: ExtendFromSlice<'a>,
-    N: 'a + Clone,
-{
-    type Slice = (&'a [N], M::Slice);
-    fn extend_from_slice(&mut self, slice: Self::Slice) {
-        let (slice, inner) = slice;
-        self.mesh.extend_from_slice(inner);
-        self.normals.extend_from_slice(slice);
-    }
-}
-
-// **Clear** implementation for all meshes.
-
-impl<T> Clear for T where T: ClearIndices + ClearVertices {}
-
-// **Default** implementations for all meshes.
-
-impl<P> Default for MeshPoints<P>
-where
-    P: Default,
-{
-    fn default() -> Self {
-        let points = Default::default();
-        MeshPoints { points }
-    }
-}
-
-impl<M, I> Default for WithIndices<M, I>
-where
-    M: Default,
-    I: Default,
-{
-    fn default() -> Self {
-        let mesh = Default::default();
-        let indices = Default::default();
-        WithIndices { mesh, indices }
-    }
-}
-
-impl<M, C> Default for WithColors<M, C>
-where
-    M: Default,
-    C: Default,
-{
-    fn default() -> Self {
-        let mesh = Default::default();
-        let colors = Default::default();
-        WithColors { mesh, colors }
-    }
-}
-
-impl<M, T> Default for WithTexCoords<M, T>
-where
-    M: Default,
-    T: Default,
-{
-    fn default() -> Self {
-        let mesh = Default::default();
-        let tex_coords = Default::default();
-        WithTexCoords { mesh, tex_coords }
-    }
-}
-
-impl<M, N> Default for WithNormals<M, N>
-where
-    M: Default,
-    N: Default,
-{
-    fn default() -> Self {
-        let mesh = Default::default();
-        let normals = Default::default();
-        WithNormals { mesh, normals }
-    }
-}
-
-// Deref implementations for the mesh adaptor types to their inner mesh.
-
-impl<M, I> Deref for WithIndices<M, I> {
-    type Target = M;
-    fn deref(&self) -> &Self::Target {
-        &self.mesh
-    }
-}
-
-impl<M, I> DerefMut for WithIndices<M, I> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.mesh
-    }
-}
-
-impl<M, C> Deref for WithColors<M, C> {
-    type Target = M;
-    fn deref(&self) -> &Self::Target {
-        &self.mesh
-    }
-}
-
-impl<M, C> DerefMut for WithColors<M, C> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.mesh
-    }
-}
-
-impl<M, T> Deref for WithTexCoords<M, T> {
-    type Target = M;
-    fn deref(&self) -> &Self::Target {
-        &self.mesh
-    }
-}
-
-impl<M, T> DerefMut for WithTexCoords<M, T> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.mesh
-    }
-}
-
-impl<M, N> Deref for WithNormals<M, N> {
-    type Target = M;
-    fn deref(&self) -> &Self::Target {
-        &self.mesh
-    }
-}
-
-impl<M, N> DerefMut for WithNormals<M, N> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.mesh
-    }
-}
-
-// Mesh length functions.
-
-/// Get the number of vertices in the mesh.
-pub fn raw_vertex_count<M>(mesh: M) -> usize
-where
-    M: Points,
-{
-    mesh.points().channel().len()
-}
-
-/// The number of vertices that would be yielded by a **Vertices** iterator for the given mesh.
-pub fn vertex_count<M>(mesh: M) -> usize
-where
-    M: Indices,
-{
-    mesh.indices().channel().len()
-}
-
-/// The number of triangles that would be yielded by a **Triangles** iterator for the given mesh.
-pub fn triangle_count<M>(mesh: M) -> usize
-where
-    M: Indices,
-{
-    vertex_count(mesh) / geom::tri::NUM_VERTICES as usize
-}
-
-// Mesh constructors.
-
-/// Create a simple base mesh from the given channel of vertex points.
-pub fn from_points<P>(points: P) -> MeshPoints<P>
-where
-    P: Channel,
-{
-    MeshPoints { points }
-}
-
-/// Combine the given mesh with the given channel of vertex indices.
-pub fn with_indices<M, I, Ix>(mesh: M, indices: I) -> WithIndices<M, I>
-where
-    M: GetVertex<Ix>,
-    I: Channel<Element = Ix>,
-{
-    WithIndices { mesh, indices }
-}
-
-/// Combine the given mesh with the given channel of vertex colors.
-///
-/// **Panics** if the length of the **colors** channel differs from **points**.
-pub fn with_colors<M, C>(mesh: M, colors: C) -> WithColors<M, C>
-where
-    M: Points,
-    C: Channel,
-{
-    assert_eq!(raw_vertex_count(&mesh), colors.channel().len());
-    WithColors { mesh, colors }
-}
-
-/// Combine the given mesh with the given channel of vertex texture coordinates.
-///
-/// **Panics** if the length of the **tex_coords** channel differs from **points**.
-pub fn with_tex_coords<M, T>(mesh: M, tex_coords: T) -> WithTexCoords<M, T>
-where
-    M: Points,
-    T: Channel,
-{
-    assert_eq!(raw_vertex_count(&mesh), tex_coords.channel().len());
-    WithTexCoords { mesh, tex_coords }
-}
-
-/// Combine the given mesh with the given **Normals** channel.
-///
-/// **Panics** if the length of the **normals** channel differs from **points**.
-pub fn with_normals<M, N>(mesh: M, normals: N) -> WithNormals<M, N>
-where
-    M: Points,
-    N: Channel,
-{
-    assert_eq!(raw_vertex_count(&mesh), normals.channel().len());
-    WithNormals { mesh, normals }
-}
-
-// Mesh mutation functions.
-
-/// Push the given vertex to the given `mesh`.
-///
-/// The lengths of all non-index channels within the mesh should remain equal before and after a
-/// call to this function.
-pub fn push_vertex<M, V>(mut mesh: M, vertex: V)
-where
-    M: PushVertex<V>,
-{
-    mesh.push_vertex(vertex);
-}
-
-/// Extend the given **mesh** with the given sequence of **vertices**.
-///
-/// The lengths of all non-index channels within the mesh should remain equal before and after a
-/// call to this function.
-pub fn extend_vertices<M, I>(mut mesh: M, vertices: I)
-where
-    M: PushVertex<I::Item>,
-    I: IntoIterator,
-{
-    for v in vertices {
-        push_vertex(&mut mesh, v);
-    }
-}
-
-/// Push the given index to the given `mesh`.
-pub fn push_index<M>(mut mesh: M, index: M::Index)
-where
-    M: PushIndex,
-{
-    mesh.push_index(index);
-}
-
-/// Extend the given mesh with the given indices.
-pub fn extend_indices<M, I>(mut mesh: M, indices: I)
-where
-    M: PushIndex,
-    I: IntoIterator<Item = M::Index>,
-{
-    mesh.extend_indices(indices);
-}
-
-/// Clear all vertices from the mesh.
-pub fn clear_vertices<M>(mut mesh: M)
-where
-    M: ClearVertices,
-{
-    mesh.clear_vertices();
-}
-
-/// Clear all indices from the mesh.
-pub fn clear_indices<M>(mut mesh: M)
-where
-    M: ClearIndices,
-{
-    mesh.clear_indices();
-}
-
-/// Clear all vertices and indices from the mesh.
-pub fn clear<M>(mut mesh: M)
-where
-    M: Clear,
-{
-    mesh.clear();
-}
-
-// Mesh iterators.
-
-/// An iterator yielding the raw vertices (with combined channels) of a mesh.
-///
-/// Requires that the mesh implements **GetVertex**.
-///
-/// Returns `None` when the inner mesh first returns `None` for a call to **GetVertex::get_vertex**.
-#[derive(Clone, Debug)]
-pub struct RawVertices<M> {
-    range: ops::Range<usize>,
-    mesh: M,
-}
-
-/// An iterator yielding vertices in the order specified via the mesh's **Indices** channel.
-///
-/// Requires that the mesh implements **Indices** and **GetVertex**.
-///
-/// Returns `None` when a vertex has been yielded for every index in the **Indices** channel.
-///
-/// **Panics** if the **Indices** channel produces an index that is out of bounds of the mesh's
-/// vertices.
-#[derive(Clone, Debug)]
-pub struct Vertices<M> {
-    index_range: ops::Range<usize>,
-    mesh: M,
-}
-
-/// An iterator yielding triangles in the order specified via the mesh's **Indices** channel.
-///
-/// Requires that the mesh implements **Indices** and **GetVertex**.
-///
-/// **Panics** if the **Indices** channel produces an index that is out of bounds of the mesh's
-pub type Triangles<M> = geom::tri::IterFromVertices<Vertices<M>>;
-
-/// An iterator yielding the raw vertices (with combined channels) of a mesh.
-///
-/// Requires that the inner mesh implements **GetVertex**.
-///
-/// Returns `None` when the inner mesh first returns `None` for a call to **GetVertex::get_vertex**.
-pub fn raw_vertices<M>(mesh: M) -> RawVertices<M>
-where
-    M: Points,
-{
-    let len = raw_vertex_count(&mesh);
-    let range = 0..len;
-    RawVertices { range, mesh }
-}
-
-/// Produce an iterator yielding vertices in the order specified via the mesh's **Indices**
-/// channel.
-///
-/// Requires that the mesh implements **Indices** and **GetVertex**.
-///
-/// Returns `None` when a vertex has been yielded for every index in the **Indices** channel.
-///
-/// **Panics** if the **Indices** channel produces an index that is out of bounds of the mesh's
-/// vertices.
-pub fn vertices<M, I>(mesh: M) -> Vertices<M>
-where
-    M: Indices<Index = I> + GetVertex<I>,
-    I: TryFrom<usize>,
-{
-    let len = mesh.indices().channel().len();
-    let index_range = 0..len;
-    Vertices { index_range, mesh }
-}
-
-/// Produce an iterator yielding triangles for every three vertices yielded in the order specified
-/// via the mesh's **Indices** channel.
-///
-/// Requires that the mesh implements **Indices** and **GetVertex**.
-///
-/// Returns `None` when there are no longer enough vertex indices to produce a triangle.
-///
-/// **Panics** if the **Indices** channel produces an index that is out of bounds of the mesh's
-/// vertices.
-pub fn triangles<M, I>(mesh: M) -> Triangles<M>
-where
-    M: Indices<Index = I> + GetVertex<I>,
-    I: Copy + TryFrom<usize>,
-{
-    geom::tri::iter_from_vertices(vertices(mesh))
-}
-
-// The error message produced when the `Vertices` iterator panics due to an out of bound index.
-const NO_VERTEX_FOR_INDEX: &'static str =
-    "no vertex for the index produced by the mesh's indices channel";
-
-impl<M> RawVertices<M> {
-    /// Specify a range of raw vertices to yield.
-    pub fn range(mut self, range: ops::Range<usize>) -> Self {
-        self.range = range;
-        self
-    }
-}
-
-impl<M> Vertices<M>
-where
-    M: Indices,
-{
-    /// Specify the range of vertex indices to yield vertices from.
-    pub fn index_range(mut self, range: ops::Range<usize>) -> Self {
-        self.index_range = range;
-        self
-    }
-
-    /// Convert this iterator yielding vertices into an iterator yielding triangles for every three
-    /// vertices yielded.
-    pub fn triangles<I>(self) -> Triangles<M>
-    where
-        M: Indices<Index = I> + GetVertex<I>,
-        I: Copy,
-    {
-        geom::tri::iter_from_vertices(self)
-    }
-}
-
-impl<M> Iterator for RawVertices<M>
-where
-    M: GetVertex<usize>,
-{
-    type Item = M::Vertex;
-    fn next(&mut self) -> Option<Self::Item> {
-        if let Some(vertex) = self.range.next().and_then(|i| self.mesh.get_vertex(i)) {
-            return Some(vertex);
-        }
-        None
-    }
-}
-
-impl<M, I> Iterator for Vertices<M>
-where
-    M: Indices<Index = I> + GetVertex<I>,
-    I: Copy,
-{
-    type Item = M::Vertex;
-    fn next(&mut self) -> Option<Self::Item> {
-        if let Some(i) = self.index_range.next() {
-            if let Some(&index) = self.mesh.indices().channel().get(i) {
-                let vertex = self.mesh.get_vertex(index).expect(NO_VERTEX_FOR_INDEX);
-                return Some(vertex);
-            }
-        }
-        None
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let len = self.len();
-        (len, Some(len))
-    }
-}
-
-impl<M> ExactSizeIterator for RawVertices<M>
-where
-    M: GetVertex<usize>,
-{
-    fn len(&self) -> usize {
-        self.range.len()
-    }
-}
-
-impl<M, I> DoubleEndedIterator for Vertices<M>
-where
-    M: Indices<Index = I> + GetVertex<I>,
-    I: Copy,
-{
-    fn next_back(&mut self) -> Option<Self::Item> {
-        if let Some(i) = self.index_range.next_back() {
-            if let Some(&index) = self.mesh.indices().channel().get(i) {
-                let vertex = self.mesh.get_vertex(index).expect(NO_VERTEX_FOR_INDEX);
-                return Some(vertex);
-            }
-        }
-        None
-    }
-}
-
-impl<M, I> ExactSizeIterator for Vertices<M>
-where
-    M: Indices<Index = I> + GetVertex<I>,
-    I: Copy,
-{
-    fn len(&self) -> usize {
-        let indices_len = self.mesh.indices().channel().len();
-        let remaining_indices = indices_len - self.index_range.start;
-        let range_len = self.index_range.len();
-        cmp::min(remaining_indices, range_len)
-    }
-}
diff --git a/nannou_mesh/src/vertex.rs b/nannou_mesh/src/vertex.rs
deleted file mode 100644
index 3f06dc6d9..000000000
--- a/nannou_mesh/src/vertex.rs
+++ /dev/null
@@ -1,206 +0,0 @@
-//! Vertex types yielded by the mesh adaptors and their implementations.
-
-use core::ops::{Deref, DerefMut};
-use nannou_core::color::{self, IntoLinSrgba};
-use nannou_core::geom::{self, Point2};
-
-#[cfg(feature = "serde1")]
-use serde::{Deserialize, Serialize};
-
-/// A vertex with a specified color.
-#[derive(Copy, Clone, Debug, Default, PartialEq)]
-#[cfg_attr(feature = "serde1", derive(Deserialize, Serialize))]
-pub struct WithColor<V, C = color::LinSrgba<color::DefaultScalar>> {
-    pub vertex: V,
-    pub color: C,
-}
-
-/// A vertex with some specified texture coordinates.
-#[derive(Copy, Clone, Debug, Default, PartialEq)]
-#[cfg_attr(feature = "serde1", derive(Deserialize, Serialize))]
-pub struct WithTexCoords<V, T = Point2> {
-    pub vertex: V,
-    pub tex_coords: T,
-}
-
-/// A vertex with its normal vector.
-#[derive(Copy, Clone, Debug, Default, PartialEq)]
-#[cfg_attr(feature = "serde1", derive(Deserialize, Serialize))]
-pub struct WithNormal<V, N = geom::vertex::Default> {
-    pub vertex: V,
-    pub normal: N,
-}
-
-// Deref implementations for each vertex adaptor to their inner vertex type.
-
-impl<V, C> Deref for WithColor<V, C> {
-    type Target = V;
-    fn deref(&self) -> &Self::Target {
-        &self.vertex
-    }
-}
-
-impl<V, C> DerefMut for WithColor<V, C> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.vertex
-    }
-}
-
-impl<V, T> Deref for WithTexCoords<V, T> {
-    type Target = V;
-    fn deref(&self) -> &Self::Target {
-        &self.vertex
-    }
-}
-
-impl<V, T> DerefMut for WithTexCoords<V, T> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.vertex
-    }
-}
-
-impl<V, N> Deref for WithNormal<V, N> {
-    type Target = V;
-    fn deref(&self) -> &Self::Target {
-        &self.vertex
-    }
-}
-
-impl<V, N> DerefMut for WithNormal<V, N> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.vertex
-    }
-}
-
-// Geometry vertex implementations.
-
-impl<V, C> geom::Vertex for WithColor<V, C>
-where
-    V: geom::Vertex,
-    C: Clone + Copy + PartialEq,
-{
-    type Scalar = V::Scalar;
-}
-
-impl<V, T> geom::Vertex for WithTexCoords<V, T>
-where
-    V: geom::Vertex,
-    T: Clone + Copy + PartialEq,
-{
-    type Scalar = V::Scalar;
-}
-
-impl<V, N> geom::Vertex for WithNormal<V, N>
-where
-    V: geom::Vertex,
-    N: Clone + Copy + PartialEq,
-{
-    type Scalar = V::Scalar;
-}
-
-impl<V, C> geom::Vertex2d for WithColor<V, C>
-where
-    V: geom::Vertex2d,
-    Self: geom::Vertex<Scalar = V::Scalar>,
-{
-    fn point2(self) -> [Self::Scalar; 2] {
-        self.vertex.point2()
-    }
-}
-
-impl<V, T> geom::Vertex2d for WithTexCoords<V, T>
-where
-    V: geom::Vertex2d,
-    Self: geom::Vertex<Scalar = V::Scalar>,
-{
-    fn point2(self) -> [Self::Scalar; 2] {
-        self.vertex.point2()
-    }
-}
-
-impl<V, N> geom::Vertex2d for WithNormal<V, N>
-where
-    V: geom::Vertex2d,
-    Self: geom::Vertex<Scalar = V::Scalar>,
-{
-    fn point2(self) -> [Self::Scalar; 2] {
-        self.vertex.point2()
-    }
-}
-
-impl<V, C> geom::Vertex3d for WithColor<V, C>
-where
-    V: geom::Vertex3d,
-    Self: geom::Vertex<Scalar = V::Scalar>,
-{
-    fn point3(self) -> [Self::Scalar; 3] {
-        self.vertex.point3()
-    }
-}
-
-impl<V, T> geom::Vertex3d for WithTexCoords<V, T>
-where
-    V: geom::Vertex3d,
-    Self: geom::Vertex<Scalar = V::Scalar>,
-{
-    fn point3(self) -> [Self::Scalar; 3] {
-        self.vertex.point3()
-    }
-}
-
-impl<V, N> geom::Vertex3d for WithNormal<V, N>
-where
-    V: geom::Vertex3d,
-    Self: geom::Vertex<Scalar = V::Scalar>,
-{
-    fn point3(self) -> [Self::Scalar; 3] {
-        self.vertex.point3()
-    }
-}
-
-// For converting from tuples to vertices.
-
-impl<A, V, B, C> From<(A, B)> for WithColor<V, C>
-where
-    A: Into<V>,
-    B: IntoLinSrgba<f32>,
-    C: From<color::LinSrgba<f32>>,
-{
-    fn from((vertex, color): (A, B)) -> Self {
-        let vertex = vertex.into();
-        // TODO: Using `into_lin_srgba` solely because palette's conversion implementations (e.g.
-        // `From` and `Into`) are not exhaustive. Using this gives more flexibility in terms of
-        // supported color conversions, but these conversions should really be added upstream to
-        // palette itself.
-        let lin_srgba = color.into_lin_srgba();
-        let color = lin_srgba.into();
-        WithColor { vertex, color }
-    }
-}
-
-impl<A, V, T> From<(A, T)> for WithTexCoords<V, T>
-where
-    A: Into<V>,
-{
-    fn from((vertex, tex_coords): (A, T)) -> Self {
-        let vertex = vertex.into();
-        WithTexCoords { vertex, tex_coords }
-    }
-}
-
-impl<A, V, N> From<(A, N)> for WithNormal<V, N>
-where
-    A: Into<V>,
-{
-    fn from((vertex, normal): (A, N)) -> Self {
-        let vertex = vertex.into();
-        WithNormal { vertex, normal }
-    }
-}
-
-#[test]
-fn test_tuple_conv() {
-    use color::named::GREEN;
-    let _: Point2 = [0.0, 0.0].into();
-    let _: WithColor<Point2> = ([0.0, 0.0], GREEN).into();
-}
diff --git a/nannou_new/src/main.rs b/nannou_new/src/main.rs
index ac1f06bfd..af8445861 100644
--- a/nannou_new/src/main.rs
+++ b/nannou_new/src/main.rs
@@ -6,7 +6,6 @@
 //! 4. Adds the latest nannou version as a dep to the `Cargo.toml`.
 //! 5. Builds the project with optimisations. Suggests getting a beverage.
 
-use cargo::CargoResult;
 use std::env;
 use std::fs::{self, File};
 use std::io::{self, BufRead, Write};
@@ -15,6 +14,8 @@ use std::process::{Command, Stdio};
 use std::sync::mpsc;
 use std::thread;
 
+use cargo::CargoResult;
+
 enum Project {
     Sketch,
     App,
@@ -145,11 +146,13 @@ fn main() {
         let template_path = nannou_package
             .root()
             .join("examples")
-            .join(&project.template_file_name());
-        std::fs::read(&template_path).expect(&format!(
-            "failed to read template bytes from {}",
-            template_path.display()
-        ))
+            .join(project.template_file_name());
+        std::fs::read(&template_path).unwrap_or_else(|_| {
+            panic!(
+                "failed to read template bytes from {}",
+                template_path.display()
+            )
+        })
     };
 
     // Get the current directory.
@@ -187,7 +190,6 @@ fn main() {
         println!("Adding nannou dependency `{}`", nannou_dependency);
         let cargo_toml_path = project_path.join("Cargo").with_extension("toml");
         let mut file = fs::OpenOptions::new()
-            .write(true)
             .append(true)
             .open(&cargo_toml_path)
             .expect("failed to open \"Cargo.toml\" to add nannou dependency");
diff --git a/nannou_osc/.dropboxignore b/nannou_osc/.dropboxignore
new file mode 100644
index 000000000..308cac8b1
--- /dev/null
+++ b/nannou_osc/.dropboxignore
@@ -0,0 +1,7 @@
+# ----
+# Automatically Generated .dropboxignore file at Tue Apr 23 13:35:38 PDT 2024
+# ----
+/target
+**/*.rs.bk
+Cargo.lock
+# ----
diff --git a/nannou_osc/src/lib.rs b/nannou_osc/src/lib.rs
index 35677f496..aa28aa183 100644
--- a/nannou_osc/src/lib.rs
+++ b/nannou_osc/src/lib.rs
@@ -1,6 +1,8 @@
 //! Tools for working with OSC. [**sender()**](./fn.sender.html) creates an OSC sender,
 //! [**receiver(port)**](./fn.receiver.html) creates an OSC receiver.
 
+use std::net::{Ipv4Addr, SocketAddr};
+
 pub use rosc;
 
 // Re-export rosc items.
@@ -16,9 +18,6 @@ pub use self::rosc::{
 };
 pub use self::send::Sender;
 
-use std;
-use std::net::{Ipv4Addr, SocketAddr};
-
 pub mod recv;
 pub mod send;
 
@@ -69,9 +68,9 @@ where
     }
 }
 
-impl Into<rosc::OscPacket> for Packet {
-    fn into(self) -> rosc::OscPacket {
-        match self {
+impl From<Packet> for rosc::OscPacket {
+    fn from(val: Packet) -> Self {
+        match val {
             Packet::Message(msg) => rosc::OscPacket::Message(msg),
             Packet::Bundle(bundle) => rosc::OscPacket::Bundle(bundle),
         }
diff --git a/nannou_osc/src/recv.rs b/nannou_osc/src/recv.rs
index 6c40a5324..45b93b076 100644
--- a/nannou_osc/src/recv.rs
+++ b/nannou_osc/src/recv.rs
@@ -1,11 +1,12 @@
 //! Items related to the `osc::Receiver` implementation.
 
-use super::{decode, rosc, CommunicationError, Connected, Packet, Unconnected};
 use std;
 use std::net::{SocketAddr, SocketAddrV4, ToSocketAddrs, UdpSocket};
 use std::sync::atomic::{self, AtomicBool};
 use std::sync::Mutex;
 
+use super::{decode, rosc, CommunicationError, Connected, Packet, Unconnected};
+
 /// The default "maximum transmission unit" size as a number of bytes.
 ///
 /// This is a common MTU size for ethernet.
diff --git a/nannou_osc/src/send.rs b/nannou_osc/src/send.rs
index 3b08f95f7..e408b58dd 100644
--- a/nannou_osc/src/send.rs
+++ b/nannou_osc/src/send.rs
@@ -1,9 +1,10 @@
 //! Items related to the `osc::Sender` implementation.
 
-use super::{encode, CommunicationError, Connected, Packet, Unconnected};
 use std;
 use std::net::{SocketAddr, SocketAddrV4, ToSocketAddrs, UdpSocket};
 
+use super::{encode, CommunicationError, Connected, Packet, Unconnected};
+
 /// The default port bound to by the `Sender`.
 ///
 /// In most cases, mono-directional networking tools will bind to port `0` for outgoing
diff --git a/nannou_package/src/main.rs b/nannou_package/src/main.rs
index e5a32f756..50cbaeaf4 100644
--- a/nannou_package/src/main.rs
+++ b/nannou_package/src/main.rs
@@ -1,10 +1,11 @@
 //! A small rust script for packaging a nannou project.
 
-use copy_dir::copy_dir;
 use std::env;
 use std::fs;
 use std::io::{self, Read, Write};
 use std::path::{Path, PathBuf};
+
+use copy_dir::copy_dir;
 use walkdir::WalkDir;
 
 // Check the given path and `depth` number of parent directories for a folder with the given name.
@@ -48,7 +49,7 @@ where
             zip.start_file(name, options)?;
             let mut f = fs::File::open(path)?;
             f.read_to_end(&mut buffer)?;
-            zip.write_all(&*buffer)?;
+            zip.write_all(&buffer)?;
             buffer.clear();
         }
     }
@@ -142,7 +143,7 @@ fn main() {
             release_path.display()
         );
     }
-    let exe_path = release_path.join(&name);
+    let exe_path = release_path.join(name);
     if !exe_path.exists() || !exe_path.is_file() {
         panic!("The file \"{}\" does not exist.", release_path.display());
     }
@@ -174,7 +175,7 @@ fn main() {
         .file_name()
         .and_then(|s| s.to_str())
         .expect("could not get exe name");
-    let build_exe_path = build_path.join(&exe_name);
+    let build_exe_path = build_path.join(exe_name);
     println!(
         "Copying \"{}\" to \"{}\"",
         exe_path.display(),
diff --git a/nannou_wgpu/Cargo.toml b/nannou_wgpu/Cargo.toml
deleted file mode 100644
index d1f32ae75..000000000
--- a/nannou_wgpu/Cargo.toml
+++ /dev/null
@@ -1,33 +0,0 @@
-[package]
-name = "nannou_wgpu"
-version ="0.19.0"
-authors = ["mitchmindtree <mitchell.nordine@gmail.com>"]
-description = "Items related to wgpu and its integration in nannou - a creative coding framework for Rust."
-readme = "README.md"
-license = "MIT"
-repository = "https://github.com/nannou-org/nannou.git"
-homepage = "https://nannou.cc"
-edition = "2018"
-
-[dependencies]
-futures = "0.3"
-image = { version = "0.23", optional = true }
-instant = { version = "0.1.9", optional = true }
-num_cpus = { version = "1", optional = true }
-wgpu_upstream = { version = "0.17.1", package = "wgpu" }
-
-[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-tokio = { version = "1", features = ["full"]}
-[target.'cfg(target_arch = "wasm32")'.dependencies]
-tokio = { version = "1", features = ["rt"]}
-
-[features]
-capturer = ["image", "instant", "num_cpus"]
-replay = ["wgpu_upstream/replay"]
-serde = ["wgpu_upstream/serde"]
-spirv = ["wgpu_upstream/spirv"]
-trace = ["wgpu_upstream/trace"]
-webgl = ["wgpu_upstream/webgl"]
-
-[package.metadata.docs.rs]
-features = ["capturer", "image", "replay", "serde", "spirv", "trace", "webgl"]
diff --git a/nannou_wgpu/README.md b/nannou_wgpu/README.md
deleted file mode 100644
index 39447f73c..000000000
--- a/nannou_wgpu/README.md
+++ /dev/null
@@ -1,31 +0,0 @@
-# `nannou_wgpu`
-
-Items related to wgpu and its integration in nannou!
-
-**WebGPU** is the portable graphics specification that nannou targets allowing
-us to write code that is both fast and allows us to target a wide range of
-platforms. **wgpu** is the name of the crate we use that implements this
-specification.
-
-The `nannou_wgpu` crate re-exports the entire `wgpu` crate along with all of its
-documentation while also adding some additional items that makes `wgpu` easier
-to use alongside `nannou`.
-
-The `image` feature enables easier interoperation with the `image` crate,
-including functions for uploading textures from image files.
-
-The `capturer` feature provides the `wgpu::TextureCapturer` API that aims to
-simplify the process of downloading textures from the GPU and easily save them
-as image files. As an example, this is particularly useful for recording the
-contents of a window or sketch.
-
-Note that when using `nannou_wgpu` via `nannou::wgpu`, both features are enabled
-by default.
-
-Useful links:
-
-- An awesome [guide for wgpu-rs](https://sotrh.github.io/learn-wgpu/#what-is-wgpu). Highly
-  recommended reading if you would like to work more closely with the GPU in nannou!
-- The [wgpu-rs repository](https://github.com/gfx-rs/wgpu-rs).
-- The [WebGPU specification](https://gpuweb.github.io/gpuweb/).
-- WebGPU [on wikipedia](https://en.wikipedia.org/wiki/WebGPU).
diff --git a/nannou_wgpu/src/bind_group_builder.rs b/nannou_wgpu/src/bind_group_builder.rs
deleted file mode 100644
index 97a788149..000000000
--- a/nannou_wgpu/src/bind_group_builder.rs
+++ /dev/null
@@ -1,254 +0,0 @@
-use wgpu_upstream::{BufferBinding, SamplerBindingType};
-
-use crate as wgpu;
-
-/// A type aimed at simplifying the creation of a bind group layout.
-#[derive(Debug, Default)]
-pub struct LayoutBuilder {
-    bindings: Vec<(wgpu::ShaderStages, wgpu::BindingType)>,
-}
-
-/// Simplified creation of a bind group.
-#[derive(Debug, Default)]
-pub struct Builder<'a> {
-    resources: Vec<wgpu::BindingResource<'a>>,
-}
-
-impl LayoutBuilder {
-    /// Begin building the bind group layout.
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Specify a new binding.
-    ///
-    /// The `binding` position of each binding will be inferred as the index within the order that
-    /// they are added to this builder type. If you require manually specifying the binding
-    /// location, you may be better off not using the `BindGroupLayoutBuilder` and instead
-    /// constructing the `BindGroupLayout` and `BindGroup` manually.
-    pub fn binding(mut self, visibility: wgpu::ShaderStages, ty: wgpu::BindingType) -> Self {
-        self.bindings.push((visibility, ty));
-        self
-    }
-
-    /// Add a uniform buffer binding to the layout.
-    pub fn uniform_buffer(self, visibility: wgpu::ShaderStages, has_dynamic_offset: bool) -> Self {
-        let ty = wgpu::BindingType::Buffer {
-            ty: wgpu::BufferBindingType::Uniform,
-            has_dynamic_offset,
-            // wgpu 0.5-0.6 TODO: potential perf hit, investigate this field
-            min_binding_size: None,
-        };
-        self.binding(visibility, ty)
-    }
-
-    /// Add a storage buffer binding to the layout.
-    pub fn storage_buffer(
-        self,
-        visibility: wgpu::ShaderStages,
-        has_dynamic_offset: bool,
-        read_only: bool,
-    ) -> Self {
-        let ty = wgpu::BindingType::Buffer {
-            ty: wgpu::BufferBindingType::Storage { read_only },
-            has_dynamic_offset,
-            // wgpu 0.5-0.6 TODO: potential perf hit, investigate this field
-            min_binding_size: None,
-        };
-        self.binding(visibility, ty)
-    }
-
-    /// Add a sampler binding to the layout.
-    pub fn sampler(self, visibility: wgpu::ShaderStages, filtering: bool) -> Self {
-        let ty = wgpu::BindingType::Sampler(if filtering {
-            SamplerBindingType::Filtering
-        } else {
-            SamplerBindingType::NonFiltering
-        });
-        self.binding(visibility, ty)
-    }
-
-    /// Add a sampler binding to the layout.
-    pub fn comparison_sampler(self, visibility: wgpu::ShaderStages) -> Self {
-        let ty = wgpu::BindingType::Sampler(SamplerBindingType::Comparison);
-        self.binding(visibility, ty)
-    }
-
-    /// Add a texture binding to the layout.
-    pub fn texture(
-        self,
-        visibility: wgpu::ShaderStages,
-        multisampled: bool,
-        view_dimension: wgpu::TextureViewDimension,
-        sample_type: wgpu::TextureSampleType,
-    ) -> Self {
-        // fix sample type in certain scenarios (constraint given by wgpu)
-        let sample_type = if multisampled
-            && matches!(
-                sample_type,
-                wgpu::TextureSampleType::Float { filterable: true }
-            ) {
-            wgpu::TextureSampleType::Float { filterable: false }
-        } else {
-            sample_type
-        };
-        let ty = wgpu::BindingType::Texture {
-            multisampled,
-            view_dimension,
-            sample_type,
-        };
-        self.binding(visibility, ty)
-    }
-
-    /// Short-hand for adding a texture binding for a full view of the given texture to the layout.
-    ///
-    /// The `multisampled` and `dimension` parameters are retrieved from the `Texture` itself.
-    ///
-    /// Note that if you wish to take a `Cube` or `CubeArray` view of the given texture, you will
-    /// need to manually specify the `TextureViewDimension` via the `sampled_texture` method
-    /// instead.
-    pub fn texture_from(self, visibility: wgpu::ShaderStages, texture: &wgpu::Texture) -> Self {
-        self.texture(
-            visibility,
-            texture.sample_count() > 1,
-            texture.view_dimension(),
-            texture.sample_type(),
-        )
-    }
-
-    /// Add a storage texture binding to the layout.
-    pub fn storage_texture(
-        self,
-        visibility: wgpu::ShaderStages,
-        format: wgpu::TextureFormat,
-        view_dimension: wgpu::TextureViewDimension,
-        access: wgpu::StorageTextureAccess,
-    ) -> Self {
-        let ty = wgpu::BindingType::StorageTexture {
-            view_dimension,
-            format,
-            access,
-        };
-        self.binding(visibility, ty)
-    }
-
-    /// Short-hand for adding a storage texture binding for a full view of the given texture to the
-    /// layout.
-    ///
-    /// The `format`, `dimension` and `sample_type` are inferred from the given `texture`.
-    pub fn storage_texture_from(
-        self,
-        visibility: wgpu::ShaderStages,
-        texture: &wgpu::Texture,
-        access: wgpu::StorageTextureAccess,
-    ) -> Self {
-        self.storage_texture(
-            visibility,
-            texture.format(),
-            texture.view_dimension(),
-            access,
-        )
-    }
-
-    /// Build the bind group layout from the specified parameters.
-    pub fn build(self, device: &wgpu::Device) -> wgpu::BindGroupLayout {
-        let mut entries = Vec::with_capacity(self.bindings.len());
-        for (i, (visibility, ty)) in self.bindings.into_iter().enumerate() {
-            let layout_binding = wgpu::BindGroupLayoutEntry {
-                binding: i as u32,
-                visibility,
-                ty,
-                count: None,
-            };
-            entries.push(layout_binding);
-        }
-        let descriptor = wgpu::BindGroupLayoutDescriptor {
-            label: Some("nannou bind group layout"),
-            entries: &entries,
-        };
-        device.create_bind_group_layout(&descriptor)
-    }
-}
-
-impl<'a> Builder<'a> {
-    /// Begin building the bind group.
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Specify a new binding.
-    ///
-    /// The `binding` position of each binding will be inferred as the index within the order that
-    /// they are added to this builder type. If you require manually specifying the binding
-    /// location, you may be better off not using the `BindGroupBuilder` and instead constructing
-    /// the `BindGroupLayout` and `BindGroup` manually.
-    pub fn binding(mut self, resource: wgpu::BindingResource<'a>) -> Self {
-        self.resources.push(resource);
-        self
-    }
-
-    /// Specify a slice of a buffer to be bound.
-    ///
-    /// The given `range` represents the start and end point of the buffer to be bound in bytes.
-    pub fn buffer_bytes(
-        self,
-        buffer: &'a wgpu::Buffer,
-        offset: wgpu::BufferAddress,
-        size: Option<wgpu::BufferSize>,
-    ) -> Self {
-        let resource = wgpu::BindingResource::Buffer(BufferBinding {
-            buffer,
-            offset,
-            size,
-        });
-        self.binding(resource)
-    }
-
-    /// Specify a slice of a buffer of elements of type `T` to be bound.
-    ///
-    /// This method is similar to `buffer_bytes`, but expects a range of **elements** rather than a
-    /// range of **bytes**.
-    ///
-    /// Type `T` *must* be either `#[repr(C)]` or `#[repr(transparent)]`.
-    // NOTE: We might want to change this to match the wgpu API by using a NonZeroU64 for size.
-    pub fn buffer<T>(self, buffer: &'a wgpu::Buffer, range: std::ops::Range<usize>) -> Self
-    where
-        T: Copy,
-    {
-        let size_bytes = std::mem::size_of::<T>() as wgpu::BufferAddress;
-        let start = range.start as wgpu::BufferAddress * size_bytes;
-        let end = range.end as wgpu::BufferAddress * size_bytes;
-        let size = std::num::NonZeroU64::new(end - start).expect("buffer slice must not be empty");
-        self.buffer_bytes(buffer, start, Some(size))
-    }
-
-    /// Specify a sampler to be bound.
-    pub fn sampler(self, sampler: &'a wgpu::Sampler) -> Self {
-        let resource = wgpu::BindingResource::Sampler(sampler);
-        self.binding(resource)
-    }
-
-    /// Specify a texture view to be bound.
-    pub fn texture_view(self, view: &'a wgpu::TextureViewHandle) -> Self {
-        let resource = wgpu::BindingResource::TextureView(view);
-        self.binding(resource)
-    }
-
-    /// Build the bind group with the specified resources.
-    pub fn build(self, device: &wgpu::Device, layout: &wgpu::BindGroupLayout) -> wgpu::BindGroup {
-        let mut entries = Vec::with_capacity(self.resources.len());
-        for (i, resource) in self.resources.into_iter().enumerate() {
-            let binding = wgpu::BindGroupEntry {
-                binding: i as u32,
-                resource,
-            };
-            entries.push(binding);
-        }
-        let descriptor = wgpu::BindGroupDescriptor {
-            label: Some("nannou bind group"),
-            layout,
-            entries: &entries,
-        };
-        device.create_bind_group(&descriptor)
-    }
-}
diff --git a/nannou_wgpu/src/blend.rs b/nannou_wgpu/src/blend.rs
deleted file mode 100644
index 6bb4c5ad9..000000000
--- a/nannou_wgpu/src/blend.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-//! A set of useful descriptors for blending colours!
-
-use crate as wgpu;
-
-pub const NORMAL: wgpu::BlendComponent = wgpu::BlendComponent {
-    src_factor: wgpu::BlendFactor::SrcAlpha,
-    dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
-    operation: wgpu::BlendOperation::Add,
-};
-
-pub const ADD: wgpu::BlendComponent = wgpu::BlendComponent {
-    src_factor: wgpu::BlendFactor::Src,
-    dst_factor: wgpu::BlendFactor::Dst,
-    operation: wgpu::BlendOperation::Add,
-};
-
-pub const SUBTRACT: wgpu::BlendComponent = wgpu::BlendComponent {
-    src_factor: wgpu::BlendFactor::Src,
-    dst_factor: wgpu::BlendFactor::Dst,
-    operation: wgpu::BlendOperation::Subtract,
-};
-
-pub const REVERSE_SUBTRACT: wgpu::BlendComponent = wgpu::BlendComponent {
-    src_factor: wgpu::BlendFactor::Src,
-    dst_factor: wgpu::BlendFactor::Dst,
-    operation: wgpu::BlendOperation::ReverseSubtract,
-};
-
-pub const DARKEST: wgpu::BlendComponent = wgpu::BlendComponent {
-    src_factor: wgpu::BlendFactor::One,
-    dst_factor: wgpu::BlendFactor::One,
-    operation: wgpu::BlendOperation::Min,
-};
-
-pub const LIGHTEST: wgpu::BlendComponent = wgpu::BlendComponent {
-    src_factor: wgpu::BlendFactor::One,
-    dst_factor: wgpu::BlendFactor::One,
-    operation: wgpu::BlendOperation::Max,
-};
diff --git a/nannou_wgpu/src/device_map.rs b/nannou_wgpu/src/device_map.rs
deleted file mode 100644
index c4373909b..000000000
--- a/nannou_wgpu/src/device_map.rs
+++ /dev/null
@@ -1,342 +0,0 @@
-use std::collections::HashMap;
-use std::hash::{Hash, Hasher};
-use std::ops::Deref;
-use std::sync::{Arc, Mutex, Weak};
-
-use crate as wgpu;
-
-/// A map from `RequestAdapterOptions` to active adapters.
-///
-/// Each time an adapter is requested via the `App`, it keeps track of which adapters are active.
-/// This is done in order to allow re-use of adapters and in turn re-use of logical devices and the
-/// sharing of resources between windows.
-///
-/// At the end of the application loop (after `update` and `view` have been called), adapters
-/// containing no active device connections are removed from the map.
-#[derive(Default)]
-pub struct AdapterMap {
-    map: Mutex<HashMap<AdapterMapKey, Arc<ActiveAdapter>>>,
-}
-
-/// The key into the adapter map.
-///
-/// This type is a thin wrapper around `wgpu::RequestAdapterOptions` that provides implementations
-/// of `Eq` and `Hash`.
-#[derive(Clone, Debug, Eq, Hash, PartialEq)]
-pub struct AdapterMapKey {
-    power_preference: wgpu::PowerPreference,
-}
-
-/// A single active adapter and its map of connected devices.
-pub struct ActiveAdapter {
-    adapter: wgpu::Adapter,
-    device_map: DeviceMap,
-}
-
-/// A map of actively connected devices for an adapter.
-///
-/// This is used so that windows built to target the same physical device may also target the same
-/// logical device and share the same queue. This allows for resources like textures and buffers to
-/// be shared between windows.
-///
-/// The map contains only weak handles to active adapters and cleans up unused entries at the end
-/// of each application loop.
-#[derive(Default)]
-pub struct DeviceMap {
-    map: Mutex<HashMap<DeviceMapKey, Weak<DeviceQueuePair>>>,
-}
-
-/// The key into the device map.
-///
-/// This type is a thin wrapper around `wgpu::DeviceDesriptor` that provides implementations of
-/// `Eq` and `Hash`.
-#[derive(Clone, Debug)]
-pub struct DeviceMapKey {
-    descriptor: wgpu::DeviceDescriptor<'static>,
-}
-
-/// A handle to a connected logical device and its associated queue.
-#[derive(Debug)]
-pub struct DeviceQueuePair {
-    device: wgpu::Device,
-    queue: wgpu::Queue,
-}
-
-impl AdapterMap {
-    #[cfg(not(target_os = "unknown"))]
-    /// Check for an adaptor with the given options or request one.
-    ///
-    /// First checks to see if an adapter for the given set of options is active. If so, returns a
-    /// handle to this adapter. Otherwise, requests a new adapter via `Adapter::request`.
-    ///
-    /// Returns `None` if there are no available adapters that meet the specified options.
-    pub fn get_or_request<'a, 'b>(
-        &'a self,
-        options: wgpu::RequestAdapterOptions<'b>,
-        instance: &'a wgpu::Instance,
-    ) -> Option<Arc<ActiveAdapter>> {
-        let rt = tokio::runtime::Handle::current();
-        rt.block_on(self.get_or_request_async(options, instance))
-    }
-
-    #[cfg(not(target_os = "unknown"))]
-    /// Request an adaptor with the given options.
-    ///
-    /// This will always request a new adapter and will never attempt to share an existing one. The
-    /// new adapter will take the place of the old within the map in the case that an existing
-    /// active adapter exists.
-    ///
-    /// Returns `None` if there are no available adapters that meet the specified options.
-    pub fn request<'a, 'b>(
-        &'a self,
-        options: wgpu::RequestAdapterOptions<'b>,
-        instance: &'a wgpu::Instance,
-    ) -> Option<Arc<ActiveAdapter>> {
-        let rt = tokio::runtime::Handle::current();
-        rt.block_on(self.request_async(options, instance))
-    }
-
-    /// The async implementation of `get_or_request`.
-    pub async fn get_or_request_async<'a, 'b>(
-        &'a self,
-        options: wgpu::RequestAdapterOptions<'b>,
-        instance: &'a wgpu::Instance,
-    ) -> Option<Arc<ActiveAdapter>> {
-        let power_preference = options.power_preference;
-        let key = AdapterMapKey { power_preference };
-        let mut map = self
-            .map
-            .lock()
-            .expect("failed to acquire `AdapterMap` lock");
-        if let Some(adapter) = map.get(&key) {
-            return Some(adapter.clone());
-        }
-        if let Some(adapter) = instance.request_adapter(&options).await {
-            let device_map = Default::default();
-            let adapter = Arc::new(ActiveAdapter {
-                adapter,
-                device_map,
-            });
-            return Some(map.entry(key).or_insert(adapter).clone());
-        }
-        None
-    }
-
-    /// The async implementation of `request`.
-    pub async fn request_async<'a, 'b>(
-        &'a self,
-        options: wgpu::RequestAdapterOptions<'b>,
-        instance: &'b wgpu::Instance,
-    ) -> Option<Arc<ActiveAdapter>> {
-        let adapter = instance.request_adapter(&options).await?;
-        let device_map = Default::default();
-        let adapter = Arc::new(ActiveAdapter {
-            adapter,
-            device_map,
-        });
-        let power_preference = options.power_preference;
-        let key = AdapterMapKey { power_preference };
-        let mut map = self
-            .map
-            .lock()
-            .expect("failed to acquire `AdapterMap` lock");
-        map.insert(key, adapter.clone());
-        Some(adapter)
-    }
-
-    /// Clear all adapters that currently have no connected devices.
-    ///
-    /// First clears all devices that no longer have any external references.
-    pub fn clear_inactive_adapters_and_devices(&self) {
-        let mut map = self
-            .map
-            .lock()
-            .expect("failed to acquire `AdapterMap` lock");
-        map.retain(|_, adapter| {
-            adapter.clear_inactive_devices();
-            adapter.device_count() > 0
-        });
-    }
-
-    /// Poll all devices within all active adapters.
-    pub(crate) fn _poll_all_devices(&self, maintain: wgpu::Maintain) {
-        let map = self
-            .map
-            .lock()
-            .expect("failed to acquire `AdapterMap` lock");
-        for adapter in map.values() {
-            adapter._poll_all_devices(maintain.clone()); // TODO: clone?
-        }
-    }
-}
-
-impl ActiveAdapter {
-    #[cfg(not(target_os = "unknown"))]
-    /// Check for a device with the given descriptor or request one.
-    ///
-    /// First checks for a connected device that matches the given descriptor. If one exists, it is
-    /// returned. Otherwise, a new device connection is requested via `Adapter::request_device`.
-    pub fn get_or_request_device(
-        &self,
-        descriptor: wgpu::DeviceDescriptor<'static>,
-    ) -> Arc<DeviceQueuePair> {
-        let rt = tokio::runtime::Handle::current();
-        rt.block_on(self.get_or_request_device_async(descriptor))
-    }
-
-    #[cfg(not(target_os = "unknown"))]
-    /// Request a device with the given descriptor.
-    ///
-    /// This will always request a new device connection and will never attempt to share an
-    /// existing one. The new device will take the place of the old within the map in the case that
-    /// an existing connected device exists.
-    pub fn request_device(
-        &self,
-        descriptor: wgpu::DeviceDescriptor<'static>,
-    ) -> Arc<DeviceQueuePair> {
-        let rt = tokio::runtime::Handle::current();
-        rt.block_on(self.request_device_async(descriptor))
-    }
-
-    /// Check for a device with the given descriptor or request one.
-    ///
-    /// First checks for a connected device that matches the given descriptor. If one exists, it is
-    /// returned. Otherwise, a new device connection is requested via `Adapter::request_device`.
-    pub async fn get_or_request_device_async(
-        &self,
-        descriptor: wgpu::DeviceDescriptor<'static>,
-    ) -> Arc<DeviceQueuePair> {
-        let key = DeviceMapKey { descriptor };
-        let mut map = self
-            .device_map
-            .map
-            .lock()
-            .expect("failed to acquire `AdapterMap` lock");
-        if let Some(device_ref) = map.get(&key) {
-            if let Some(device) = device_ref.upgrade() {
-                return device;
-            }
-        }
-        let (device, queue) = self
-            .adapter
-            .request_device(&key.descriptor, None)
-            .await
-            .expect("could not get or request device");
-        let device = Arc::new(DeviceQueuePair { device, queue });
-        map.insert(key, Arc::downgrade(&device));
-        device
-    }
-
-    /// Request a device with the given descriptor.
-    ///
-    /// This will always request a new device connection and will never attempt to share an
-    /// existing one. The new device will take the place of the old within the map in the case that
-    /// an existing connected device exists.
-    pub async fn request_device_async(
-        &self,
-        descriptor: wgpu::DeviceDescriptor<'static>,
-    ) -> Arc<DeviceQueuePair> {
-        let (device, queue) = self
-            .adapter
-            .request_device(&descriptor, None)
-            .await
-            .expect("could not request device async");
-        let device = Arc::new(DeviceQueuePair { device, queue });
-        let key = DeviceMapKey { descriptor };
-        let mut map = self
-            .device_map
-            .map
-            .lock()
-            .expect("failed to acquire `DeviceMap` lock");
-        map.insert(key, Arc::downgrade(&device));
-        device
-    }
-
-    /// A count of devices that are currently active.
-    pub fn device_count(&self) -> usize {
-        let map = self
-            .device_map
-            .map
-            .lock()
-            .expect("failed to acquire `DeviceMap` lock");
-        map.len()
-    }
-
-    /// Clear all device queue pairs that have been dropped.
-    pub fn clear_inactive_devices(&self) {
-        let mut map = self
-            .device_map
-            .map
-            .lock()
-            .expect("failed to acquire `DeviceMap` lock");
-        map.retain(|_, pair| pair.upgrade().is_some());
-    }
-
-    /// Poll all of the active devices within the map.
-    fn _poll_all_devices(&self, maintain: wgpu::Maintain) {
-        let map = self
-            .device_map
-            .map
-            .lock()
-            .expect("failed to acquire `DeviceMap` lock");
-        for weak in map.values() {
-            if let Some(pair) = weak.upgrade() {
-                pair.device().poll(maintain.clone()); // TODO: clone?
-            }
-        }
-    }
-}
-
-impl DeviceQueuePair {
-    /// A reference to the inner `wgpu::Device`.
-    pub fn device(&self) -> &wgpu::Device {
-        &self.device
-    }
-
-    /// A reference to the inner `wgpu::Queue`.
-    ///
-    /// The queue is guarded by a `Mutex` in order to synchronise submissions of command buffers in
-    /// cases that the queue is shared between more than one window.
-    pub fn queue(&self) -> &wgpu::Queue {
-        &self.queue
-    }
-}
-
-impl Deref for ActiveAdapter {
-    type Target = wgpu::Adapter;
-    fn deref(&self) -> &Self::Target {
-        &self.adapter
-    }
-}
-
-impl Hash for DeviceMapKey {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        hash_device_descriptor(&self.descriptor, state);
-    }
-}
-
-impl PartialEq for DeviceMapKey {
-    fn eq(&self, other: &Self) -> bool {
-        eq_device_descriptor(&self.descriptor, &other.descriptor)
-    }
-}
-
-impl Eq for DeviceMapKey {}
-
-// NOTE: This should be updated as fields are added to the `wgpu::DeviceDescriptor` type.
-fn eq_device_descriptor(
-    a: &wgpu::DeviceDescriptor<'static>,
-    b: &wgpu::DeviceDescriptor<'static>,
-) -> bool {
-    a.label == b.label && a.features == b.features && a.limits == b.limits
-}
-
-// NOTE: This should be updated as fields are added to the `wgpu::DeviceDescriptor` type.
-fn hash_device_descriptor<H>(desc: &wgpu::DeviceDescriptor<'static>, state: &mut H)
-where
-    H: Hasher,
-{
-    desc.label.hash(state);
-    desc.features.hash(state);
-    desc.limits.hash(state);
-}
diff --git a/nannou_wgpu/src/lib.rs b/nannou_wgpu/src/lib.rs
deleted file mode 100644
index a9b2f9f7f..000000000
--- a/nannou_wgpu/src/lib.rs
+++ /dev/null
@@ -1,264 +0,0 @@
-//! Items related to wgpu and its integration in nannou!
-//!
-//! **WebGPU** is the portable graphics specification that nannou targets allowing us to write code
-//! that is both fast and allows us to target a wide range of platforms. **wgpu** is the name of
-//! the crate we use that implements this specification.
-//!
-//! This crate re-exports the entire `wgpu` crate along with all of its documentation while also
-//! adding some additional items that makes `wgpu` easier to use alongside nannou.
-//!
-//! The `image` feature enables easier interoperation with the `image` crate, including functions
-//! for uploading textures from image files.
-//!
-//! The `capturer` feature provides the `wgpu::TextureCapturer` API that aims to simplify the
-//! process of downloading textures from the GPU and easily save them as image files. As an
-//! example, this is particularly useful for recording the contents of a window or sketch.
-//!
-//! Note that when using `nannou_wgpu` via `nannou::wgpu`, both features are enabled by default.
-//!
-//! Useful links:
-//!
-//! - An awesome [guide for wgpu-rs](https://sotrh.github.io/learn-wgpu/#what-is-wgpu). Highly
-//!   recommended reading if you would like to work more closely with the GPU in nannou!
-//! - The [wgpu-rs repository](https://github.com/gfx-rs/wgpu-rs).
-//! - The [WebGPU specification](https://gpuweb.github.io/gpuweb/).
-//! - WebGPU [on wikipedia](https://en.wikipedia.org/wiki/WebGPU).
-
-mod bind_group_builder;
-pub mod blend;
-mod device_map;
-mod render_pass;
-mod render_pipeline_builder;
-mod sampler_builder;
-mod texture;
-
-// Re-export all of `wgpu` along with its documentation.
-//
-// We do this manually rather than a glob-re-export in order to rename `Texture` to `TextureHandle`
-// and have it show up in the documentation properly.
-pub use self::bind_group_builder::{
-    Builder as BindGroupBuilder, LayoutBuilder as BindGroupLayoutBuilder,
-};
-pub use self::device_map::{
-    ActiveAdapter, AdapterMap, AdapterMapKey, DeviceMap, DeviceMapKey, DeviceQueuePair,
-};
-pub use self::render_pass::{
-    Builder as RenderPassBuilder,
-    ColorAttachmentDescriptorBuilder as RenderPassColorAttachmentDescriptorBuilder,
-};
-pub use self::render_pipeline_builder::RenderPipelineBuilder;
-pub use self::sampler_builder::SamplerBuilder;
-#[cfg(feature = "capturer")]
-pub use self::texture::capturer::{
-    AwaitWorkerTimeout as TextureCapturerAwaitWorkerTimeout, Capturer as TextureCapturer,
-    Snapshot as TextureSnapshot,
-};
-#[cfg(feature = "image")]
-pub use self::texture::image::{
-    format_from_image_color_type as texture_format_from_image_color_type, ImageHolder,
-    ImageReadMapping, WithDeviceQueuePair,
-};
-pub use self::texture::reshaper::Reshaper as TextureReshaper;
-pub use self::texture::row_padded_buffer::RowPaddedBuffer;
-pub use self::texture::{
-    descriptor_eq as texture_descriptor_eq, extent_3d_eq,
-    format_size_bytes as texture_format_size_bytes, Builder as TextureBuilder, Texture, TextureId,
-    TextureView, TextureViewId, ToTextureView,
-};
-#[doc(inline)]
-pub use wgpu_upstream::{
-    include_wgsl,
-    util::{self, BufferInitDescriptor},
-    vertex_attr_array, Adapter, AdapterInfo, AddressMode, Backend, Backends, BindGroup,
-    BindGroupDescriptor, BindGroupEntry, BindGroupLayout, BindGroupLayoutDescriptor,
-    BindGroupLayoutEntry, BindingResource, BindingType, BlendComponent, BlendFactor,
-    BlendOperation, BlendState, Buffer, BufferAddress, BufferAsyncError, BufferBinding,
-    BufferBindingType, BufferDescriptor, BufferSize, BufferSlice, BufferUsages, BufferView,
-    BufferViewMut, Color, ColorTargetState, ColorWrites, CommandBuffer, CommandBufferDescriptor,
-    CommandEncoder, CommandEncoderDescriptor, CompareFunction, ComputePass, ComputePassDescriptor,
-    ComputePipeline, ComputePipelineDescriptor, DepthBiasState, DepthStencilState, Device,
-    DeviceDescriptor, DeviceType, DownlevelCapabilities, DownlevelFlags, DynamicOffset, Error,
-    Extent3d, Face, Features, FilterMode, FragmentState, FrontFace, ImageCopyBuffer,
-    ImageCopyBufferBase, ImageCopyTexture, ImageCopyTextureBase, ImageDataLayout,
-    ImageSubresourceRange, IndexFormat, Instance, Label, Limits, LoadOp, Maintain, MapMode,
-    MultisampleState, Operations, Origin3d, PipelineLayout, PipelineLayoutDescriptor,
-    PipelineStatisticsTypes, PolygonMode, PowerPreference, PresentMode, PrimitiveState,
-    PrimitiveTopology, PushConstantRange, QuerySet, QuerySetDescriptor, QueryType, Queue,
-    RenderBundle, RenderBundleDepthStencil, RenderBundleDescriptor, RenderBundleEncoder,
-    RenderBundleEncoderDescriptor, RenderPass, RenderPassColorAttachment,
-    RenderPassDepthStencilAttachment, RenderPassDescriptor, RenderPipeline,
-    RenderPipelineDescriptor, RequestAdapterOptions, RequestAdapterOptionsBase, RequestDeviceError,
-    Sampler, SamplerBorderColor, SamplerDescriptor, ShaderLocation, ShaderModel, ShaderModule,
-    ShaderModuleDescriptor, ShaderSource, ShaderStages, StencilFaceState, StencilOperation,
-    StencilState, StorageTextureAccess, Surface, SurfaceConfiguration, SurfaceError, SurfaceStatus,
-    SurfaceTexture, Texture as TextureHandle, TextureAspect, TextureDescriptor, TextureDimension,
-    TextureFormat, TextureFormatFeatureFlags, TextureFormatFeatures, TextureSampleType,
-    TextureUsages, TextureView as TextureViewHandle, TextureViewDescriptor, TextureViewDimension,
-    UncapturedErrorHandler, VertexAttribute, VertexBufferLayout, VertexFormat, VertexState,
-    VertexStepMode, COPY_BUFFER_ALIGNMENT, COPY_BYTES_PER_ROW_ALIGNMENT, MAP_ALIGNMENT,
-    PUSH_CONSTANT_ALIGNMENT, QUERY_RESOLVE_BUFFER_ALIGNMENT, QUERY_SET_MAX_QUERIES, QUERY_SIZE,
-    VERTEX_STRIDE_ALIGNMENT,
-};
-
-/// The default power preference used for requesting the WGPU adapter.
-pub const DEFAULT_POWER_PREFERENCE: PowerPreference = PowerPreference::HighPerformance;
-
-/// Nannou's default WGPU backend preferences.
-pub const DEFAULT_BACKENDS: Backends = Backends::PRIMARY.union(Backends::GL);
-
-/// Create a wgpu shader module from the given slice of SPIR-V bytes.
-#[cfg(feature = "spirv")]
-pub fn shader_from_spirv_bytes(
-    device: &wgpu_upstream::Device,
-    bytes: &[u8],
-) -> wgpu_upstream::ShaderModule {
-    let source = util::make_spirv(bytes);
-    let desc = ShaderModuleDescriptor {
-        label: Some("nannou_shader_module"),
-        source,
-    };
-    device.create_shader_module(desc)
-}
-
-/// Adds a simple render pass command to the given encoder that simply clears the given texture
-/// with the given colour.
-///
-/// The given `texture` must have `TextureUsage::OUTPUT_ATTACHMENT` enabled.
-pub fn clear_texture(
-    texture: &TextureViewHandle,
-    clear_color: Color,
-    encoder: &mut CommandEncoder,
-) {
-    RenderPassBuilder::new()
-        .color_attachment(texture, |builder| {
-            builder.load_op(LoadOp::Clear(clear_color))
-        })
-        .begin(encoder);
-}
-
-/// The default device descriptor used to instantiate a logical device when creating windows.
-pub fn default_device_descriptor() -> DeviceDescriptor<'static> {
-    let features = Features::default();
-    let limits = Limits::default();
-    DeviceDescriptor {
-        label: Some("nannou_device"),
-        features,
-        limits,
-    }
-}
-
-/// Adds a simple render pass command to the given encoder that resolves the given multisampled
-/// `src_texture` to the given non-multisampled `dst_texture`.
-///
-/// Both the `src_texture` and `dst_texture` must have:
-///
-/// - `TextureUsage::OUTPUT_ATTACHMENT` enabled.
-/// - The same dimensions.
-/// - The same `TextureFormat`.
-pub fn resolve_texture(
-    src_texture: &TextureViewHandle,
-    dst_texture: &TextureViewHandle,
-    encoder: &mut CommandEncoder,
-) {
-    RenderPassBuilder::new()
-        .color_attachment(src_texture, |color| {
-            color
-                .load_op(LoadOp::Load)
-                .resolve_target_handle(Some(dst_texture))
-        })
-        .begin(encoder);
-}
-
-/// Shorthand for creating the pipeline layout from a slice of bind group layouts.
-pub fn create_pipeline_layout<'p>(
-    device: &wgpu_upstream::Device,
-    label: Option<&'p str>,
-    bind_group_layouts: &[&wgpu_upstream::BindGroupLayout],
-    push_constant_ranges: &'p [wgpu_upstream::PushConstantRange],
-) -> wgpu_upstream::PipelineLayout {
-    let descriptor = wgpu_upstream::PipelineLayoutDescriptor {
-        label,
-        bind_group_layouts,
-        push_constant_ranges,
-    };
-    device.create_pipeline_layout(&descriptor)
-}
-
-/// Whether or not the sampler descriptor describes a sampler that might perform linear filtering.
-///
-/// This is used to determine the `filtering` field for the sampler binding type variant which
-/// assists wgpu with validation.
-pub fn sampler_filtering(desc: &SamplerDescriptor) -> bool {
-    match (desc.mag_filter, desc.min_filter, desc.mipmap_filter) {
-        (FilterMode::Nearest, FilterMode::Nearest, FilterMode::Nearest) => false,
-        _ => true,
-    }
-}
-
-/// Given the initial number of bytes per row within an image, compute the number of bytes that
-/// must be added per row to produce a valid bytes per row alignment.
-///
-/// See here:
-/// https://docs.rs/wgpu/latest/wgpu/struct.ImageDataLayout.html#structfield.bytes_per_row
-pub fn compute_row_padding(bytes_per_row: u32) -> u32 {
-    COPY_BYTES_PER_ROW_ALIGNMENT - (bytes_per_row % COPY_BYTES_PER_ROW_ALIGNMENT)
-}
-
-/// The functions within this module use unsafe in order to retrieve their input as a slice of
-/// bytes. This is necessary in order to upload data to the GPU via the wgpu
-/// `DeviceExt::create_buffer_init` buffer constructor. This method is unsafe as the type `T` may contain
-/// padding which is considered to be uninitialised memory in Rust and may potentially lead to
-/// undefined behaviour.
-///
-/// These should be replaced in the future with something similar to `zerocopy`. Unfortunately, we
-/// don't gain much benefit from using `zerocopy` in our case as `zerocopy` provides no way to
-/// implement the `AsBytes` trait for generic types (e.g. `Vector*`), even with their type
-/// parameters filled (e.g. `Vector2<f32>`). This means we can't derive `AsBytes` for the majority
-/// of the types where we need to as `derive(AsBytes)` requires that all fields implement
-/// `AsBytes`, and neither our `Vector` types or the palette color types can implement it.
-///
-/// There is a relatively new crate `bytemuck` which provides traits for this, however these traits
-/// are `unsafe` and so we don't gain much benefit in terms of safety, especially for our simple
-/// use-case. There is a `zeroable` crate that attempts to derive the `Zeroable` trait from
-/// `bytemuck`, however:
-/// 1. there not yet any other publicly dependent crates or public discussion around the safety of
-///    the provided derives and
-/// 2. we would still require implementing `Pod` unsafely.
-pub mod bytes {
-    pub unsafe fn from_slice<T>(slice: &[T]) -> &[u8]
-    where
-        T: Copy + Sized,
-    {
-        let len = slice.len() * std::mem::size_of::<T>();
-        let ptr = slice.as_ptr() as *const u8;
-        std::slice::from_raw_parts(ptr, len)
-    }
-
-    pub unsafe fn from<T>(t: &T) -> &[u8]
-    where
-        T: Copy + Sized,
-    {
-        let len = std::mem::size_of::<T>();
-        let ptr = t as *const T as *const u8;
-        std::slice::from_raw_parts(ptr, len)
-    }
-
-    /// This is really an astonishingly unsafe function.
-    /// Please don't use it.
-    pub unsafe fn to_slice<T>(slice: &[u8]) -> &[T]
-    where
-        T: Copy + Sized,
-    {
-        let size = std::mem::size_of::<T>();
-        let align = std::mem::align_of::<T>();
-        assert_eq!(slice.len() % size, 0, "incorrect buffer size");
-        assert_eq!(
-            slice.as_ptr() as usize % align,
-            0,
-            "incorrect buffer alignment"
-        );
-        let len = slice.len() / size;
-        let ptr = slice.as_ptr() as *const T;
-        std::slice::from_raw_parts(ptr, len)
-    }
-}
diff --git a/nannou_wgpu/src/render_pass.rs b/nannou_wgpu/src/render_pass.rs
deleted file mode 100644
index d69f2597e..000000000
--- a/nannou_wgpu/src/render_pass.rs
+++ /dev/null
@@ -1,219 +0,0 @@
-use crate::{self as wgpu, Color, LoadOp};
-
-/// A builder type to simplify the process of creating a render pass descriptor.
-#[derive(Debug, Default)]
-pub struct Builder<'a> {
-    color_attachments: Vec<Option<wgpu::RenderPassColorAttachment<'a>>>,
-    depth_stencil_attachment: Option<wgpu::RenderPassDepthStencilAttachment<'a>>,
-}
-
-/// A builder type to simplify the process of creating a render pass descriptor.
-#[derive(Debug)]
-pub struct ColorAttachmentDescriptorBuilder<'a> {
-    descriptor: wgpu::RenderPassColorAttachment<'a>,
-}
-
-/// A builder type to simplify the process of creating a render pass descriptor.
-#[derive(Debug)]
-pub struct DepthStencilAttachmentDescriptorBuilder<'a> {
-    descriptor: wgpu::RenderPassDepthStencilAttachment<'a>,
-}
-
-impl<'a> ColorAttachmentDescriptorBuilder<'a> {
-    pub const DEFAULT_CLEAR_COLOR: Color = Color::TRANSPARENT;
-    pub const DEFAULT_LOAD_OP: LoadOp<Color> = LoadOp::Clear(Self::DEFAULT_CLEAR_COLOR);
-    pub const DEFAULT_STORE_OP: bool = true;
-
-    /// Begin building a new render pass color attachment descriptor.
-    fn new(attachment: &'a wgpu::TextureViewHandle) -> Self {
-        ColorAttachmentDescriptorBuilder {
-            descriptor: wgpu::RenderPassColorAttachment {
-                view: attachment,
-                resolve_target: None,
-                ops: wgpu::Operations {
-                    load: LoadOp::Clear(Color::TRANSPARENT),
-                    store: true,
-                },
-            },
-        }
-    }
-
-    /// Specify the resolve target for this render pass color attachment.
-    pub fn resolve_target(mut self, target: Option<&'a wgpu::TextureView>) -> Self {
-        self.descriptor.resolve_target = target.map(|t| &**t);
-        self
-    }
-
-    /// Specify the resolve target for this render pass color attachment.
-    pub fn resolve_target_handle(mut self, target: Option<&'a wgpu::TextureViewHandle>) -> Self {
-        self.descriptor.resolve_target = target;
-        self
-    }
-
-    /// The beginning-of-pass load operation for this color attachment.
-    pub fn load_op(mut self, load_op: LoadOp<Color>) -> Self {
-        self.descriptor.ops.load = load_op;
-        self
-    }
-
-    /// The end-of-pass store operation for this color attachment.
-    pub fn store_op(mut self, store_op: bool) -> Self {
-        self.descriptor.ops.store = store_op;
-        self
-    }
-}
-
-impl<'a> DepthStencilAttachmentDescriptorBuilder<'a> {
-    pub const DEFAULT_DEPTH_LOAD_OP: LoadOp<f32> = LoadOp::Clear(Self::DEFAULT_CLEAR_DEPTH);
-    pub const DEFAULT_DEPTH_STORE_OP: bool = true;
-    pub const DEFAULT_CLEAR_DEPTH: f32 = 1.0;
-    pub const DEFAULT_STENCIL_LOAD_OP: LoadOp<u32> = LoadOp::Clear(Self::DEFAULT_CLEAR_STENCIL);
-    pub const DEFAULT_STENCIL_STORE_OP: bool = true;
-    pub const DEFAULT_CLEAR_STENCIL: u32 = 0;
-
-    fn new(attachment: &'a wgpu::TextureViewHandle) -> Self {
-        DepthStencilAttachmentDescriptorBuilder {
-            descriptor: wgpu::RenderPassDepthStencilAttachment {
-                view: attachment,
-                depth_ops: Some(wgpu::Operations {
-                    load: Self::DEFAULT_DEPTH_LOAD_OP,
-                    store: Self::DEFAULT_DEPTH_STORE_OP,
-                }),
-                stencil_ops: Some(wgpu::Operations {
-                    load: Self::DEFAULT_STENCIL_LOAD_OP,
-                    store: Self::DEFAULT_STENCIL_STORE_OP,
-                }),
-            },
-        }
-    }
-
-    /// The beginning-of-pass load operation for this depth attachment.
-    pub fn depth_load_op(mut self, load: LoadOp<f32>) -> Self {
-        self.descriptor.depth_ops = Some(wgpu::Operations {
-            load,
-            store: self.descriptor.depth_ops.expect("no depth ops field").store,
-        });
-        self
-    }
-
-    /// The end-of-pass store operation for this depth attachment.
-    pub fn depth_store_op(mut self, store: bool) -> Self {
-        self.descriptor.depth_ops = Some(wgpu::Operations {
-            load: self.descriptor.depth_ops.expect("no depth ops field").load,
-            store,
-        });
-        self
-    }
-
-    /// The beginning-of-pass load operation for this stencil attachment.
-    pub fn stencil_load_op(mut self, load: LoadOp<u32>) -> Self {
-        self.descriptor.stencil_ops = Some(wgpu::Operations {
-            load,
-            store: self
-                .descriptor
-                .stencil_ops
-                .expect("no stencil ops field")
-                .store,
-        });
-        self
-    }
-
-    /// The end-of-pass store operation for this stencil attachment.
-    pub fn stencil_store_op(mut self, store: bool) -> Self {
-        self.descriptor.stencil_ops = Some(wgpu::Operations {
-            load: self
-                .descriptor
-                .stencil_ops
-                .expect("no stencil ops field")
-                .load,
-            store,
-        });
-        self
-    }
-}
-
-impl<'a> Builder<'a> {
-    pub const DEFAULT_COLOR_LOAD_OP: LoadOp<Color> =
-        ColorAttachmentDescriptorBuilder::DEFAULT_LOAD_OP;
-    pub const DEFAULT_COLOR_STORE_OP: bool = ColorAttachmentDescriptorBuilder::DEFAULT_STORE_OP;
-    pub const DEFAULT_CLEAR_COLOR: Color = ColorAttachmentDescriptorBuilder::DEFAULT_CLEAR_COLOR;
-    pub const DEFAULT_DEPTH_LOAD_OP: LoadOp<f32> =
-        DepthStencilAttachmentDescriptorBuilder::DEFAULT_DEPTH_LOAD_OP;
-    pub const DEFAULT_DEPTH_STORE_OP: bool =
-        DepthStencilAttachmentDescriptorBuilder::DEFAULT_DEPTH_STORE_OP;
-    pub const DEFAULT_CLEAR_DEPTH: f32 =
-        DepthStencilAttachmentDescriptorBuilder::DEFAULT_CLEAR_DEPTH;
-    pub const DEFAULT_STENCIL_LOAD_OP: LoadOp<u32> =
-        DepthStencilAttachmentDescriptorBuilder::DEFAULT_STENCIL_LOAD_OP;
-    pub const DEFAULT_STENCIL_STORE_OP: bool =
-        DepthStencilAttachmentDescriptorBuilder::DEFAULT_STENCIL_STORE_OP;
-    pub const DEFAULT_CLEAR_STENCIL: u32 =
-        DepthStencilAttachmentDescriptorBuilder::DEFAULT_CLEAR_STENCIL;
-
-    /// Begin building a new render pass descriptor.
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Add a single color attachment descriptor to the render pass descriptor.
-    ///
-    /// Call this multiple times in succession to add multiple color attachments.
-    pub fn color_attachment<F>(
-        mut self,
-        attachment: &'a wgpu::TextureViewHandle,
-        color_builder: F,
-    ) -> Self
-    where
-        F: FnOnce(ColorAttachmentDescriptorBuilder<'a>) -> ColorAttachmentDescriptorBuilder<'a>,
-    {
-        let builder = ColorAttachmentDescriptorBuilder::new(attachment);
-        let descriptor = color_builder(builder).descriptor;
-        self.color_attachments.push(Some(descriptor));
-        self
-    }
-
-    /// Add a depth stencil attachment to the render pass.
-    ///
-    /// This should only be called once, as only a single depth stencil attachment is valid. Only
-    /// the attachment submitted last will be used.
-    pub fn depth_stencil_attachment<F>(
-        mut self,
-        attachment: &'a wgpu::TextureViewHandle,
-        depth_stencil_builder: F,
-    ) -> Self
-    where
-        F: FnOnce(
-            DepthStencilAttachmentDescriptorBuilder<'a>,
-        ) -> DepthStencilAttachmentDescriptorBuilder<'a>,
-    {
-        let builder = DepthStencilAttachmentDescriptorBuilder::new(attachment);
-        let descriptor = depth_stencil_builder(builder).descriptor;
-        self.depth_stencil_attachment = Some(descriptor);
-        self
-    }
-
-    /// Return the built color and depth attachments.
-    pub fn into_inner(
-        self,
-    ) -> (
-        Vec<Option<wgpu::RenderPassColorAttachment<'a>>>,
-        Option<wgpu::RenderPassDepthStencilAttachment<'a>>,
-    ) {
-        let Builder {
-            color_attachments,
-            depth_stencil_attachment,
-        } = self;
-        (color_attachments, depth_stencil_attachment)
-    }
-
-    /// Begin a render pass with the specified parameters on the given encoder.
-    pub fn begin(self, encoder: &'a mut wgpu::CommandEncoder) -> wgpu::RenderPass<'a> {
-        let (color_attachments, depth_stencil_attachment) = self.into_inner();
-        let descriptor = wgpu::RenderPassDescriptor {
-            label: Some("nannou_render_pass"),
-            color_attachments: &color_attachments,
-            depth_stencil_attachment,
-        };
-        encoder.begin_render_pass(&descriptor)
-    }
-}
diff --git a/nannou_wgpu/src/render_pipeline_builder.rs b/nannou_wgpu/src/render_pipeline_builder.rs
deleted file mode 100644
index b4f1ce0f8..000000000
--- a/nannou_wgpu/src/render_pipeline_builder.rs
+++ /dev/null
@@ -1,566 +0,0 @@
-//! Items aimed at easing the contruction of a render pipeline.
-//!
-//! Creating a `RenderPipeline` tends to involve a lot of boilerplate that we don't always want to
-//! have to consider when writing graphics code. Here we define a set of helpers that allow us to
-//! simplify the process and fall back to a set of reasonable defaults.
-
-use crate as wgpu;
-
-#[derive(Debug)]
-enum Layout<'a> {
-    Descriptor(wgpu::PipelineLayoutDescriptor<'a>),
-    Created(&'a wgpu::PipelineLayout),
-}
-
-/// Types that may be directly converted into a pipeline layout descriptor.
-pub trait IntoPipelineLayoutDescriptor<'a> {
-    /// Convert the type into a pipeline layout descriptor.
-    fn into_pipeline_layout_descriptor(self) -> wgpu::PipelineLayoutDescriptor<'a>;
-}
-
-/// A builder type to help simplify the construction of a **RenderPipeline**.
-///
-/// We've attempted to provide a suite of reasonable defaults in the case that none are provided.
-#[derive(Debug)]
-pub struct RenderPipelineBuilder<'a> {
-    layout: Layout<'a>,
-    vs_mod: &'a wgpu::ShaderModule,
-    fs_mod: Option<&'a wgpu::ShaderModule>,
-    vs_entry_point: &'a str,
-    fs_entry_point: &'a str,
-    primitive: wgpu::PrimitiveState,
-    color_state: Option<wgpu::ColorTargetState>,
-    color_states: &'a [Option<wgpu::ColorTargetState>],
-    depth_stencil: Option<wgpu::DepthStencilState>,
-    vertex_buffers: Vec<wgpu::VertexBufferLayout<'static>>,
-    multisample: wgpu::MultisampleState,
-}
-
-impl<'a> RenderPipelineBuilder<'a> {
-    // The default entry point used for shaders when unspecified.
-    pub const DEFAULT_SHADER_ENTRY_POINT: &'static str = "main";
-
-    // Primitive state.
-    pub const DEFAULT_FRONT_FACE: wgpu::FrontFace = wgpu::FrontFace::Ccw;
-    pub const DEFAULT_CULL_MODE: Option<wgpu::Face> = None;
-    pub const DEFAULT_POLYGON_MODE: wgpu::PolygonMode = wgpu::PolygonMode::Fill;
-    pub const DEFAULT_PRIMITIVE_TOPOLOGY: wgpu::PrimitiveTopology =
-        wgpu::PrimitiveTopology::TriangleList;
-    pub const DEFAULT_PRIMITIVE: wgpu::PrimitiveState = wgpu::PrimitiveState {
-        topology: Self::DEFAULT_PRIMITIVE_TOPOLOGY,
-        strip_index_format: None,
-        front_face: Self::DEFAULT_FRONT_FACE,
-        cull_mode: Self::DEFAULT_CULL_MODE,
-        polygon_mode: Self::DEFAULT_POLYGON_MODE,
-        unclipped_depth: Self::DEFAULT_UNCLIPPED_DEPTH,
-        conservative: false,
-    };
-
-    // Color state defaults.
-    pub const DEFAULT_COLOR_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba16Float;
-    pub const DEFAULT_COLOR_BLEND: wgpu::BlendComponent = wgpu::BlendComponent {
-        src_factor: wgpu::BlendFactor::SrcAlpha,
-        dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
-        operation: wgpu::BlendOperation::Add,
-    };
-    pub const DEFAULT_ALPHA_BLEND: wgpu::BlendComponent = wgpu::BlendComponent {
-        src_factor: wgpu::BlendFactor::One,
-        dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
-        operation: wgpu::BlendOperation::Add,
-    };
-    pub const DEFAULT_COLOR_WRITE: wgpu::ColorWrites = wgpu::ColorWrites::ALL;
-    pub const DEFAULT_BLEND_STATE: wgpu::BlendState = wgpu::BlendState {
-        color: Self::DEFAULT_COLOR_BLEND,
-        alpha: Self::DEFAULT_ALPHA_BLEND,
-    };
-    pub const DEFAULT_COLOR_STATE: wgpu::ColorTargetState = wgpu::ColorTargetState {
-        format: Self::DEFAULT_COLOR_FORMAT,
-        blend: Some(Self::DEFAULT_BLEND_STATE),
-        write_mask: Self::DEFAULT_COLOR_WRITE,
-    };
-
-    // Depth state defaults.
-    pub const DEFAULT_DEPTH_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Depth32Float;
-    pub const DEFAULT_DEPTH_WRITE_ENABLED: bool = true;
-    pub const DEFAULT_DEPTH_COMPARE: wgpu::CompareFunction = wgpu::CompareFunction::LessEqual;
-    pub const DEFAULT_STENCIL_FRONT: wgpu::StencilFaceState = wgpu::StencilFaceState::IGNORE;
-    pub const DEFAULT_STENCIL_BACK: wgpu::StencilFaceState = wgpu::StencilFaceState::IGNORE;
-    pub const DEFAULT_STENCIL_READ_MASK: u32 = 0;
-    pub const DEFAULT_STENCIL_WRITE_MASK: u32 = 0;
-    pub const DEFAULT_STENCIL: wgpu::StencilState = wgpu::StencilState {
-        front: Self::DEFAULT_STENCIL_FRONT,
-        back: Self::DEFAULT_STENCIL_BACK,
-        read_mask: Self::DEFAULT_STENCIL_READ_MASK,
-        write_mask: Self::DEFAULT_STENCIL_WRITE_MASK,
-    };
-    pub const DEFAULT_DEPTH_BIAS_CONSTANT: i32 = 0;
-    pub const DEFAULT_DEPTH_BIAS_SLOPE_SCALE: f32 = 0.0;
-    pub const DEFAULT_DEPTH_BIAS_CLAMP: f32 = 0.0;
-    pub const DEFAULT_DEPTH_BIAS: wgpu::DepthBiasState = wgpu::DepthBiasState {
-        constant: Self::DEFAULT_DEPTH_BIAS_CONSTANT,
-        slope_scale: Self::DEFAULT_DEPTH_BIAS_SLOPE_SCALE,
-        clamp: Self::DEFAULT_DEPTH_BIAS_CLAMP,
-    };
-    pub const DEFAULT_UNCLIPPED_DEPTH: bool = false;
-    pub const DEFAULT_DEPTH_STENCIL: wgpu::DepthStencilState = wgpu::DepthStencilState {
-        format: Self::DEFAULT_DEPTH_FORMAT,
-        depth_write_enabled: Self::DEFAULT_DEPTH_WRITE_ENABLED,
-        depth_compare: Self::DEFAULT_DEPTH_COMPARE,
-        stencil: Self::DEFAULT_STENCIL,
-        bias: Self::DEFAULT_DEPTH_BIAS,
-    };
-
-    // Multisample state.
-    pub const DEFAULT_SAMPLE_COUNT: u32 = 1;
-    pub const DEFAULT_SAMPLE_MASK: u64 = !0;
-    pub const DEFAULT_ALPHA_TO_COVERAGE_ENABLED: bool = false;
-    pub const DEFAULT_MULTISAMPLE: wgpu::MultisampleState = wgpu::MultisampleState {
-        count: Self::DEFAULT_SAMPLE_COUNT,
-        mask: Self::DEFAULT_SAMPLE_MASK,
-        alpha_to_coverage_enabled: Self::DEFAULT_ALPHA_TO_COVERAGE_ENABLED,
-    };
-
-    // Constructors
-
-    /// Begin building the render pipeline for the given pipeline layout and the vertex shader
-    /// module.
-    pub fn from_layout(layout: &'a wgpu::PipelineLayout, vs_mod: &'a wgpu::ShaderModule) -> Self {
-        let layout = Layout::Created(layout);
-        Self::new_inner(layout, vs_mod)
-    }
-
-    /// Begin building the render pipeline for a pipeline with the given layout descriptor and the
-    /// vertex shader module.
-    pub fn from_layout_descriptor<T>(layout_desc: T, vs_mod: &'a wgpu::ShaderModule) -> Self
-    where
-        T: IntoPipelineLayoutDescriptor<'a>,
-    {
-        let desc = layout_desc.into_pipeline_layout_descriptor();
-        let layout = Layout::Descriptor(desc);
-        Self::new_inner(layout, vs_mod)
-    }
-
-    // Shared between constructors.
-    fn new_inner(layout: Layout<'a>, vs_mod: &'a wgpu::ShaderModule) -> Self {
-        RenderPipelineBuilder {
-            layout,
-            vs_mod,
-            fs_mod: None,
-            vs_entry_point: Self::DEFAULT_SHADER_ENTRY_POINT,
-            fs_entry_point: Self::DEFAULT_SHADER_ENTRY_POINT,
-            color_state: None,
-            color_states: &[],
-            primitive: Self::DEFAULT_PRIMITIVE,
-            depth_stencil: None,
-            vertex_buffers: vec![],
-            multisample: Self::DEFAULT_MULTISAMPLE,
-        }
-    }
-
-    // Builders
-
-    /// The name of the entry point in the compiled shader.
-    ///
-    /// There must be a function that returns void with this name in the shader.
-    pub fn vertex_entry_point(mut self, entry_point: &'a str) -> Self {
-        self.vs_entry_point = entry_point;
-        self
-    }
-
-    /// The name of the entry point in the compiled shader.
-    ///
-    /// There must be a function that returns void with this name in the shader.
-    pub fn fragment_entry_point(mut self, entry_point: &'a str) -> Self {
-        self.fs_entry_point = entry_point;
-        self
-    }
-
-    /// Specify a compiled fragment shader for the render pipeline.
-    pub fn fragment_shader(mut self, fs_mod: &'a wgpu::ShaderModule) -> Self {
-        self.fs_mod = Some(fs_mod);
-        self
-    }
-
-    // Primitive state.
-
-    /// Specify the full primitive state.
-    ///
-    /// Describes the state of primitive assembly and rasterization in a render pipeline.
-    pub fn primitive(mut self, p: wgpu::PrimitiveState) -> Self {
-        self.primitive = p;
-        self
-    }
-
-    /// The face to consider the front for the purpose of culling and stencil operations.
-    pub fn front_face(mut self, front_face: wgpu::FrontFace) -> Self {
-        self.primitive.front_face = front_face;
-        self
-    }
-
-    /// The face culling mode.
-    pub fn cull_mode(mut self, cull_mode: Option<wgpu::Face>) -> Self {
-        self.primitive.cull_mode = cull_mode;
-        self
-    }
-
-    /// Specify the primitive topology.
-    ///
-    /// This represents the way vertices will be read from the **VertexBuffer**.
-    pub fn primitive_topology(mut self, topology: wgpu::PrimitiveTopology) -> Self {
-        self.primitive.topology = topology;
-        self
-    }
-
-    /// Controls the way each polygon is rasterized. Can be either `Fill` (default), `Line` or
-    /// `Point`.
-    ///
-    /// Setting this to something other than `Fill` requires `Features::NON_FILL_POLYGON_MODE` to
-    /// be enabled.
-    pub fn polygon_mode(mut self, mode: wgpu::PolygonMode) -> Self {
-        self.primitive.polygon_mode = mode;
-        self
-    }
-
-    // Color state.
-
-    /// Specify the full color state for drawing to the output attachment.
-    ///
-    /// If you have multiple output attachments, see the `color_states` method.
-    pub fn color_state(mut self, state: wgpu::ColorTargetState) -> Self {
-        self.color_state = Some(state);
-        self
-    }
-
-    /// The texture formrat of the image that this pipelinew ill render to.
-    ///
-    /// Must match the format of the corresponding color attachment.
-    pub fn color_format(mut self, format: wgpu::TextureFormat) -> Self {
-        let state = self.color_state.get_or_insert(Self::DEFAULT_COLOR_STATE);
-        state.format = format;
-        self
-    }
-
-    /// The color blending used for this pipeline.
-    pub fn color_blend(mut self, color_blend: wgpu::BlendComponent) -> Self {
-        let state = self.color_state.get_or_insert(Self::DEFAULT_COLOR_STATE);
-        let blend = state.blend.get_or_insert(Self::DEFAULT_BLEND_STATE);
-        blend.color = color_blend;
-
-        self
-    }
-
-    /// The alpha blending used for this pipeline.
-    pub fn alpha_blend(mut self, alpha_blend: wgpu::BlendComponent) -> Self {
-        let state = self.color_state.get_or_insert(Self::DEFAULT_COLOR_STATE);
-        let blend = state.blend.get_or_insert(Self::DEFAULT_BLEND_STATE);
-        blend.alpha = alpha_blend;
-
-        self
-    }
-
-    /// Mask which enables/disables writes to different color/alpha channel.
-    pub fn write_mask(mut self, mask: wgpu::ColorWrites) -> Self {
-        let state = self.color_state.get_or_insert(Self::DEFAULT_COLOR_STATE);
-        state.write_mask = mask;
-        self
-    }
-
-    // Depth / Stencil state
-
-    /// Specify the full depth stencil state.
-    pub fn depth_stencil(mut self, state: wgpu::DepthStencilState) -> Self {
-        self.depth_stencil = Some(state);
-        self
-    }
-
-    /// Format of the depth/stencil buffer. Must be one of the depth formats. Must match the format
-    /// of the depth/stencil attachment.
-    pub fn depth_format(mut self, format: wgpu::TextureFormat) -> Self {
-        let state = self
-            .depth_stencil
-            .get_or_insert(Self::DEFAULT_DEPTH_STENCIL);
-        state.format = format;
-        self
-    }
-
-    pub fn depth_write_enabled(mut self, enabled: bool) -> Self {
-        let state = self
-            .depth_stencil
-            .get_or_insert(Self::DEFAULT_DEPTH_STENCIL);
-        state.depth_write_enabled = enabled;
-        self
-    }
-
-    /// Comparison function used to compare depth values in the depth test.
-    pub fn depth_compare(mut self, compare: wgpu::CompareFunction) -> Self {
-        let state = self
-            .depth_stencil
-            .get_or_insert(Self::DEFAULT_DEPTH_STENCIL);
-        state.depth_compare = compare;
-        self
-    }
-
-    /// Specify the full set of stencil parameters.
-    pub fn stencil(mut self, stencil: wgpu::StencilState) -> Self {
-        let state = self
-            .depth_stencil
-            .get_or_insert(Self::DEFAULT_DEPTH_STENCIL);
-        state.stencil = stencil;
-        self
-    }
-
-    /// Front face mode.
-    pub fn stencil_front(mut self, stencil: wgpu::StencilFaceState) -> Self {
-        let state = self
-            .depth_stencil
-            .get_or_insert(Self::DEFAULT_DEPTH_STENCIL);
-        state.stencil.front = stencil;
-        self
-    }
-
-    /// Back face mode.
-    pub fn stencil_back(mut self, stencil: wgpu::StencilFaceState) -> Self {
-        let state = self
-            .depth_stencil
-            .get_or_insert(Self::DEFAULT_DEPTH_STENCIL);
-        state.stencil.back = stencil;
-        self
-    }
-
-    /// Stencil values are AND'd with this mask when reading and writing from the stencil buffer.
-    /// Only low 8 bits are used.
-    pub fn stencil_read_mask(mut self, mask: u32) -> Self {
-        let state = self
-            .depth_stencil
-            .get_or_insert(Self::DEFAULT_DEPTH_STENCIL);
-        state.stencil.read_mask = mask;
-        self
-    }
-
-    /// Stencil values are AND'd with this mask when writing to the stencil buffer.
-    /// Only low 8 bits are used.
-    pub fn stencil_write_mask(mut self, mask: u32) -> Self {
-        let state = self
-            .depth_stencil
-            .get_or_insert(Self::DEFAULT_DEPTH_STENCIL);
-        state.stencil.write_mask = mask;
-        self
-    }
-
-    /// Specify the full set of depth bias parameters.
-    ///
-    /// Describes the biasing setting for the depth target.
-    pub fn depth_bias(mut self, bias: wgpu::DepthBiasState) -> Self {
-        let state = self
-            .depth_stencil
-            .get_or_insert(Self::DEFAULT_DEPTH_STENCIL);
-        state.bias = bias;
-        self
-    }
-
-    /// Constant depth biasing factor, in basic units of the depth format.
-    pub fn depth_bias_constant(mut self, constant: i32) -> Self {
-        let state = self
-            .depth_stencil
-            .get_or_insert(Self::DEFAULT_DEPTH_STENCIL);
-        state.bias.constant = constant;
-        self
-    }
-
-    /// Slope depth biasing factor.
-    pub fn depth_bias_slope_scale(mut self, scale: f32) -> Self {
-        let state = self
-            .depth_stencil
-            .get_or_insert(Self::DEFAULT_DEPTH_STENCIL);
-        state.bias.slope_scale = scale;
-        self
-    }
-
-    /// Depth bias clamp value (absolute).
-    pub fn depth_bias_clamp(mut self, clamp: f32) -> Self {
-        let state = self
-            .depth_stencil
-            .get_or_insert(Self::DEFAULT_DEPTH_STENCIL);
-        state.bias.clamp = clamp;
-        self
-    }
-
-    /// If enabled polygon depth is clamped to 0-1 range instead of being clipped.
-    ///
-    /// Requires `Features::DEPTH_CLIP_CONTROL` enabled.
-    pub fn unclipped_depth(mut self, b: bool) -> Self {
-        self.primitive.unclipped_depth = b;
-        self
-    }
-
-    // Vertex buffer methods.
-
-    /// Add a new vertex buffer descriptor to the render pipeline.
-    pub fn add_vertex_buffer_layout(mut self, d: wgpu::VertexBufferLayout<'static>) -> Self {
-        self.vertex_buffers.push(d);
-        self
-    }
-
-    /// Short-hand for adding a descriptor to the render pipeline describing a buffer of vertices
-    /// of the given vertex type.
-    ///
-    /// The vertex stride is assumed to be equal to `size_of::<V>()`. If this is not the case,
-    /// consider using `add_vertex_buffer_layout` instead.
-    pub fn add_vertex_buffer<V>(self, attrs: &'static [wgpu::VertexAttribute]) -> Self {
-        let array_stride = std::mem::size_of::<V>() as wgpu::BufferAddress;
-        let step_mode = wgpu::VertexStepMode::Vertex;
-        let descriptor = wgpu::VertexBufferLayout {
-            array_stride,
-            step_mode,
-            attributes: attrs,
-        };
-        self.add_vertex_buffer_layout(descriptor)
-    }
-
-    /// Short-hand for adding a descriptor to the render pipeline describing a buffer of instances
-    /// of the given vertex type.
-    pub fn add_instance_buffer<I>(self, attrs: &'static [wgpu::VertexAttribute]) -> Self {
-        let array_stride = std::mem::size_of::<I>() as wgpu::BufferAddress;
-        let step_mode = wgpu::VertexStepMode::Instance;
-        let descriptor = wgpu::VertexBufferLayout {
-            array_stride,
-            step_mode,
-            attributes: attrs,
-        };
-        self.add_vertex_buffer_layout(descriptor)
-    }
-
-    // Multisample state.
-
-    /// Specify the full multisample state.
-    pub fn multisample(mut self, multisample: wgpu::MultisampleState) -> Self {
-        self.multisample = multisample;
-        self
-    }
-
-    /// The number of samples calculated per pixel (for MSAA).
-    ///
-    /// For non-multisampled textures, this should be 1 (the default).
-    pub fn sample_count(mut self, sample_count: u32) -> Self {
-        self.multisample.count = sample_count;
-        self
-    }
-
-    /// Bitmask that restricts the samples of a pixel modified by this pipeline. All samples can be
-    /// enabled using the value !0 (the default).
-    pub fn sample_mask(mut self, sample_mask: u64) -> Self {
-        self.multisample.mask = sample_mask;
-        self
-    }
-
-    /// When enabled, produces another sample mask per pixel based on the alpha output value, that
-    /// is ANDed with the sample_mask and the primitive coverage to restrict the set of samples
-    /// affected by a primitive.
-    ///
-    /// The implicit mask produced for alpha of zero is guaranteed to be zero, and for alpha of one
-    /// is guaranteed to be all 1-s.
-    ///
-    /// Disabled by default.
-    pub fn alpha_to_coverage_enabled(mut self, b: bool) -> Self {
-        self.multisample.alpha_to_coverage_enabled = b;
-        self
-    }
-
-    // Finalising methods.
-
-    /// Build the render pipeline layout, its descriptor and ultimately the pipeline itself with
-    /// the specified parameters.
-    ///
-    /// **Panic!**s in the following occur:
-    ///
-    /// - A rasterization state field was specified but no fragment shader was given.
-    /// - A color state field was specified but no fragment shader was given.
-    pub fn build(self, device: &wgpu::Device) -> wgpu::RenderPipeline {
-        match self.layout {
-            Layout::Descriptor(ref desc) => {
-                let layout = device.create_pipeline_layout(desc);
-                build(self, &layout, device)
-            }
-            Layout::Created(layout) => build(self, layout, device),
-        }
-    }
-}
-
-impl<'a> IntoPipelineLayoutDescriptor<'a> for wgpu::PipelineLayoutDescriptor<'a> {
-    fn into_pipeline_layout_descriptor(self) -> wgpu::PipelineLayoutDescriptor<'a> {
-        self
-    }
-}
-
-impl<'a> IntoPipelineLayoutDescriptor<'a> for &'a [&'a wgpu::BindGroupLayout] {
-    fn into_pipeline_layout_descriptor(self) -> wgpu::PipelineLayoutDescriptor<'a> {
-        wgpu::PipelineLayoutDescriptor {
-            label: Some("nannou render pipeline layout"),
-            bind_group_layouts: self,
-            push_constant_ranges: &[],
-        }
-    }
-}
-
-fn build(
-    builder: RenderPipelineBuilder,
-    layout: &wgpu::PipelineLayout,
-    device: &wgpu::Device,
-) -> wgpu::RenderPipeline {
-    let RenderPipelineBuilder {
-        layout: _layout,
-        vs_mod,
-        fs_mod,
-        vs_entry_point,
-        fs_entry_point,
-        primitive,
-        color_state,
-        color_states,
-        depth_stencil,
-        multisample,
-        vertex_buffers,
-    } = builder;
-
-    let vertex = wgpu::VertexState {
-        module: &vs_mod,
-        entry_point: vs_entry_point,
-        buffers: &vertex_buffers[..],
-    };
-
-    let mut single_color_state = [Some(RenderPipelineBuilder::DEFAULT_COLOR_STATE)];
-    let color_states = match (fs_mod.is_some(), color_states.is_empty()) {
-        (true, true) => {
-            if let cs @ Some(_) = color_state {
-                single_color_state[0] = cs;
-            }
-            &single_color_state[..]
-        }
-        (true, false) => color_states,
-        (false, true) => panic!("specified color states but no fragment shader"),
-        (false, false) => match color_state.is_some() {
-            true => panic!("specified color state fields but no fragment shader"),
-            false => &[],
-        },
-    };
-    let fragment = match (fs_mod, color_states.is_empty()) {
-        (Some(fs_mod), false) => Some(wgpu::FragmentState {
-            module: &fs_mod,
-            entry_point: fs_entry_point,
-            targets: color_states,
-        }),
-        _ => None,
-    };
-
-    let pipeline_desc = wgpu::RenderPipelineDescriptor {
-        label: Some("nannou render pipeline"),
-        layout: Some(layout),
-        vertex,
-        primitive,
-        depth_stencil,
-        multisample,
-        fragment,
-        multiview: None,
-    };
-
-    device.create_render_pipeline(&pipeline_desc)
-}
diff --git a/nannou_wgpu/src/sampler_builder.rs b/nannou_wgpu/src/sampler_builder.rs
deleted file mode 100644
index d5514e406..000000000
--- a/nannou_wgpu/src/sampler_builder.rs
+++ /dev/null
@@ -1,152 +0,0 @@
-use crate as wgpu;
-
-/// Simplifies the construction of a `Sampler` with a set of reasonable defaults.
-#[derive(Debug)]
-pub struct SamplerBuilder {
-    pub descriptor: wgpu::SamplerDescriptor<'static>,
-}
-
-impl<'b> SamplerBuilder {
-    pub const DEFAULT_ADDRESS_MODE_U: wgpu::AddressMode = wgpu::AddressMode::ClampToEdge;
-    pub const DEFAULT_ADDRESS_MODE_V: wgpu::AddressMode = wgpu::AddressMode::ClampToEdge;
-    pub const DEFAULT_ADDRESS_MODE_W: wgpu::AddressMode = wgpu::AddressMode::ClampToEdge;
-    pub const DEFAULT_MAG_FILTER: wgpu::FilterMode = wgpu::FilterMode::Linear;
-    pub const DEFAULT_MIN_FILTER: wgpu::FilterMode = wgpu::FilterMode::Linear;
-    pub const DEFAULT_MIPMAP_FILTER: wgpu::FilterMode = wgpu::FilterMode::Nearest;
-    pub const DEFAULT_LOD_MIN_CLAMP: f32 = 0.0;
-    pub const DEFAULT_LOD_MAX_CLAMP: f32 = 100.0;
-    pub const DEFAULT_COMPARE: Option<wgpu::CompareFunction> = None;
-    pub const DEFAULT_ANISOTROPY_CLAMP: u16 = 1;
-    pub const DEFAULT_LABEL: &'static str = "nannou-sampler";
-    pub const DEFAULT_BORDER_COLOR: Option<wgpu::SamplerBorderColor> = None;
-    pub const DEFAULT_DESCRIPTOR: wgpu::SamplerDescriptor<'static> = wgpu::SamplerDescriptor {
-        address_mode_u: Self::DEFAULT_ADDRESS_MODE_U,
-        address_mode_v: Self::DEFAULT_ADDRESS_MODE_V,
-        address_mode_w: Self::DEFAULT_ADDRESS_MODE_W,
-        mag_filter: Self::DEFAULT_MAG_FILTER,
-        min_filter: Self::DEFAULT_MIN_FILTER,
-        mipmap_filter: Self::DEFAULT_MIPMAP_FILTER,
-        lod_min_clamp: Self::DEFAULT_LOD_MIN_CLAMP,
-        lod_max_clamp: Self::DEFAULT_LOD_MAX_CLAMP,
-        compare: Self::DEFAULT_COMPARE,
-        anisotropy_clamp: Self::DEFAULT_ANISOTROPY_CLAMP,
-        label: Some(Self::DEFAULT_LABEL),
-        border_color: Self::DEFAULT_BORDER_COLOR,
-    };
-
-    /// Begin building a `Sampler`, starting with the `Default` parameters.
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// How the implementation should behave when sampling outside of the texture coordinates range
-    /// [0.0, 1.0].
-    pub fn address_mode_u(mut self, mode: wgpu::AddressMode) -> Self {
-        self.descriptor.address_mode_u = mode;
-        self
-    }
-
-    /// How the implementation should behave when sampling outside of the texture coordinates range
-    /// [0.0, 1.0].
-    pub fn address_mode_v(mut self, mode: wgpu::AddressMode) -> Self {
-        self.descriptor.address_mode_v = mode;
-        self
-    }
-
-    /// How the implementation should behave when sampling outside of the texture coordinates range
-    /// [0.0, 1.0].
-    pub fn address_mode_w(mut self, mode: wgpu::AddressMode) -> Self {
-        self.descriptor.address_mode_w = mode;
-        self
-    }
-
-    /// How the implementation should behave when sampling outside of the texture coordinates range
-    /// [0.0, 1.0].
-    ///
-    /// Applies the same address mode to all axes.
-    pub fn address_mode(self, mode: wgpu::AddressMode) -> Self {
-        self.address_mode_u(mode)
-            .address_mode_v(mode)
-            .address_mode_w(mode)
-    }
-
-    /// How the implementation should sample from the image when it is respectively larger than the
-    /// original.
-    pub fn mag_filter(mut self, filter: wgpu::FilterMode) -> Self {
-        self.descriptor.mag_filter = filter;
-        self
-    }
-
-    /// How the implementation should sample from the image when it is respectively smaller than
-    /// the original.
-    pub fn min_filter(mut self, filter: wgpu::FilterMode) -> Self {
-        self.descriptor.min_filter = filter;
-        self
-    }
-
-    /// How the implementation should choose which mipmap to use.
-    pub fn mipmap_filter(mut self, filter: wgpu::FilterMode) -> Self {
-        self.descriptor.mipmap_filter = filter;
-        self
-    }
-
-    /// The minimum mipmap level to use.
-    pub fn lod_min_clamp(mut self, min: f32) -> Self {
-        self.descriptor.lod_min_clamp = min;
-        self
-    }
-
-    /// The maximum mipmap level to use.
-    pub fn lod_max_clamp(mut self, max: f32) -> Self {
-        self.descriptor.lod_max_clamp = max;
-        self
-    }
-
-    /// The comparison function to use, if any.
-    pub fn compare(mut self, f: Option<wgpu::CompareFunction>) -> Self {
-        self.descriptor.compare = f;
-        self
-    }
-
-    /// The anisotropy level to clamp to, if any.
-    pub fn anisotropy_clamp(mut self, clamp: u16) -> Self {
-        self.descriptor.anisotropy_clamp = clamp;
-        self
-    }
-
-    /// The label to use, if any.
-    pub fn label(mut self, label: Option<&'static str>) -> Self {
-        self.descriptor.label = label;
-        self
-    }
-
-    /// Calls `device.create_sampler(&self.descriptor)` internally.
-    pub fn build(&self, device: &wgpu::Device) -> wgpu::Sampler {
-        device.create_sampler(&self.descriptor)
-    }
-
-    /// Consume the builder and produce the inner `SamplerDescriptor`.
-    pub fn into_descriptor(self) -> wgpu::SamplerDescriptor<'static> {
-        self.into()
-    }
-}
-
-impl Default for SamplerBuilder {
-    fn default() -> Self {
-        SamplerBuilder {
-            descriptor: Self::DEFAULT_DESCRIPTOR,
-        }
-    }
-}
-
-impl Into<wgpu::SamplerDescriptor<'static>> for SamplerBuilder {
-    fn into(self) -> wgpu::SamplerDescriptor<'static> {
-        self.descriptor
-    }
-}
-
-impl From<wgpu::SamplerDescriptor<'static>> for SamplerBuilder {
-    fn from(descriptor: wgpu::SamplerDescriptor<'static>) -> Self {
-        SamplerBuilder { descriptor }
-    }
-}
diff --git a/nannou_wgpu/src/texture/capturer.rs b/nannou_wgpu/src/texture/capturer.rs
deleted file mode 100644
index 9ed8b76a3..000000000
--- a/nannou_wgpu/src/texture/capturer.rs
+++ /dev/null
@@ -1,362 +0,0 @@
-use crate as wgpu;
-use std::fmt;
-use std::future::Future;
-use std::sync::atomic::{self, AtomicU32};
-use std::sync::{Arc, Mutex};
-use std::time::Duration;
-
-use image::{GenericImage, GenericImageView};
-
-/// A type dedicated to capturing a texture as a non-linear sRGBA image that can be read on the
-/// CPU.
-///
-/// Calling **capture** will return a **Snapshot** that may be read after the given command encoder
-/// has been submitted. **Snapshot**s can be read on the current thread via **read** or on a thread
-/// pool via **read_threaded**.
-///
-/// If the **Capturer** is dropped while threaded callbacks are still being processed, the drop
-/// implementation will block the current thread.
-#[derive(Debug, Default)]
-pub struct Capturer {
-    converter_data_pair: Mutex<Option<ConverterDataPair>>,
-    thread_pool: Arc<Mutex<Option<Arc<ThreadPool>>>>,
-    workers: Option<u32>,
-    timeout: Option<Duration>,
-}
-
-/// A wrapper around the futures thread pool that counts active futures.
-#[derive(Debug)]
-struct ThreadPool {
-    active_futures: Arc<AtomicU32>,
-    workers: u32,
-    timeout: Option<Duration>,
-}
-
-/// A snapshot captured by a **Capturer**.
-///
-/// A snapshot is a thin wrapper around a **wgpu::BufferImage** that knows that the image format is
-/// specifically non-linear sRGBA8.
-pub struct Snapshot {
-    buffer: wgpu::RowPaddedBuffer,
-    thread_pool: Arc<Mutex<Option<Arc<ThreadPool>>>>,
-    workers: Option<u32>,
-    timeout: Option<Duration>,
-}
-
-/// An error indicating that the threadpool timed out while waiting for a worker to become
-/// available.
-pub struct AwaitWorkerTimeout<F>(pub F);
-
-#[derive(Debug)]
-struct ConverterDataPair {
-    src_descriptor: wgpu::TextureDescriptor<'static>,
-    reshaper: wgpu::TextureReshaper,
-    dst_texture: wgpu::Texture,
-}
-
-/// A wrapper around a slice of bytes representing a non-linear sRGBA image.
-///
-/// Can be read from a captured `Snapshot`.
-pub struct Rgba8AsyncMappedImageBuffer<'buffer>(wgpu::ImageReadMapping<'buffer>);
-
-impl ThreadPool {
-    /// Spawns the given future if a worker is available. Otherwise, blocks and waits for a worker
-    /// to become available before spawning the future.
-    fn spawn_when_worker_available<F>(&self, future: F) -> Result<(), AwaitWorkerTimeout<F>>
-    where
-        F: 'static + Future<Output = ()> + Send,
-    {
-        // Wait until the number of active futures is less than the number of threads.
-        // If we don't wait, the capture futures may quickly fall far behind the main
-        // swapchain thread resulting in an out of memory error.
-        let mut start = None;
-        let mut interval_us = 128;
-        while self.active_futures() >= self.workers() {
-            if let Some(timeout) = self.timeout {
-                let start = start.get_or_insert_with(instant::Instant::now);
-                if start.elapsed() > timeout {
-                    return Err(AwaitWorkerTimeout(future));
-                }
-            }
-            let duration = Duration::from_micros(interval_us);
-            std::thread::sleep(duration);
-            interval_us *= 2;
-        }
-
-        // Wrap the future with the counter.
-        let active_futures = self.active_futures.clone();
-        let future = async move {
-            active_futures.fetch_add(1, atomic::Ordering::SeqCst);
-            future.await;
-            active_futures.fetch_sub(1, atomic::Ordering::SeqCst);
-        };
-
-        tokio::spawn(future);
-        Ok(())
-    }
-
-    fn active_futures(&self) -> u32 {
-        self.active_futures.load(atomic::Ordering::SeqCst)
-    }
-
-    fn workers(&self) -> u32 {
-        self.workers
-    }
-
-    /// Await for the completion of all active futures, polling the device as necessary until all
-    /// futures have completed.
-    fn await_active_futures(&self, device: &wgpu::Device) -> Result<(), AwaitWorkerTimeout<()>> {
-        let mut start = None;
-        let mut interval_us = 128;
-        while self.active_futures() > 0 {
-            if let Some(timeout) = self.timeout {
-                let start = start.get_or_insert_with(instant::Instant::now);
-                if start.elapsed() > timeout {
-                    return Err(AwaitWorkerTimeout(()));
-                }
-            }
-            device.poll(wgpu::Maintain::Wait);
-            let duration = Duration::from_micros(interval_us);
-            std::thread::sleep(duration);
-            interval_us *= 2;
-        }
-        Ok(())
-    }
-}
-
-impl Capturer {
-    /// The format to which textures will be converted before being mapped back to the CPU.
-    pub const DST_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8UnormSrgb;
-
-    /// Create a new **TextureCapturer**.
-    ///
-    /// Note that a **TextureCapturer** must only be used with a single texture. If you require
-    /// capturing multiple textures, you may create multiple **TextureCapturers**.
-    ///
-    /// `workers` refers to the number of worker threads used to await GPU buffers to be mapped for
-    /// reading and for running user callbacks. If `None` is specified, a threadpool will be
-    /// spawned with a number of threads equal to the number of CPUs available on the system.
-    ///
-    /// `timeout` specifies how long to block and wait for an available worker in the case that all
-    /// workers are busy at the time a `Snapshot::read` occurs. If `None` is specified, calls to
-    /// `Snapshot::read` will never time out (the default behaviour).
-    ///
-    /// Note that the specified parameters are only relevant to calls to `Snapshot::read`. In the
-    /// case that the user uses `Snapshot::read_async`, it is the responsibility of the user to
-    /// execute the future.
-    pub fn new(workers: Option<u32>, timeout: Option<Duration>) -> Self {
-        Capturer {
-            converter_data_pair: Default::default(),
-            thread_pool: Default::default(),
-            workers,
-            timeout,
-        }
-    }
-
-    /// The number of futures currently running on the inner `ThreadPool`.
-    ///
-    /// Note that futures are only run on the threadpool when the `Snapshot::read` method is used.
-    /// In the case that `Snapshot::read_async` is used it is up to the user to track their
-    /// futures.
-    ///
-    /// If the inner thread pool mutex has been poisoned, or if the thread pool has not been
-    /// created due to no calls to `read`, this will return `0`.
-    pub fn active_snapshots(&self) -> u32 {
-        if let Ok(guard) = self.thread_pool.lock() {
-            if let Some(tp) = guard.as_ref() {
-                return tp.active_futures.load(atomic::Ordering::SeqCst);
-            }
-        }
-        0
-    }
-
-    /// The number of worker threads used to await GPU buffers to be mapped for reading and for
-    /// running user callbacks.
-    pub fn workers(&self) -> u32 {
-        if let Ok(guard) = self.thread_pool.lock() {
-            if let Some(tp) = guard.as_ref() {
-                return tp.workers();
-            }
-        }
-        self.workers.unwrap_or(num_cpus::get() as u32)
-    }
-
-    /// Capture the given texture at the state of the given command encoder.
-    pub fn capture(
-        &self,
-        device: &wgpu::Device,
-        encoder: &mut wgpu::CommandEncoder,
-        src_texture: &wgpu::Texture,
-    ) -> Snapshot {
-        let buffer = if src_texture.format() != Self::DST_FORMAT {
-            let mut converter_data_pair = self
-                .converter_data_pair
-                .lock()
-                .expect("failed to lock converter");
-
-            // Create converter and target texture if they don't exist.
-            let converter_data_pair = converter_data_pair
-                .get_or_insert_with(|| create_converter_data_pair(device, src_texture));
-
-            // If the texture has changed in some way, recreate the converter.
-            if !wgpu::texture_descriptor_eq(
-                src_texture.descriptor(),
-                &converter_data_pair.src_descriptor,
-            ) {
-                *converter_data_pair = create_converter_data_pair(device, src_texture);
-            }
-
-            // Encode the texture format conversion.
-            let dst_view = converter_data_pair.dst_texture.view();
-            converter_data_pair
-                .reshaper
-                .encode_render_pass(&dst_view.build(), encoder);
-
-            converter_data_pair.dst_texture.to_buffer(device, encoder)
-        } else {
-            src_texture.to_buffer(device, encoder)
-        };
-
-        Snapshot {
-            buffer,
-            thread_pool: self.thread_pool.clone(),
-            workers: self.workers,
-            timeout: self.timeout,
-        }
-    }
-
-    /// Await for the completion of all `Snapshot::read` active futures, polling the device as
-    /// necessary until all futures have reached completion or until a timeout is reached.
-    pub fn await_active_snapshots(
-        &self,
-        device: &wgpu::Device,
-    ) -> Result<(), AwaitWorkerTimeout<()>> {
-        if let Ok(guard) = self.thread_pool.lock() {
-            if let Some(tp) = guard.as_ref() {
-                return tp.await_active_futures(device);
-            }
-        }
-        Ok(())
-    }
-}
-
-impl Snapshot {
-    /// Reads the non-linear sRGBA image from mapped memory and convert it to an owned buffer.
-    pub async fn read_async<'buffer>(
-        &'buffer self,
-    ) -> Result<Rgba8AsyncMappedImageBuffer<'buffer>, wgpu::BufferAsyncError> {
-        let mapping = self.buffer.read().await?;
-        Ok(Rgba8AsyncMappedImageBuffer(mapping))
-    }
-
-    /// The same as `read_async`, but runs the resulting future on an inner threadpool and calls
-    /// the given callback with the mapped image buffer once complete.
-    ///
-    /// Note: The given callback will not be called until the memory is mapped and the device is
-    /// polled. You should not rely on the callback being called immediately.
-    ///
-    /// Note: The given callback will be called on the inner thread pool and will not be called on
-    /// the current thread.
-    ///
-    /// Note: **This method may block** if the associated `wgpu::TextureCapturer` has an
-    /// `active_futures` count that is greater than the number of worker threads with which it was
-    /// created. This is necessary in order to avoid "out of memory" errors resulting from an
-    /// accumulating queue of pending texture buffers waiting to be mapped. To avoid blocking, you
-    /// can try using a higher thread count, capturing a smaller texture, or using `read_async`
-    /// instead and running the resulting future on a custom runtime or threadpool.
-    pub fn read<F>(self, callback: F) -> Result<(), AwaitWorkerTimeout<impl Future<Output = ()>>>
-    where
-        F: 'static + Send + FnOnce(Result<Rgba8AsyncMappedImageBuffer, wgpu::BufferAsyncError>),
-    {
-        let thread_pool = self.thread_pool();
-        let read_future = async move {
-            let res = self.read_async().await;
-            callback(res);
-        };
-        thread_pool.spawn_when_worker_available(read_future)
-    }
-
-    fn thread_pool(&self) -> Arc<ThreadPool> {
-        let mut guard = self
-            .thread_pool
-            .lock()
-            .expect("failed to acquire thread handle");
-        let thread_pool = guard.get_or_insert_with(|| {
-            let workers = self.workers.unwrap_or(num_cpus::get() as u32);
-            let thread_pool = ThreadPool {
-                active_futures: Arc::new(AtomicU32::new(0)),
-                workers,
-                timeout: self.timeout,
-            };
-            Arc::new(thread_pool)
-        });
-        thread_pool.clone()
-    }
-}
-
-impl<'b> Rgba8AsyncMappedImageBuffer<'b> {
-    pub fn as_image(&self) -> image::SubImage<wgpu::ImageHolder<image::Rgba<u8>>> {
-        // safe: we know it's Rgba<u8>
-        unsafe { self.0.as_image::<image::Rgba<u8>>() }
-    }
-    /// Convert the mapped image buffer to an owned buffer.
-    pub fn to_owned(&self) -> image::ImageBuffer<image::Rgba<u8>, Vec<u8>> {
-        let view = self.as_image();
-        let mut result = image::ImageBuffer::new(view.width(), view.height());
-        result
-            .copy_from(&view, 0, 0)
-            .expect("nannou internal error: image copy failed");
-        result
-    }
-}
-
-impl<T> std::error::Error for AwaitWorkerTimeout<T> {}
-
-impl<T> fmt::Debug for AwaitWorkerTimeout<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("AwaitWorkerTimeout").finish()
-    }
-}
-
-impl<T> fmt::Display for AwaitWorkerTimeout<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("AwaitWorkerTimeout").finish()
-    }
-}
-
-// Create the format converter and the target texture.
-fn create_converter_data_pair(
-    device: &wgpu::Device,
-    src_texture: &wgpu::Texture,
-) -> ConverterDataPair {
-    // Create the destination format texture.
-    let dst_texture = wgpu::TextureBuilder::from(src_texture.descriptor.clone())
-        .sample_count(1)
-        .format(Capturer::DST_FORMAT)
-        .usage(wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC)
-        .build(device);
-
-    // Create the converter.
-    let src_sample_count = src_texture.sample_count();
-    let src_sample_type = src_texture.sample_type();
-    let src_view = src_texture.create_view(&wgpu::TextureViewDescriptor::default());
-    let dst_sample_count = 1;
-    let dst_format = dst_texture.format();
-    let reshaper = wgpu::TextureReshaper::new(
-        device,
-        &src_view,
-        src_sample_count,
-        src_sample_type,
-        dst_sample_count,
-        dst_format,
-    );
-
-    // Keep track of the `src_descriptor` to check if we need to recreate the converter.
-    let src_descriptor = src_texture.descriptor.clone();
-
-    ConverterDataPair {
-        src_descriptor,
-        reshaper,
-        dst_texture,
-    }
-}
diff --git a/nannou_wgpu/src/texture/image.rs b/nannou_wgpu/src/texture/image.rs
deleted file mode 100644
index 95eb1de4e..000000000
--- a/nannou_wgpu/src/texture/image.rs
+++ /dev/null
@@ -1,797 +0,0 @@
-//! Items related to the inter-operation of the `image` crate (images on disk and in RAM) and
-//! textures from the wgpu crate (images in GPU memory).
-//!
-//! This module can be enabled via the `image` feature.
-
-use crate as wgpu;
-use std::ops::Deref;
-use std::path::Path;
-
-/// The set of pixel types from the image crate that can be loaded directly into a texture.
-///
-/// The `Rgba8` and `Bgra8` color types are assumed to be non-linear sRGB.
-///
-/// Note that wgpu only supports texture formats whose size are a power of 2. If you notice a
-/// `image::Pixel` type that does not implement `Pixel`, this is likely why.
-pub trait Pixel: image::Pixel {
-    /// The wgpu texture format of the pixel type.
-    const TEXTURE_FORMAT: wgpu::TextureFormat;
-}
-
-/// A wrapper around a slice of bytes representing an image.
-///
-/// An `ImageReadMapping` may only be created via `RowPaddedBuffer::read()`.
-pub struct ImageReadMapping<'buffer> {
-    buffer: &'buffer wgpu::RowPaddedBuffer,
-    view: wgpu::BufferView<'buffer>,
-}
-
-/// Workaround for the fact that `image::SubImage` requires a `Deref` impl on the wrapped image.
-pub struct ImageHolder<'b, P: Pixel>(image::ImageBuffer<P, &'b [P::Subpixel]>);
-impl<'b, P: Pixel> Deref for ImageHolder<'b, P> {
-    type Target = image::ImageBuffer<P, &'b [P::Subpixel]>;
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl wgpu::TextureBuilder {
-    /// The minimum required texture usage when loading from an image.
-    pub const REQUIRED_IMAGE_TEXTURE_USAGE: wgpu::TextureUsages = wgpu::TextureUsages::COPY_DST;
-
-    /// Produce a texture descriptor from an image.
-    ///
-    /// Specifically, this supports any image type implementing `image::GenericImageView` whose
-    /// `Pixel` type implements `Pixel`.
-    ///
-    /// By default, the produced builder will have the `wgpu::TextureUsages` returned by
-    /// `wgpu::TextureBuilder::default_image_texture_usage()`. This is a general-purpose usage that
-    /// should allow for copying to and from the texture, sampling the texture and rendering to the
-    /// texture. Specifying only the texture usage required may result in better performance. It
-    /// may be necessary to manually specify the the usage if `STORAGE` is required.
-    pub fn from_image_view<T>(image_view: &T) -> Self
-    where
-        T: image::GenericImageView,
-        T::Pixel: Pixel,
-    {
-        builder_from_image_view(image_view)
-    }
-
-    /// The default texture usage for the case where a user has loaded a texture from an image.
-    pub fn default_image_texture_usage() -> wgpu::TextureUsages {
-        wgpu::TextureUsages::COPY_SRC
-            | wgpu::TextureUsages::COPY_DST
-            | wgpu::TextureUsages::TEXTURE_BINDING
-            | wgpu::TextureUsages::RENDER_ATTACHMENT
-    }
-}
-
-/// Types that may provide access to a `wgpu::Device` and an associated `wgpu::Queue` for loading
-/// a texture from an image.
-///
-/// Notably, implementations exist for `&App`, `&Window`, `&wgpu::DeviceQueuePair` and `(&Device,
-/// &Queue)`.
-pub trait WithDeviceQueuePair {
-    fn with_device_queue_pair<F, O>(self, f: F) -> O
-    where
-        F: FnOnce(&wgpu::Device, &wgpu::Queue) -> O;
-}
-
-impl wgpu::Texture {
-    /// Load an image from the given path and upload it as a texture.
-    ///
-    /// The device and queue `src` can be either the `App`, a `Window`, a `wgpu::DeviceQueuePair`
-    /// or a tuple `(&wgpu::Device, &mut wgpu::Queue)`. Access to a `Device` is necessary in order
-    /// to create the texture and buffer GPU resources, and access to a `Queue` is necessary for
-    /// submitting the commands responsible for copying the buffer contents to the texture. Note
-    /// that a texture may only be used with the device with which it was created. This is worth
-    /// keeping in mind if you have more than one window and they do not share the same device.
-    ///
-    /// By default, the texture will have the `COPY_SRC`, `COPY_DST`, `SAMPLED` and
-    /// `RENDER_ATTACHMENT` usages enabled. If you wish to specify the usage yourself, see the
-    /// `load_from_path` constructor.
-    ///
-    /// If the `&App` is passed as the `src`, the window returned via `app.main_window()` will be
-    /// used as the source of the device and queue.
-    pub fn from_path<T, P>(src: T, path: P) -> image::ImageResult<Self>
-    where
-        T: WithDeviceQueuePair,
-        P: AsRef<Path>,
-    {
-        let path = path.as_ref();
-        let usage = wgpu::TextureBuilder::default_image_texture_usage();
-        src.with_device_queue_pair(|device, queue| {
-            wgpu::Texture::load_from_path(device, queue, usage, path)
-        })
-    }
-
-    /// Load a texture from the given image.
-    ///
-    /// The device and queue `src` can be either the `App`, a `Window`, a `wgpu::DeviceQueuePair`
-    /// or a tuple `(&wgpu::Device, &mut wgpu::Queue)`. Access to a `Device` is necessary in order
-    /// to create the texture and buffer GPU resources, and access to a `Queue` is necessary for
-    /// submitting the commands responsible for copying the buffer contents to the texture. Note
-    /// that a texture may only be used with the device with which it was created. This is worth
-    /// keeping in mind if you have more than one window and they do not share the same device.
-    ///
-    /// By default, the texture will have the `COPY_SRC`, `COPY_DST`, `SAMPLED` and
-    /// `RENDER_ATTACHMENT` usages enabled. If you wish to specify the usage yourself, see the
-    /// `load_from_path` constructor.
-    ///
-    /// If the `&App` is passed as the `src`, the window returned via `app.main_window()` will be
-    /// used as the source of the device and queue.
-    ///
-    /// The `DeviceQueuePairSource` can be either the `App`, a `Window`, a `DeviceQueuePair` or a
-    /// tuple `(&Device, &Queue)`.
-    pub fn from_image<T>(src: T, image: &image::DynamicImage) -> Self
-    where
-        T: WithDeviceQueuePair,
-    {
-        let usage = wgpu::TextureBuilder::default_image_texture_usage();
-        src.with_device_queue_pair(|device, queue| {
-            wgpu::Texture::load_from_image(device, queue, usage, image)
-        })
-    }
-
-    /// Read an image file from the given path and load it directly into a texture.
-    ///
-    /// This is short-hand for calling `image::open` and then `Texture::load_from_image`.
-    pub fn load_from_path<P>(
-        device: &wgpu::Device,
-        queue: &wgpu::Queue,
-        usage: wgpu::TextureUsages,
-        path: P,
-    ) -> image::ImageResult<Self>
-    where
-        P: AsRef<Path>,
-    {
-        let path = path.as_ref();
-        let image = image::open(path)?;
-        Ok(Self::load_from_image(device, queue, usage, &image))
-    }
-
-    /// Load a texture directly from a dynamic image.
-    ///
-    /// If the image is already in a format supported by wgpu, no conversions are performed and the
-    /// image is loaded directly as-is with a texture format that matches the original image color
-    /// type.
-    ///
-    /// If the image is of an unsupported format, it will be converted to the closest supported format
-    /// before being uploaded.
-    pub fn load_from_image(
-        device: &wgpu::Device,
-        queue: &wgpu::Queue,
-        usage: wgpu::TextureUsages,
-        image: &image::DynamicImage,
-    ) -> Self {
-        load_texture_from_image(device, queue, usage, image)
-    }
-
-    /// Load a texture directly from an image buffer using the given device queue.
-    ///
-    /// No format or size conversions are performed - the given buffer is loaded directly into GPU
-    /// memory.
-    ///
-    /// Pixel type compatibility is ensured via the `Pixel` trait.
-    pub fn load_from_image_buffer<P, Container>(
-        device: &wgpu::Device,
-        queue: &wgpu::Queue,
-        usage: wgpu::TextureUsages,
-        buffer: &image::ImageBuffer<P, Container>,
-    ) -> Self
-    where
-        P: 'static + Pixel,
-        Container: std::ops::Deref<Target = [P::Subpixel]>,
-    {
-        load_texture_from_image_buffer(device, queue, usage, buffer)
-    }
-
-    /// Load a texture array directly from a sequence of image buffers.
-    ///
-    /// No format or size conversions are performed - the given buffer is loaded directly into GPU
-    /// memory.
-    ///
-    /// Pixel type compatibility is ensured via the `Pixel` trait.
-    ///
-    /// Returns `None` if there are no images in the given sequence.
-    pub fn load_array_from_image_buffers<'a, I, P, Container>(
-        device: &wgpu::Device,
-        queue: &wgpu::Queue,
-        usage: wgpu::TextureUsages,
-        buffers: I,
-    ) -> Option<Self>
-    where
-        I: IntoIterator<Item = &'a image::ImageBuffer<P, Container>>,
-        I::IntoIter: ExactSizeIterator,
-        P: 'static + Pixel,
-        Container: 'a + std::ops::Deref<Target = [P::Subpixel]>,
-    {
-        load_texture_array_from_image_buffers(device, queue, usage, buffers)
-    }
-
-    /// Encode the necessary commands to load a texture directly from a dynamic image.
-    ///
-    /// If the image is already in a format supported by wgpu, no conversions are performed and the
-    /// image is loaded directly as-is with a texture format that matches the original image color
-    /// type.
-    ///
-    /// If the image is of an unsupported format, it will be converted to the closest supported format
-    /// before being uploaded.
-    ///
-    /// NOTE: The returned texture will remain empty until the given `encoder` has its command buffer
-    /// submitted to the given `device`'s queue.
-    pub fn encode_load_from_image(
-        device: &wgpu::Device,
-        encoder: &mut wgpu::CommandEncoder,
-        usage: wgpu::TextureUsages,
-        image: &image::DynamicImage,
-    ) -> Self {
-        encode_load_texture_from_image(device, encoder, usage, image)
-    }
-
-    /// Encode the necessary commands to load a texture from the given image buffer.
-    ///
-    /// NOTE: The returned texture will remain empty until the given `encoder` has its command
-    /// buffer submitted to the given `device`'s queue.
-    ///
-    /// No format or size conversions are performed - the given buffer is loaded directly into GPU
-    /// memory.
-    ///
-    /// Pixel type compatibility is ensured via the `Pixel` trait.
-    pub fn encode_load_from_image_buffer<P, Container>(
-        device: &wgpu::Device,
-        encoder: &mut wgpu::CommandEncoder,
-        usage: wgpu::TextureUsages,
-        buffer: &image::ImageBuffer<P, Container>,
-    ) -> Self
-    where
-        P: 'static + Pixel,
-        Container: std::ops::Deref<Target = [P::Subpixel]>,
-    {
-        encode_load_texture_from_image_buffer(device, encoder, usage, buffer)
-    }
-
-    /// Encode the necessary commands to load a 3d texture directly from a sequence of image
-    /// buffers.
-    ///
-    /// NOTE: The returned texture will remain empty until the given `encoder` has its command buffer
-    /// submitted to the given `device`'s queue.
-    ///
-    /// NOTE: The returned texture will be 3d; you must create
-    ///
-    /// No format or size conversions are performed - the given buffer is loaded directly into GPU
-    /// memory.
-    ///
-    /// Pixel type compatibility is ensured via the `Pixel` trait.
-    ///
-    /// Returns `None` if there are no images in the given sequence.
-    pub fn encode_load_3d_from_image_buffers<'a, I, P, Container>(
-        device: &wgpu::Device,
-        encoder: &mut wgpu::CommandEncoder,
-        usage: wgpu::TextureUsages,
-        buffers: I,
-    ) -> Option<Self>
-    where
-        I: IntoIterator<Item = &'a image::ImageBuffer<P, Container>>,
-        I::IntoIter: ExactSizeIterator,
-        P: 'static + Pixel,
-        Container: 'a + std::ops::Deref<Target = [P::Subpixel]>,
-    {
-        encode_load_texture_array_from_image_buffers(device, encoder, usage, buffers)
-    }
-}
-
-impl wgpu::RowPaddedBuffer {
-    /// Initialize from an image buffer (i.e. an image on CPU).
-    pub fn from_image_buffer<P, Container>(
-        device: &wgpu::Device,
-        image_buffer: &image::ImageBuffer<P, Container>,
-    ) -> Self
-    where
-        P: 'static + Pixel,
-        Container: std::ops::Deref<Target = [P::Subpixel]>,
-    {
-        let result = Self::new(
-            device,
-            image_buffer.width() * P::COLOR_TYPE.bytes_per_pixel() as u32,
-            image_buffer.height(),
-            wgpu::BufferUsages::MAP_WRITE | wgpu::BufferUsages::COPY_SRC,
-        );
-        // TODO:
-        // This can theoretically be exploited by implementing `image::Primitive` for some type
-        // that has padding. Instead, should make some `Subpixel` trait that we can control and is
-        // only guaranteed to be implemented for safe types.
-        result.write(unsafe { wgpu::bytes::from_slice(&*image_buffer) });
-        result
-    }
-
-    /// Asynchronously maps the buffer of bytes from GPU to host memory.
-    ///
-    /// Note: The returned future will not be ready until the memory is mapped and the device is
-    /// polled. You should *not* rely on the being ready immediately.
-    pub async fn read<'b>(&'b self) -> Result<ImageReadMapping<'b>, wgpu::BufferAsyncError> {
-        let slice = self.buffer.slice(..);
-        let (tx, rx) = futures::channel::oneshot::channel();
-
-        slice.map_async(wgpu::MapMode::Read, |res| {
-            tx.send(res).expect("Failed to send map_async result");
-        });
-
-        rx.await.expect("Failed to receive map_async result")?;
-
-        Ok(wgpu::ImageReadMapping {
-            buffer: self,
-            // fun exercise:
-            // read the signature of wgpu::BufferSlice::get_mapped_range()
-            // and try to figure out why we don't need another lifetime in ImageReadMapping :)
-            view: slice.get_mapped_range(),
-        })
-    }
-}
-
-impl<'buffer> ImageReadMapping<'buffer> {
-    /// View as an image::SubImage.
-    ///
-    /// Unsafe: `P::TEXTURE_FORMAT` MUST match the texture format / image type used to create the
-    /// wrapped RowPaddedBuffer! If this is not the case, may result in undefined behavior!
-    pub unsafe fn as_image<P>(&self) -> image::SubImage<ImageHolder<P>>
-    where
-        P: Pixel + 'static,
-    {
-        let subpixel_size = std::mem::size_of::<P::Subpixel>() as u32;
-        let pixel_size = subpixel_size * P::CHANNEL_COUNT as u32;
-        assert_eq!(pixel_size, P::COLOR_TYPE.bytes_per_pixel() as u32);
-
-        assert_eq!(
-            self.buffer.padded_width() % pixel_size,
-            0,
-            "buffer padded width not an even multiple of primitive size"
-        );
-        assert_eq!(
-            self.buffer.width() % pixel_size,
-            0,
-            "buffer row width not an even multiple of primitive size"
-        );
-
-        let width_pixels = self.buffer.width() / pixel_size;
-        let padded_width_pixels = self.buffer.padded_width() / pixel_size;
-
-        // ways this cast could go wrong:
-        // - buffer is the wrong size: checked in to_slice, panics
-        // - buffer is the wrong alignment: checked in to_slice, panics
-        // - buffer rows are the wrong size: checked above, panics
-        // - buffer has not been initialized / has invalid data for primitive type:
-        //   very possible. That's why this function is `unsafe`.
-        let container = wgpu::bytes::to_slice::<P::Subpixel>(&self.view[..]);
-
-        let full_image =
-            image::ImageBuffer::from_raw(padded_width_pixels, self.buffer.height(), container)
-                .expect("nannou internal error: incorrect buffer size");
-        image::SubImage::new(
-            ImageHolder(full_image),
-            0,
-            0,
-            width_pixels,
-            self.buffer.height(),
-        )
-    }
-}
-
-impl Pixel for image::Bgra<u8> {
-    const TEXTURE_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Bgra8UnormSrgb;
-}
-
-impl Pixel for image::Luma<u8> {
-    const TEXTURE_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::R8Unorm;
-}
-
-impl Pixel for image::Luma<i8> {
-    const TEXTURE_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::R8Snorm;
-}
-
-impl Pixel for image::Luma<u16> {
-    const TEXTURE_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::R16Uint;
-}
-
-impl Pixel for image::Luma<i16> {
-    const TEXTURE_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::R16Sint;
-}
-
-impl Pixel for image::LumaA<u8> {
-    const TEXTURE_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rg8Unorm;
-}
-
-impl Pixel for image::LumaA<i8> {
-    const TEXTURE_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rg8Snorm;
-}
-
-impl Pixel for image::LumaA<u16> {
-    const TEXTURE_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rg16Uint;
-}
-
-impl Pixel for image::LumaA<i16> {
-    const TEXTURE_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rg16Sint;
-}
-
-impl Pixel for image::Rgba<u8> {
-    const TEXTURE_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8UnormSrgb;
-}
-
-impl Pixel for image::Rgba<i8> {
-    const TEXTURE_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Snorm;
-}
-
-impl Pixel for image::Rgba<u16> {
-    const TEXTURE_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba16Uint;
-}
-
-impl Pixel for image::Rgba<i16> {
-    const TEXTURE_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba16Sint;
-}
-
-impl<'a> WithDeviceQueuePair for (&'a wgpu::Device, &'a wgpu::Queue) {
-    fn with_device_queue_pair<F, O>(self, f: F) -> O
-    where
-        F: FnOnce(&wgpu::Device, &wgpu::Queue) -> O,
-    {
-        let (device, queue) = self;
-        f(device, queue)
-    }
-}
-
-impl<'a> WithDeviceQueuePair for &'a wgpu::DeviceQueuePair {
-    fn with_device_queue_pair<F, O>(self, f: F) -> O
-    where
-        F: FnOnce(&wgpu::Device, &wgpu::Queue) -> O,
-    {
-        let device = self.device();
-        let queue = self.queue();
-        f(&*device, &*queue)
-    }
-}
-
-impl<'a, 'b, T> wgpu::WithDeviceQueuePair for &'a std::cell::Ref<'b, T>
-where
-    &'a T: wgpu::WithDeviceQueuePair,
-{
-    fn with_device_queue_pair<F, O>(self, f: F) -> O
-    where
-        F: FnOnce(&wgpu::Device, &wgpu::Queue) -> O,
-    {
-        (**self).with_device_queue_pair(f)
-    }
-}
-
-/// Convert the given color type from the `image` crate to the corresponding wgpu texture format.
-///
-/// Returns `None` if there is no directly compatible texture format - this is normally the case if
-/// the `ColorType` would have a bits_per_pixel that is not equal to a power of 2.
-///
-/// The `Rgba8` and `Bgra8` color types are assumed to be non-linear sRGB.
-pub fn format_from_image_color_type(color_type: image::ColorType) -> Option<wgpu::TextureFormat> {
-    let format = match color_type {
-        image::ColorType::L8 => wgpu::TextureFormat::R8Unorm,
-        image::ColorType::La8 => wgpu::TextureFormat::Rg8Unorm,
-        image::ColorType::Rgba8 => wgpu::TextureFormat::Rgba8UnormSrgb,
-        image::ColorType::L16 => wgpu::TextureFormat::R16Uint,
-        image::ColorType::La16 => wgpu::TextureFormat::Rg16Uint,
-        image::ColorType::Rgba16 => wgpu::TextureFormat::Rgba16Uint,
-        image::ColorType::Bgra8 => wgpu::TextureFormat::Bgra8UnormSrgb,
-        _ => return None,
-    };
-    Some(format)
-}
-
-/// Produce a texture descriptor from any type implementing `image::GenericImageView` whose `Pixel`
-/// type implements `Pixel`.
-///
-/// By default, the produced builder will have the `wgpu::TextureUsages` returned by
-/// `wgpu::TextureBuilder::default_image_texture_usage()`. This is a general-purpose usage that
-/// should allow for copying to and from the texture, sampling the texture and rendering to the
-/// texture. Specifying only the texture usage required may result in better performance. It
-/// may be necessary to manually specify the the usage if `STORAGE` is required.
-pub fn builder_from_image_view<T>(image: &T) -> wgpu::TextureBuilder
-where
-    T: image::GenericImageView,
-    T::Pixel: Pixel,
-{
-    let (width, height) = image.dimensions();
-    let format = <T::Pixel as Pixel>::TEXTURE_FORMAT;
-    wgpu::TextureBuilder::new()
-        .size([width, height])
-        .format(format)
-        .usage(wgpu::TextureBuilder::default_image_texture_usage())
-}
-
-/// Load a texture directly from a dynamic image.
-///
-/// This uses the `Queue::write_texture` method, meaning that the texture is not immediately
-/// written. Rather, the write is enqueued internally and scheduled to happen at the start of the
-/// next call to `Queue::submit`.
-///
-/// If the image is already in a format supported by wgpu, no conversions are performed and the
-/// image is loaded directly as-is with a texture format that matches the original image color
-/// type.
-///
-/// If the image is of an unsupported format, it will be converted to the closest supported format
-/// before being uploaded.
-pub fn load_texture_from_image(
-    device: &wgpu::Device,
-    queue: &wgpu::Queue,
-    usage: wgpu::TextureUsages,
-    image: &image::DynamicImage,
-) -> wgpu::Texture {
-    use image::DynamicImage::*;
-    match image {
-        ImageLuma8(img) => load_texture_from_image_buffer(device, queue, usage, img),
-        ImageLumaA8(img) => load_texture_from_image_buffer(device, queue, usage, img),
-        ImageRgba8(img) => load_texture_from_image_buffer(device, queue, usage, img),
-        ImageBgra8(img) => load_texture_from_image_buffer(device, queue, usage, img),
-        ImageLuma16(img) => load_texture_from_image_buffer(device, queue, usage, img),
-        ImageLumaA16(img) => load_texture_from_image_buffer(device, queue, usage, img),
-        ImageRgba16(img) => load_texture_from_image_buffer(device, queue, usage, img),
-        ImageRgb8(_img) => {
-            let img = image.to_rgba8();
-            load_texture_from_image_buffer(device, queue, usage, &img)
-        }
-        ImageBgr8(_img) => {
-            let img = image.to_bgra8();
-            load_texture_from_image_buffer(device, queue, usage, &img)
-        }
-        ImageRgb16(_img) => {
-            let img = image.to_rgba16();
-            load_texture_from_image_buffer(device, queue, usage, &img)
-        }
-    }
-}
-
-/// Load a texture directly from an image buffer using the given device queue.
-///
-/// This uses the `Queue::write_texture` method, meaning that the texture is not immediately
-/// written. Rather, the write is enqueued internally and scheduled to happen at the start of the
-/// next call to `Queue::submit`.
-///
-/// No format or size conversions are performed - the given buffer is loaded directly into GPU
-/// memory.
-///
-/// Pixel type compatibility is ensured via the `Pixel` trait.
-pub fn load_texture_from_image_buffer<P, Container>(
-    device: &wgpu::Device,
-    queue: &wgpu::Queue,
-    usage: wgpu::TextureUsages,
-    buffer: &image::ImageBuffer<P, Container>,
-) -> wgpu::Texture
-where
-    P: 'static + Pixel,
-    Container: std::ops::Deref<Target = [P::Subpixel]>,
-{
-    // Create the texture.
-    let texture = wgpu::TextureBuilder::from_image_view(buffer)
-        .usage(wgpu::TextureBuilder::REQUIRED_IMAGE_TEXTURE_USAGE | usage)
-        .build(device);
-
-    // Describe the layout of the data.
-    let extent = texture.extent();
-    let format = texture.format();
-    let block_size = format
-        .block_size(None)
-        .expect("Expected the format to have a block size");
-    let bytes_per_row = extent.width * block_size as u32;
-    let image_data_layout = wgpu::ImageDataLayout {
-        offset: 0,
-        bytes_per_row: Some(bytes_per_row),
-        rows_per_image: None,
-    };
-
-    // Copy into the entire texture.
-    let image_copy_texture = texture.as_image_copy();
-
-    // TODO:
-    // This can theoretically be exploited by implementing our `image::Pixel` trait for some type
-    // that has padding. Perhaps it should be an unsafe trait? Should investigate how to achieve
-    // this in a safer manner.
-    let data = unsafe { wgpu::bytes::from_slice(&*buffer) };
-
-    queue.write_texture(image_copy_texture, data, image_data_layout, extent);
-    texture
-}
-
-/// Load a 3d texture directly from a sequence of image buffers.
-///
-/// No format or size conversions are performed - the given buffer is loaded directly into GPU
-/// memory.
-///
-/// Pixel type compatibility is ensured via the `Pixel` trait.
-///
-/// Returns `None` if there are no images in the given sequence.
-pub fn load_texture_array_from_image_buffers<'a, I, P, Container>(
-    device: &wgpu::Device,
-    queue: &wgpu::Queue,
-    usage: wgpu::TextureUsages,
-    buffers: I,
-) -> Option<wgpu::Texture>
-where
-    I: IntoIterator<Item = &'a image::ImageBuffer<P, Container>>,
-    I::IntoIter: ExactSizeIterator,
-    P: 'static + Pixel,
-    Container: 'a + std::ops::Deref<Target = [P::Subpixel]>,
-{
-    let mut buffers = buffers.into_iter();
-    let array_layers = buffers.len() as u32;
-    let first_buffer = buffers.next()?;
-
-    // Build the texture ready to receive the data.
-    let (width, height) = first_buffer.dimensions();
-    let extent = wgpu::Extent3d {
-        width,
-        height,
-        depth_or_array_layers: array_layers,
-    };
-    let texture = wgpu::TextureBuilder::from_image_view(first_buffer)
-        .extent(extent)
-        .dimension(wgpu::TextureDimension::D2) // force an array
-        .usage(wgpu::TextureBuilder::REQUIRED_IMAGE_TEXTURE_USAGE | usage)
-        .build(device);
-
-    // Describe the layout of the data.
-    let format = texture.format();
-    let block_size = format
-        .block_size(None)
-        .expect("Expected the format to have a block size");
-    let bytes_per_row = extent.width * block_size as u32;
-    let image_data_layout = wgpu::ImageDataLayout {
-        offset: 0,
-        bytes_per_row: Some(bytes_per_row),
-        rows_per_image: Some(height),
-    };
-
-    // Collect the data into a single slice.
-    //
-    // NOTE: Previously we used `encode_load_texture_array_from_image_buffers` which avoids
-    // collecting the image data into a single slice. However, the `wgpu::Texture::from_*`
-    // constructors have been changed to avoid submitting an extra command buffer in favour
-    // of using `Queue::write_texture` which schedules the write for the next call to
-    // `Queue::submit`. This is to avoid an Intel driver bug where submitting more than one command
-    // buffer per frame appears to be causing issues:
-    // https://github.com/gfx-rs/wgpu/issues/1672#issuecomment-917510810
-    //
-    // While this likely means consuming more RAM, it also likely results in slightly better
-    // performance due to reducing the number of command buffers submitted.
-    //
-    // Users can still use `encode_load_texture_array_from_image_buffers` directly if they wish.
-    let capacity = bytes_per_row as usize * height as usize * array_layers as usize;
-    let mut data: Vec<u8> = Vec::with_capacity(capacity);
-    for buffer in Some(first_buffer).into_iter().chain(buffers) {
-        let layer_data = unsafe { wgpu::bytes::from_slice(&*buffer) };
-        data.extend_from_slice(layer_data);
-    }
-
-    // Copy into the entire texture.
-    let image_copy_texture = texture.as_image_copy();
-
-    queue.write_texture(image_copy_texture, &data, image_data_layout, extent);
-
-    Some(texture)
-}
-
-/// Encode the necessary commands to load a texture directly from a dynamic image.
-///
-/// If the image is already in a format supported by wgpu, no conversions are performed and the
-/// image is loaded directly as-is with a texture format that matches the original image color
-/// type.
-///
-/// If the image is of an unsupported format, it will be converted to the closest supported format
-/// before being uploaded.
-///
-/// NOTE: The returned texture will remain empty until the given `encoder` has its command buffer
-/// submitted to the given `device`'s queue.
-pub fn encode_load_texture_from_image(
-    device: &wgpu::Device,
-    encoder: &mut wgpu::CommandEncoder,
-    usage: wgpu::TextureUsages,
-    image: &image::DynamicImage,
-) -> wgpu::Texture {
-    use image::DynamicImage::*;
-    match image {
-        ImageLuma8(img) => encode_load_texture_from_image_buffer(device, encoder, usage, img),
-        ImageLumaA8(img) => encode_load_texture_from_image_buffer(device, encoder, usage, img),
-        ImageRgba8(img) => encode_load_texture_from_image_buffer(device, encoder, usage, img),
-        ImageBgra8(img) => encode_load_texture_from_image_buffer(device, encoder, usage, img),
-        ImageLuma16(img) => encode_load_texture_from_image_buffer(device, encoder, usage, img),
-        ImageLumaA16(img) => encode_load_texture_from_image_buffer(device, encoder, usage, img),
-        ImageRgba16(img) => encode_load_texture_from_image_buffer(device, encoder, usage, img),
-        ImageRgb8(_img) => {
-            let img = image.to_rgba8();
-            encode_load_texture_from_image_buffer(device, encoder, usage, &img)
-        }
-        ImageBgr8(_img) => {
-            let img = image.to_bgra8();
-            encode_load_texture_from_image_buffer(device, encoder, usage, &img)
-        }
-        ImageRgb16(_img) => {
-            let img = image.to_rgba16();
-            encode_load_texture_from_image_buffer(device, encoder, usage, &img)
-        }
-    }
-}
-
-/// Encode the necessary commands to load a texture directly from an image buffer.
-///
-/// NOTE: The returned texture will remain empty until the given `encoder` has its command buffer
-/// submitted to the given `device`'s queue.
-///
-/// No format or size conversions are performed - the given buffer is loaded directly into GPU
-/// memory.
-///
-/// Pixel type compatibility is ensured via the `Pixel` trait.
-pub fn encode_load_texture_from_image_buffer<P, Container>(
-    device: &wgpu::Device,
-    encoder: &mut wgpu::CommandEncoder,
-    usage: wgpu::TextureUsages,
-    buffer: &image::ImageBuffer<P, Container>,
-) -> wgpu::Texture
-where
-    P: 'static + Pixel,
-    Container: std::ops::Deref<Target = [P::Subpixel]>,
-{
-    // Create the texture.
-    let texture = wgpu::TextureBuilder::from_image_view(buffer)
-        .usage(wgpu::TextureBuilder::REQUIRED_IMAGE_TEXTURE_USAGE | usage)
-        .build(device);
-
-    let buffer_image = wgpu::RowPaddedBuffer::from_image_buffer(device, buffer);
-    buffer_image.encode_copy_into(encoder, &texture);
-
-    texture
-}
-
-/// Encode the necessary commands to load a texture array directly from a sequence of image
-/// buffers.
-///
-/// NOTE: The returned texture will remain empty until the given `encoder` has its command buffer
-/// submitted to the given `device`'s queue.
-///
-/// No format or size conversions are performed - the given buffer is loaded directly into GPU
-/// memory.
-///
-/// Pixel type compatibility is ensured via the `Pixel` trait.
-///
-/// Returns `None` if there are no images in the given sequence.
-pub fn encode_load_texture_array_from_image_buffers<'a, I, P, Container>(
-    device: &wgpu::Device,
-    encoder: &mut wgpu::CommandEncoder,
-    usage: wgpu::TextureUsages,
-    buffers: I,
-) -> Option<wgpu::Texture>
-where
-    I: IntoIterator<Item = &'a image::ImageBuffer<P, Container>>,
-    I::IntoIter: ExactSizeIterator,
-    P: 'static + Pixel,
-    Container: 'a + std::ops::Deref<Target = [P::Subpixel]>,
-{
-    let mut buffers = buffers.into_iter();
-    let array_layers = buffers.len() as u32;
-    let first_buffer = buffers.next()?;
-
-    let (width, height) = first_buffer.dimensions();
-
-    // Build the texture ready to receive the data.
-    let texture = wgpu::TextureBuilder::from_image_view(first_buffer)
-        .extent(wgpu::Extent3d {
-            width,
-            height,
-            depth_or_array_layers: array_layers,
-        })
-        .dimension(wgpu::TextureDimension::D2) // force an array
-        .usage(wgpu::TextureBuilder::REQUIRED_IMAGE_TEXTURE_USAGE | usage)
-        .build(device);
-
-    // Copy each buffer to the texture, one layer at a time.
-    for (layer, buffer) in Some(first_buffer).into_iter().chain(buffers).enumerate() {
-        // Upload the pixel data.
-        let buffer = wgpu::RowPaddedBuffer::from_image_buffer(device, &buffer);
-        buffer.encode_copy_into_at(encoder, &texture, layer as u32);
-    }
-
-    Some(texture)
-}
diff --git a/nannou_wgpu/src/texture/mod.rs b/nannou_wgpu/src/texture/mod.rs
deleted file mode 100644
index 74495af28..000000000
--- a/nannou_wgpu/src/texture/mod.rs
+++ /dev/null
@@ -1,813 +0,0 @@
-use crate::{self as wgpu, RowPaddedBuffer, TextureHandle, TextureViewHandle};
-use std::ops::Deref;
-use std::sync::Arc;
-
-#[cfg(feature = "capturer")]
-pub mod capturer;
-#[cfg(feature = "image")]
-pub mod image;
-pub mod reshaper;
-pub mod row_padded_buffer;
-
-/// Types that can produce a texture view.
-///
-/// The primary purpose of this trait is to allow for APIs to be generic over both `Texture` and
-/// `TextureView`. This is particularly useful for the `draw` API as we can avoid needing users to
-/// understand the difference between the two. That said, it *is* slightly more efficient to create
-/// your texture view once and re-use it, rather than have these APIs create a new one from your
-/// texture each time they are invoked.
-pub trait ToTextureView {
-    fn to_texture_view(&self) -> TextureView;
-}
-
-/// A convenient wrapper around a handle to a texture on the GPU along with its descriptor.
-///
-/// A texture can be thought of as an image that resides in GPU memory (as opposed to CPU memory).
-///
-/// This type is a thin wrapper around the `wgpu` crate's `Texture` type, but provides access to
-/// useful information like size, format, usage, etc.
-#[derive(Debug)]
-pub struct Texture {
-    handle: Arc<TextureHandle>,
-    descriptor: wgpu::TextureDescriptor<'static>,
-}
-
-/// A convenient wrapper around a handle to a texture view along with its descriptor.
-///
-/// A **TextureView** is, perhaps unsurprisingly, a view of some existing texture. The view might
-/// be of the whole texture, but it might also be of some sub-section of the texture. When an API
-/// provides
-#[derive(Debug)]
-pub struct TextureView {
-    handle: Arc<TextureViewHandle>,
-    info: TextureViewInfo,
-    texture_extent: wgpu::Extent3d,
-    texture_id: TextureId,
-}
-
-/// Similar to `TextureViewDescriptor`, but contains the built fields rather than `Option`s.
-#[derive(Clone, Debug, Eq, Hash, PartialEq)]
-pub struct TextureViewInfo {
-    /// Debug label of the texture view.
-    ///
-    /// This will show up in graphics debuggers for easy identification.
-    pub label: &'static str,
-    /// Format of the texture view.
-    ///
-    /// At this time, it must be the same as the underlying format of the texture.
-    pub format: wgpu::TextureFormat,
-    /// The dimension of the texture view.
-    ///
-    /// - For 1D textures, this must be 1D.
-    /// - For 2D textures it must be one of D2, D2Array, Cube, and CubeArray.
-    /// - For 3D textures it must be 3D.
-    pub dimension: wgpu::TextureViewDimension,
-    /// Aspect of the texture. Color textures must be TextureAspect::All.
-    pub aspect: wgpu::TextureAspect,
-    pub base_mip_level: u32,
-    /// Mip level count.
-    ///
-    /// If `Some`, base_mip_level + count must be less or equal to underlying texture mip count.
-    ///
-    /// If `None`, considered to include the rest of the mipmap levels, but at least 1 in total.
-    pub level_count: Option<u32>,
-    pub base_array_layer: u32,
-    /// Layer count.
-    ///
-    /// If `Some`, base_array_layer + count must be less or equal to the underlying array count.
-    ///
-    /// If `None`, considered to include the rest of the array layers, but at least 1 in total.
-    pub array_layer_count: Option<u32>,
-}
-
-/// A unique identifier associated with a **Texture**.
-///
-/// If a texture is cloned, the result of a call to `id` will return the same result for
-/// both the original and the clone.
-#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
-pub struct TextureId(usize);
-
-/// A unique identifier associated with a **TextureView**.
-///
-/// A **TextureViewId** is derived from the hash of both the **TextureView**'s parent texture ID
-/// and the contents of its **TextureViewDescriptor**. This allows the same **TextureViewId** to
-/// represent two separate yet texture views of the same texture that share the exact same
-/// descriptor.
-#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)]
-pub struct TextureViewId(u64);
-
-/// A type aimed at simplifying the construction of a **Texture**.
-///
-/// The builder assumes a set of defaults describing a 128x128, non-multisampled, single-layer,
-/// non-linear sRGBA-8 texture. A suite of builder methods may be used to specify the exact
-/// properties desired.
-#[derive(Debug)]
-pub struct Builder {
-    descriptor: wgpu::TextureDescriptor<'static>,
-}
-
-/// A type aimed at simplifying the construction of a **TextureView**.
-///
-/// The builder assumes a set of defaults that match view produced via `create_view`.
-#[derive(Debug)]
-pub struct ViewBuilder<'a> {
-    texture: &'a wgpu::Texture,
-    info: TextureViewInfo,
-}
-
-impl Texture {
-    /// The inner descriptor from which this **Texture** was constructed.
-    pub fn descriptor(&self) -> &wgpu::TextureDescriptor<'static> {
-        &self.descriptor
-    }
-
-    /// Consume the **Texture** and produce the inner **Arc<TextureHandle>**.
-    pub fn into_inner(self) -> Arc<TextureHandle> {
-        self.into()
-    }
-
-    /// A reference to the inner **TextureHandle**.
-    pub fn inner(&self) -> &Arc<TextureHandle> {
-        &self.handle
-    }
-
-    /// The width and height of the texture.
-    ///
-    /// See the `extent` method for producing the full width, height and *depth* of the texture.
-    pub fn size(&self) -> [u32; 2] {
-        [self.descriptor.size.width, self.descriptor.size.height]
-    }
-
-    /// The width, height and depth of the texture.
-    pub fn extent(&self) -> wgpu::Extent3d {
-        self.descriptor.size
-    }
-
-    /// Mip count of texture. For a texture with no extra mips, this must be 1.
-    pub fn mip_level_count(&self) -> u32 {
-        self.descriptor.mip_level_count
-    }
-
-    /// Sample count of texture. If this is not 1, texture must have BindingType::SampledTexture::multisampled set to true.
-    pub fn sample_count(&self) -> u32 {
-        self.descriptor.sample_count
-    }
-
-    /// Describes whether the texture is of 1, 2 or 3 dimensions.
-    pub fn dimension(&self) -> wgpu::TextureDimension {
-        self.descriptor.dimension
-    }
-
-    /// The format of the underlying texture data.
-    pub fn format(&self) -> wgpu::TextureFormat {
-        self.descriptor.format
-    }
-
-    /// The set of usage bits describing the ways in which the **Texture** may be used.
-    pub fn usage(&self) -> wgpu::TextureUsages {
-        self.descriptor.usage
-    }
-
-    /// The size of the texture data in bytes.
-    pub fn size_bytes(&self) -> usize {
-        data_size_bytes(&self.descriptor)
-    }
-
-    /// The component type associated with the texture's format.
-    pub fn sample_type(&self) -> wgpu::TextureSampleType {
-        self.format()
-            .sample_type(None)
-            .expect("Expected the format to have a sample type")
-    }
-
-    // Custom constructors.
-
-    /// Create a **Texture** from the inner wgpu texture handle and the descriptor used to create
-    /// it.
-    ///
-    /// This constructor should only be used in the case that you already have a texture handle and
-    /// a descriptor but need a **Texture**. The preferred construction approach is to use the
-    /// [**TextureBuilder**](./struct.TextureBuilder.html).
-    ///
-    /// The `descriptor` must be the same used to create the texture.
-    pub fn from_handle_and_descriptor(
-        handle: Arc<TextureHandle>,
-        descriptor: wgpu::TextureDescriptor<'static>,
-    ) -> Self {
-        Texture { handle, descriptor }
-    }
-
-    // Custom common use methods.
-
-    /// A unique identifier associated with this texture.
-    ///
-    /// This is useful for distinguishing between two **Texture**s or for producing a hashable
-    /// representation.
-    pub fn id(&self) -> TextureId {
-        TextureId(Arc::as_ptr(&self.handle) as usize)
-    }
-
-    /// Begin building a **TextureView** for this **Texture**.
-    ///
-    /// By default, the produced **TextureViewBuilder** will build a texture view for the
-    /// descriptor returned via `default_view_descriptor`.
-    pub fn view(&self) -> ViewBuilder {
-        ViewBuilder {
-            texture: self,
-            info: self.default_view_info(),
-        }
-    }
-
-    /// A `TextureViewDimension` for a full view of the entire texture.
-    ///
-    /// NOTE: This will never produce the `D2Array`, `Cube` or `CubeArray` variants. You may have to
-    /// construct your own `wgpu::TextureViewDimension` via the `view` method if these are desired.
-    pub fn view_dimension(&self) -> wgpu::TextureViewDimension {
-        match self.dimension() {
-            wgpu::TextureDimension::D1 => wgpu::TextureViewDimension::D1,
-            wgpu::TextureDimension::D2 => match self.descriptor.size.depth_or_array_layers {
-                1 => wgpu::TextureViewDimension::D2,
-                _ => wgpu::TextureViewDimension::D2Array,
-            },
-            wgpu::TextureDimension::D3 => wgpu::TextureViewDimension::D3,
-        }
-    }
-
-    /// The view info, describing a full view of the texture.
-    pub fn default_view_info(&self) -> TextureViewInfo {
-        let format = self.format();
-        TextureViewInfo {
-            label: TextureView::DEFAULT_LABEL,
-            format: format,
-            dimension: self.view_dimension(),
-            aspect: infer_aspect_from_format(format),
-            base_mip_level: 0,
-            level_count: Some(self.mip_level_count()),
-            base_array_layer: 0,
-            array_layer_count: Some(1),
-        }
-    }
-
-    /// The view descriptor, describing a full view of the texture.
-    pub fn default_view_descriptor(&self) -> wgpu::TextureViewDescriptor<'static> {
-        view_info_to_view_descriptor(&self.default_view_info())
-    }
-
-    /// Encode a command for uploading the given data to the texture.
-    ///
-    /// The length of the data must be equal to the length returned by `texture.size_bytes()`.
-    pub fn upload_data(
-        &self,
-        device: &wgpu::Device,
-        encoder: &mut wgpu::CommandEncoder,
-        data: &[u8],
-    ) {
-        // Ensure data has valid length.
-        let texture_size_bytes = self.size_bytes();
-        assert_eq!(data.len(), texture_size_bytes);
-
-        let buffer = wgpu::RowPaddedBuffer::for_texture(
-            device,
-            self,
-            wgpu::BufferUsages::COPY_SRC | wgpu::BufferUsages::MAP_WRITE,
-        );
-        buffer.write(data);
-        buffer.encode_copy_into(encoder, self);
-    }
-
-    /// Write the contents of the texture into a new buffer.
-    ///
-    /// Commands will be added to the given encoder to copy the entire contents of the texture into
-    /// the buffer.
-    ///
-    /// If the texture has a sample count greater than one, it will first be resolved to a
-    /// non-multisampled texture before being copied to the buffer.
-    /// `copy_texture_to_buffer` command has been performed by the GPU.
-    ///
-    /// NOTE: `read` should not be called on the returned buffer until the encoded commands have
-    /// been submitted to the device queue.
-    pub fn to_buffer(
-        &self,
-        device: &wgpu::Device,
-        encoder: &mut wgpu::CommandEncoder,
-    ) -> wgpu::RowPaddedBuffer {
-        assert_eq!(
-            self.extent().depth_or_array_layers,
-            1,
-            "cannot convert a 3d texture to a RowPaddedBuffer"
-        );
-
-        // If this texture is multi-sampled, resolve it first.
-        if self.sample_count() > 1 {
-            let view = self.create_view(&wgpu::TextureViewDescriptor::default());
-            let descriptor = self.descriptor.clone();
-            let resolved_texture = wgpu::TextureBuilder::from(descriptor)
-                .sample_count(1)
-                .usage(wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC)
-                .build(device);
-            let resolved_view =
-                resolved_texture.create_view(&wgpu::TextureViewDescriptor::default());
-            wgpu::resolve_texture(&view, &resolved_view, encoder);
-            let buffer = RowPaddedBuffer::for_texture(
-                device,
-                &resolved_texture,
-                wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
-            );
-            buffer.encode_copy_from(encoder, &resolved_texture);
-            buffer
-        } else {
-            let buffer = RowPaddedBuffer::for_texture(
-                device,
-                self,
-                wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
-            );
-            buffer.encode_copy_from(encoder, self);
-            buffer
-        }
-    }
-}
-
-impl TextureViewInfo {
-    /// Produces a `TextureViewDescriptor` that matches this info instance.
-    pub fn descriptor(&self) -> wgpu::TextureViewDescriptor<'static> {
-        view_info_to_view_descriptor(self)
-    }
-}
-
-impl TextureView {
-    pub const DEFAULT_LABEL: &'static str = "nannou-texture-view";
-
-    pub fn info(&self) -> &TextureViewInfo {
-        &self.info
-    }
-
-    pub fn descriptor(&self) -> wgpu::TextureViewDescriptor<'static> {
-        self.info.descriptor()
-    }
-
-    pub fn format(&self) -> wgpu::TextureFormat {
-        self.info.format
-    }
-
-    pub fn dimension(&self) -> wgpu::TextureViewDimension {
-        self.info.dimension
-    }
-
-    pub fn aspect(&self) -> wgpu::TextureAspect {
-        self.info.aspect
-    }
-
-    pub fn base_mip_level(&self) -> u32 {
-        self.info.base_mip_level
-    }
-
-    pub fn level_count(&self) -> Option<u32> {
-        self.info.level_count
-    }
-
-    pub fn base_array_layer(&self) -> u32 {
-        self.info.base_array_layer
-    }
-
-    pub fn array_layer_count(&self) -> Option<u32> {
-        self.info.array_layer_count
-    }
-
-    pub fn sample_type(&self) -> wgpu::TextureSampleType {
-        self.format()
-            .sample_type(None)
-            .expect("Expected the format to have a sample type")
-    }
-
-    pub fn id(&self) -> TextureViewId {
-        texture_view_id(&self.texture_id, &self.info)
-    }
-
-    /// The width and height of the source texture.
-    ///
-    /// See the `extent` method for producing the full width, height and *depth* of the source
-    /// texture.
-    pub fn size(&self) -> [u32; 2] {
-        [self.texture_extent.width, self.texture_extent.height]
-    }
-
-    /// The width, height and depth of the source texture.
-    pub fn extent(&self) -> wgpu::Extent3d {
-        self.texture_extent.clone()
-    }
-
-    /// The unique identifier associated with the texture that this view is derived from.
-    pub fn texture_id(&self) -> TextureId {
-        self.texture_id
-    }
-
-    /// Access to the inner texture view handle.
-    pub fn inner(&self) -> &Arc<wgpu::TextureViewHandle> {
-        &self.handle
-    }
-
-    /// Consume the **TextureView** and produce the inner **Arc<TextureViewHandle>**.
-    pub fn into_inner(self) -> Arc<wgpu::TextureViewHandle> {
-        self.handle
-    }
-}
-
-impl Builder {
-    pub const DEFAULT_SIDE: u32 = 128;
-    pub const DEFAULT_DEPTH: u32 = 1;
-    pub const DEFAULT_SIZE: wgpu::Extent3d = wgpu::Extent3d {
-        width: Self::DEFAULT_SIDE,
-        height: Self::DEFAULT_SIDE,
-        depth_or_array_layers: Self::DEFAULT_DEPTH,
-    };
-    pub const DEFAULT_ARRAY_LAYER_COUNT: u32 = 1;
-    pub const DEFAULT_MIP_LEVEL_COUNT: u32 = 1;
-    pub const DEFAULT_SAMPLE_COUNT: u32 = 1;
-    pub const DEFAULT_DIMENSION: wgpu::TextureDimension = wgpu::TextureDimension::D2;
-    pub const DEFAULT_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm;
-    pub const DEFAULT_USAGE: wgpu::TextureUsages = wgpu::TextureUsages::all(); // TODO: is this the right choice?
-    pub const DEFAULT_DESCRIPTOR: wgpu::TextureDescriptor<'static> = wgpu::TextureDescriptor {
-        label: Some("nannou Texture"),
-        size: Self::DEFAULT_SIZE,
-        mip_level_count: Self::DEFAULT_MIP_LEVEL_COUNT,
-        sample_count: Self::DEFAULT_SAMPLE_COUNT,
-        dimension: Self::DEFAULT_DIMENSION,
-        format: Self::DEFAULT_FORMAT,
-        usage: Self::DEFAULT_USAGE,
-        view_formats: &[],
-    };
-
-    /// Creates a new `Default` builder
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Specify the width and height of the texture.
-    ///
-    /// Note: On calls to `size`, `depth` and `extent` the `Builder` will attempt to infer the
-    /// `wgpu::TextureDimension` of its inner `wgpu::TextureDescriptor` by examining its `size`
-    /// field. Use `TextureBuilder::dimension()` to override this behavior.
-    pub fn size(mut self, [width, height]: [u32; 2]) -> Self {
-        self.descriptor.size.width = width;
-        self.descriptor.size.height = height;
-        self.infer_dimension_from_size();
-        self
-    }
-
-    /// Specify the depth of the texture.
-    ///
-    /// Note: On calls to `size`, `depth` and `extent` the `Builder` will attempt to infer the
-    /// `wgpu::TextureDimension` of its inner `wgpu::TextureDescriptor` by examining its `size`
-    /// field. Use `TextureBuilder::dimension()` to override this behavior.
-    pub fn depth(mut self, depth: u32) -> Self {
-        self.descriptor.size.depth_or_array_layers = depth;
-        self.infer_dimension_from_size();
-        self
-    }
-
-    /// Specify the width, height and depth of the texture.
-    ///
-    /// Note: On calls to `size`, `depth` and `extent` the `Builder` will attempt to infer the
-    /// `wgpu::TextureDimension` of its inner `wgpu::TextureDescriptor` by examining its `size`
-    /// field. Use `TextureBuilder::dimension()` to override this behavior.
-    pub fn extent(mut self, extent: wgpu::Extent3d) -> Self {
-        self.descriptor.size = extent;
-        self.infer_dimension_from_size();
-        self
-    }
-
-    /// Specify the dimension of the texture, overriding inferred dimension.
-    ///
-    /// Mainly useful for creating 2d texture arrays -- override dimension with
-    /// `wgpu::TextureDimension::D2` on a texture with `extent.depth > 1` in order to create a
-    /// texture array (/ cubemap / cubemap array) instead of a 3d texture.
-    pub fn dimension(mut self, dimension: wgpu::TextureDimension) -> Self {
-        self.descriptor.dimension = dimension;
-        self
-    }
-
-    /// Specify the number of mip levels of the texture.
-    pub fn mip_level_count(mut self, count: u32) -> Self {
-        self.descriptor.mip_level_count = count;
-        self
-    }
-
-    /// Specify the number of samples per pixel in the case that the texture is multisampled.
-    pub fn sample_count(mut self, count: u32) -> Self {
-        self.descriptor.sample_count = count;
-        self
-    }
-
-    /// Specify the texture format.
-    pub fn format(mut self, format: wgpu::TextureFormat) -> Self {
-        self.descriptor.format = format;
-        self
-    }
-
-    /// Describes to the implementation how the texture is to be used.
-    ///
-    /// It is important that the set of usage bits reflects the
-    pub fn usage(mut self, usage: wgpu::TextureUsages) -> Self {
-        self.descriptor.usage = usage;
-        self
-    }
-
-    // If `depth` is greater than `1` then `D3` is assumed, otherwise if `height` is greater than
-    // `1` then `D2` is assumed, otherwise `D1` is assumed.
-    fn infer_dimension_from_size(&mut self) {
-        if self.descriptor.size.depth_or_array_layers > 1 {
-            self.descriptor.dimension = wgpu::TextureDimension::D3;
-        } else if self.descriptor.size.height > 1 {
-            self.descriptor.dimension = wgpu::TextureDimension::D2;
-        } else {
-            self.descriptor.dimension = wgpu::TextureDimension::D1;
-        }
-    }
-
-    /// Build the texture resulting from the specified parameters with the given device.
-    pub fn build(self, device: &wgpu::Device) -> Texture {
-        let handle = Arc::new(device.create_texture(&self.descriptor));
-        let descriptor = self.into();
-        Texture { handle, descriptor }
-    }
-
-    /// Consumes the builder and returns the resulting `wgpu::TextureDescriptor`.
-    pub fn into_descriptor(self) -> wgpu::TextureDescriptor<'static> {
-        self.into()
-    }
-}
-
-impl<'a> ViewBuilder<'a> {
-    /// Debug label of the texture view.
-    ///
-    /// This will show up in graphics debuggers for easy identification.
-    ///
-    /// By default, this is `"nannou-texture-view"`.
-    pub fn label(mut self, label: &'static str) -> Self {
-        self.info.label = label;
-        self
-    }
-
-    /// Format of the texture view.
-    ///
-    /// At this time, it must be the same as the underlying format of the texture.
-    ///
-    /// By default, this is derived from the parent texture.
-    pub fn format(mut self, format: wgpu::TextureFormat) -> Self {
-        self.info.format = format;
-        self
-    }
-
-    /// The dimension of the texture view.
-    ///
-    /// - For 1D textures, this must be 1D.
-    /// - For 2D textures it must be one of D2, D2Array, Cube, and CubeArray.
-    /// - For 3D textures it must be 3D.
-    ///
-    /// By default, this is derived from the parent texture.
-    pub fn dimension(mut self, dimension: wgpu::TextureViewDimension) -> Self {
-        self.info.dimension = dimension;
-        self
-    }
-
-    /// Aspect of the texture.
-    ///
-    /// Color textures **must** be `TextureAspect::All`.
-    ///
-    /// By default, this is the result of `infer_aspect_from_format` called for the parent
-    /// texture's texture format. See the `infer_aspect_from_format` function docs for details.
-    pub fn aspect(mut self, aspect: wgpu::TextureAspect) -> Self {
-        self.info.aspect = aspect;
-        self
-    }
-
-    /// Mip level count.
-    ///
-    /// If `Some`, base_mip_level + count must be less or equal to underlying texture mip count.
-    ///
-    /// If `None`, considered to include the rest of the mipmap levels, but at least 1 in total.
-    pub fn level_count(mut self, level_count: Option<u32>) -> Self {
-        self.info.level_count = level_count;
-        self
-    }
-
-    pub fn base_array_layer(mut self, base_array_layer: u32) -> Self {
-        self.info.base_array_layer = base_array_layer;
-        self
-    }
-
-    /// Layer count.
-    ///
-    /// If `Some`, base_array_layer + count must be less or equal to the underlying array count.
-    ///
-    /// If `None`, considered to include the rest of the array layers, but at least 1 in total.
-    pub fn array_layer_count(mut self, array_layer_count: Option<u32>) -> Self {
-        match (self.info.dimension, array_layer_count) {
-            (wgpu::TextureViewDimension::D2Array, Some(1)) => {
-                self.info.dimension = wgpu::TextureViewDimension::D2;
-            }
-            _ => (),
-        }
-        self.info.array_layer_count = array_layer_count;
-        self
-    }
-
-    /// Short-hand for specifying a **TextureView** for a single given base array layer.
-    ///
-    /// In other words, this is short-hand for the following:
-    ///
-    /// ```ignore
-    /// builder
-    ///     .base_array_layer(layer)
-    ///     .array_layer_count(1)
-    /// ```
-    pub fn layer(self, layer: u32) -> Self {
-        self.base_array_layer(layer).array_layer_count(Some(1))
-    }
-
-    pub fn build(self) -> TextureView {
-        let descriptor = self.info.descriptor();
-        TextureView {
-            handle: Arc::new(self.texture.inner().create_view(&descriptor)),
-            info: self.info,
-            texture_id: self.texture.id(),
-            texture_extent: self.texture.extent(),
-        }
-    }
-
-    /// Consumes the texture view builder and returns the resulting `wgpu::TextureViewDescriptor`.
-    pub fn into_descriptor(self) -> wgpu::TextureViewDescriptor<'static> {
-        self.info.descriptor()
-    }
-}
-
-impl<'a, T> ToTextureView for &'a T
-where
-    T: ToTextureView,
-{
-    fn to_texture_view(&self) -> TextureView {
-        (**self).to_texture_view()
-    }
-}
-
-impl<'a, T> ToTextureView for &'a mut T
-where
-    T: ToTextureView,
-{
-    fn to_texture_view(&self) -> TextureView {
-        (**self).to_texture_view()
-    }
-}
-
-impl ToTextureView for TextureView {
-    fn to_texture_view(&self) -> TextureView {
-        self.clone()
-    }
-}
-
-impl ToTextureView for Texture {
-    fn to_texture_view(&self) -> TextureView {
-        self.view().build()
-    }
-}
-
-impl Clone for TextureView {
-    fn clone(&self) -> Self {
-        TextureView {
-            handle: self.handle.clone(),
-            info: self.info.clone(),
-            texture_id: self.texture_id(),
-            texture_extent: self.extent(),
-        }
-    }
-}
-
-impl Clone for Texture {
-    fn clone(&self) -> Self {
-        let handle = self.handle.clone();
-        let descriptor = self.descriptor.clone();
-        Self { handle, descriptor }
-    }
-}
-
-impl Deref for Texture {
-    type Target = TextureHandle;
-    fn deref(&self) -> &Self::Target {
-        &*self.handle
-    }
-}
-
-impl Deref for TextureView {
-    type Target = TextureViewHandle;
-    fn deref(&self) -> &Self::Target {
-        &self.handle
-    }
-}
-
-impl Default for Builder {
-    fn default() -> Self {
-        Self {
-            descriptor: Self::DEFAULT_DESCRIPTOR,
-        }
-    }
-}
-
-impl From<Texture> for Arc<TextureHandle> {
-    fn from(t: Texture) -> Self {
-        t.handle
-    }
-}
-
-impl From<TextureViewInfo> for wgpu::TextureViewDescriptor<'static> {
-    fn from(info: TextureViewInfo) -> Self {
-        view_info_to_view_descriptor(&info)
-    }
-}
-
-impl From<wgpu::TextureDescriptor<'static>> for Builder {
-    fn from(descriptor: wgpu::TextureDescriptor<'static>) -> Self {
-        Self { descriptor }
-    }
-}
-
-impl Into<wgpu::TextureDescriptor<'static>> for Builder {
-    fn into(self) -> wgpu::TextureDescriptor<'static> {
-        self.descriptor
-    }
-}
-
-impl<'a> From<ViewBuilder<'a>> for TextureViewInfo {
-    fn from(builder: ViewBuilder<'a>) -> Self {
-        builder.info
-    }
-}
-
-/// Create a texture ID by hashing the source texture ID along with the contents of the descriptor.
-fn texture_view_id(texture_id: &TextureId, view_info: &TextureViewInfo) -> TextureViewId {
-    use std::hash::{Hash, Hasher};
-    let mut s = std::collections::hash_map::DefaultHasher::new();
-    texture_id.hash(&mut s);
-    view_info.hash(&mut s);
-    TextureViewId(s.finish())
-}
-
-/// The size of the texture data in bytes as described by the given descriptor.
-pub fn data_size_bytes(desc: &wgpu::TextureDescriptor) -> usize {
-    desc.size.width as usize
-        * desc.size.height as usize
-        * desc.size.depth_or_array_layers as usize
-        * format_size_bytes(desc.format) as usize
-}
-
-/// Return the size of the given texture format in bytes.
-pub fn format_size_bytes(format: wgpu::TextureFormat) -> u32 {
-    format
-        .block_size(None)
-        .expect("Expected the format to have a block size") as u32
-}
-
-/// Returns `true` if the given `wgpu::Extent3d`s are equal.
-pub fn extent_3d_eq(a: &wgpu::Extent3d, b: &wgpu::Extent3d) -> bool {
-    a.width == b.width && a.height == b.height && a.depth_or_array_layers == b.depth_or_array_layers
-}
-
-/// Returns `true` if the given texture descriptors are equal.
-pub fn descriptor_eq(a: &wgpu::TextureDescriptor, b: &wgpu::TextureDescriptor) -> bool {
-    extent_3d_eq(&a.size, &b.size)
-        && a.mip_level_count == b.mip_level_count
-        && a.sample_count == b.sample_count
-        && a.dimension == b.dimension
-        && a.format == b.format
-        && a.usage == b.usage
-}
-
-/// Used to infer the `TextureAspect` for a `TextureView` from a specific `TextureFormat`.
-///
-/// Does the following:
-///
-/// - If the format is `Depth32Float` or `Depth24Plus`, `TextureAspect::DepthOnly` is assumed.
-/// - Otherwise, `TextureAspect::All` is assumed.
-///
-/// Please note that `wgpu::TextureAspect::StencilOnly` can never be inferred with this function.
-/// If you require using a `TextureView` as a stencil, consider explicitly specify the
-/// `TextureAspect` you require.
-pub fn infer_aspect_from_format(format: wgpu::TextureFormat) -> wgpu::TextureAspect {
-    use wgpu::TextureFormat::*;
-    match format {
-        Depth32Float | Depth24Plus => wgpu::TextureAspect::DepthOnly,
-        _ => wgpu::TextureAspect::All,
-    }
-}
-
-fn view_info_to_view_descriptor(info: &TextureViewInfo) -> wgpu::TextureViewDescriptor<'static> {
-    wgpu::TextureViewDescriptor {
-        label: Some(info.label),
-        format: Some(info.format),
-        dimension: Some(info.dimension),
-        aspect: info.aspect,
-        base_mip_level: info.base_mip_level,
-        mip_level_count: info.level_count,
-        base_array_layer: info.base_array_layer,
-        array_layer_count: info.array_layer_count,
-    }
-}
diff --git a/nannou_wgpu/src/texture/reshaper/mod.rs b/nannou_wgpu/src/texture/reshaper/mod.rs
deleted file mode 100644
index f9269c1e8..000000000
--- a/nannou_wgpu/src/texture/reshaper/mod.rs
+++ /dev/null
@@ -1,237 +0,0 @@
-use crate::{self as wgpu, util::DeviceExt, BufferInitDescriptor};
-
-/// Reshapes a texture from its original size, sample_count and format to the destination size,
-/// sample_count and format.
-///
-/// The `src_texture` must have the `TextureUsages::SAMPLED` enabled.
-///
-/// The `dst_texture` must have the `TextureUsages::RENDER_ATTACHMENT` enabled.
-#[derive(Debug)]
-pub struct Reshaper {
-    _vs_mod: wgpu::ShaderModule,
-    _fs_mod: wgpu::ShaderModule,
-    _bind_group_layout: wgpu::BindGroupLayout,
-    bind_group: wgpu::BindGroup,
-    render_pipeline: wgpu::RenderPipeline,
-    _sampler: wgpu::Sampler,
-    _uniform_buffer: Option<wgpu::Buffer>,
-    vertex_buffer: wgpu::Buffer,
-}
-
-#[repr(C)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, PartialOrd)]
-struct Vertex {
-    pub position: [f32; 2],
-}
-
-#[repr(C)]
-#[derive(Copy, Clone)]
-struct Uniforms {
-    sample_count: u32,
-}
-
-impl Reshaper {
-    /// Construct a new `Reshaper`.
-    pub fn new(
-        device: &wgpu::Device,
-        src_texture: &wgpu::TextureViewHandle,
-        src_sample_count: u32,
-        src_sample_type: wgpu::TextureSampleType,
-        dst_sample_count: u32,
-        dst_format: wgpu::TextureFormat,
-    ) -> Self {
-        // Load shader modules.
-        let vs_desc = wgpu::include_wgsl!("shaders/vs.wgsl");
-        let fs_desc = match src_sample_count {
-            1 => wgpu::include_wgsl!("shaders/fs.wgsl"),
-            2 => wgpu::include_wgsl!("shaders/fs_msaa2.wgsl"),
-            4 => wgpu::include_wgsl!("shaders/fs_msaa4.wgsl"),
-            8 => wgpu::include_wgsl!("shaders/fs_msaa8.wgsl"),
-            16 => wgpu::include_wgsl!("shaders/fs_msaa16.wgsl"),
-            _ => wgpu::include_wgsl!("shaders/fs_msaa.wgsl"),
-        };
-        let vs_mod = device.create_shader_module(vs_desc);
-        let fs_mod = device.create_shader_module(fs_desc);
-
-        // Create the sampler for sampling from the source texture.
-        let sampler_desc = wgpu::SamplerBuilder::new().into_descriptor();
-        let sampler_filtering = wgpu::sampler_filtering(&sampler_desc);
-        let sampler = device.create_sampler(&sampler_desc);
-
-        // Create the render pipeline.
-        let bind_group_layout =
-            bind_group_layout(device, src_sample_count, src_sample_type, sampler_filtering);
-        let pipeline_layout = pipeline_layout(device, &bind_group_layout);
-        let render_pipeline = render_pipeline(
-            device,
-            &pipeline_layout,
-            &vs_mod,
-            &fs_mod,
-            dst_sample_count,
-            dst_format,
-        );
-
-        // Create the uniform buffer to pass the sample count if we don't have an unrolled resolve
-        // fragment shader for it.
-        let uniform_buffer = match unrolled_sample_count(src_sample_count) {
-            true => None,
-            false => {
-                let uniforms = Uniforms {
-                    sample_count: src_sample_count,
-                };
-                let uniforms_bytes = uniforms_as_bytes(&uniforms);
-                let usage = wgpu::BufferUsages::UNIFORM;
-                let buffer = device.create_buffer_init(&BufferInitDescriptor {
-                    label: None,
-                    contents: &uniforms_bytes,
-                    usage,
-                });
-                Some(buffer)
-            }
-        };
-
-        // Create the bind group.
-        let bind_group = bind_group(
-            device,
-            &bind_group_layout,
-            src_texture,
-            &sampler,
-            uniform_buffer.as_ref(),
-        );
-
-        // Create the vertex buffer.
-        let vertices_bytes = vertices_as_bytes(&VERTICES[..]);
-        let vertex_usage = wgpu::BufferUsages::VERTEX;
-        let vertex_buffer = device.create_buffer_init(&BufferInitDescriptor {
-            label: None,
-            contents: vertices_bytes,
-            usage: vertex_usage,
-        });
-
-        Reshaper {
-            _vs_mod: vs_mod,
-            _fs_mod: fs_mod,
-            _bind_group_layout: bind_group_layout,
-            bind_group,
-            render_pipeline,
-            _sampler: sampler,
-            _uniform_buffer: uniform_buffer,
-            vertex_buffer,
-        }
-    }
-
-    /// Given an encoder, submits a render pass command for writing the source texture to the
-    /// destination texture.
-    pub fn encode_render_pass(
-        &self,
-        dst_texture: &wgpu::TextureViewHandle,
-        encoder: &mut wgpu::CommandEncoder,
-    ) {
-        let mut render_pass = wgpu::RenderPassBuilder::new()
-            .color_attachment(dst_texture, |color| color)
-            .begin(encoder);
-        render_pass.set_pipeline(&self.render_pipeline);
-        render_pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
-        render_pass.set_bind_group(0, &self.bind_group, &[]);
-        let vertex_range = 0..VERTICES.len() as u32;
-        let instance_range = 0..1;
-        render_pass.draw(vertex_range, instance_range);
-    }
-}
-
-const VERTICES: [Vertex; 4] = [
-    Vertex {
-        position: [-1.0, 1.0],
-    },
-    Vertex {
-        position: [-1.0, -1.0],
-    },
-    Vertex {
-        position: [1.0, 1.0],
-    },
-    Vertex {
-        position: [1.0, -1.0],
-    },
-];
-
-// We provide pre-prepared fragment shaders with unrolled resolves for common sample counts.
-fn unrolled_sample_count(sample_count: u32) -> bool {
-    match sample_count {
-        1 | 2 | 4 | 8 | 16 => true,
-        _ => false,
-    }
-}
-
-fn bind_group_layout(
-    device: &wgpu::Device,
-    src_sample_count: u32,
-    src_sample_type: wgpu::TextureSampleType,
-    sampler_filtering: bool,
-) -> wgpu::BindGroupLayout {
-    let mut builder = wgpu::BindGroupLayoutBuilder::new()
-        .texture(
-            wgpu::ShaderStages::FRAGMENT,
-            src_sample_count > 1,
-            wgpu::TextureViewDimension::D2,
-            src_sample_type,
-        )
-        .sampler(wgpu::ShaderStages::FRAGMENT, sampler_filtering);
-    if !unrolled_sample_count(src_sample_count) {
-        builder = builder.uniform_buffer(wgpu::ShaderStages::FRAGMENT, false);
-    }
-    builder.build(device)
-}
-fn bind_group(
-    device: &wgpu::Device,
-    layout: &wgpu::BindGroupLayout,
-    texture: &wgpu::TextureViewHandle,
-    sampler: &wgpu::Sampler,
-    uniform_buffer: Option<&wgpu::Buffer>,
-) -> wgpu::BindGroup {
-    let mut builder = wgpu::BindGroupBuilder::new()
-        .texture_view(texture)
-        .sampler(sampler);
-    if let Some(buffer) = uniform_buffer {
-        builder = builder.buffer::<Uniforms>(buffer, 0..1);
-    }
-    builder.build(device, layout)
-}
-
-fn pipeline_layout(
-    device: &wgpu::Device,
-    bind_group_layout: &wgpu::BindGroupLayout,
-) -> wgpu::PipelineLayout {
-    let desc = wgpu::PipelineLayoutDescriptor {
-        label: Some("nannou_reshaper"),
-        bind_group_layouts: &[&bind_group_layout],
-        push_constant_ranges: &[],
-    };
-    device.create_pipeline_layout(&desc)
-}
-
-fn render_pipeline(
-    device: &wgpu::Device,
-    layout: &wgpu::PipelineLayout,
-    vs_mod: &wgpu::ShaderModule,
-    fs_mod: &wgpu::ShaderModule,
-    dst_sample_count: u32,
-    dst_format: wgpu::TextureFormat,
-) -> wgpu::RenderPipeline {
-    wgpu::RenderPipelineBuilder::from_layout(layout, vs_mod)
-        .fragment_shader(fs_mod)
-        .color_format(dst_format)
-        .color_blend(wgpu::BlendComponent::REPLACE)
-        .alpha_blend(wgpu::BlendComponent::REPLACE)
-        .add_vertex_buffer::<Vertex>(&wgpu::vertex_attr_array![0 => Float32x2])
-        .primitive_topology(wgpu::PrimitiveTopology::TriangleStrip)
-        .sample_count(dst_sample_count)
-        .build(device)
-}
-
-fn uniforms_as_bytes(uniforms: &Uniforms) -> &[u8] {
-    unsafe { wgpu::bytes::from(uniforms) }
-}
-
-fn vertices_as_bytes(data: &[Vertex]) -> &[u8] {
-    unsafe { wgpu::bytes::from_slice(data) }
-}
diff --git a/nannou_wgpu/src/texture/reshaper/shaders/fs.wgsl b/nannou_wgpu/src/texture/reshaper/shaders/fs.wgsl
deleted file mode 100644
index c49bc9bec..000000000
--- a/nannou_wgpu/src/texture/reshaper/shaders/fs.wgsl
+++ /dev/null
@@ -1,16 +0,0 @@
-struct FragmentOutput {
-    @location(0) out_color: vec4<f32>,
-};
-
-@group(0) @binding(0)
-var tex: texture_2d<f32>;
-@group(0) @binding(1)
-var tex_sampler: sampler;
-
-@fragment
-fn main(
-    @location(0) tex_coords: vec2<f32>,
-) -> FragmentOutput {
-    let out_color: vec4<f32> = textureSample(tex, tex_sampler, tex_coords);
-    return FragmentOutput(out_color);
-}
diff --git a/nannou_wgpu/src/texture/reshaper/shaders/fs_msaa.wgsl b/nannou_wgpu/src/texture/reshaper/shaders/fs_msaa.wgsl
deleted file mode 100644
index 0fe431c89..000000000
--- a/nannou_wgpu/src/texture/reshaper/shaders/fs_msaa.wgsl
+++ /dev/null
@@ -1,43 +0,0 @@
-struct FragmentOutput {
-    @location(0) out_color: vec4<f32>,
-};
-
-struct Data {
-    sample_count: u32,
-};
-
-@group(0) @binding(0)
-var tex: texture_multisampled_2d<f32>;
-@group(0) @binding(1)
-var tex_sampler: sampler;
-@group(0) @binding(2)
-var<uniform> uniforms: Data;
-
-@fragment
-fn main(
-    @location(0) tex_coords: vec2<f32>,
-) -> FragmentOutput {
-    // Get the integer tex coordinates.
-    let tex_size: vec2<u32> = textureDimensions(tex);
-    let tex_x: i32 = i32(f32(tex_size.x) * tex_coords.x);
-    let tex_y: i32 = i32(f32(tex_size.y) * tex_coords.y);;
-    let itex_coords: vec2<i32> = vec2<i32>(tex_x, tex_y);
-
-    // Perform the resolve.
-    var color: vec4<f32> = vec4<f32>(0.0, 0.0, 0.0, 0.0);
-    var i: i32 = 0;
-    loop {
-        if (u32(i) < uniforms.sample_count) {
-            color = color + textureLoad(tex, itex_coords, i);
-            continue;
-        } else {
-            break;
-        }
-        continuing {
-            i = i + 1;
-        }
-    }
-    color = color / vec4<f32>(f32(uniforms.sample_count));
-
-    return FragmentOutput(color);
-}
diff --git a/nannou_wgpu/src/texture/reshaper/shaders/fs_msaa16.wgsl b/nannou_wgpu/src/texture/reshaper/shaders/fs_msaa16.wgsl
deleted file mode 100644
index 22a4df815..000000000
--- a/nannou_wgpu/src/texture/reshaper/shaders/fs_msaa16.wgsl
+++ /dev/null
@@ -1,41 +0,0 @@
-struct FragmentOutput {
-    @location(0) out_color: vec4<f32>,
-};
-
-@group(0) @binding(0)
-var tex: texture_multisampled_2d<f32>;
-@group(0) @binding(1)
-var tex_sampler: sampler;
-
-@fragment
-fn main(
-    @location(0) tex_coords: vec2<f32>,
-) -> FragmentOutput {
-    // Get the integer tex coordinates.
-    let tex_size: vec2<u32> = textureDimensions(tex);
-    let tex_x: i32 = i32(f32(tex_size.x) * tex_coords.x);
-    let tex_y: i32 = i32(f32(tex_size.y) * tex_coords.y);;
-    let itex_coords: vec2<i32> = vec2<i32>(tex_x, tex_y);
-
-    // Manually unroll the resolve. The less conditions the better!
-    var color: vec4<f32> = vec4<f32>(0.0, 0.0, 0.0, 0.0);
-    color = color + textureLoad(tex, itex_coords, 0);
-    color = color + textureLoad(tex, itex_coords, 1);
-    color = color + textureLoad(tex, itex_coords, 2);
-    color = color + textureLoad(tex, itex_coords, 3);
-    color = color + textureLoad(tex, itex_coords, 4);
-    color = color + textureLoad(tex, itex_coords, 5);
-    color = color + textureLoad(tex, itex_coords, 6);
-    color = color + textureLoad(tex, itex_coords, 7);
-    color = color + textureLoad(tex, itex_coords, 8);
-    color = color + textureLoad(tex, itex_coords, 9);
-    color = color + textureLoad(tex, itex_coords, 10);
-    color = color + textureLoad(tex, itex_coords, 11);
-    color = color + textureLoad(tex, itex_coords, 12);
-    color = color + textureLoad(tex, itex_coords, 13);
-    color = color + textureLoad(tex, itex_coords, 14);
-    color = color + textureLoad(tex, itex_coords, 15);
-    color = color * 0.0625;
-
-    return FragmentOutput(color);
-}
diff --git a/nannou_wgpu/src/texture/reshaper/shaders/fs_msaa2.wgsl b/nannou_wgpu/src/texture/reshaper/shaders/fs_msaa2.wgsl
deleted file mode 100644
index 689af77b6..000000000
--- a/nannou_wgpu/src/texture/reshaper/shaders/fs_msaa2.wgsl
+++ /dev/null
@@ -1,27 +0,0 @@
-struct FragmentOutput {
-    @location(0) out_color: vec4<f32>,
-};
-
-@group(0) @binding(0)
-var tex: texture_multisampled_2d<f32>;
-@group(0) @binding(1)
-var tex_sampler: sampler;
-
-@fragment
-fn main(
-    @location(0) tex_coords: vec2<f32>,
-) -> FragmentOutput {
-    // Get the integer tex coordinates.
-    let tex_size: vec2<u32> = textureDimensions(tex);
-    let tex_x: i32 = i32(f32(tex_size.x) * tex_coords.x);
-    let tex_y: i32 = i32(f32(tex_size.y) * tex_coords.y);;
-    let itex_coords: vec2<i32> = vec2<i32>(tex_x, tex_y);
-
-    // Manually unroll the resolve. The less conditions the better!
-    var color: vec4<f32> = vec4<f32>(0.0, 0.0, 0.0, 0.0);
-    color = color + textureLoad(tex, itex_coords, 0);
-    color = color + textureLoad(tex, itex_coords, 1);
-    color = color * 0.5;
-
-    return FragmentOutput(color);
-}
diff --git a/nannou_wgpu/src/texture/reshaper/shaders/fs_msaa4.wgsl b/nannou_wgpu/src/texture/reshaper/shaders/fs_msaa4.wgsl
deleted file mode 100644
index 96c88e341..000000000
--- a/nannou_wgpu/src/texture/reshaper/shaders/fs_msaa4.wgsl
+++ /dev/null
@@ -1,29 +0,0 @@
-struct FragmentOutput {
-    @location(0) out_color: vec4<f32>,
-};
-
-@group(0) @binding(0)
-var tex: texture_multisampled_2d<f32>;
-@group(0) @binding(1)
-var tex_sampler: sampler;
-
-@fragment
-fn main(
-    @location(0) tex_coords: vec2<f32>,
-) -> FragmentOutput {
-    // Get the integer tex coordinates.
-    let tex_size: vec2<u32> = textureDimensions(tex);
-    let tex_x: i32 = i32(f32(tex_size.x) * tex_coords.x);
-    let tex_y: i32 = i32(f32(tex_size.y) * tex_coords.y);;
-    let itex_coords: vec2<i32> = vec2<i32>(tex_x, tex_y);
-
-    // Manually unroll the resolve. The less conditions the better!
-    var color: vec4<f32> = vec4<f32>(0.0, 0.0, 0.0, 0.0);
-    color = color + textureLoad(tex, itex_coords, 0);
-    color = color + textureLoad(tex, itex_coords, 1);
-    color = color + textureLoad(tex, itex_coords, 2);
-    color = color + textureLoad(tex, itex_coords, 3);
-    color = color * 0.25;
-
-    return FragmentOutput(color);
-}
diff --git a/nannou_wgpu/src/texture/reshaper/shaders/fs_msaa8.wgsl b/nannou_wgpu/src/texture/reshaper/shaders/fs_msaa8.wgsl
deleted file mode 100644
index 5e52e2c09..000000000
--- a/nannou_wgpu/src/texture/reshaper/shaders/fs_msaa8.wgsl
+++ /dev/null
@@ -1,33 +0,0 @@
-struct FragmentOutput {
-    @location(0) out_color: vec4<f32>,
-};
-
-@group(0) @binding(0)
-var tex: texture_multisampled_2d<f32>;
-@group(0) @binding(1)
-var tex_sampler: sampler;
-
-@fragment
-fn main(
-    @location(0) tex_coords: vec2<f32>,
-) -> FragmentOutput {
-    // Get the integer tex coordinates.
-    let tex_size: vec2<u32> = textureDimensions(tex);
-    let tex_x: i32 = i32(f32(tex_size.x) * tex_coords.x);
-    let tex_y: i32 = i32(f32(tex_size.y) * tex_coords.y);;
-    let itex_coords: vec2<i32> = vec2<i32>(tex_x, tex_y);
-
-    // Manually unroll the resolve. The less conditions the better!
-    var color: vec4<f32> = vec4<f32>(0.0, 0.0, 0.0, 0.0);
-    color = color + textureLoad(tex, itex_coords, 0);
-    color = color + textureLoad(tex, itex_coords, 1);
-    color = color + textureLoad(tex, itex_coords, 2);
-    color = color + textureLoad(tex, itex_coords, 3);
-    color = color + textureLoad(tex, itex_coords, 4);
-    color = color + textureLoad(tex, itex_coords, 5);
-    color = color + textureLoad(tex, itex_coords, 6);
-    color = color + textureLoad(tex, itex_coords, 7);
-    color = color * 0.125;
-
-    return FragmentOutput(color);
-}
diff --git a/nannou_wgpu/src/texture/reshaper/shaders/vs.wgsl b/nannou_wgpu/src/texture/reshaper/shaders/vs.wgsl
deleted file mode 100644
index 7859f9c3a..000000000
--- a/nannou_wgpu/src/texture/reshaper/shaders/vs.wgsl
+++ /dev/null
@@ -1,13 +0,0 @@
-struct VertexOutput {
-    @location(0) tex_coords: vec2<f32>,
-    @builtin(position) out_pos: vec4<f32>,
-};
-
-@vertex
-fn main(
-    @location(0) pos: vec2<f32>,
-) -> VertexOutput {
-    let out_pos: vec4<f32> = vec4<f32>(pos, 0.0, 1.0);
-    let tex_coords: vec2<f32> = vec2<f32>(pos.x * 0.5 + 0.5, 1.0 - (pos.y * 0.5 + 0.5));
-    return VertexOutput(tex_coords, out_pos);
-}
diff --git a/nannou_wgpu/src/texture/row_padded_buffer.rs b/nannou_wgpu/src/texture/row_padded_buffer.rs
deleted file mode 100644
index 2b41a4dfe..000000000
--- a/nannou_wgpu/src/texture/row_padded_buffer.rs
+++ /dev/null
@@ -1,227 +0,0 @@
-use crate as wgpu;
-
-/// A wrapper around a wgpu buffer suitable for copying to and from Textures. Automatically handles
-/// the padding necessary for buffer-to-texture and texture-to-buffer copies.
-///
-/// Note: as of `wgpu` 0.6, texture-to-buffer and buffer-to-texture copies require that image rows
-/// are padded to a multiple `wgpu::COPY_BYTES_PER_ROW_ALIGNMENT` bytes. Note that this is a
-/// requirement on the *buffers*, not on the textures! You can have textures of whatever size you
-/// like, but when you copy them to/from a buffer, the *buffer rows* need padding. This is referred
-/// to as "pitch alignment".
-///
-/// In a `RowPaddedBuffer`, the image is stored in row-major order, with rows padded at the end with
-/// uninitialized bytes to reach the necessary size.
-#[derive(Debug)]
-pub struct RowPaddedBuffer {
-    /// The width of the buffer in bytes, *without padding*.
-    width: u32,
-    /// The padding on each row of the buffer in bytes.
-    row_padding: u32,
-    /// The height of the buffer.
-    height: u32,
-    /// The wrapped buffer handle.
-    pub(crate) buffer: wgpu::Buffer,
-    /// The descriptor used to create the wrapped buffer.
-    buffer_descriptor: wgpu::BufferDescriptor<'static>,
-}
-
-impl RowPaddedBuffer {
-    /// Create a row-padded buffer on the device.
-    ///
-    /// Width should be given in bytes.
-    pub fn new(device: &wgpu::Device, width: u32, height: u32, usage: wgpu::BufferUsages) -> Self {
-        let row_padding = wgpu::compute_row_padding(width);
-
-        // only create mapped for buffers that we're going to write to.
-        let mapped_at_creation = usage.contains(wgpu::BufferUsages::MAP_WRITE);
-
-        let buffer_descriptor = wgpu::BufferDescriptor {
-            label: Some("nannou::RowPaddedBuffer"),
-            size: ((width + row_padding) * height) as u64,
-            usage,
-            mapped_at_creation,
-        };
-        let buffer = device.create_buffer(&buffer_descriptor);
-
-        Self {
-            width,
-            row_padding,
-            height,
-            buffer,
-            buffer_descriptor,
-        }
-    }
-
-    /// Creates a buffer compatible with a 2d slice of the given texture.
-    pub fn for_texture(
-        device: &wgpu::Device,
-        texture: &wgpu::Texture,
-        usage: wgpu::BufferUsages,
-    ) -> RowPaddedBuffer {
-        Self::new(
-            device,
-            texture.extent().width * wgpu::texture_format_size_bytes(texture.format()),
-            texture.extent().height,
-            usage,
-        )
-    }
-
-    /// The width of the buffer, in bytes, NOT including padding bytes.
-    pub fn width(&self) -> u32 {
-        self.width
-    }
-
-    /// The padding of each row of this buffer.
-    pub fn row_padding(&self) -> u32 {
-        self.row_padding
-    }
-
-    /// The width of the buffer, in bytes, INCLUDING padding bytes.
-    pub fn padded_width(&self) -> u32 {
-        self.width + self.row_padding
-    }
-
-    /// The height of the buffer.
-    pub fn height(&self) -> u32 {
-        self.height
-    }
-
-    /// Copy data into the padded buffer.
-    ///
-    /// Will copy `data_width` bytes of data into each row of the buffer, leaving the remainder
-    /// of the buffer unmodified.
-    ///
-    /// The buffer usage must include `BufferUsages::map_read()`.
-    pub fn write(&self, buf: &[u8]) {
-        assert_eq!(
-            (self.width * self.height) as usize,
-            buf.len(),
-            "Incorrect input slice size"
-        );
-        assert!(
-            self.buffer_descriptor
-                .usage
-                .contains(wgpu::BufferUsages::MAP_WRITE),
-            "Wrapped buffer cannot be mapped for writing"
-        );
-
-        let mut mapped = self.buffer.slice(..).get_mapped_range_mut();
-        let mapped = &mut mapped[..];
-
-        let width = self.width as usize;
-        let padded_width = width + self.row_padding as usize;
-        let height = self.height as usize;
-        for row in 0..height {
-            let in_start = row * width;
-            let out_start = row * padded_width;
-
-            // note: leaves mapped[out_start + width..out_start + padded_width] uninitialized!
-            mapped[out_start..out_start + width].copy_from_slice(&buf[in_start..in_start + width]);
-        }
-    }
-
-    /// Encode a copy into a texture. Assumes the texture is 2d.
-    ///
-    /// The copy will not be performed until the encoded command buffer is submitted.
-    pub fn encode_copy_into(
-        &self,
-        encoder: &mut wgpu::CommandEncoder,
-        destination: &wgpu::Texture,
-    ) {
-        assert_eq!(
-            destination.extent().depth_or_array_layers,
-            1,
-            "use encode_copy_into_at for 3d textures"
-        );
-        self.encode_copy_into_at(encoder, destination, 0);
-    }
-
-    /// Encode a copy into a 3d texture at a given depth. Will copy this buffer (modulo padding)
-    /// to a slice of the texture at the given depth.
-    ///
-    /// The copy will not be performed until the encoded command buffer is submitted.
-    pub fn encode_copy_into_at(
-        &self,
-        encoder: &mut wgpu::CommandEncoder,
-        destination: &wgpu::Texture,
-        depth: u32,
-    ) {
-        let (source, destination, copy_size) = self.copy_views(destination, depth);
-        encoder.copy_buffer_to_texture(source, destination, copy_size);
-    }
-
-    /// Encode a copy from a texture.
-    ///
-    /// The copy will not be performed until the encoded command buffer is submitted.
-    pub fn encode_copy_from(&self, encoder: &mut wgpu::CommandEncoder, source: &wgpu::Texture) {
-        assert_eq!(
-            source.extent().depth_or_array_layers,
-            1,
-            "use encode_copy_from_at for 3d textures"
-        );
-        self.encode_copy_from_at(encoder, source, 0);
-    }
-
-    /// Encode a copy from a 3d texture at a given depth. Will copy a slice of the texture to fill
-    /// this whole buffer (modulo padding).
-    ///
-    /// The copy will not be performed until the encoded command buffer is submitted.
-    pub fn encode_copy_from_at(
-        &self,
-        encoder: &mut wgpu::CommandEncoder,
-        source: &wgpu::Texture,
-        depth: u32,
-    ) {
-        let (destination, source, copy_size) = self.copy_views(source, depth);
-        encoder.copy_texture_to_buffer(source, destination, copy_size);
-    }
-
-    /// Copy view logic.
-    /// This is precisely the same for texture-to-buffer and buffer-to-texture copies.
-    fn copy_views<'s, 't>(
-        &'s self,
-        texture: &'t wgpu::Texture,
-        depth: u32,
-    ) -> (
-        wgpu::ImageCopyBuffer<'s>,
-        wgpu::ImageCopyTexture<'t>,
-        wgpu::Extent3d,
-    ) {
-        let format_size_bytes = wgpu::texture_format_size_bytes(texture.format());
-
-        assert_eq!(
-            self.width % format_size_bytes,
-            0,
-            "buffer rows do not map evenly onto texture rows"
-        );
-        assert_eq!(
-            texture.extent().width,
-            self.width / format_size_bytes,
-            "buffer rows are the wrong width"
-        );
-        assert_eq!(
-            texture.extent().height,
-            self.height,
-            "buffer is the wrong height"
-        );
-        assert!(
-            depth <= texture.extent().depth_or_array_layers,
-            "texture not deep enough"
-        );
-
-        let mut copy_size = texture.extent();
-        copy_size.depth_or_array_layers = 1;
-
-        let buffer_view = wgpu::ImageCopyBuffer {
-            buffer: &self.buffer,
-            // note: this is the layout of *this buffer*.
-            layout: wgpu::ImageDataLayout {
-                offset: 0,
-                bytes_per_row: Some(self.padded_width()),
-                rows_per_image: Some(self.height),
-            },
-        };
-        let texture_view = texture.as_image_copy();
-        (buffer_view, texture_view, copy_size)
-    }
-}
diff --git a/nature_of_code/chp_01_vectors/1_10_motion101_acceleration.rs b/nature_of_code/chp_01_vectors/1_10_motion101_acceleration.rs
index 5e9ebbf6f..f2b2b39d1 100644
--- a/nature_of_code/chp_01_vectors/1_10_motion101_acceleration.rs
+++ b/nature_of_code/chp_01_vectors/1_10_motion101_acceleration.rs
@@ -21,7 +21,7 @@ struct Mover {
 }
 
 impl Mover {
-    fn new(rect: Rect<f32>) -> Self {
+    fn new(rect: geom::Rect<f32>) -> Self {
         let position = pt2(rect.x(), rect.y());
         let velocity = vec2(0.0, 0.0);
         let acceleration = vec2(0.0, 0.0);
@@ -59,23 +59,20 @@ impl Mover {
 }
 
 fn model(app: &App) -> Model {
-    let _window = app.new_window().size(640, 360).view(view).build().unwrap();
+    let _window = app.new_window().size(640, 360).view(view).build();
     let mover = Mover::new(app.window_rect());
     Model { mover }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
+fn update(app: &App, m: &mut Model) {
     // update gets called just before view every frame
-    m.mover.update(pt2(app.mouse.x, app.mouse.y));
+    m.mover.update(pt2(app.mouse().x, app.mouse().y));
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
     m.mover.display(&draw);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_01_vectors/1_11_motion101_acceleration_array.rs b/nature_of_code/chp_01_vectors/1_11_motion101_acceleration_array.rs
index fb789341b..d91334453 100644
--- a/nature_of_code/chp_01_vectors/1_11_motion101_acceleration_array.rs
+++ b/nature_of_code/chp_01_vectors/1_11_motion101_acceleration_array.rs
@@ -26,7 +26,7 @@ struct Mover {
 }
 
 impl Mover {
-    fn new(rect: Rect<f32>) -> Self {
+    fn new(rect: geom::Rect<f32>) -> Self {
         let rand_x = random_range(rect.left(), rect.right());
         let rand_y = random_range(rect.top(), rect.bottom());
         let position = pt2(rand_x, rand_y);
@@ -59,32 +59,31 @@ impl Mover {
         draw.ellipse()
             .xy(self.position)
             .w_h(48.0, 48.0)
-            .rgba(0.5, 0.5, 0.5, 0.7)
+            .srgba(0.5, 0.5, 0.5, 0.7)
             .stroke(BLACK)
             .stroke_weight(2.0);
     }
 }
 
 fn model(app: &App) -> Model {
-    let rect = Rect::from_w_h(640.0, 360.0);
+    let rect = geom::Rect::from_w_h(640.0, 360.0);
     app.new_window()
         .size(rect.w() as u32, rect.h() as u32)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     let movers = (0..20).map(|_| Mover::new(rect)).collect();
     Model { movers }
 }
 
 // update gets called just before view every frame
-fn update(app: &App, m: &mut Model, _update: Update) {
+fn update(app: &App, m: &mut Model) {
     for mover in &mut m.movers {
-        mover.update(pt2(app.mouse.x, app.mouse.y));
+        mover.update(pt2(app.mouse().x, app.mouse().y));
     }
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -92,7 +91,4 @@ fn view(app: &App, m: &Model, frame: Frame) {
     for mover in &m.movers {
         mover.display(&draw);
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_01_vectors/1_1_bouncingball_novectors.rs b/nature_of_code/chp_01_vectors/1_1_bouncingball_novectors.rs
index a1120dbac..b88051fae 100644
--- a/nature_of_code/chp_01_vectors/1_1_bouncingball_novectors.rs
+++ b/nature_of_code/chp_01_vectors/1_1_bouncingball_novectors.rs
@@ -22,7 +22,7 @@ fn model(app: &App) -> Model {
     let x_speed = 2.5;
     let y_speed = 2.0;
 
-    let _window = app.new_window().size(800, 200).view(view).build().unwrap();
+    let _window = app.new_window().size(800, 200).view(view).build();
     Model {
         x,
         y,
@@ -31,22 +31,22 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(app: &App, model: &mut Model, _update: Update) {
+fn update(app: &App, model: &mut Model) {
     // Add the current speed to the position
-    model.x = model.x + model.x_speed;
-    model.y = model.y + model.y_speed;
+    model.x += model.x_speed;
+    model.y += model.y_speed;
 
     let win_rect = app.window_rect();
 
     if (model.x > win_rect.right()) || (model.x < win_rect.left()) {
-        model.x_speed = model.x_speed * -1.0;
+        model.x_speed *= -1.0;
     }
     if (model.y > win_rect.top()) || (model.y < win_rect.bottom()) {
-        model.y_speed = model.y_speed * -1.0;
+        model.y_speed *= -1.0;
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -54,9 +54,6 @@ fn view(app: &App, model: &Model, frame: Frame) {
     draw.ellipse()
         .x_y(model.x, model.y)
         .w_h(50.0, 50.0)
-        .rgba(0.5, 0.5, 0.5, 1.0)
+        .srgba(0.5, 0.5, 0.5, 1.0)
         .stroke(BLACK);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_01_vectors/1_2_bouncingball_vectors.rs b/nature_of_code/chp_01_vectors/1_2_bouncingball_vectors.rs
index 6a82804b8..e779c6a8c 100644
--- a/nature_of_code/chp_01_vectors/1_2_bouncingball_vectors.rs
+++ b/nature_of_code/chp_01_vectors/1_2_bouncingball_vectors.rs
@@ -18,30 +18,30 @@ fn model(app: &App) -> Model {
     let position = pt2(100.0, 100.0);
     let velocity = vec2(2.5, 5.0);
 
-    let _window = app.new_window().size(200, 200).view(view).build().unwrap();
+    let _window = app.new_window().size(200, 200).view(view).build();
     Model { position, velocity }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
+fn update(app: &App, m: &mut Model) {
     // Add the current speed to the position.
     m.position += m.velocity;
 
     let rect = app.window_rect();
     if (m.position.x > rect.right()) || (m.position.x < rect.left()) {
-        m.velocity.x = m.velocity.x * -1.0;
+        m.velocity.x *= -1.0;
     }
     if (m.position.y > rect.top()) || (m.position.y < rect.bottom()) {
-        m.velocity.y = m.velocity.y * -1.0;
+        m.velocity.y *= -1.0;
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
 
     draw.rect()
         .wh(app.window_rect().wh())
-        .rgba(1.0, 1.0, 1.0, 0.03);
+        .srgba(1.0, 1.0, 1.0, 0.03);
 
     // Display circle at x position
     draw.ellipse()
@@ -49,7 +49,4 @@ fn view(app: &App, model: &Model, frame: Frame) {
         .w_h(16.0, 16.0)
         .gray(0.5)
         .stroke(BLACK);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_01_vectors/1_2_bouncingball_vectors_object.rs b/nature_of_code/chp_01_vectors/1_2_bouncingball_vectors_object.rs
index e9b6b3a63..786a01a9e 100644
--- a/nature_of_code/chp_01_vectors/1_2_bouncingball_vectors_object.rs
+++ b/nature_of_code/chp_01_vectors/1_2_bouncingball_vectors_object.rs
@@ -29,15 +29,15 @@ impl Ball {
         Ball { position, velocity }
     }
 
-    fn update(&mut self, rect: Rect<f32>) {
+    fn update(&mut self, rect: geom::Rect<f32>) {
         // Add the current speed to the position.
         self.position += self.velocity;
 
         if self.position.x > rect.right() || self.position.x < rect.left() {
-            self.velocity.x = self.velocity.x * -1.0;
+            self.velocity.x *= -1.0;
         }
         if self.position.y > rect.top() || self.position.y < rect.bottom() {
-            self.velocity.y = self.velocity.y * -1.0;
+            self.velocity.y *= -1.0;
         }
     }
 
@@ -56,19 +56,16 @@ fn model(_app: &App) -> Model {
     Model { ball }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
+fn update(app: &App, m: &mut Model) {
     m.ball.update(app.window_rect());
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model, _window: Entity) {
     // Begin drawing
     let draw = app.draw();
     draw.rect()
         .wh(app.window_rect().wh())
-        .rgba(1.0, 1.0, 1.0, 0.03);
+        .srgba(1.0, 1.0, 1.0, 0.03);
 
     m.ball.display(&draw);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_01_vectors/1_3_vector_subtraction.rs b/nature_of_code/chp_01_vectors/1_3_vector_subtraction.rs
index 5e7892f94..1c5b2f98c 100644
--- a/nature_of_code/chp_01_vectors/1_3_vector_subtraction.rs
+++ b/nature_of_code/chp_01_vectors/1_3_vector_subtraction.rs
@@ -9,17 +9,14 @@ fn main() {
     nannou::sketch(view).size(640, 360).run();
 }
 
-fn view(app: &App, frame: Frame) {
+fn view(app: &App) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
-    let mut mouse = app.mouse.position();
+    let mut mouse = app.mouse();
     let center = vec2(0.0, 0.0);
     mouse -= center;
 
     draw.line().weight(2.0).color(BLACK).points(center, mouse);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_01_vectors/1_4_vector_multiplication.rs b/nature_of_code/chp_01_vectors/1_4_vector_multiplication.rs
index c135af729..d18d1a404 100644
--- a/nature_of_code/chp_01_vectors/1_4_vector_multiplication.rs
+++ b/nature_of_code/chp_01_vectors/1_4_vector_multiplication.rs
@@ -9,19 +9,16 @@ fn main() {
     nannou::sketch(view).size(640, 360).run();
 }
 
-fn view(app: &App, frame: Frame) {
+fn view(app: &App) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
-    let mut mouse = vec2(app.mouse.x, app.mouse.y);
+    let mut mouse = vec2(app.mouse().x, app.mouse().y);
     let center = vec2(0.0, 0.0);
 
     // Multiplying a vector! The vector is now half its original size (multilies by 0.5)
     mouse *= 0.5;
 
     draw.line().weight(2.0).color(BLACK).points(center, mouse);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_01_vectors/1_5_vector_magnitude.rs b/nature_of_code/chp_01_vectors/1_5_vector_magnitude.rs
index 6e680a799..c1ed147b6 100644
--- a/nature_of_code/chp_01_vectors/1_5_vector_magnitude.rs
+++ b/nature_of_code/chp_01_vectors/1_5_vector_magnitude.rs
@@ -9,24 +9,21 @@ fn main() {
     nannou::sketch(view).size(640, 360).run();
 }
 
-fn view(app: &App, frame: Frame) {
+fn view(app: &App) {
     // Begin drawing
     let draw = app.draw();
     let win = app.window_rect();
 
     draw.background().color(WHITE);
 
-    let mut mouse = vec2(app.mouse.x, app.mouse.y);
+    let mut mouse = vec2(app.mouse().x, app.mouse().y);
     let center = vec2(0.0, 0.0);
     mouse -= center;
 
     let m = mouse.length();
 
-    let r = Rect::from_w_h(m, 10.0).top_left_of(win);
+    let r = geom::Rect::from_w_h(m, 10.0).top_left_of(win);
     draw.rect().xy(r.xy()).wh(r.wh()).color(BLACK);
 
     draw.line().weight(2.0).color(BLACK).points(center, mouse);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_01_vectors/1_6_vector_normalize.rs b/nature_of_code/chp_01_vectors/1_6_vector_normalize.rs
index 321048de5..583f1b923 100644
--- a/nature_of_code/chp_01_vectors/1_6_vector_normalize.rs
+++ b/nature_of_code/chp_01_vectors/1_6_vector_normalize.rs
@@ -9,13 +9,13 @@ fn main() {
     nannou::sketch(view).size(640, 360).run();
 }
 
-fn view(app: &App, frame: Frame) {
+fn view(app: &App) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
     // A vector that points to the mouse position
-    let mut mouse = vec2(app.mouse.x, app.mouse.y);
+    let mut mouse = vec2(app.mouse().x, app.mouse().y);
     // A vector that points to the center of the window
     let center = vec2(0.0, 0.0);
     // Subtract center from mouse which results in a vector that points from center to mouse
@@ -28,7 +28,4 @@ fn view(app: &App, frame: Frame) {
     mouse *= 150.0;
 
     draw.line().weight(2.0).color(BLACK).points(center, mouse);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_01_vectors/1_7_motion101.rs b/nature_of_code/chp_01_vectors/1_7_motion101.rs
index 5fe6a90c1..d0cd183b9 100644
--- a/nature_of_code/chp_01_vectors/1_7_motion101.rs
+++ b/nature_of_code/chp_01_vectors/1_7_motion101.rs
@@ -19,7 +19,7 @@ struct Mover {
 }
 
 impl Mover {
-    fn new(rect: Rect) -> Self {
+    fn new(rect: geom::Rect) -> Self {
         let position = pt2(
             random_range(rect.left(), rect.right()),
             random_range(rect.top(), rect.bottom()),
@@ -33,7 +33,7 @@ impl Mover {
         self.position += self.velocity;
     }
 
-    fn check_edges(&mut self, rect: Rect) {
+    fn check_edges(&mut self, rect: geom::Rect) {
         if self.position.x > rect.right() {
             self.position.x = rect.left();
         } else if self.position.x < rect.left() {
@@ -52,30 +52,27 @@ impl Mover {
             .xy(self.position)
             .w_h(48.0, 48.0)
             .gray(0.5)
-            .stroke(gray(0.0));
+            .stroke(Color::gray(0.0));
     }
 }
 
 fn model(app: &App) -> Model {
-    app.new_window().size(640, 360).view(view).build().unwrap();
+    app.new_window().size(640, 360).view(view).build();
     let mover = Mover::new(app.window_rect());
     Model { mover }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
+fn update(app: &App, m: &mut Model) {
     m.mover.update();
     m.mover.check_edges(app.window_rect());
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.rect()
         .wh(app.window_rect().wh())
-        .rgba(1.0, 1.0, 1.0, 0.03);
+        .srgba(1.0, 1.0, 1.0, 0.03);
 
     m.mover.display(&draw);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_01_vectors/1_8_motion101_acceleration.rs b/nature_of_code/chp_01_vectors/1_8_motion101_acceleration.rs
index 3797aec41..58be11d56 100644
--- a/nature_of_code/chp_01_vectors/1_8_motion101_acceleration.rs
+++ b/nature_of_code/chp_01_vectors/1_8_motion101_acceleration.rs
@@ -21,7 +21,7 @@ struct Mover {
 }
 
 impl Mover {
-    fn new(_rect: Rect) -> Self {
+    fn new(_rect: geom::Rect) -> Self {
         let position = pt2(0.0, 0.0);
         let velocity = vec2(0.0, 0.0);
         let acceleration = vec2(-0.001, 0.01);
@@ -43,7 +43,7 @@ impl Mover {
         self.position += self.velocity;
     }
 
-    fn check_edges(&mut self, rect: Rect) {
+    fn check_edges(&mut self, rect: geom::Rect) {
         if self.position.x > rect.right() {
             self.position.x = rect.left();
         } else if self.position.x < rect.left() {
@@ -68,25 +68,22 @@ impl Mover {
 }
 
 fn model(app: &App) -> Model {
-    app.new_window().size(640, 360).view(view).build().unwrap();
+    app.new_window().size(640, 360).view(view).build();
     let mover = Mover::new(app.window_rect());
     Model { mover }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
+fn update(app: &App, m: &mut Model) {
     m.mover.update();
     m.mover.check_edges(app.window_rect());
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.rect()
         .wh(app.window_rect().wh())
-        .rgba(1.0, 1.0, 1.0, 0.03);
+        .srgba(1.0, 1.0, 1.0, 0.03);
 
     m.mover.display(&draw);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_01_vectors/1_9_motion101_acceleration.rs b/nature_of_code/chp_01_vectors/1_9_motion101_acceleration.rs
index 6bc3655c8..49b208bf4 100644
--- a/nature_of_code/chp_01_vectors/1_9_motion101_acceleration.rs
+++ b/nature_of_code/chp_01_vectors/1_9_motion101_acceleration.rs
@@ -21,7 +21,7 @@ struct Mover {
 }
 
 impl Mover {
-    fn new(_rect: Rect) -> Self {
+    fn new(_rect: geom::Rect) -> Self {
         let position = pt2(0.0, 0.0);
         let velocity = vec2(0.0, 0.0);
         let acceleration = vec2(0.0, 0.0);
@@ -45,7 +45,7 @@ impl Mover {
         self.position += self.velocity;
     }
 
-    fn check_edges(&mut self, rect: Rect) {
+    fn check_edges(&mut self, rect: geom::Rect) {
         if self.position.x > rect.right() {
             self.position.x = rect.left();
         } else if self.position.x < rect.left() {
@@ -70,23 +70,20 @@ impl Mover {
 }
 
 fn model(app: &App) -> Model {
-    app.new_window().size(640, 360).view(view).build().unwrap();
+    app.new_window().size(640, 360).view(view).build();
     let mover = Mover::new(app.window_rect());
     Model { mover }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
+fn update(app: &App, m: &mut Model) {
     m.mover.update();
     m.mover.check_edges(app.window_rect());
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
     m.mover.display(&draw);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_02_forces/2_10_exercise_attract_repel.rs b/nature_of_code/chp_02_forces/2_10_exercise_attract_repel.rs
index 7a4ea1c39..b156159ca 100644
--- a/nature_of_code/chp_02_forces/2_10_exercise_attract_repel.rs
+++ b/nature_of_code/chp_02_forces/2_10_exercise_attract_repel.rs
@@ -27,7 +27,7 @@ struct Attractor {
 }
 
 impl Attractor {
-    fn new(rect: Rect) -> Self {
+    fn new(rect: geom::Rect) -> Self {
         let position = rect.xy();
         let mass = 10.0;
         let radius = mass * 3.0;
@@ -81,11 +81,7 @@ impl Attractor {
 
     fn rollover(&mut self, mx: f32, my: f32) {
         let d = self.position.distance(pt2(mx, my));
-        if d < self.mass {
-            self.roll_over = true;
-        } else {
-            self.roll_over = false;
-        }
+        self.roll_over = d < self.mass;
     }
 
     fn stop_dragging(&mut self) {
@@ -129,7 +125,7 @@ impl Mover {
         draw.ellipse()
             .xy(self.position)
             .w_h(self.mass * 2.0, self.mass * 2.0)
-            .rgba(0.6, 0.6, 0.6, 0.5);
+            .srgba(0.6, 0.6, 0.6, 0.5);
     }
 
     fn repel(&self, m: &Mover) -> Vec2 {
@@ -142,7 +138,7 @@ impl Mover {
         force * (-1.0 * strength) // Get force vector --> magnitude * direction
     }
 
-    fn _check_edges(&mut self, rect: Rect) {
+    fn _check_edges(&mut self, rect: geom::Rect) {
         if self.position.x < rect.left() {
             self.position.x = rect.left();
             self.velocity.x *= -1.0;
@@ -166,13 +162,13 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    let rect = Rect::from_w_h(640.0, 360.0);
+    let rect = geom::Rect::from_w_h(640.0, 360.0);
     app.new_window()
         .size(rect.w() as u32, rect.h() as u32)
-        .event(event)
+        .mouse_pressed(mouse_pressed)
+        .mouse_released(mouse_released)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     let movers = (0..20)
         .map(|_| {
@@ -189,21 +185,17 @@ fn model(app: &App) -> Model {
     Model { movers, attractor }
 }
 
-fn event(app: &App, m: &mut Model, event: WindowEvent) {
-    match event {
-        MousePressed(_button) => {
-            m.attractor.clicked(app.mouse.x, app.mouse.y);
-        }
-        MouseReleased(_buttom) => {
-            m.attractor.stop_dragging();
-        }
-        _other => (),
-    }
+fn mouse_pressed(app: &App, m: &mut Model, _button: MouseButton) {
+    m.attractor.clicked(app.mouse().x, app.mouse().y);
+}
+
+fn mouse_released(_app: &App, m: &mut Model, _button: MouseButton) {
+    m.attractor.stop_dragging();
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
-    m.attractor.drag(app.mouse.x, app.mouse.y);
-    m.attractor.rollover(app.mouse.x, app.mouse.y);
+fn update(app: &App, m: &mut Model) {
+    m.attractor.drag(app.mouse().x, app.mouse().y);
+    m.attractor.rollover(app.mouse().x, app.mouse().y);
 
     for i in 0..m.movers.len() {
         for j in 0..m.movers.len() {
@@ -218,7 +210,7 @@ fn update(app: &App, m: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     let draw = app.draw();
     draw.background().color(WHITE);
 
@@ -228,7 +220,4 @@ fn view(app: &App, m: &Model, frame: Frame) {
     for mover in &m.movers {
         mover.display(&draw);
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_02_forces/2_1_forces.rs b/nature_of_code/chp_02_forces/2_1_forces.rs
index 2402fae35..c42fb449d 100644
--- a/nature_of_code/chp_02_forces/2_1_forces.rs
+++ b/nature_of_code/chp_02_forces/2_1_forces.rs
@@ -21,7 +21,7 @@ struct Mover {
 }
 
 impl Mover {
-    fn new(rect: Rect) -> Self {
+    fn new(rect: geom::Rect) -> Self {
         let position = pt2(rect.left() + 30.0, rect.top() - 30.0);
         let velocity = vec2(0.0, 0.0);
         let acceleration = vec2(0.0, 0.0);
@@ -45,7 +45,7 @@ impl Mover {
         self.acceleration *= 0.0;
     }
 
-    fn check_edges(&mut self, rect: Rect) {
+    fn check_edges(&mut self, rect: geom::Rect) {
         if self.position.x > rect.right() {
             self.position.x = rect.right();
             self.velocity.x *= -1.0;
@@ -71,17 +71,16 @@ impl Mover {
 }
 
 fn model(app: &App) -> Model {
-    let rect = Rect::from_w_h(640.0, 360.0);
+    let rect = geom::Rect::from_w_h(640.0, 360.0);
     app.new_window()
         .size(rect.w() as u32, rect.h() as u32)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
     let mover = Mover::new(rect);
     Model { mover }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
+fn update(app: &App, m: &mut Model) {
     let wind = vec2(0.01, 0.0);
     let gravity = vec2(0.0, -0.1);
     m.mover.apply_force(wind);
@@ -90,13 +89,10 @@ fn update(app: &App, m: &mut Model, _update: Update) {
     m.mover.check_edges(app.window_rect());
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
     m.mover.display(&draw);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_02_forces/2_2_forces_many.rs b/nature_of_code/chp_02_forces/2_2_forces_many.rs
index 1cab33015..481ff1626 100644
--- a/nature_of_code/chp_02_forces/2_2_forces_many.rs
+++ b/nature_of_code/chp_02_forces/2_2_forces_many.rs
@@ -50,12 +50,12 @@ impl Mover {
         draw.ellipse()
             .xy(self.position)
             .w_h(self.mass * 16.0, self.mass * 16.0)
-            .rgba(0.3, 0.3, 0.3, 0.5)
+            .srgba(0.3, 0.3, 0.3, 0.5)
             .stroke(BLACK)
             .stroke_weight(2.0);
     }
 
-    fn check_edges(&mut self, rect: Rect) {
+    fn check_edges(&mut self, rect: geom::Rect) {
         if self.position.x > rect.right() {
             self.position.x = rect.right();
             self.velocity.x *= -1.0;
@@ -71,12 +71,11 @@ impl Mover {
 }
 
 fn model(app: &App) -> Model {
-    let rect = Rect::from_w_h(640.0, 360.0);
+    let rect = geom::Rect::from_w_h(640.0, 360.0);
     app.new_window()
         .size(rect.w() as u32, rect.h() as u32)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     let movers = (0..20)
         .map(|_| Mover::new(random_range(0.01f32, 4.0), rect.left(), rect.top()))
@@ -84,7 +83,7 @@ fn model(app: &App) -> Model {
     Model { movers }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
+fn update(app: &App, m: &mut Model) {
     for i in 0..m.movers.len() {
         let wind = vec2(0.01, 0.0);
         let gravity = vec2(0.0, -0.1);
@@ -95,7 +94,7 @@ fn update(app: &App, m: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -103,7 +102,4 @@ fn view(app: &App, m: &Model, frame: Frame) {
     for mover in &m.movers {
         mover.display(&draw);
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_02_forces/2_3_forces_many_real_gravity.rs b/nature_of_code/chp_02_forces/2_3_forces_many_real_gravity.rs
index 9363d97fc..72e86b7c4 100644
--- a/nature_of_code/chp_02_forces/2_3_forces_many_real_gravity.rs
+++ b/nature_of_code/chp_02_forces/2_3_forces_many_real_gravity.rs
@@ -50,12 +50,12 @@ impl Mover {
         draw.ellipse()
             .xy(self.position)
             .w_h(self.mass * 16.0, self.mass * 16.0)
-            .rgba(0.0, 0.0, 0.0, 0.5)
+            .srgba(0.0, 0.0, 0.0, 0.5)
             .stroke(BLACK)
             .stroke_weight(2.0);
     }
 
-    fn check_edges(&mut self, rect: Rect) {
+    fn check_edges(&mut self, rect: geom::Rect) {
         if self.position.x > rect.right() {
             self.position.x = rect.right();
             self.velocity.x *= -1.0;
@@ -71,12 +71,11 @@ impl Mover {
 }
 
 fn model(app: &App) -> Model {
-    let rect = Rect::from_w_h(640.0, 360.0);
+    let rect = geom::Rect::from_w_h(640.0, 360.0);
     app.new_window()
         .size(rect.w() as u32, rect.h() as u32)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     let movers = (0..20)
         .map(|_| Mover::new(random_range(1.0f32, 4.0), rect.left(), rect.top()))
@@ -84,7 +83,7 @@ fn model(app: &App) -> Model {
     Model { movers }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
+fn update(app: &App, m: &mut Model) {
     for i in 0..m.movers.len() {
         let wind = vec2(0.01, 0.0);
         let gravity = vec2(0.0, -0.1 * m.movers[i].mass);
@@ -95,7 +94,7 @@ fn update(app: &App, m: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -103,7 +102,4 @@ fn view(app: &App, m: &Model, frame: Frame) {
     for mover in &m.movers {
         mover.display(&draw);
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_02_forces/2_4_forces_friction.rs b/nature_of_code/chp_02_forces/2_4_forces_friction.rs
index 5f6c635e8..a4eeba6a0 100644
--- a/nature_of_code/chp_02_forces/2_4_forces_friction.rs
+++ b/nature_of_code/chp_02_forces/2_4_forces_friction.rs
@@ -50,12 +50,12 @@ impl Mover {
         draw.ellipse()
             .xy(self.position)
             .w_h(self.mass * 16.0, self.mass * 16.0)
-            .rgba(0.0, 0.0, 0.0, 0.5)
+            .srgba(0.0, 0.0, 0.0, 0.5)
             .stroke(BLACK)
             .stroke_weight(2.0);
     }
 
-    fn check_edges(&mut self, rect: Rect) {
+    fn check_edges(&mut self, rect: geom::Rect) {
         if self.position.x > rect.right() {
             self.position.x = rect.right();
             self.velocity.x *= -1.0;
@@ -71,12 +71,11 @@ impl Mover {
 }
 
 fn model(app: &App) -> Model {
-    let rect = Rect::from_w_h(383.0, 200.0);
+    let rect = geom::Rect::from_w_h(383.0, 200.0);
     app.new_window()
         .size(rect.w() as u32, rect.h() as u32)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     let movers = (0..5)
         .map(|_| {
@@ -90,7 +89,7 @@ fn model(app: &App) -> Model {
     Model { movers }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
+fn update(app: &App, m: &mut Model) {
     for mover in &mut m.movers {
         let wind = vec2(0.01, 0.0);
         let gravity = vec2(0.0, -0.1 * mover.mass);
@@ -111,7 +110,7 @@ fn update(app: &App, m: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -119,7 +118,4 @@ fn view(app: &App, m: &Model, frame: Frame) {
     for mover in &m.movers {
         mover.display(&draw);
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_02_forces/2_4_forces_no_friction.rs b/nature_of_code/chp_02_forces/2_4_forces_no_friction.rs
index 6827db06a..dd90168c6 100644
--- a/nature_of_code/chp_02_forces/2_4_forces_no_friction.rs
+++ b/nature_of_code/chp_02_forces/2_4_forces_no_friction.rs
@@ -50,12 +50,12 @@ impl Mover {
         draw.ellipse()
             .xy(self.position)
             .w_h(self.mass * 16.0, self.mass * 16.0)
-            .rgba(0.0, 0.0, 0.0, 0.5)
+            .srgba(0.0, 0.0, 0.0, 0.5)
             .stroke(BLACK)
             .stroke_weight(2.0);
     }
 
-    fn check_edges(&mut self, rect: Rect) {
+    fn check_edges(&mut self, rect: geom::Rect) {
         if self.position.x > rect.right() {
             self.position.x = rect.right();
             self.velocity.x *= -1.0;
@@ -71,12 +71,11 @@ impl Mover {
 }
 
 fn model(app: &App) -> Model {
-    let rect = Rect::from_w_h(383.0, 200.0);
+    let rect = geom::Rect::from_w_h(383.0, 200.0);
     app.new_window()
         .size(rect.w() as u32, rect.h() as u32)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     let movers = (0..5)
         .map(|_| {
@@ -90,7 +89,7 @@ fn model(app: &App) -> Model {
     Model { movers }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
+fn update(app: &App, m: &mut Model) {
     for mover in &mut m.movers {
         let wind = vec2(0.01, 0.0);
         let gravity = vec2(0.0, -0.1 * mover.mass);
@@ -102,7 +101,7 @@ fn update(app: &App, m: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -110,7 +109,4 @@ fn view(app: &App, m: &Model, frame: Frame) {
     for mover in &m.movers {
         mover.display(&draw);
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_02_forces/2_5_fluid_resistance.rs b/nature_of_code/chp_02_forces/2_5_fluid_resistance.rs
index e9ad1de25..91691eef7 100644
--- a/nature_of_code/chp_02_forces/2_5_fluid_resistance.rs
+++ b/nature_of_code/chp_02_forces/2_5_fluid_resistance.rs
@@ -28,13 +28,13 @@ struct Mover {
 // Liquid type
 struct Liquid {
     // Liquid is a rectangle
-    rect: Rect,
+    rect: geom::Rect,
     // Coefficient of drag
     c: f32,
 }
 
 impl Liquid {
-    fn new(rect: Rect, c: f32) -> Self {
+    fn new(rect: geom::Rect, c: f32) -> Self {
         let rect = rect;
         let c = c;
         Liquid { rect, c }
@@ -81,7 +81,7 @@ impl Mover {
         }
     }
 
-    fn new_random(rect: &Rect) -> Self {
+    fn new_random(rect: &geom::Rect) -> Self {
         Mover::new(
             random_range(0.5f32, 4.0),
             random_range(rect.left(), rect.right()),
@@ -112,13 +112,13 @@ impl Mover {
         draw.ellipse()
             .xy(self.position)
             .w_h(self.mass * 16.0, self.mass * 16.0)
-            .rgba(0.0, 0.0, 0.0, 0.5)
+            .srgba(0.0, 0.0, 0.0, 0.5)
             .stroke(BLACK)
             .stroke_weight(2.0);
     }
 
     // Bounce off bottom of window
-    fn check_edges(&mut self, rect: Rect) {
+    fn check_edges(&mut self, rect: geom::Rect) {
         if self.position.y < rect.bottom() {
             self.velocity.y *= -0.9; // A little dampening when hitting the bottom
             self.position.y = rect.bottom();
@@ -127,13 +127,12 @@ impl Mover {
 }
 
 fn model(app: &App) -> Model {
-    let rect = Rect::from_w_h(640.0, 360.0);
+    let rect = geom::Rect::from_w_h(640.0, 360.0);
     app.new_window()
         .size(rect.w() as u32, rect.h() as u32)
         .mouse_pressed(mouse_pressed)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     // Nine moving bodies
     let movers = (0..9)
@@ -141,7 +140,7 @@ fn model(app: &App) -> Model {
         .collect();
 
     // Create an instance of our Liquid type
-    let rect = Rect::from_w_h(rect.w(), rect.h() * 0.5).align_bottom_of(rect);
+    let rect = geom::Rect::from_w_h(rect.w(), rect.h() * 0.5).align_bottom_of(rect);
     let liquid = Liquid::new(rect, 0.1);
 
     Model { movers, liquid }
@@ -154,7 +153,7 @@ fn mouse_pressed(app: &App, m: &mut Model, _button: MouseButton) {
     }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
+fn update(app: &App, m: &mut Model) {
     for i in 0..m.movers.len() {
         // Is the Mover in the liquid?
         if m.liquid.contains(&m.movers[i]) {
@@ -173,7 +172,7 @@ fn update(app: &App, m: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -185,7 +184,4 @@ fn view(app: &App, m: &Model, frame: Frame) {
     for mover in &m.movers {
         mover.display(&draw);
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_02_forces/2_6_attraction.rs b/nature_of_code/chp_02_forces/2_6_attraction.rs
index 5fa7ae012..980d805e7 100644
--- a/nature_of_code/chp_02_forces/2_6_attraction.rs
+++ b/nature_of_code/chp_02_forces/2_6_attraction.rs
@@ -32,7 +32,7 @@ struct Attractor {
 
 impl Attractor {
     const G: f32 = 1.0; // Gravitational Constant
-    fn new(rect: Rect) -> Self {
+    fn new(rect: geom::Rect) -> Self {
         let position = rect.xy();
         let mass = 20.0;
         let drag_offset = vec2(0.0, 0.0);
@@ -68,7 +68,7 @@ impl Attractor {
         draw.ellipse()
             .xy(self.position)
             .w_h(self.mass * 2.0, self.mass * 2.0)
-            .rgba(gray, gray, gray, 0.8)
+            .srgba(gray, gray, gray, 0.8)
             .stroke(BLACK)
             .stroke_weight(4.0);
     }
@@ -85,11 +85,7 @@ impl Attractor {
 
     fn hover(&mut self, mx: f32, my: f32) {
         let d = self.position.distance(pt2(mx, my));
-        if d < self.mass {
-            self.roll_over = true;
-        } else {
-            self.roll_over = false;
-        }
+        self.roll_over = d < self.mass;
     }
 
     fn stop_dragging(&mut self) {
@@ -138,7 +134,7 @@ impl Mover {
             .stroke_weight(2.0);
     }
 
-    fn _check_edges(&mut self, rect: Rect) {
+    fn _check_edges(&mut self, rect: geom::Rect) {
         if self.position.x > rect.right() {
             self.position.x = rect.left();
         } else if self.position.x < rect.left() {
@@ -152,13 +148,13 @@ impl Mover {
 }
 
 fn model(app: &App) -> Model {
-    let rect = Rect::from_w_h(640.0, 360.0);
+    let rect = geom::Rect::from_w_h(640.0, 360.0);
     app.new_window()
         .size(rect.w() as u32, rect.h() as u32)
-        .event(event)
+        .mouse_pressed(mouse_pressed)
+        .mouse_released(mouse_release)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     let mover = Mover::new();
     let attractor = Attractor::new(rect);
@@ -166,34 +162,27 @@ fn model(app: &App) -> Model {
     Model { mover, attractor }
 }
 
-fn event(app: &App, m: &mut Model, event: WindowEvent) {
-    match event {
-        MousePressed(_button) => {
-            m.attractor.clicked(app.mouse.x, app.mouse.y);
-        }
-        MouseReleased(_buttom) => {
-            m.attractor.stop_dragging();
-        }
-        _other => (),
-    }
+fn mouse_pressed(app: &App, m: &mut Model, _button: MouseButton) {
+    m.attractor.clicked(app.mouse().x, app.mouse().y);
+}
+
+fn mouse_release(_app: &App, m: &mut Model, _button: MouseButton) {
+    m.attractor.stop_dragging();
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
+fn update(app: &App, m: &mut Model) {
     let force = m.attractor.attract(&m.mover);
     m.mover.apply_force(force);
     m.mover.update();
-    m.attractor.drag(app.mouse.x, app.mouse.y);
-    m.attractor.hover(app.mouse.x, app.mouse.y);
+    m.attractor.drag(app.mouse().x, app.mouse().y);
+    m.attractor.hover(app.mouse().x, app.mouse().y);
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
     m.attractor.display(&draw);
     m.mover.display(&draw);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_02_forces/2_7_attraction_many.rs b/nature_of_code/chp_02_forces/2_7_attraction_many.rs
index 54c7f120b..fb280c40a 100644
--- a/nature_of_code/chp_02_forces/2_7_attraction_many.rs
+++ b/nature_of_code/chp_02_forces/2_7_attraction_many.rs
@@ -32,7 +32,7 @@ struct Attractor {
 
 impl Attractor {
     const G: f32 = 1.0; // Gravitational Constant
-    fn new(rect: Rect) -> Self {
+    fn new(rect: geom::Rect) -> Self {
         let position = rect.xy();
         let mass = 20.0;
         let drag_offset = vec2(0.0, 0.0);
@@ -68,7 +68,7 @@ impl Attractor {
         draw.ellipse()
             .xy(self.position)
             .w_h(self.mass * 2.0, self.mass * 2.0)
-            .rgba(gray, gray, gray, 0.8)
+            .srgba(gray, gray, gray, 0.8)
             .stroke(BLACK)
             .stroke_weight(4.0);
     }
@@ -85,11 +85,7 @@ impl Attractor {
 
     fn hover(&mut self, mx: f32, my: f32) {
         let d = self.position.distance(pt2(mx, my));
-        if d < self.mass {
-            self.roll_over = true;
-        } else {
-            self.roll_over = false;
-        }
+        self.roll_over = d < self.mass;
     }
 
     fn stop_dragging(&mut self) {
@@ -133,21 +129,21 @@ impl Mover {
         draw.ellipse()
             .xy(self.position)
             .w_h(self.mass * 16.0, self.mass * 16.0)
-            .rgba(0.0, 0.0, 0.0, 0.5)
+            .srgba(0.0, 0.0, 0.0, 0.5)
             .stroke(BLACK)
             .stroke_weight(2.0);
     }
 }
 
 fn model(app: &App) -> Model {
-    let rect = Rect::from_w_h(640.0, 360.0);
+    let rect = geom::Rect::from_w_h(640.0, 360.0);
     let _window = app
         .new_window()
         .size(rect.w() as u32, rect.h() as u32)
-        .event(event)
+        .mouse_pressed(mouse_pressed)
+        .mouse_released(mouse_released)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     let movers = (0..90)
         .map(|_| {
@@ -164,21 +160,17 @@ fn model(app: &App) -> Model {
     Model { movers, attractor }
 }
 
-fn event(app: &App, m: &mut Model, event: WindowEvent) {
-    match event {
-        MousePressed(_button) => {
-            m.attractor.clicked(app.mouse.x, app.mouse.y);
-        }
-        MouseReleased(_buttom) => {
-            m.attractor.stop_dragging();
-        }
-        _other => (),
-    }
+fn mouse_pressed(app: &App, m: &mut Model, _button: MouseButton) {
+    m.attractor.clicked(app.mouse().x, app.mouse().y);
+}
+
+fn mouse_released(_app: &App, m: &mut Model, _button: MouseButton) {
+    m.attractor.stop_dragging();
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
-    m.attractor.drag(app.mouse.x, app.mouse.y);
-    m.attractor.hover(app.mouse.x, app.mouse.y);
+fn update(app: &App, m: &mut Model) {
+    m.attractor.drag(app.mouse().x, app.mouse().y);
+    m.attractor.hover(app.mouse().x, app.mouse().y);
     for i in 0..m.movers.len() {
         let force = m.attractor.attract(&m.movers[i]);
         m.movers[i].apply_force(force);
@@ -186,7 +178,7 @@ fn update(app: &App, m: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -197,7 +189,4 @@ fn view(app: &App, m: &Model, frame: Frame) {
     for mover in &m.movers {
         mover.display(&draw);
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_02_forces/2_8_mutual_attraction.rs b/nature_of_code/chp_02_forces/2_8_mutual_attraction.rs
index a4125b649..9695b07bc 100644
--- a/nature_of_code/chp_02_forces/2_8_mutual_attraction.rs
+++ b/nature_of_code/chp_02_forces/2_8_mutual_attraction.rs
@@ -59,19 +59,18 @@ impl Mover {
         draw.ellipse()
             .xy(self.position)
             .w_h(self.mass * 24.0, self.mass * 24.0)
-            .rgba(0.0, 0.0, 0.0, 0.5)
+            .srgba(0.0, 0.0, 0.0, 0.5)
             .stroke(BLACK)
             .stroke_weight(2.0);
     }
 }
 
 fn model(app: &App) -> Model {
-    let rect = Rect::from_w_h(640.0, 360.0);
+    let rect = geom::Rect::from_w_h(640.0, 360.0);
     app.new_window()
         .size(rect.w() as u32, rect.h() as u32)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     let movers = (0..1000)
         .map(|_| {
@@ -86,7 +85,7 @@ fn model(app: &App) -> Model {
     Model { movers }
 }
 
-fn update(_app: &App, m: &mut Model, _update: Update) {
+fn update(_app: &App, m: &mut Model) {
     for i in 0..m.movers.len() {
         for j in 0..m.movers.len() {
             if i != j {
@@ -98,7 +97,7 @@ fn update(_app: &App, m: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -107,7 +106,4 @@ fn view(app: &App, m: &Model, frame: Frame) {
     for mover in &m.movers {
         mover.display(&draw);
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_02_forces/2_forces_many_mutual_boundaries.rs b/nature_of_code/chp_02_forces/2_forces_many_mutual_boundaries.rs
index b4923d0b6..0ed2290a4 100644
--- a/nature_of_code/chp_02_forces/2_forces_many_mutual_boundaries.rs
+++ b/nature_of_code/chp_02_forces/2_forces_many_mutual_boundaries.rs
@@ -45,7 +45,7 @@ impl Mover {
         draw.ellipse()
             .xy(self.position)
             .w_h(self.mass * 16.0, self.mass * 16.0)
-            .rgba(0.6, 0.6, 0.6, 0.7);
+            .srgba(0.6, 0.6, 0.6, 0.7);
     }
 
     fn attract(&self, m: &Mover) -> Vec2 {
@@ -58,7 +58,7 @@ impl Mover {
         force * strength // Get force vector --> magnitude * direction
     }
 
-    fn boundaries(&mut self, rect: Rect) {
+    fn boundaries(&mut self, rect: geom::Rect) {
         let d = 50.0;
         let mut force = vec2(0.0, 0.0);
 
@@ -85,12 +85,11 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    let rect = Rect::from_w_h(640.0, 360.0);
+    let rect = geom::Rect::from_w_h(640.0, 360.0);
     app.new_window()
         .size(rect.w() as u32, rect.h() as u32)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     let movers = (0..20)
         .map(|_| {
@@ -105,7 +104,7 @@ fn model(app: &App) -> Model {
     Model { movers }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
+fn update(app: &App, m: &mut Model) {
     for i in 0..m.movers.len() {
         for j in 0..m.movers.len() {
             if i != j {
@@ -118,7 +117,7 @@ fn update(app: &App, m: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -127,7 +126,4 @@ fn view(app: &App, m: &Model, frame: Frame) {
     for mover in &m.movers {
         mover.display(&draw);
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_03_oscillation/3_01_angular_motion.rs b/nature_of_code/chp_03_oscillation/3_01_angular_motion.rs
index bf691d273..dc3bf3fdf 100644
--- a/nature_of_code/chp_03_oscillation/3_01_angular_motion.rs
+++ b/nature_of_code/chp_03_oscillation/3_01_angular_motion.rs
@@ -20,7 +20,7 @@ fn model(app: &App) -> Model {
     let angle = 0.0;
     let angle_velocity = 0.0;
     let angle_acceleration = -0.0001;
-    app.new_window().size(800, 200).view(view).build().unwrap();
+    app.new_window().size(800, 200).view(view).build();
     Model {
         angle,
         angle_velocity,
@@ -28,12 +28,12 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(_app: &App, model: &mut Model, _update: Update) {
+fn update(_app: &App, model: &mut Model) {
     model.angle += model.angle_velocity;
     model.angle_velocity += model.angle_acceleration;
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.rect().wh(app.window_rect().wh()).color(WHITE);
@@ -58,7 +58,4 @@ fn view(app: &App, model: &Model, frame: Frame) {
         .gray(0.5)
         .stroke_weight(2.0)
         .stroke_color(BLACK);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_03_oscillation/3_02_forces_angular_motion.rs b/nature_of_code/chp_03_oscillation/3_02_forces_angular_motion.rs
index 10dd742f6..e3e5242a8 100644
--- a/nature_of_code/chp_03_oscillation/3_02_forces_angular_motion.rs
+++ b/nature_of_code/chp_03_oscillation/3_02_forces_angular_motion.rs
@@ -17,7 +17,7 @@ struct Attractor {
 }
 
 impl Attractor {
-    fn new(rect: Rect) -> Self {
+    fn new(rect: geom::Rect) -> Self {
         let location = rect.xy();
         let mass = 20.0;
         let g = 0.4;
@@ -27,7 +27,7 @@ impl Attractor {
     fn attract(&self, m: &Mover) -> Vec2 {
         let mut force = self.location - m.location; // Calculate direction of force
         let mut distance = force.length(); // Distance between objects
-        distance = distance.max(5.0).min(25.0); // Limiting the distance to eliminate "extreme" results for very cose or very far object
+        distance = distance.clamp(5.0, 25.0); // Limiting the distance to eliminate "extreme" results for very cose or very far object
         force = force.normalize(); // Normalize vector (distance doesn't matter, we just want this vector for direction)
         let strength = (self.g * self.mass * m.mass) / (distance * distance); // Calculate gravitational force magnitude
         force * strength // Get force vector --> magnitude * direction
@@ -95,7 +95,7 @@ impl Mover {
         draw.rect()
             .x_y(self.location.x, self.location.y)
             .w_h(self.mass * 16.0, self.mass * 16.0)
-            .rgba(0.6, 0.6, 0.6, 0.78)
+            .srgba(0.6, 0.6, 0.6, 0.78)
             .stroke(BLACK)
             .rotate(self.angle);
     }
@@ -107,12 +107,11 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    let rect = Rect::from_w_h(800.0, 200.0);
+    let rect = geom::Rect::from_w_h(800.0, 200.0);
     app.new_window()
         .size(rect.w() as u32, rect.h() as u32)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     let movers = (0..20)
         .map(|_| {
@@ -129,7 +128,7 @@ fn model(app: &App) -> Model {
     Model { movers, attractor }
 }
 
-fn update(_app: &App, m: &mut Model, _update: Update) {
+fn update(_app: &App, m: &mut Model) {
     for i in 0..m.movers.len() {
         let force = m.attractor.attract(&m.movers[i]);
         m.movers[i].apply_force(force);
@@ -137,7 +136,7 @@ fn update(_app: &App, m: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -148,7 +147,4 @@ fn view(app: &App, m: &Model, frame: Frame) {
     for mover in &m.movers {
         mover.display(&draw);
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_03_oscillation/3_04_exercise_spiral.rs b/nature_of_code/chp_03_oscillation/3_04_exercise_spiral.rs
index 2b7a4994b..f5cd037c7 100644
--- a/nature_of_code/chp_03_oscillation/3_04_exercise_spiral.rs
+++ b/nature_of_code/chp_03_oscillation/3_04_exercise_spiral.rs
@@ -18,18 +18,18 @@ fn model(app: &App) -> Model {
     let r = 0.0;
     let theta = 0.0;
 
-    app.new_window().size(640, 360).view(view).build().unwrap();
+    app.new_window().size(640, 360).view(view).build();
     Model { r, theta }
 }
 
-fn update(_app: &App, model: &mut Model, _update: Update) {
+fn update(_app: &App, model: &mut Model) {
     // Increment the angle
     model.theta += 0.01;
     // Increment the radius
     model.r += 0.05;
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
 
@@ -45,8 +45,5 @@ fn view(app: &App, model: &Model, frame: Frame) {
     draw.ellipse()
         .x_y(x, y)
         .w_h(16.0, 16.0)
-        .rgba(0.0, 0.0, 0.0, 1.0);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
+        .srgba(0.0, 0.0, 0.0, 1.0);
 }
diff --git a/nature_of_code/chp_03_oscillation/3_04_polar_to_cartesian.rs b/nature_of_code/chp_03_oscillation/3_04_polar_to_cartesian.rs
index 396bedb39..c0fe7bd09 100644
--- a/nature_of_code/chp_03_oscillation/3_04_polar_to_cartesian.rs
+++ b/nature_of_code/chp_03_oscillation/3_04_polar_to_cartesian.rs
@@ -15,12 +15,11 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    let rect = Rect::from_w_h(640.0, 360.0);
+    let rect = geom::Rect::from_w_h(640.0, 360.0);
     app.new_window()
         .size(rect.w() as u32, rect.h() as u32)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     let r = rect.h() * 0.45;
     let theta = 0.0;
@@ -28,12 +27,12 @@ fn model(app: &App) -> Model {
     Model { r, theta }
 }
 
-fn update(_app: &App, model: &mut Model, _update: Update) {
+fn update(_app: &App, model: &mut Model) {
     // Increase the angle over time
     model.theta += 0.02;
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -44,7 +43,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
     draw.line()
         .start(pt2(0.0, 0.0))
         .end(pt2(x, y))
-        .rgb(0.0, 0.0, 0.0)
+        .srgb(0.0, 0.0, 0.0)
         .stroke_weight(2.0);
 
     // Draw an ellipse at cartesian coordinate
@@ -54,7 +53,4 @@ fn view(app: &App, model: &Model, frame: Frame) {
         .gray(0.5)
         .stroke(BLACK)
         .stroke_weight(2.0);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_03_oscillation/3_04_polar_to_cartesian_trail.rs b/nature_of_code/chp_03_oscillation/3_04_polar_to_cartesian_trail.rs
index b879fa26a..dcd5a5ed5 100644
--- a/nature_of_code/chp_03_oscillation/3_04_polar_to_cartesian_trail.rs
+++ b/nature_of_code/chp_03_oscillation/3_04_polar_to_cartesian_trail.rs
@@ -15,12 +15,11 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    let rect = Rect::from_w_h(800.0, 200.0);
+    let rect = geom::Rect::from_w_h(800.0, 200.0);
     app.new_window()
         .size(rect.w() as u32, rect.h() as u32)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     let r = rect.h() * 0.45;
     let theta = 0.0;
@@ -28,18 +27,18 @@ fn model(app: &App) -> Model {
     Model { r, theta }
 }
 
-fn update(_app: &App, model: &mut Model, _update: Update) {
+fn update(_app: &App, model: &mut Model) {
     // Increase the angle over time
     model.theta += 0.02;
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
 
     draw.rect()
         .wh(app.window_rect().wh())
-        .rgba(1.0, 1.0, 1.0, 0.03);
+        .srgba(1.0, 1.0, 1.0, 0.03);
 
     let x = model.r * model.theta.cos();
     let y = model.r * -model.theta.sin();
@@ -47,7 +46,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
     draw.line()
         .start(pt2(0.0, 0.0))
         .end(pt2(x, y))
-        .rgb(0.0, 0.0, 0.0)
+        .srgb(0.0, 0.0, 0.0)
         .stroke_weight(2.0);
 
     // Draw an ellipse at cartesian coordinate
@@ -57,7 +56,4 @@ fn view(app: &App, model: &Model, frame: Frame) {
         .gray(0.5)
         .stroke(BLACK)
         .stroke_weight(2.0);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_03_oscillation/3_05_simple_harmonic_motion.rs b/nature_of_code/chp_03_oscillation/3_05_simple_harmonic_motion.rs
index 8295487c5..96aff1801 100644
--- a/nature_of_code/chp_03_oscillation/3_05_simple_harmonic_motion.rs
+++ b/nature_of_code/chp_03_oscillation/3_05_simple_harmonic_motion.rs
@@ -9,7 +9,7 @@ fn main() {
     nannou::sketch(view).size(640, 360).run();
 }
 
-fn view(app: &App, frame: Frame) {
+fn view(app: &App) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -18,21 +18,18 @@ fn view(app: &App, frame: Frame) {
     let amplitude = 300.0;
     // Calculating horizontal position according to formula for simple harmonic motion
     let two_pi = std::f64::consts::PI * 2.0;
-    let x = amplitude * (two_pi * app.duration.since_start.secs() * period).sin() as f32;
+    let x = amplitude * (two_pi * app.time() as f64 * period).sin() as f32;
 
     draw.line()
         .start(pt2(0.0, 0.0))
         .end(pt2(x, 0.0))
-        .rgb(0.0, 0.0, 0.0)
+        .srgb(0.0, 0.0, 0.0)
         .stroke_weight(2.0);
 
     draw.ellipse()
         .x_y(x, 0.0)
         .w_h(50.0, 50.0)
-        .rgba(0.5, 0.5, 0.5, 1.0)
+        .srgba(0.5, 0.5, 0.5, 1.0)
         .stroke(BLACK)
         .stroke_weight(2.0);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_03_oscillation/3_06_simple_harmonic_motion.rs b/nature_of_code/chp_03_oscillation/3_06_simple_harmonic_motion.rs
index 2cdc94f09..e398c508b 100644
--- a/nature_of_code/chp_03_oscillation/3_06_simple_harmonic_motion.rs
+++ b/nature_of_code/chp_03_oscillation/3_06_simple_harmonic_motion.rs
@@ -18,33 +18,30 @@ fn model(app: &App) -> Model {
     let angle = 0.0;
     let a_velocity = 0.03;
 
-    app.new_window().size(640, 360).view(view).build().unwrap();
+    app.new_window().size(640, 360).view(view).build();
     Model { angle, a_velocity }
 }
 
-fn update(_app: &App, model: &mut Model, _update: Update) {
+fn update(_app: &App, model: &mut Model) {
     model.angle += model.a_velocity;
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
     let amplitude = 300.0;
-    let x = amplitude * model.angle.sin() as f32;
+    let x = amplitude * model.angle.sin();
 
     draw.line()
         .start(pt2(0.0, 0.0))
         .end(pt2(x, 0.0))
-        .rgb(0.0, 0.0, 0.0);
+        .srgb(0.0, 0.0, 0.0);
 
     draw.ellipse()
         .x_y(x, 0.0)
         .w_h(20.0, 20.0)
-        .rgba(0.68, 0.68, 0.68, 1.0)
+        .srgba(0.68, 0.68, 0.68, 1.0)
         .stroke(BLACK);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_03_oscillation/3_07_oscillating_objects.rs b/nature_of_code/chp_03_oscillation/3_07_oscillating_objects.rs
index aaf6de81d..3c6a1be3c 100644
--- a/nature_of_code/chp_03_oscillation/3_07_oscillating_objects.rs
+++ b/nature_of_code/chp_03_oscillation/3_07_oscillating_objects.rs
@@ -22,7 +22,7 @@ struct Oscillator {
 }
 
 impl Oscillator {
-    fn new(rect: Rect) -> Self {
+    fn new(rect: geom::Rect) -> Self {
         let angle = vec2(0.0, 0.0);
         let velocity = vec2(random_f32() * 0.1 - 0.05, random_f32() * 0.1 - 0.05);
         let rand_amp_x = random_range(20.0, rect.right());
@@ -46,45 +46,41 @@ impl Oscillator {
         draw.line()
             .start(pt2(0.0, 0.0))
             .end(pt2(x, y))
-            .rgb(0.0, 0.0, 0.0)
+            .srgb(0.0, 0.0, 0.0)
             .stroke_weight(2.0);
 
         draw.ellipse()
             .x_y(x, y)
             .w_h(32.0, 32.0)
-            .rgba(0.5, 0.5, 0.5, 0.5)
+            .srgba(0.5, 0.5, 0.5, 0.5)
             .stroke(BLACK)
             .stroke_weight(2.0);
     }
 }
 
 fn model(app: &App) -> Model {
-    let rect = Rect::from_w_h(640.0, 360.0);
+    let rect = geom::Rect::from_w_h(640.0, 360.0);
     app.new_window()
         .size(rect.w() as u32, rect.h() as u32)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
     //let oscillators = vec![Oscillator::new(app.window_rect()); 10];
     let oscillators = (0..10).map(|_| Oscillator::new(rect)).collect();
     Model { oscillators }
 }
 
-fn update(_app: &App, m: &mut Model, _update: Update) {
+fn update(_app: &App, m: &mut Model) {
     for osc in &mut m.oscillators {
         osc.oscillate();
     }
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
-    draw.background().rgba(1.0, 1.0, 1.0, 1.0);
+    draw.background().srgba(1.0, 1.0, 1.0, 1.0);
 
     for osc in &m.oscillators {
         osc.display(&draw);
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_03_oscillation/3_08_static_wave_lines.rs b/nature_of_code/chp_03_oscillation/3_08_static_wave_lines.rs
index 8fe2c0405..6c02ec331 100644
--- a/nature_of_code/chp_03_oscillation/3_08_static_wave_lines.rs
+++ b/nature_of_code/chp_03_oscillation/3_08_static_wave_lines.rs
@@ -16,8 +16,8 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    app.set_loop_mode(LoopMode::loop_once());
-    app.new_window().size(640, 360).view(view).build().unwrap();
+    app.set_update_mode(UpdateMode::freeze());
+    app.new_window().size(640, 360).view(view).build();
 
     Model {
         angle: 0.0,
@@ -26,7 +26,7 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(app: &App, model: &mut Model, _update: Update) {
+fn update(app: &App, model: &mut Model) {
     let win = app.window_rect();
     model.vertices.clear();
 
@@ -37,7 +37,7 @@ fn update(app: &App, model: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -46,7 +46,4 @@ fn view(app: &App, model: &Model, frame: Frame) {
         .weight(2.0)
         .points(model.vertices.clone())
         .color(BLACK);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_03_oscillation/3_09_exercise_additive_wave.rs b/nature_of_code/chp_03_oscillation/3_09_exercise_additive_wave.rs
index 6a0a35550..9170dca8f 100644
--- a/nature_of_code/chp_03_oscillation/3_09_exercise_additive_wave.rs
+++ b/nature_of_code/chp_03_oscillation/3_09_exercise_additive_wave.rs
@@ -23,7 +23,7 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    app.new_window().size(640, 360).view(view).build().unwrap();
+    app.new_window().size(640, 360).view(view).build();
 
     let x_spacing = 8.0;
     let w = app.window_rect().w() + 16.0; // Width of entire wave
@@ -47,7 +47,7 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(_app: &App, m: &mut Model, _update: Update) {
+fn update(_app: &App, m: &mut Model) {
     // Increment theta (try different values for 'angular velocity' here
     m.theta += 0.02;
 
@@ -71,7 +71,7 @@ fn update(_app: &App, m: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(BLACK);
@@ -84,9 +84,6 @@ fn view(app: &App, m: &Model, frame: Frame) {
                 m.y_values[x],
             )
             .w_h(16.0, 16.0)
-            .rgba(1.0, 1.0, 1.0, 0.25);
+            .srgba(1.0, 1.0, 1.0, 0.25);
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_03_oscillation/3_09_wave.rs b/nature_of_code/chp_03_oscillation/3_09_wave.rs
index 0097cb037..34cca0597 100644
--- a/nature_of_code/chp_03_oscillation/3_09_wave.rs
+++ b/nature_of_code/chp_03_oscillation/3_09_wave.rs
@@ -15,7 +15,7 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    app.new_window().size(640, 360).view(view).build().unwrap();
+    app.new_window().size(640, 360).view(view).build();
     let start_angle = 0.0;
     let angle_vel = 0.23;
     Model {
@@ -24,11 +24,11 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(_app: &App, model: &mut Model, _update: Update) {
+fn update(_app: &App, model: &mut Model) {
     model.start_angle += 0.015;
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -39,16 +39,13 @@ fn view(app: &App, model: &Model, frame: Frame) {
     while x <= rect.right() {
         let y = map_range(angle.sin(), -1.0, 1.0, rect.top(), rect.bottom());
         draw.ellipse()
-            .x_y(x as f32, y)
+            .x_y(x, y)
             .w_h(48.0, 48.0)
-            .rgba(0.0, 0.0, 0.0, 0.5)
+            .srgba(0.0, 0.0, 0.0, 0.5)
             .stroke(BLACK)
             .stroke_weight(2.0);
 
         angle += model.angle_vel;
         x += 24.0;
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_03_oscillation/3_09_wave_a.rs b/nature_of_code/chp_03_oscillation/3_09_wave_a.rs
index ce8b68b87..678ec9527 100644
--- a/nature_of_code/chp_03_oscillation/3_09_wave_a.rs
+++ b/nature_of_code/chp_03_oscillation/3_09_wave_a.rs
@@ -15,7 +15,7 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    app.new_window().size(250, 200).view(view).build().unwrap();
+    app.new_window().size(250, 200).view(view).build();
     let start_angle = 0.0;
     let angle_vel = 0.05;
     Model {
@@ -24,11 +24,11 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(_app: &App, model: &mut Model, _update: Update) {
+fn update(_app: &App, model: &mut Model) {
     model.start_angle += 0.015;
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -39,16 +39,13 @@ fn view(app: &App, model: &Model, frame: Frame) {
     while x <= rect.right() {
         let y = map_range(angle.sin(), -1.0, 1.0, rect.top(), rect.bottom());
         draw.ellipse()
-            .x_y(x as f32, y)
+            .x_y(x, y)
             .w_h(48.0, 48.0)
-            .rgba(0.0, 0.0, 0.0, 0.5)
+            .srgba(0.0, 0.0, 0.0, 0.5)
             .stroke(BLACK)
             .stroke_weight(2.0);
 
         angle += model.angle_vel;
         x += 24.0;
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_03_oscillation/3_09_wave_b.rs b/nature_of_code/chp_03_oscillation/3_09_wave_b.rs
index df3a08c5f..c81623a5d 100644
--- a/nature_of_code/chp_03_oscillation/3_09_wave_b.rs
+++ b/nature_of_code/chp_03_oscillation/3_09_wave_b.rs
@@ -15,7 +15,7 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    app.new_window().size(250, 200).view(view).build().unwrap();
+    app.new_window().size(250, 200).view(view).build();
     let start_angle = 0.0;
     let angle_vel = 0.2;
     Model {
@@ -24,11 +24,11 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(_app: &App, model: &mut Model, _update: Update) {
+fn update(_app: &App, model: &mut Model) {
     model.start_angle += 0.015;
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -39,16 +39,13 @@ fn view(app: &App, model: &Model, frame: Frame) {
     while x <= rect.right() {
         let y = map_range(angle.sin(), -1.0, 1.0, rect.top(), rect.bottom());
         draw.ellipse()
-            .x_y(x as f32, y)
+            .x_y(x, y)
             .w_h(48.0, 48.0)
-            .rgba(0.0, 0.0, 0.0, 0.5)
+            .srgba(0.0, 0.0, 0.0, 0.5)
             .stroke(BLACK)
             .stroke_weight(2.0);
 
         angle += model.angle_vel;
         x += 24.0;
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_03_oscillation/3_09_wave_c.rs b/nature_of_code/chp_03_oscillation/3_09_wave_c.rs
index 2fdffdf83..693ddb758 100644
--- a/nature_of_code/chp_03_oscillation/3_09_wave_c.rs
+++ b/nature_of_code/chp_03_oscillation/3_09_wave_c.rs
@@ -15,7 +15,7 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    app.new_window().size(200, 200).view(view).build().unwrap();
+    app.new_window().size(200, 200).view(view).build();
     let start_angle = 0.0;
     let angle_vel = 0.4;
     Model {
@@ -24,11 +24,11 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(_app: &App, model: &mut Model, _update: Update) {
+fn update(_app: &App, model: &mut Model) {
     model.start_angle += 0.015;
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -39,16 +39,13 @@ fn view(app: &App, model: &Model, frame: Frame) {
     while x <= rect.right() {
         let y = map_range(angle.sin(), -1.0, 1.0, rect.top(), rect.bottom());
         draw.ellipse()
-            .x_y(x as f32, y)
+            .x_y(x, y)
             .w_h(48.0, 48.0)
-            .rgba(0.0, 0.0, 0.0, 0.5)
+            .srgba(0.0, 0.0, 0.0, 0.5)
             .stroke(BLACK)
             .stroke_weight(2.0);
 
         angle += model.angle_vel;
         x += 24.0;
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_03_oscillation/3_10_exercise_oop_wave.rs b/nature_of_code/chp_03_oscillation/3_10_exercise_oop_wave.rs
index c05ab276d..f7148b680 100644
--- a/nature_of_code/chp_03_oscillation/3_10_exercise_oop_wave.rs
+++ b/nature_of_code/chp_03_oscillation/3_10_exercise_oop_wave.rs
@@ -28,12 +28,12 @@ struct Wave {
 impl Wave {
     fn new(o: Point2, w: f32, a: f32, p: f32) -> Self {
         let origin = o;
-        let x_spacing = 8.0 as f32;
-        let theta = 0.0 as f32;
+        let x_spacing = 8.0_f32;
+        let theta = 0.0_f32;
         let _w = w;
         let _period = p;
         let amplitude = a;
-        let dx = (((PI * 2.0) / _period) * x_spacing) as f32;
+        let dx = ((PI * 2.0) / _period) * x_spacing;
         let y_values = (0..(w / x_spacing) as i32).map(|_| 0.0).collect();
         Wave {
             origin,
@@ -68,26 +68,26 @@ impl Wave {
                     self.origin.y + self.y_values[x],
                 )
                 .w_h(48.0, 48.0)
-                .rgba(0.0, 0.0, 0.0, 0.2)
+                .srgba(0.0, 0.0, 0.0, 0.2)
                 .stroke(BLACK);
         }
     }
 }
 
 fn model(app: &App) -> Model {
-    app.new_window().size(750, 200).view(view).build().unwrap();
+    app.new_window().size(750, 200).view(view).build();
     let wave0 = Wave::new(pt2(-325.0, 25.0), 100.0, 20.0, 500.0);
     let wave1 = Wave::new(pt2(-75.0, 0.0), 300.0, 40.0, 220.0);
     Model { wave0, wave1 }
 }
 
-fn update(_app: &App, m: &mut Model, _update: Update) {
+fn update(_app: &App, m: &mut Model) {
     // Update waves
     m.wave0.calculate();
     m.wave1.calculate();
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -95,7 +95,4 @@ fn view(app: &App, m: &Model, frame: Frame) {
     // display waves
     m.wave0.display(&draw);
     m.wave1.display(&draw);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_03_oscillation/3_10_pendulum_example.rs b/nature_of_code/chp_03_oscillation/3_10_pendulum_example.rs
index 446cafc42..8dc874e34 100644
--- a/nature_of_code/chp_03_oscillation/3_10_pendulum_example.rs
+++ b/nature_of_code/chp_03_oscillation/3_10_pendulum_example.rs
@@ -55,7 +55,7 @@ impl Pendulum {
         }
     }
 
-    fn update(&mut self, rect: Rect) {
+    fn update(&mut self, rect: geom::Rect) {
         // As long as we aren't dragging the pendulum, let it swing!
         if !self.dragging {
             let gravity = 0.4; // Arbitrary constant
@@ -131,31 +131,27 @@ fn model(app: &App) -> Model {
         .view(view)
         .mouse_pressed(mouse_pressed)
         .mouse_released(mouse_released)
-        .build()
-        .unwrap();
+        .build();
     let pendulum = Pendulum::new(pt2(0.0, app.window_rect().top()), 175.0);
 
     Model { pendulum }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
+fn update(app: &App, m: &mut Model) {
     m.pendulum.update(app.window_rect());
-    m.pendulum.drag(app.mouse.x, app.mouse.y);
+    m.pendulum.drag(app.mouse().x, app.mouse().y);
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
     m.pendulum.display(&draw);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn mouse_pressed(app: &App, m: &mut Model, _button: MouseButton) {
-    m.pendulum.clicked(app.mouse.x, app.mouse.y);
+    m.pendulum.clicked(app.mouse().x, app.mouse().y);
 }
 
 fn mouse_released(_app: &App, m: &mut Model, _button: MouseButton) {
diff --git a/nature_of_code/chp_03_oscillation/3_10_pendulum_example_simplified.rs b/nature_of_code/chp_03_oscillation/3_10_pendulum_example_simplified.rs
index 0c17656ff..aa5e9640c 100644
--- a/nature_of_code/chp_03_oscillation/3_10_pendulum_example_simplified.rs
+++ b/nature_of_code/chp_03_oscillation/3_10_pendulum_example_simplified.rs
@@ -51,7 +51,7 @@ impl Pendulum {
         }
     }
 
-    fn update(&mut self, rect: Rect) {
+    fn update(&mut self, rect: geom::Rect) {
         let gravity = 0.4; // Arbitrary constant
         self.a_acceleration = (-1.0 * gravity / self.r) * self.angle.sin(); // Calculate acceleration (see: http://www.myphysicslab.com/pendulum1.html)
         self.a_velocity += self.a_acceleration; // Increment velocity
@@ -89,23 +89,20 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    app.new_window().size(640, 360).view(view).build().unwrap();
+    app.new_window().size(640, 360).view(view).build();
     let pendulum = Pendulum::new(pt2(0.0, app.window_rect().top()), 175.0);
 
     Model { pendulum }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
+fn update(app: &App, m: &mut Model) {
     m.pendulum.update(app.window_rect());
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
     m.pendulum.display(&draw);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_03_oscillation/3_11_exercise_additive_wave.rs b/nature_of_code/chp_03_oscillation/3_11_exercise_additive_wave.rs
index 9f6fa473e..206f954dd 100644
--- a/nature_of_code/chp_03_oscillation/3_11_exercise_additive_wave.rs
+++ b/nature_of_code/chp_03_oscillation/3_11_exercise_additive_wave.rs
@@ -21,7 +21,7 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    app.new_window().size(750, 200).view(view).build().unwrap();
+    app.new_window().size(750, 200).view(view).build();
 
     let x_spacing = 8.0;
     let w = app.window_rect().w() + 16.0; // Width of entire wave
@@ -45,7 +45,7 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(_app: &App, m: &mut Model, _update: Update) {
+fn update(_app: &App, m: &mut Model) {
     // Increment theta (try different values for 'angular velocity' here
     m.theta += 0.02;
 
@@ -68,7 +68,7 @@ fn update(_app: &App, m: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -81,10 +81,7 @@ fn view(app: &App, m: &Model, frame: Frame) {
                 m.y_values[x],
             )
             .w_h(48.0, 48.0)
-            .rgba(0.0, 0.0, 0.0, 0.2)
+            .srgba(0.0, 0.0, 0.0, 0.2)
             .stroke(BLACK);
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_03_oscillation/3_11_spring.rs b/nature_of_code/chp_03_oscillation/3_11_spring.rs
index 9eed5688c..b7febb1a7 100644
--- a/nature_of_code/chp_03_oscillation/3_11_spring.rs
+++ b/nature_of_code/chp_03_oscillation/3_11_spring.rs
@@ -122,7 +122,7 @@ impl Bob {
     }
 
     fn display(&self, draw: &Draw) {
-        let c = if self.dragging { GREY } else { DARKGREY };
+        let c = if self.dragging { GREY } else { DARK_GREY };
         draw.ellipse()
             .xy(self.position)
             .w_h(self.mass * 2.0, self.mass * 2.0)
@@ -166,8 +166,7 @@ fn model(app: &App) -> Model {
         .view(view)
         .mouse_pressed(mouse_pressed)
         .mouse_released(mouse_released)
-        .build()
-        .unwrap();
+        .build();
 
     // Create objects at starting position
     // Note third argument in Spring constructor is "rest length"
@@ -178,7 +177,7 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
+fn update(app: &App, m: &mut Model) {
     // Apply a gravity force to the bob
     let gravity = pt2(0.0, -2.0);
     m.bob.apply_force(gravity);
@@ -191,10 +190,10 @@ fn update(app: &App, m: &mut Model, _update: Update) {
     // Update bob
     m.bob.update();
     // if it's being dragged
-    m.bob.drag(app.mouse.x, app.mouse.y);
+    m.bob.drag(app.mouse().x, app.mouse().y);
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -202,13 +201,10 @@ fn view(app: &App, m: &Model, frame: Frame) {
     m.spring.display_line(&draw, &m.bob); // Draw a line between spring and bob
     m.bob.display(&draw);
     m.spring.display(&draw);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn mouse_pressed(app: &App, m: &mut Model, _button: MouseButton) {
-    m.bob.clicked(app.mouse.x, app.mouse.y);
+    m.bob.clicked(app.mouse().x, app.mouse().y);
 }
 
 fn mouse_released(_app: &App, m: &mut Model, _button: MouseButton) {
diff --git a/nature_of_code/chp_03_oscillation/3_16_exercise_springs.rs b/nature_of_code/chp_03_oscillation/3_16_exercise_springs.rs
index 6c89dd5b6..2f27de044 100644
--- a/nature_of_code/chp_03_oscillation/3_16_exercise_springs.rs
+++ b/nature_of_code/chp_03_oscillation/3_16_exercise_springs.rs
@@ -87,7 +87,7 @@ impl Bob {
     }
 
     fn display(&self, draw: &Draw) {
-        let c = if self.dragging { GREY } else { DARKGREY };
+        let c = if self.dragging { GREY } else { DARK_GREY };
         draw.ellipse()
             .xy(self.position)
             .w_h(self.mass * 2.0, self.mass * 2.0)
@@ -135,8 +135,7 @@ fn model(app: &App) -> Model {
         .view(view)
         .mouse_pressed(mouse_pressed)
         .mouse_released(mouse_released)
-        .build()
-        .unwrap();
+        .build();
 
     // Create objects at starting position
     // Note third argument in Spring constructor is "rest length"
@@ -152,7 +151,7 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
+fn update(app: &App, m: &mut Model) {
     m.s1.update(&mut m.b1, &mut m.b2);
     m.s2.update(&mut m.b2, &mut m.b3);
     m.s3.update(&mut m.b1, &mut m.b3);
@@ -160,10 +159,10 @@ fn update(app: &App, m: &mut Model, _update: Update) {
     m.b1.update();
     m.b2.update();
     m.b3.update();
-    m.b1.drag(app.mouse.x, app.mouse.y);
+    m.b1.drag(app.mouse().x, app.mouse().y);
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -175,13 +174,10 @@ fn view(app: &App, m: &Model, frame: Frame) {
     m.b1.display(&draw);
     m.b2.display(&draw);
     m.b3.display(&draw);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn mouse_pressed(app: &App, m: &mut Model, _button: MouseButton) {
-    m.b1.clicked(app.mouse.x, app.mouse.y);
+    m.b1.clicked(app.mouse().x, app.mouse().y);
 }
 
 fn mouse_released(_app: &App, m: &mut Model, _button: MouseButton) {
diff --git a/nature_of_code/chp_03_oscillation/3_16_exercise_springs_array.rs b/nature_of_code/chp_03_oscillation/3_16_exercise_springs_array.rs
index d674cf05f..f7048e8ed 100644
--- a/nature_of_code/chp_03_oscillation/3_16_exercise_springs_array.rs
+++ b/nature_of_code/chp_03_oscillation/3_16_exercise_springs_array.rs
@@ -87,7 +87,7 @@ impl Bob {
     }
 
     fn display(&self, draw: &Draw) {
-        let c = if self.dragging { GREY } else { DARKGREY };
+        let c = if self.dragging { GREY } else { DARK_GREY };
         draw.ellipse()
             .xy(self.position)
             .w_h(self.mass * 2.0, self.mass * 2.0)
@@ -131,8 +131,7 @@ fn model(app: &App) -> Model {
         .view(view)
         .mouse_pressed(mouse_pressed)
         .mouse_released(mouse_released)
-        .build()
-        .unwrap();
+        .build();
 
     let win = app.window_rect();
 
@@ -154,18 +153,18 @@ fn model(app: &App) -> Model {
     Model { bobs, springs }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
+fn update(app: &App, m: &mut Model) {
     for (i, s) in m.springs.iter().enumerate() {
         s.update(&mut m.bobs, i);
     }
 
     for b in &mut m.bobs {
         b.update();
-        b.drag(app.mouse.x, app.mouse.y);
+        b.drag(app.mouse().x, app.mouse().y);
     }
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -177,14 +176,11 @@ fn view(app: &App, m: &Model, frame: Frame) {
     for b in &m.bobs {
         b.display(&draw);
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn mouse_pressed(app: &App, m: &mut Model, _button: MouseButton) {
     for b in &mut m.bobs {
-        b.clicked(app.mouse.x, app.mouse.y);
+        b.clicked(app.mouse().x, app.mouse().y);
     }
 }
 
diff --git a/nature_of_code/chp_03_oscillation/3_exercise_spring_sine.rs b/nature_of_code/chp_03_oscillation/3_exercise_spring_sine.rs
index 9e9a054c1..7f1098d5f 100644
--- a/nature_of_code/chp_03_oscillation/3_exercise_spring_sine.rs
+++ b/nature_of_code/chp_03_oscillation/3_exercise_spring_sine.rs
@@ -14,18 +14,18 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    app.new_window().size(640, 360).view(view).build().unwrap();
+    app.new_window().size(640, 360).view(view).build();
     Model {
         angle: 0.0,
         a_velocity: 0.05,
     }
 }
 
-fn update(_app: &App, model: &mut Model, _update: Update) {
+fn update(_app: &App, model: &mut Model) {
     model.angle += model.a_velocity;
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -46,9 +46,6 @@ fn view(app: &App, model: &Model, frame: Frame) {
     draw.ellipse()
         .x_y(0.0, y)
         .radius(10.0)
-        .color(LIGHTGREY)
+        .color(LIGHT_GRAY)
         .stroke(BLACK);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_03_oscillation/3_extra_oscillating_body.rs b/nature_of_code/chp_03_oscillation/3_extra_oscillating_body.rs
index 33873941c..97c3773af 100644
--- a/nature_of_code/chp_03_oscillation/3_extra_oscillating_body.rs
+++ b/nature_of_code/chp_03_oscillation/3_extra_oscillating_body.rs
@@ -41,11 +41,11 @@ impl Attractor {
     // Method to display
     fn display(&self, draw: &Draw) {
         let c = if self.dragging {
-            rgba(0.2, 0.2, 0.2, 1.0)
+            Color::srgba(0.2, 0.2, 0.2, 1.0)
         } else if self.rollover {
-            rgba(0.4, 0.4, 0.4, 1.0)
+            Color::srgba(0.4, 0.4, 0.4, 1.0)
         } else {
-            rgba(0.7, 0.7, 0.7, 0.78)
+            Color::srgba(0.7, 0.7, 0.7, 0.78)
         };
         draw.ellipse()
             .xy(self.position)
@@ -66,11 +66,7 @@ impl Attractor {
 
     fn hover(&mut self, mx: f32, my: f32) {
         let d = pt2(mx, my).distance(self.position);
-        if d < self.mass {
-            self.rollover = true;
-        } else {
-            self.rollover = false;
-        }
+        self.rollover = d < self.mass;
     }
 
     fn stop_dragging(&mut self) {
@@ -144,8 +140,7 @@ fn model(app: &App) -> Model {
         .view(view)
         .mouse_pressed(mouse_pressed)
         .mouse_released(mouse_released)
-        .build()
-        .unwrap();
+        .build();
 
     Model {
         mover: Mover::new(),
@@ -153,29 +148,26 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
+fn update(app: &App, m: &mut Model) {
     let force = m.attractor.attract(&m.mover);
     m.mover.apply_force(force);
     m.mover.update();
 
-    m.attractor.drag(app.mouse.x, app.mouse.y);
-    m.attractor.hover(app.mouse.x, app.mouse.y);
+    m.attractor.drag(app.mouse().x, app.mouse().y);
+    m.attractor.hover(app.mouse().x, app.mouse().y);
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
     m.attractor.display(&draw);
     m.mover.display(&draw);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn mouse_pressed(app: &App, m: &mut Model, _button: MouseButton) {
-    m.attractor.clicked(app.mouse.x, app.mouse.y);
+    m.attractor.clicked(app.mouse().x, app.mouse().y);
 }
 
 fn mouse_released(_app: &App, m: &mut Model, _button: MouseButton) {
diff --git a/nature_of_code/chp_03_oscillation/3_extra_oscillating_up_and_down.rs b/nature_of_code/chp_03_oscillation/3_extra_oscillating_up_and_down.rs
index a9dd2d3a1..65029ea7e 100644
--- a/nature_of_code/chp_03_oscillation/3_extra_oscillating_up_and_down.rs
+++ b/nature_of_code/chp_03_oscillation/3_extra_oscillating_up_and_down.rs
@@ -14,16 +14,16 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    app.new_window().size(400, 400).view(view).build().unwrap();
+    app.new_window().size(400, 400).view(view).build();
     let angle = 0.0;
     Model { angle }
 }
 
-fn update(_app: &App, model: &mut Model, _update: Update) {
+fn update(_app: &App, model: &mut Model) {
     model.angle += 0.02;
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -33,13 +33,10 @@ fn view(app: &App, model: &Model, frame: Frame) {
     draw.line()
         .start(pt2(0.0, 0.0))
         .end(pt2(0.0, y))
-        .rgb(0.4, 0.4, 0.4);
+        .srgb(0.4, 0.4, 0.4);
     draw.ellipse()
         .x_y(0.0, y)
         .w_h(16.0, 16.0)
         .gray(0.4)
         .stroke(BLACK);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_03_oscillation/3_multiple_oscillations.rs b/nature_of_code/chp_03_oscillation/3_multiple_oscillations.rs
index 62a65e5ef..1456622d0 100644
--- a/nature_of_code/chp_03_oscillation/3_multiple_oscillations.rs
+++ b/nature_of_code/chp_03_oscillation/3_multiple_oscillations.rs
@@ -27,7 +27,7 @@ fn model(app: &App) -> Model {
     let a_velocity2 = 0.3;
     let amplitude2 = 10.0;
 
-    app.new_window().size(640, 360).view(view).build().unwrap();
+    app.new_window().size(640, 360).view(view).build();
     Model {
         angle1,
         a_velocity1,
@@ -38,12 +38,12 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(_app: &App, model: &mut Model, _update: Update) {
+fn update(_app: &App, model: &mut Model) {
     model.angle1 += model.a_velocity1;
     model.angle2 += model.a_velocity2;
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -55,14 +55,11 @@ fn view(app: &App, model: &Model, frame: Frame) {
     draw.line()
         .start(pt2(0.0, 0.0))
         .end(pt2(x, 0.0))
-        .rgb(0.0, 0.0, 0.0);
+        .srgb(0.0, 0.0, 0.0);
 
     draw.ellipse()
         .x_y(x, 0.0)
         .w_h(20.0, 20.0)
-        .rgba(0.7, 0.7, 0.7, 1.0)
+        .srgba(0.7, 0.7, 0.7, 1.0)
         .stroke(BLACK);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_03_oscillation/3_oop_wave_particles.rs b/nature_of_code/chp_03_oscillation/3_oop_wave_particles.rs
index 4da0ce994..159ed1699 100644
--- a/nature_of_code/chp_03_oscillation/3_oop_wave_particles.rs
+++ b/nature_of_code/chp_03_oscillation/3_oop_wave_particles.rs
@@ -51,12 +51,12 @@ impl Particle {
 impl Wave {
     fn new(o: Point2, w: f32, a: f32, p: f32) -> Self {
         let origin = o;
-        let x_spacing = 8.0 as f32;
-        let theta = 0.0 as f32;
+        let x_spacing = 8.0_f32;
+        let theta = 0.0_f32;
         let w = w; // Width of entire wave
         let period = p; // How many pixels before the wave repeats
         let amplitude = a;
-        let dx = (((std::f32::consts::PI * 2.0) / period) * x_spacing) as f32;
+        let dx = ((std::f32::consts::PI * 2.0) / period) * x_spacing;
         let range = (w / x_spacing) as i32;
         let _y_values = (0..range).map(|_| 0.0).collect();
         let particles = (0..range).map(|_| Particle::new()).collect();
@@ -89,25 +89,25 @@ impl Wave {
     fn display(&self, draw: &Draw) {
         // A simple way to draw the wave with an ellipse at each position
         for x in 0..self.particles.len() {
-            self.particles[x].display(&draw);
+            self.particles[x].display(draw);
         }
     }
 }
 
 fn model(app: &App) -> Model {
-    app.new_window().size(750, 200).view(view).build().unwrap();
+    app.new_window().size(750, 200).view(view).build();
     let wave0 = Wave::new(pt2(-325.0, 25.0), 100.0, 20.0, 500.0);
     let wave1 = Wave::new(pt2(-75.0, 0.0), 300.0, 40.0, 220.0);
     Model { wave0, wave1 }
 }
 
-fn update(_app: &App, m: &mut Model, _update: Update) {
+fn update(_app: &App, m: &mut Model) {
     // Update waves
     m.wave0.calculate();
     m.wave1.calculate();
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -115,7 +115,4 @@ fn view(app: &App, m: &Model, frame: Frame) {
     // display waves
     m.wave0.display(&draw);
     m.wave1.display(&draw);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_04_systems/4_01_single_particle.rs b/nature_of_code/chp_04_systems/4_01_single_particle.rs
index ea51713de..94f369e16 100644
--- a/nature_of_code/chp_04_systems/4_01_single_particle.rs
+++ b/nature_of_code/chp_04_systems/4_01_single_particle.rs
@@ -47,41 +47,34 @@ impl Particle {
         draw.ellipse()
             .xy(self.position)
             .w_h(12.0, 12.0)
-            .rgba(0.5, 0.5, 0.5, self.life_span / 255.0)
-            .stroke(rgba(0.0, 0.0, 0.0, self.life_span / 255.0))
+            .srgba(0.5, 0.5, 0.5, self.life_span / 255.0)
+            .stroke(Color::srgba(0.0, 0.0, 0.0, self.life_span / 255.0))
             .stroke_weight(2.0);
     }
 
     // Is the poarticel still useful?
     fn is_dead(&self) -> bool {
-        if self.life_span < 0.0 {
-            true
-        } else {
-            false
-        }
+        self.life_span < 0.0
     }
 }
 
 fn model(app: &App) -> Model {
-    app.new_window().size(640, 360).view(view).build().unwrap();
+    app.new_window().size(640, 360).view(view).build();
     let p = Particle::new(pt2(0.0, app.window_rect().top() - 20.0));
     Model { p }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
+fn update(app: &App, m: &mut Model) {
     m.p.update();
     if m.p.is_dead() {
         m.p = Particle::new(pt2(0.0, app.window_rect().top() - 20.0));
     }
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
     m.p.display(&draw);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_04_systems/4_01_single_particle_trail.rs b/nature_of_code/chp_04_systems/4_01_single_particle_trail.rs
index 938fba720..1c0bfdf6a 100644
--- a/nature_of_code/chp_04_systems/4_01_single_particle_trail.rs
+++ b/nature_of_code/chp_04_systems/4_01_single_particle_trail.rs
@@ -43,18 +43,14 @@ impl Particle {
         draw.ellipse()
             .xy(self.position)
             .w_h(12.0, 12.0)
-            .rgba(0.5, 0.5, 0.5, self.life_span / 255.0)
-            .stroke(rgba(0.0, 0.0, 0.0, self.life_span / 255.0))
+            .srgba(0.5, 0.5, 0.5, self.life_span / 255.0)
+            .stroke(Color::srgba(0.0, 0.0, 0.0, self.life_span / 255.0))
             .stroke_weight(2.0);
     }
 
     // Is the poarticel still useful?
     fn is_dead(&self) -> bool {
-        if self.life_span < 0.0 {
-            true
-        } else {
-            false
-        }
+        self.life_span < 0.0
     }
 }
 
@@ -69,8 +65,7 @@ fn model(app: &App) -> Model {
         .view(view)
         .mouse_pressed(mouse_pressed)
         .mouse_released(mouse_released)
-        .build()
-        .unwrap();
+        .build();
     let p = Particle::new(pt2(0.0, app.window_rect().top() - 20.0));
     Model {
         p,
@@ -78,7 +73,7 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(_app: &App, m: &mut Model, _update: Update) {
+fn update(_app: &App, m: &mut Model) {
     if m.mouse_down {
         m.p.update();
         if m.p.is_dead() {
@@ -87,7 +82,7 @@ fn update(_app: &App, m: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
 
@@ -98,12 +93,9 @@ fn view(app: &App, m: &Model, frame: Frame) {
     if m.mouse_down {
         draw.rect()
             .wh(app.window_rect().wh())
-            .rgba(1.0, 1.0, 1.0, 0.03);
+            .srgba(1.0, 1.0, 1.0, 0.03);
         m.p.display(&draw);
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn mouse_pressed(_app: &App, m: &mut Model, _button: MouseButton) {
diff --git a/nature_of_code/chp_04_systems/4_02_vector_particle.rs b/nature_of_code/chp_04_systems/4_02_vector_particle.rs
index ac93545c2..832c7903a 100644
--- a/nature_of_code/chp_04_systems/4_02_vector_particle.rs
+++ b/nature_of_code/chp_04_systems/4_02_vector_particle.rs
@@ -47,28 +47,24 @@ impl Particle {
         draw.ellipse()
             .xy(self.position)
             .w_h(12.0, 12.0)
-            .rgba(0.5, 0.5, 0.5, self.life_span / 255.0)
-            .stroke(rgba(0.0, 0.0, 0.0, self.life_span / 255.0))
+            .srgba(0.5, 0.5, 0.5, self.life_span / 255.0)
+            .stroke(Color::srgba(0.0, 0.0, 0.0, self.life_span / 255.0))
             .stroke_weight(2.0);
     }
 
     // Is the poarticel still useful?
     fn is_dead(&self) -> bool {
-        if self.life_span < 0.0 {
-            true
-        } else {
-            false
-        }
+        self.life_span < 0.0
     }
 }
 
 fn model(app: &App) -> Model {
-    app.new_window().size(640, 360).view(view).build().unwrap();
+    app.new_window().size(640, 360).view(view).build();
     let particles = Vec::new();
     Model { particles }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
+fn update(app: &App, m: &mut Model) {
     m.particles
         .push(Particle::new(pt2(0.0, app.window_rect().top() - 50.0)));
     for i in (0..m.particles.len()).rev() {
@@ -79,7 +75,7 @@ fn update(app: &App, m: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -87,7 +83,4 @@ fn view(app: &App, m: &Model, frame: Frame) {
     for p in m.particles.iter() {
         p.display(&draw);
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_04_systems/4_03_exercise_moving_particle_system.rs b/nature_of_code/chp_04_systems/4_03_exercise_moving_particle_system.rs
index 6e2988b68..30126994f 100644
--- a/nature_of_code/chp_04_systems/4_03_exercise_moving_particle_system.rs
+++ b/nature_of_code/chp_04_systems/4_03_exercise_moving_particle_system.rs
@@ -43,18 +43,14 @@ impl Particle {
         draw.ellipse()
             .xy(self.position)
             .w_h(12.0, 12.0)
-            .rgba(0.5, 0.5, 0.5, self.life_span / 255.0)
-            .stroke(rgba(0.0, 0.0, 0.0, self.life_span / 255.0))
+            .srgba(0.5, 0.5, 0.5, self.life_span / 255.0)
+            .stroke(Color::srgba(0.0, 0.0, 0.0, self.life_span / 255.0))
             .stroke_weight(2.0);
     }
 
     // Is the particle still useful?
     fn is_dead(&self) -> bool {
-        if self.life_span < 0.0 {
-            true
-        } else {
-            false
-        }
+        self.life_span < 0.0
     }
 }
 
@@ -85,7 +81,7 @@ impl ParticleSystem {
 
     fn draw(&self, draw: &Draw) {
         for p in self.particles.iter() {
-            p.display(&draw);
+            p.display(draw);
         }
     }
 }
@@ -95,25 +91,22 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    app.new_window().size(640, 360).view(view).build().unwrap();
+    app.new_window().size(640, 360).view(view).build();
     let (_w, h) = app.window_rect().w_h();
-    let ps = ParticleSystem::new(pt2(0.0, (h as f32 / 2.0) - 50.0));
+    let ps = ParticleSystem::new(pt2(0.0, (h / 2.0) - 50.0));
     Model { ps }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
-    m.ps.origin = pt2(app.mouse.x, app.mouse.y);
+fn update(app: &App, m: &mut Model) {
+    m.ps.origin = pt2(app.mouse().x, app.mouse().y);
     m.ps.add_particle();
     m.ps.update();
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
     m.ps.draw(&draw);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_04_systems/4_03_particle_system_type.rs b/nature_of_code/chp_04_systems/4_03_particle_system_type.rs
index 033923d9d..e9f81dd27 100644
--- a/nature_of_code/chp_04_systems/4_03_particle_system_type.rs
+++ b/nature_of_code/chp_04_systems/4_03_particle_system_type.rs
@@ -48,18 +48,14 @@ impl Particle {
         draw.ellipse()
             .xy(self.position)
             .w_h(size, size)
-            .rgba(0.5, 0.5, 0.5, self.life_span / 255.0)
-            .stroke(rgba(0.0, 0.0, 0.0, self.life_span / 255.0))
+            .srgba(0.5, 0.5, 0.5, self.life_span / 255.0)
+            .stroke(Color::srgba(0.0, 0.0, 0.0, self.life_span / 255.0))
             .stroke_weight(2.0);
     }
 
     // Is the poarticel still useful?
     fn is_dead(&self) -> bool {
-        if self.life_span < 0.0 {
-            true
-        } else {
-            false
-        }
+        self.life_span < 0.0
     }
 }
 
@@ -90,30 +86,27 @@ impl ParticleSystem {
 
     fn draw(&self, draw: &Draw) {
         for p in self.particles.iter() {
-            p.display(&draw);
+            p.display(draw);
         }
     }
 }
 
 fn model(app: &App) -> Model {
-    app.new_window().size(640, 360).view(view).build().unwrap();
+    app.new_window().size(640, 360).view(view).build();
     let (_w, h) = app.window_rect().w_h();
-    let ps = ParticleSystem::new(pt2(0.0, (h as f32 / 2.0) - 50.0));
+    let ps = ParticleSystem::new(pt2(0.0, (h / 2.0) - 50.0));
     Model { ps }
 }
 
-fn update(_app: &App, m: &mut Model, _update: Update) {
+fn update(_app: &App, m: &mut Model) {
     m.ps.add_particle();
     m.ps.update();
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
     m.ps.draw(&draw);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_04_systems/4_04_system_of_systems.rs b/nature_of_code/chp_04_systems/4_04_system_of_systems.rs
index 2de928f32..6b3270f78 100644
--- a/nature_of_code/chp_04_systems/4_04_system_of_systems.rs
+++ b/nature_of_code/chp_04_systems/4_04_system_of_systems.rs
@@ -48,18 +48,14 @@ impl Particle {
         draw.ellipse()
             .xy(self.position)
             .w_h(size, size)
-            .rgba(0.5, 0.5, 0.5, self.life_span / 255.0)
-            .stroke(rgba(0.0, 0.0, 0.0, self.life_span / 255.0))
+            .srgba(0.5, 0.5, 0.5, self.life_span / 255.0)
+            .stroke(Color::srgba(0.0, 0.0, 0.0, self.life_span / 255.0))
             .stroke_weight(2.0);
     }
 
     // Is the particle still useful?
     fn is_dead(&self) -> bool {
-        if self.life_span < 0.0 {
-            true
-        } else {
-            false
-        }
+        self.life_span < 0.0
     }
 }
 
@@ -93,17 +89,13 @@ impl ParticleSystem {
 
     fn draw(&self, draw: &Draw) {
         for p in self.particles.iter() {
-            p.display(&draw);
+            p.display(draw);
         }
     }
 
     // A method to test if the particle system still has particles
     fn _dead(&self) -> bool {
-        if self.particles.is_empty() {
-            true
-        } else {
-            false
-        }
+        self.particles.is_empty()
     }
 }
 
@@ -112,25 +104,24 @@ fn model(app: &App) -> Model {
         .size(640, 360)
         .mouse_pressed(mouse_pressed)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
     let systems = Vec::new();
     Model { systems }
 }
 
 fn mouse_pressed(app: &App, m: &mut Model, _button: MouseButton) {
     m.systems
-        .push(ParticleSystem::new(1, pt2(app.mouse.x, app.mouse.y)));
+        .push(ParticleSystem::new(1, pt2(app.mouse().x, app.mouse().y)));
 }
 
-fn update(_app: &App, m: &mut Model, _update: Update) {
+fn update(_app: &App, m: &mut Model) {
     for ps in m.systems.iter_mut() {
         ps.add_particle();
         ps.update();
     }
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -138,7 +129,4 @@ fn view(app: &App, m: &Model, frame: Frame) {
     for i in 0..m.systems.len() {
         m.systems[i].draw(&draw);
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_04_systems/4_05_particle_system_inheritance_polymorphism.rs b/nature_of_code/chp_04_systems/4_05_particle_system_inheritance_polymorphism.rs
index 94b8509bc..9c8bff20f 100644
--- a/nature_of_code/chp_04_systems/4_05_particle_system_inheritance_polymorphism.rs
+++ b/nature_of_code/chp_04_systems/4_05_particle_system_inheritance_polymorphism.rs
@@ -46,14 +46,14 @@ impl Particle {
     }
 
     // Method to display
-    fn display(&self, draw: &Draw, win: Rect) {
+    fn display(&self, draw: &Draw, win: geom::Rect) {
         match &self.particle_type {
             ParticleType::Ellipse => {
                 draw.ellipse()
                     .xy(self.position)
                     .radius(6.0)
-                    .rgba(0.5, 0.5, 0.5, self.life_span / 255.0)
-                    .stroke(rgba(0.0, 0.0, 0.0, self.life_span / 255.0))
+                    .srgba(0.5, 0.5, 0.5, self.life_span / 255.0)
+                    .stroke(Color::srgba(0.0, 0.0, 0.0, self.life_span / 255.0))
                     .stroke_weight(2.0);
             }
             ParticleType::Confetti => {
@@ -61,8 +61,8 @@ impl Particle {
                 draw.rect()
                     .xy(self.position)
                     .w_h(12.0, 12.0)
-                    .rgba(0.5, 0.5, 0.5, self.life_span / 255.0)
-                    .stroke(rgba(0.0, 0.0, 0.0, self.life_span / 255.0))
+                    .srgba(0.5, 0.5, 0.5, self.life_span / 255.0)
+                    .stroke(Color::srgba(0.0, 0.0, 0.0, self.life_span / 255.0))
                     .stroke_weight(2.0)
                     .rotate(theta);
             }
@@ -71,11 +71,7 @@ impl Particle {
 
     // Is the poarticel still useful?
     fn is_dead(&self) -> bool {
-        if self.life_span < 0.0 {
-            true
-        } else {
-            false
-        }
+        self.life_span < 0.0
     }
 }
 
@@ -110,9 +106,9 @@ impl ParticleSystem {
         }
     }
 
-    fn draw(&self, draw: &Draw, win: Rect) {
+    fn draw(&self, draw: &Draw, win: geom::Rect) {
         for i in (0..self.particles.len()).rev() {
-            self.particles[i].display(&draw, win);
+            self.particles[i].display(draw, win);
         }
     }
 }
@@ -122,24 +118,21 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    app.new_window().size(640, 360).view(view).build().unwrap();
+    app.new_window().size(640, 360).view(view).build();
     let (_w, h) = app.window_rect().w_h();
-    let ps = ParticleSystem::new(pt2(0.0, (h as f32 / 2.0) - 50.0));
+    let ps = ParticleSystem::new(pt2(0.0, (h / 2.0) - 50.0));
     Model { ps }
 }
 
-fn update(_app: &App, m: &mut Model, _update: Update) {
+fn update(_app: &App, m: &mut Model) {
     m.ps.add_particle();
     m.ps.update();
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
     m.ps.draw(&draw, app.window_rect());
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_04_systems/4_06_exercise_shatter.rs b/nature_of_code/chp_04_systems/4_06_exercise_shatter.rs
index 2f46d0178..476029561 100644
--- a/nature_of_code/chp_04_systems/4_06_exercise_shatter.rs
+++ b/nature_of_code/chp_04_systems/4_06_exercise_shatter.rs
@@ -42,7 +42,7 @@ impl Particle {
 
     // Method to display
     fn display(&self, draw: &Draw) {
-        draw.rect().xy(self.position).w_h(self.r, self.r).rgba(
+        draw.rect().xy(self.position).w_h(self.r, self.r).srgba(
             0.0,
             0.0,
             0.0,
@@ -52,11 +52,7 @@ impl Particle {
 
     // Is the particle still useful?
     fn _is_dead(&self) -> bool {
-        if self.life_span < 0.0 {
-            true
-        } else {
-            false
-        }
+        self.life_span < 0.0
     }
 }
 
@@ -101,7 +97,7 @@ impl ParticleSystem {
 
     fn draw(&self, draw: &Draw) {
         for p in self.particles.iter() {
-            p.display(&draw);
+            p.display(draw);
         }
     }
 }
@@ -115,26 +111,22 @@ fn model(app: &App) -> Model {
         .size(640, 360)
         .view(view)
         .mouse_pressed(mouse_pressed)
-        .build()
-        .unwrap();
+        .build();
     let win = app.window_rect();
     let ps = ParticleSystem::new(win.left() + 100.0, win.top() - 100.0, 5.0);
     Model { ps }
 }
 
-fn update(_app: &App, m: &mut Model, _update: Update) {
+fn update(_app: &App, m: &mut Model) {
     m.ps.update();
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
     m.ps.draw(&draw);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn mouse_pressed(_app: &App, m: &mut Model, _button: MouseButton) {
diff --git a/nature_of_code/chp_04_systems/4_06_particle_system_forces.rs b/nature_of_code/chp_04_systems/4_06_particle_system_forces.rs
index d016ba392..9b6b89fae 100644
--- a/nature_of_code/chp_04_systems/4_06_particle_system_forces.rs
+++ b/nature_of_code/chp_04_systems/4_06_particle_system_forces.rs
@@ -52,18 +52,14 @@ impl Particle {
         draw.ellipse()
             .xy(self.position)
             .radius(6.0)
-            .rgba(0.5, 0.5, 0.5, self.life_span / 255.0)
-            .stroke(rgba(0.0, 0.0, 0.0, self.life_span / 255.0))
+            .srgba(0.5, 0.5, 0.5, self.life_span / 255.0)
+            .stroke(Color::srgba(0.0, 0.0, 0.0, self.life_span / 255.0))
             .stroke_weight(2.0);
     }
 
     // Is the particle still useful?
     fn is_dead(&self) -> bool {
-        if self.life_span < 0.0 {
-            true
-        } else {
-            false
-        }
+        self.life_span < 0.0
     }
 }
 
@@ -101,7 +97,7 @@ impl ParticleSystem {
 
     fn draw(&self, draw: &Draw) {
         for p in self.particles.iter() {
-            p.display(&draw);
+            p.display(draw);
         }
     }
 }
@@ -111,12 +107,12 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    app.new_window().size(640, 360).view(view).build().unwrap();
+    app.new_window().size(640, 360).view(view).build();
     let ps = ParticleSystem::new(pt2(0.0, app.window_rect().top() - 50.0));
     Model { ps }
 }
 
-fn update(_app: &App, m: &mut Model, _update: Update) {
+fn update(_app: &App, m: &mut Model) {
     let gravity = pt2(0.0, 0.1);
     m.ps.apply_force(gravity);
 
@@ -124,13 +120,10 @@ fn update(_app: &App, m: &mut Model, _update: Update) {
     m.ps.update();
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
     m.ps.draw(&draw);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_04_systems/4_07_particle_system_forces_repeller.rs b/nature_of_code/chp_04_systems/4_07_particle_system_forces_repeller.rs
index ec9255313..42fa3d592 100644
--- a/nature_of_code/chp_04_systems/4_07_particle_system_forces_repeller.rs
+++ b/nature_of_code/chp_04_systems/4_07_particle_system_forces_repeller.rs
@@ -89,18 +89,14 @@ impl Particle {
         draw.ellipse()
             .xy(self.position)
             .radius(6.0)
-            .rgba(0.5, 0.5, 0.5, self.life_span / 255.0)
-            .stroke(rgba(0.0, 0.0, 0.0, self.life_span / 255.0))
+            .srgba(0.5, 0.5, 0.5, self.life_span / 255.0)
+            .stroke(Color::srgba(0.0, 0.0, 0.0, self.life_span / 255.0))
             .stroke_weight(2.0);
     }
 
     // Is the particle still useful?
     fn is_dead(&self) -> bool {
-        if self.life_span < 0.0 {
-            true
-        } else {
-            false
-        }
+        self.life_span < 0.0
     }
 }
 
@@ -145,7 +141,7 @@ impl ParticleSystem {
 
     fn draw(&self, draw: &Draw) {
         for p in self.particles.iter() {
-            p.display(&draw);
+            p.display(draw);
         }
     }
 }
@@ -156,13 +152,13 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    app.new_window().size(640, 360).view(view).build().unwrap();
+    app.new_window().size(640, 360).view(view).build();
     let ps = ParticleSystem::new(pt2(0.0, app.window_rect().top() - 50.0));
     let repeller = Repeller::new(-20.0, 0.0);
     Model { ps, repeller }
 }
 
-fn update(_app: &App, m: &mut Model, _update: Update) {
+fn update(_app: &App, m: &mut Model) {
     m.ps.add_particle();
 
     // Apply gravity force to all Particles
@@ -173,14 +169,11 @@ fn update(_app: &App, m: &mut Model, _update: Update) {
     m.ps.update();
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
     m.repeller.display(&draw);
     m.ps.draw(&draw);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_04_systems/4_10_exercise_particle_intersection.rs b/nature_of_code/chp_04_systems/4_10_exercise_particle_intersection.rs
index 5a1929105..c70c1832e 100644
--- a/nature_of_code/chp_04_systems/4_10_exercise_particle_intersection.rs
+++ b/nature_of_code/chp_04_systems/4_10_exercise_particle_intersection.rs
@@ -65,26 +65,22 @@ impl Particle {
     // Method to display
     fn display(&self, draw: &Draw) {
         let c = if self.highlight {
-            rgba(0.5, 0.0, 0.0, 1.0)
+            Color::srgba(0.5, 0.0, 0.0, 1.0)
         } else {
-            rgba(0.5, 0.5, 0.5, self.life_span / 255.0)
+            Color::srgba(0.5, 0.5, 0.5, self.life_span / 255.0)
         };
 
         draw.ellipse()
             .xy(self.position)
             .radius(self.r)
             .color(c)
-            .stroke(rgba(0.0, 0.0, 0.0, self.life_span / 255.0))
+            .stroke(Color::srgba(0.0, 0.0, 0.0, self.life_span / 255.0))
             .stroke_weight(2.0);
     }
 
     // Is the particle still useful?
     fn is_dead(&self) -> bool {
-        if self.life_span < 0.0 {
-            true
-        } else {
-            false
-        }
+        self.life_span < 0.0
     }
 }
 
@@ -122,7 +118,7 @@ impl ParticleSystem {
 
     fn draw(&self, draw: &Draw) {
         for p in self.particles.iter() {
-            p.display(&draw);
+            p.display(draw);
         }
     }
 }
@@ -132,25 +128,22 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    app.new_window().size(640, 360).view(view).build().unwrap();
+    app.new_window().size(640, 360).view(view).build();
     let ps = ParticleSystem::new(pt2(0.0, 0.0));
     Model { ps }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
-    m.ps.origin = pt2(app.mouse.x, app.mouse.y);
+fn update(app: &App, m: &mut Model) {
+    m.ps.origin = pt2(app.mouse().x, app.mouse().y);
     m.ps.add_particle(app.elapsed_frames());
     m.ps.update();
     m.ps.intersection();
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
     m.ps.draw(&draw);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_04_systems/4_10_exercise_particle_repel.rs b/nature_of_code/chp_04_systems/4_10_exercise_particle_repel.rs
index 063e51f77..c015b16a4 100644
--- a/nature_of_code/chp_04_systems/4_10_exercise_particle_repel.rs
+++ b/nature_of_code/chp_04_systems/4_10_exercise_particle_repel.rs
@@ -65,18 +65,14 @@ impl Particle {
         draw.ellipse()
             .xy(self.position)
             .radius(self.r)
-            .rgba(0.5, 0.5, 0.5, self.life_span / 255.0)
-            .stroke(rgba(0.0, 0.0, 0.0, self.life_span / 255.0))
+            .srgba(0.5, 0.5, 0.5, self.life_span / 255.0)
+            .stroke(Color::srgba(0.0, 0.0, 0.0, self.life_span / 255.0))
             .stroke_weight(2.0);
     }
 
     // Is the particle still useful?
     fn is_dead(&self) -> bool {
-        if self.life_span < 0.0 {
-            true
-        } else {
-            false
-        }
+        self.life_span < 0.0
     }
 }
 
@@ -120,7 +116,7 @@ impl ParticleSystem {
 
     fn draw(&self, draw: &Draw) {
         for p in self.particles.iter() {
-            p.display(&draw);
+            p.display(draw);
         }
     }
 }
@@ -130,12 +126,12 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    app.new_window().size(640, 360).view(view).build().unwrap();
+    app.new_window().size(640, 360).view(view).build();
     let ps = ParticleSystem::new(pt2(0.0, 0.0));
     Model { ps }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
+fn update(app: &App, m: &mut Model) {
     let win = app.window_rect();
     m.ps.origin = pt2(
         random_range(win.left(), win.right()),
@@ -149,13 +145,10 @@ fn update(app: &App, m: &mut Model, _update: Update) {
     m.ps.intersection();
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
     m.ps.draw(&draw);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_06_agents/6_01_seek.rs b/nature_of_code/chp_06_agents/6_01_seek.rs
index 2b16ef9aa..355ed17d1 100644
--- a/nature_of_code/chp_06_agents/6_01_seek.rs
+++ b/nature_of_code/chp_06_agents/6_01_seek.rs
@@ -8,7 +8,6 @@
 // One vehicle "seeks"
 // See: http://www.red3d.com/cwr/
 use nannou::prelude::*;
-use nannou::Draw;
 
 fn main() {
     nannou::app(model).update(update).run();
@@ -66,35 +65,32 @@ impl Vehicle {
 }
 
 fn model(app: &App) -> Model {
-    app.new_window().size(640, 360).view(view).build().unwrap();
+    app.new_window().size(640, 360).view(view).build();
     let middle = app.window_rect().xy();
     let vehicle = Vehicle::new(middle.x, middle.y);
     Model { vehicle }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
-    seek(&mut m.vehicle, app.mouse.position());
+fn update(app: &App, m: &mut Model) {
+    seek(&mut m.vehicle, app.mouse());
     m.vehicle.update();
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
-    let mouse = vec2(app.mouse.x, app.mouse.y);
+    let mouse = vec2(app.mouse().x, app.mouse().y);
 
     draw.ellipse()
         .x_y(mouse.x, mouse.y)
         .radius(48.0)
-        .rgb(0.78, 0.78, 0.78)
-        .stroke(gray(0.0))
+        .srgb(0.78, 0.78, 0.78)
+        .stroke(Color::gray(0.0))
         .stroke_weight(2.0);
 
     display(&m.vehicle, &draw);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 // A method that calculates a steering force towards a target
@@ -136,6 +132,6 @@ fn display(vehicle: &Vehicle, draw: &Draw) {
         .stroke_weight(1.0)
         .points(points)
         .xy(*position)
-        .rgb(0.5, 0.5, 0.5)
+        .srgb(0.5, 0.5, 0.5)
         .rotate(-theta);
 }
diff --git a/nature_of_code/chp_06_agents/6_01_seek_trail.rs b/nature_of_code/chp_06_agents/6_01_seek_trail.rs
index d17c25514..48156907c 100644
--- a/nature_of_code/chp_06_agents/6_01_seek_trail.rs
+++ b/nature_of_code/chp_06_agents/6_01_seek_trail.rs
@@ -8,7 +8,6 @@
 // One vehicle "seeks"
 // See: http://www.red3d.com/cwr/
 use nannou::prelude::*;
-use nannou::Draw;
 use std::collections::VecDeque;
 
 fn main() {
@@ -72,33 +71,32 @@ impl Vehicle {
 }
 
 fn model(app: &App) -> Model {
-    app.new_window().size(640, 360).view(view).build().unwrap();
+    app.new_window().size(640, 360).view(view).build();
     let middle = app.window_rect().xy();
     let vehicle = Vehicle::new(middle.x, middle.y);
     Model { vehicle }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
-    seek(&mut m.vehicle, app.mouse.position());
+fn update(app: &App, m: &mut Model) {
+    seek(&mut m.vehicle, app.mouse());
     m.vehicle.update();
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
-    let mouse = vec2(app.mouse.x, app.mouse.y);
+    let mouse = vec2(app.mouse().x, app.mouse().y);
 
     draw.ellipse()
         // Missing Stroke
         .x_y(mouse.x, mouse.y)
         .radius(48.0)
-        .rgb(0.78, 0.78, 0.78);
+        .srgb(0.78, 0.78, 0.78);
     display(&m.vehicle, &draw);
 
     // Write the result of our drawing to the window's OpenGL frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 // A method that calculates a steering force towards a target
@@ -134,15 +132,11 @@ fn display(vehicle: &Vehicle, draw: &Draw) {
     } = vehicle;
 
     if history.len() > 1 {
-        let vertices = history
-            .iter()
-            .map(|v| pt2(v.x, v.y))
-            .enumerate()
-            .map(|(_, p)| {
-                let rgba = srgba(0.0, 0.0, 0.0, 1.0);
-                (p, rgba)
-            });
-        draw.polyline().weight(1.0).points_colored(vertices);
+        let points_colored = history.iter().map(|v| pt2(v.x, v.y)).map(|p| {
+            let rgba = Color::srgba(0.0, 0.0, 0.0, 1.0);
+            (p, rgba)
+        });
+        draw.polyline().weight(1.0).points_colored(points_colored);
     }
 
     // Draw a triangle rotated in the direction of velocity
@@ -154,6 +148,6 @@ fn display(vehicle: &Vehicle, draw: &Draw) {
         .stroke_weight(1.0)
         .points(points)
         .xy(*position)
-        .rgb(0.5, 0.5, 0.5)
+        .srgb(0.5, 0.5, 0.5)
         .rotate(-theta);
 }
diff --git a/nature_of_code/chp_06_agents/6_02_arrive.rs b/nature_of_code/chp_06_agents/6_02_arrive.rs
index cb4b1be39..5e378ca71 100644
--- a/nature_of_code/chp_06_agents/6_02_arrive.rs
+++ b/nature_of_code/chp_06_agents/6_02_arrive.rs
@@ -5,7 +5,6 @@
 // One vehicle "arrives"
 // See: http://www.red3d.com/cwr/
 use nannou::prelude::*;
-use nannou::Draw;
 
 fn main() {
     nannou::app(model).update(update).run();
@@ -50,7 +49,7 @@ impl Vehicle {
         // Update velocity
         self.velocity += self.acceleration;
         // Limit speed
-        self.velocity.clamp_length_max(self.max_speed);
+        self.velocity = self.velocity.clamp_length_max(self.max_speed);
         self.position += self.velocity;
         // Reset accelerationelertion to 0 each cycle
         self.acceleration *= 0.0;
@@ -63,35 +62,32 @@ impl Vehicle {
 }
 
 fn model(app: &App) -> Model {
-    app.new_window().size(640, 360).view(view).build().unwrap();
+    app.new_window().size(640, 360).view(view).build();
     let middle = app.window_rect().xy();
     let vehicle = Vehicle::new(middle.x, middle.y);
     Model { vehicle }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
-    arrive(&mut m.vehicle, app.mouse.position());
+fn update(app: &App, m: &mut Model) {
+    arrive(&mut m.vehicle, app.mouse());
     m.vehicle.update();
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
-    let mouse = vec2(app.mouse.x, app.mouse.y);
+    let mouse = vec2(app.mouse().x, app.mouse().y);
 
     draw.ellipse()
         .x_y(mouse.x, mouse.y)
         .radius(24.0)
-        .rgb(0.78, 0.78, 0.78)
-        .stroke(gray(0.0))
+        .srgb(0.78, 0.78, 0.78)
+        .stroke(Color::gray(0.0))
         .stroke_weight(2.0);
 
     display(&m.vehicle, &draw);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 // A method that calculates a steering force towards a target
@@ -140,6 +136,6 @@ fn display(vehicle: &Vehicle, draw: &Draw) {
         .stroke_weight(1.0)
         .points(points)
         .xy(*position)
-        .rgb(0.5, 0.5, 0.5)
+        .srgb(0.5, 0.5, 0.5)
         .rotate(-theta);
 }
diff --git a/nature_of_code/chp_06_agents/6_03_stay_within_walls.rs b/nature_of_code/chp_06_agents/6_03_stay_within_walls.rs
index d1659b2b7..042d413fb 100644
--- a/nature_of_code/chp_06_agents/6_03_stay_within_walls.rs
+++ b/nature_of_code/chp_06_agents/6_03_stay_within_walls.rs
@@ -9,7 +9,6 @@
 // One vehicle "seeks"
 // See: http://www.red3d.com/cwr/
 use nannou::prelude::*;
-use nannou::Draw;
 
 fn main() {
     nannou::app(model).update(update).run();
@@ -56,7 +55,7 @@ impl Vehicle {
         // Update velocity
         self.velocity += self.acceleration;
         // Limit speed
-        self.velocity.clamp_length_max(self.max_speed);
+        self.velocity = self.velocity.clamp_length_max(self.max_speed);
         self.position += self.velocity;
         // Reset accelerationelertion to 0 each cycle
         self.acceleration *= 0.0;
@@ -67,7 +66,7 @@ impl Vehicle {
         self.acceleration += force;
     }
 
-    fn boundaries(&mut self, d: f32, win: &Rect) {
+    fn boundaries(&mut self, d: f32, win: &geom::Rect) {
         let left = win.left() + d;
         let right = win.right() - d;
         let top = win.top() - d;
@@ -94,8 +93,7 @@ fn model(app: &App) -> Model {
         .size(640, 360)
         .view(view)
         .mouse_pressed(mouse_pressed)
-        .build()
-        .unwrap();
+        .build();
     let middle = app.window_rect().xy();
     let vehicle = Vehicle::new(middle.x, middle.y);
     let debug = true;
@@ -103,12 +101,12 @@ fn model(app: &App) -> Model {
     Model { vehicle, debug, d }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
+fn update(app: &App, m: &mut Model) {
     m.vehicle.boundaries(m.d, &app.window_rect());
     m.vehicle.update();
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -124,9 +122,6 @@ fn view(app: &App, m: &Model, frame: Frame) {
     }
 
     display(&m.vehicle, &draw);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn display(vehicle: &Vehicle, draw: &Draw) {
@@ -145,7 +140,7 @@ fn display(vehicle: &Vehicle, draw: &Draw) {
         .stroke_weight(1.0)
         .points(points)
         .xy(*position)
-        .rgb(0.5, 0.5, 0.5)
+        .srgb(0.5, 0.5, 0.5)
         .rotate(-theta);
 }
 
diff --git a/nature_of_code/chp_06_agents/6_03_stay_within_walls_trail.rs b/nature_of_code/chp_06_agents/6_03_stay_within_walls_trail.rs
index 54ef51dfd..f14bab725 100644
--- a/nature_of_code/chp_06_agents/6_03_stay_within_walls_trail.rs
+++ b/nature_of_code/chp_06_agents/6_03_stay_within_walls_trail.rs
@@ -9,7 +9,6 @@
 // One vehicle "seeks"
 // See: http://www.red3d.com/cwr/
 use nannou::prelude::*;
-use nannou::Draw;
 use std::collections::VecDeque;
 
 fn main() {
@@ -60,7 +59,7 @@ impl Vehicle {
         // Update velocity
         self.velocity += self.acceleration;
         // Limit speed
-        self.velocity.clamp_length_max(self.max_speed);
+        self.velocity = self.velocity.clamp_length_max(self.max_speed);
         self.position += self.velocity;
         // Reset accelerationelertion to 0 each cycle
         self.acceleration *= 0.0;
@@ -75,7 +74,7 @@ impl Vehicle {
         self.acceleration += force;
     }
 
-    fn boundaries(&mut self, d: f32, win: &Rect) {
+    fn boundaries(&mut self, d: f32, win: &geom::Rect) {
         let left = win.left() + d;
         let right = win.right() - d;
         let top = win.top() - d;
@@ -102,8 +101,7 @@ fn model(app: &App) -> Model {
         .size(640, 360)
         .view(view)
         .mouse_pressed(mouse_pressed)
-        .build()
-        .unwrap();
+        .build();
     let middle = app.window_rect().xy();
     let vehicle = Vehicle::new(middle.x, middle.y);
     let debug = false;
@@ -111,12 +109,12 @@ fn model(app: &App) -> Model {
     Model { vehicle, debug, d }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
+fn update(app: &App, m: &mut Model) {
     m.vehicle.boundaries(m.d, &app.window_rect());
     m.vehicle.update();
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -132,9 +130,6 @@ fn view(app: &App, m: &Model, frame: Frame) {
     }
 
     display(&m.vehicle, &draw);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn display(vehicle: &Vehicle, draw: &Draw) {
@@ -147,15 +142,11 @@ fn display(vehicle: &Vehicle, draw: &Draw) {
     } = vehicle;
 
     if history.len() > 1 {
-        let vertices = history
-            .iter()
-            .map(|v| pt2(v.x, v.y))
-            .enumerate()
-            .map(|(_, p)| {
-                let rgba = srgba(0.0, 0.0, 0.0, 1.0);
-                (p, rgba)
-            });
-        draw.polyline().weight(1.0).points_colored(vertices);
+        let points_colored = history.iter().map(|v| pt2(v.x, v.y)).map(|p| {
+            let rgba = Color::srgba(0.0, 0.0, 0.0, 1.0);
+            (p, rgba)
+        });
+        draw.polyline().weight(1.0).points_colored(points_colored);
     }
 
     // Draw a triangle rotated in the direction of velocity
@@ -167,7 +158,7 @@ fn display(vehicle: &Vehicle, draw: &Draw) {
         .stroke_weight(1.0)
         .points(points)
         .xy(*position)
-        .rgb(0.5, 0.5, 0.5)
+        .srgb(0.5, 0.5, 0.5)
         .rotate(-theta);
 }
 
diff --git a/nature_of_code/chp_07_cellular_automata/7_01_wolfram_ca_figures.rs b/nature_of_code/chp_07_cellular_automata/7_01_wolfram_ca_figures.rs
index 97cf87c6e..54f9e1878 100644
--- a/nature_of_code/chp_07_cellular_automata/7_01_wolfram_ca_figures.rs
+++ b/nature_of_code/chp_07_cellular_automata/7_01_wolfram_ca_figures.rs
@@ -6,9 +6,10 @@
 
 // Simple demonstration of a Wolfram 1-dimensional cellular automata
 
-use nannou::prelude::*;
 use std::ops::Range;
 
+use nannou::prelude::*;
+
 fn main() {
     nannou::app(model).update(update).run();
 }
@@ -23,7 +24,7 @@ struct Ca {
 }
 
 impl Ca {
-    fn new(r: Vec<i32>, rect: Rect) -> Self {
+    fn new(r: Vec<i32>, rect: geom::Rect) -> Self {
         let rule_set = r;
         let scl = 20;
         let cells = vec![0; (rect.w() as i32 / scl) as usize];
@@ -82,7 +83,7 @@ impl Ca {
     }
 
     // This is the easy part, just draw the cells fill white if 1, black if 0
-    fn display(&self, draw: &Draw, rect: &Rect) {
+    fn display(&self, draw: &Draw, rect: &geom::Rect) {
         for i in 0..self.cells.len() {
             let mut fill = 1.0;
             if self.cells[i] == 1 {
@@ -90,8 +91,8 @@ impl Ca {
             }
             draw.rect()
                 .x_y(
-                    ((self.scl / 2) + i as i32 * self.scl) as f32 - rect.right() as f32,
-                    rect.top() as f32 - (self.generation * self.scl - (self.scl / 2)) as f32,
+                    ((self.scl / 2) + i as i32 * self.scl) as f32 - rect.right(),
+                    rect.top() - (self.generation * self.scl - (self.scl / 2)) as f32,
                 )
                 .w_h(self.scl as f32, self.scl as f32)
                 .gray(fill)
@@ -130,12 +131,8 @@ impl Ca {
     }
 
     // The CA is done if it reaches the bottom of the screen
-    fn finished(&self, rect: &Rect) -> bool {
-        if self.generation > rect.h() as i32 / self.scl {
-            true
-        } else {
-            false
-        }
+    fn finished(&self, rect: &geom::Rect) -> bool {
+        self.generation > rect.h() as i32 / self.scl
     }
 }
 
@@ -144,20 +141,19 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    let rect = Rect::from_w_h(1800.0, 600.0);
+    let rect = geom::Rect::from_w_h(1800.0, 600.0);
     app.new_window()
         .size(rect.w() as u32, rect.h() as u32)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     let rule_set = vec![0, 1, 1, 1, 1, 0, 1, 1];
     let ca = Ca::new(rule_set, rect);
     Model { ca }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
-    if m.ca.finished(&app.window_rect()) == false {
+fn update(app: &App, m: &mut Model) {
+    if !m.ca.finished(&app.window_rect()) {
         m.ca.generate();
     } else {
         m.ca.randomize();
@@ -165,12 +161,9 @@ fn update(app: &App, m: &mut Model, _update: Update) {
     }
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
 
     m.ca.display(&draw, &app.window_rect());
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_07_cellular_automata/7_01_wolfram_ca_simple.rs b/nature_of_code/chp_07_cellular_automata/7_01_wolfram_ca_simple.rs
index a4c5b37dd..acb460f00 100644
--- a/nature_of_code/chp_07_cellular_automata/7_01_wolfram_ca_simple.rs
+++ b/nature_of_code/chp_07_cellular_automata/7_01_wolfram_ca_simple.rs
@@ -6,9 +6,10 @@
 
 // Simple demonstration of a Wolfram 1-dimensional cellular automata
 
-use nannou::prelude::*;
 use std::ops::Range;
 
+use nannou::prelude::*;
+
 fn main() {
     nannou::app(model).update(update).run();
 }
@@ -23,12 +24,12 @@ struct Ca {
 }
 
 impl Ca {
-    fn new(rect: Rect) -> Self {
+    fn new(rect: geom::Rect) -> Self {
         let w = 10;
         let rule_set = vec![0, 1, 0, 1, 1, 0, 1, 0];
         let mut cells = vec![0; (rect.w() as i32 / w) as usize];
         let length = cells.len();
-        cells[length / 2 as usize] = 1; // We arbitrarily start with just the middle cell having a state of "1"
+        cells[length / 2_usize] = 1; // We arbitrarily start with just the middle cell having a state of "1"
         let generation = 0;
         let cells_range = 1..cells.len() - 1;
         Ca {
@@ -59,7 +60,7 @@ impl Ca {
     }
 
     // This is the easy part, just draw the cells fill white if 1, black if 0
-    fn display(&self, draw: &Draw, rect: &Rect) {
+    fn display(&self, draw: &Draw, rect: &geom::Rect) {
         for i in 0..self.cells.len() {
             let mut fill = 1.0;
             if self.cells[i] == 1 {
@@ -67,8 +68,8 @@ impl Ca {
             }
             draw.rect()
                 .x_y(
-                    ((self.w / 2) + i as i32 * self.w) as f32 - rect.right() as f32,
-                    rect.top() as f32 - (self.generation * self.w - (self.w / 2)) as f32,
+                    ((self.w / 2) + i as i32 * self.w) as f32 - rect.right(),
+                    rect.top() - (self.generation * self.w - (self.w / 2)) as f32,
                 )
                 .w_h(self.w as f32, self.w as f32)
                 .gray(fill);
@@ -111,30 +112,26 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    let rect = Rect::from_w_h(800.0, 400.0);
+    let rect = geom::Rect::from_w_h(800.0, 400.0);
     let _window = app
         .new_window()
         .size(rect.w() as u32, rect.h() as u32)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     let ca = Ca::new(rect);
     Model { ca }
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
+fn update(app: &App, m: &mut Model) {
     if m.ca.generation < app.window_rect().h() as i32 / m.ca.w {
         m.ca.generate();
     }
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
 
     m.ca.display(&draw, &app.window_rect());
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_07_cellular_automata/7_02_game_of_life_simple.rs b/nature_of_code/chp_07_cellular_automata/7_02_game_of_life_simple.rs
index 00060a41c..045697c1a 100644
--- a/nature_of_code/chp_07_cellular_automata/7_02_game_of_life_simple.rs
+++ b/nature_of_code/chp_07_cellular_automata/7_02_game_of_life_simple.rs
@@ -10,9 +10,10 @@
 // to describe each individual cell and a "cellular automata" class
 // to describe a collection of cells
 
-use nannou::prelude::*;
 use std::ops::Range;
 
+use nannou::prelude::*;
+
 fn main() {
     nannou::app(model).update(update).run();
 }
@@ -27,7 +28,7 @@ struct Gol {
 }
 
 impl Gol {
-    fn new(rect: Rect) -> Self {
+    fn new(rect: geom::Rect) -> Self {
         let w = 8;
         let columns = rect.w() as usize / w;
         let rows = rect.h() as usize / w;
@@ -78,8 +79,8 @@ impl Gol {
                 let mut neighbors = 0;
                 for i in 0..3 {
                     for j in 0..3 {
-                        neighbors += self.board[(x as i32 + (i as i32 - 1)) as usize]
-                            [(y as i32 + (j as i32 - 1)) as usize];
+                        neighbors += self.board[(x as i32 + (i - 1)) as usize]
+                            [(y as i32 + (j - 1)) as usize];
                     }
                 }
 
@@ -104,7 +105,7 @@ impl Gol {
     }
 
     // This is the easy part, just draw the cells fill white if 1, black if 0
-    fn display(&self, draw: &Draw, rect: &Rect) {
+    fn display(&self, draw: &Draw, rect: &geom::Rect) {
         for i in 0..self.columns {
             for j in 0..self.rows {
                 let mut fill = 1.0;
@@ -114,8 +115,8 @@ impl Gol {
                 let offset = self.w as f32 / 2.0;
                 draw.rect()
                     .x_y(
-                        offset + (i * self.w) as f32 - rect.right() as f32,
-                        offset + (j * self.w) as f32 - rect.top() as f32,
+                        offset + (i * self.w) as f32 - rect.right(),
+                        offset + (j * self.w) as f32 - rect.top(),
                     )
                     .w_h(self.w as f32, self.w as f32)
                     .gray(fill)
@@ -130,13 +131,12 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    let rect = Rect::from_w_h(640.0, 360.0);
+    let rect = geom::Rect::from_w_h(640.0, 360.0);
     app.new_window()
         .size(rect.w() as u32, rect.h() as u32)
         .mouse_pressed(mouse_pressed)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     let gol = Gol::new(rect);
     Model { gol }
@@ -147,17 +147,14 @@ fn mouse_pressed(_app: &App, m: &mut Model, _button: MouseButton) {
     m.gol.init();
 }
 
-fn update(_app: &App, m: &mut Model, _update: Update) {
+fn update(_app: &App, m: &mut Model) {
     m.gol.generate();
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
     m.gol.display(&draw, &app.window_rect());
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_07_cellular_automata/7_03_game_of_life_oop.rs b/nature_of_code/chp_07_cellular_automata/7_03_game_of_life_oop.rs
index ee9f88744..081e1e9ce 100644
--- a/nature_of_code/chp_07_cellular_automata/7_03_game_of_life_oop.rs
+++ b/nature_of_code/chp_07_cellular_automata/7_03_game_of_life_oop.rs
@@ -7,9 +7,10 @@
 // A basic implementation of John Conway's Game of Life CA
 // Each cell is now an object!
 
-use nannou::prelude::*;
 use std::ops::Range;
 
+use nannou::prelude::*;
+
 fn main() {
     nannou::app(model).update(update).run();
 }
@@ -39,18 +40,18 @@ impl Cell {
 
     fn display(&self, draw: &Draw, x: f32, y: f32) {
         let fill = if self.previous == 0 && self.state == 1 {
-            rgb(0.0, 0.0, 1.0)
+            Color::srgb(0.0, 0.0, 1.0)
         } else if self.state == 1 {
-            gray(0.0)
+            Color::gray(0.0)
         } else if self.previous == 1 && self.state == 0 {
-            rgb(1.0, 0.0, 0.0)
+            Color::srgb(1.0, 0.0, 0.0)
         } else {
-            gray(1.0)
+            Color::gray(1.0)
         };
         draw.rect()
             .x_y(x, y)
             .w_h(self.w, self.w)
-            .rgb(fill.red, fill.green, fill.blue)
+            .color(fill)
             .stroke(BLACK);
     }
 }
@@ -65,7 +66,7 @@ struct Gol {
 }
 
 impl Gol {
-    fn new(rect: Rect) -> Self {
+    fn new(rect: geom::Rect) -> Self {
         let w = 8;
         let columns = rect.w() as usize / w;
         let rows = rect.h() as usize / w;
@@ -112,9 +113,8 @@ impl Gol {
                 for i in 0..3 {
                     for j in 0..3 {
                         let i_idx =
-                            (x as i32 + (i as i32 - 1) + self.columns as i32) % self.columns as i32;
-                        let j_idx =
-                            (y as i32 + (j as i32 - 1) + self.rows as i32) % self.rows as i32;
+                            (x as i32 + (i - 1) + self.columns as i32) % self.columns as i32;
+                        let j_idx = (y as i32 + (j - 1) + self.rows as i32) % self.rows as i32;
                         neighbors += self.board[i_idx as usize][j_idx as usize].previous;
                     }
                 }
@@ -136,13 +136,13 @@ impl Gol {
     }
 
     // This is the easy part, just draw the cells fill white if 1, black if 0
-    fn display(&self, draw: &Draw, rect: &Rect) {
+    fn display(&self, draw: &Draw, rect: &geom::Rect) {
         for i in 0..self.columns {
             for j in 0..self.rows {
-                let x = (i * self.w) as f32 - rect.right() as f32;
-                let y = (j * self.w) as f32 - rect.top() as f32;
+                let x = (i * self.w) as f32 - rect.right();
+                let y = (j * self.w) as f32 - rect.top();
                 let offset = self.w as f32 / 2.0;
-                self.board[i][j].display(&draw, x + offset, y + offset);
+                self.board[i][j].display(draw, x + offset, y + offset);
             }
         }
     }
@@ -153,13 +153,12 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    let rect = Rect::from_w_h(640.0, 360.0);
+    let rect = geom::Rect::from_w_h(640.0, 360.0);
     app.new_window()
         .size(rect.w() as u32, rect.h() as u32)
         .mouse_pressed(mouse_pressed)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     let gol = Gol::new(rect);
     Model { gol }
@@ -170,17 +169,14 @@ fn mouse_pressed(_app: &App, m: &mut Model, _button: MouseButton) {
     m.gol.init();
 }
 
-fn update(_app: &App, m: &mut Model, _update: Update) {
+fn update(_app: &App, m: &mut Model) {
     m.gol.generate();
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
     m.gol.display(&draw, &app.window_rect());
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_07_cellular_automata/7_04_exercise_wolfram_ca_scrolling.rs b/nature_of_code/chp_07_cellular_automata/7_04_exercise_wolfram_ca_scrolling.rs
index 451bd4e16..eee181609 100644
--- a/nature_of_code/chp_07_cellular_automata/7_04_exercise_wolfram_ca_scrolling.rs
+++ b/nature_of_code/chp_07_cellular_automata/7_04_exercise_wolfram_ca_scrolling.rs
@@ -8,9 +8,10 @@
 // with the system scrolling by
 // Also implements wrap around
 
-use nannou::prelude::*;
 use std::ops::Range;
 
+use nannou::prelude::*;
+
 const RULE: i32 = 5;
 
 fn main() {
@@ -29,7 +30,7 @@ struct Ca {
 }
 
 impl Ca {
-    fn new(r: Vec<i32>, rect: Rect) -> Self {
+    fn new(r: Vec<i32>, rect: geom::Rect) -> Self {
         let rule_set = r;
         let generation = 0;
         let w = 4;
@@ -82,21 +83,20 @@ impl Ca {
     }
 
     // This is the easy part, just draw the cells fill white if 1, black if 0
-    fn display(&self, draw: &Draw, rect: &Rect) {
+    fn display(&self, draw: &Draw, rect: &geom::Rect) {
         let offset = self.generation % self.rows as i32;
         for col in 0..self.columns {
             for row in 0..self.rows {
                 let mut y = row as i32 - offset;
                 if y <= rect.top() as i32 {
-                    y = self.rows as i32 + y;
+                    y += self.rows as i32;
                 }
                 // Only draw if cell state is 1
                 let mut fill = 1.0;
                 if self.matrix[col][row] == 1 {
                     fill = 0.0;
                 }
-                let x =
-                    ((self.w as i32 / 2) + col as i32 * self.w as i32) as f32 - rect.right() as f32;
+                let x = ((self.w as i32 / 2) + col as i32 * self.w as i32) as f32 - rect.right();
                 let y = rect.top() - (self.w / 2) as f32 - ((y - 1) * self.w as i32) as f32;
                 draw.rect()
                     .x_y(x, y)
@@ -137,12 +137,8 @@ impl Ca {
     }
 
     // The CA is done if it reaches the bottom of the screen
-    fn _finished(&self, rect: &Rect) -> bool {
-        if self.generation > rect.h() as i32 / self.w as i32 {
-            true
-        } else {
-            false
-        }
+    fn _finished(&self, rect: &geom::Rect) -> bool {
+        self.generation > rect.h() as i32 / self.w as i32
     }
 }
 
@@ -151,12 +147,11 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    let rect = Rect::from_w_h(640.0, 800.0);
+    let rect = geom::Rect::from_w_h(640.0, 800.0);
     app.new_window()
         .size(rect.w() as u32, rect.h() as u32)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     let rule_set = match RULE {
         1 => vec![0, 1, 1, 1, 1, 0, 1, 1], // Rule 222
@@ -171,18 +166,15 @@ fn model(app: &App) -> Model {
     Model { ca }
 }
 
-fn update(_app: &App, m: &mut Model, _update: Update) {
+fn update(_app: &App, m: &mut Model) {
     m.ca.generate();
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
 
     draw.background().color(WHITE);
 
     m.ca.display(&draw, &app.window_rect());
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_07_cellular_automata/7_game_of_life_wrap_around.rs b/nature_of_code/chp_07_cellular_automata/7_game_of_life_wrap_around.rs
index b9639c799..b067d7865 100644
--- a/nature_of_code/chp_07_cellular_automata/7_game_of_life_wrap_around.rs
+++ b/nature_of_code/chp_07_cellular_automata/7_game_of_life_wrap_around.rs
@@ -25,7 +25,7 @@ struct Gol {
 }
 
 impl Gol {
-    fn new(rect: Rect) -> Self {
+    fn new(rect: geom::Rect) -> Self {
         let w = 8;
         let columns = rect.w() as usize / w;
         let rows = rect.h() as usize / w;
@@ -91,7 +91,7 @@ impl Gol {
     }
 
     // This is the easy part, just draw the cells fill white if 1, black if 0
-    fn display(&self, draw: &Draw, rect: &Rect) {
+    fn display(&self, draw: &Draw, rect: &geom::Rect) {
         for i in 0..self.columns {
             for j in 0..self.rows {
                 let mut fill = 1.0;
@@ -101,8 +101,8 @@ impl Gol {
                 let offset = self.w as f32 / 2.0;
                 draw.rect()
                     .x_y(
-                        offset + (i * self.w) as f32 - rect.right() as f32,
-                        offset + (j * self.w) as f32 - rect.top() as f32,
+                        offset + (i * self.w) as f32 - rect.right(),
+                        offset + (j * self.w) as f32 - rect.top(),
                     )
                     .w_h(self.w as f32, self.w as f32)
                     .gray(fill)
@@ -117,13 +117,12 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    let rect = Rect::from_w_h(400.0, 400.0);
+    let rect = geom::Rect::from_w_h(400.0, 400.0);
     app.new_window()
         .size(rect.w() as u32, rect.h() as u32)
         .mouse_pressed(mouse_pressed)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     let gol = Gol::new(rect);
     Model { gol }
@@ -134,17 +133,14 @@ fn mouse_pressed(_app: &App, m: &mut Model, _button: MouseButton) {
     m.gol.init();
 }
 
-fn update(_app: &App, m: &mut Model, _update: Update) {
+fn update(_app: &App, m: &mut Model) {
     m.gol.generate();
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
     m.gol.display(&draw, &app.window_rect());
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_07_cellular_automata/7_hexagon_cells.rs b/nature_of_code/chp_07_cellular_automata/7_hexagon_cells.rs
index 166a8e570..6ddd3a079 100644
--- a/nature_of_code/chp_07_cellular_automata/7_hexagon_cells.rs
+++ b/nature_of_code/chp_07_cellular_automata/7_hexagon_cells.rs
@@ -25,11 +25,11 @@ impl Cell {
         Cell { x, y, w, state }
     }
 
-    fn display(&self, draw: &Draw, rect: &Rect) {
+    fn display(&self, draw: &Draw, rect: &geom::Rect) {
         let fill = if self.state == 1 {
-            gray(0.0)
+            Color::gray(0.0)
         } else {
-            gray(1.0)
+            Color::gray(1.0)
         };
 
         let n_points = 6;
@@ -60,7 +60,7 @@ struct Gol {
 }
 
 impl Gol {
-    fn new(rect: Rect) -> Self {
+    fn new(rect: geom::Rect) -> Self {
         let w = 20.0;
         let h = deg_to_rad(60.0).sin() * w;
         let columns = (rect.w() / (w * 3.0)) as usize;
@@ -99,10 +99,10 @@ impl Gol {
     }
 
     // This is the easy part, just draw the cells fill white if 1, black if 0
-    fn display(&self, draw: &Draw, rect: &Rect) {
+    fn display(&self, draw: &Draw, rect: &geom::Rect) {
         for i in 0..self.columns {
             for j in 0..self.rows {
-                self.board[i][j].display(&draw, &rect);
+                self.board[i][j].display(draw, rect);
             }
         }
     }
@@ -113,13 +113,12 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    let rect = Rect::from_w_h(600.0, 600.0);
+    let rect = geom::Rect::from_w_h(600.0, 600.0);
     app.new_window()
         .size(rect.w() as u32, rect.h() as u32)
         .mouse_pressed(mouse_pressed)
         .view(view)
-        .build()
-        .unwrap();
+        .build();
 
     let gol = Gol::new(rect);
     Model { gol }
@@ -130,15 +129,12 @@ fn mouse_pressed(_app: &App, m: &mut Model, _button: MouseButton) {
     m.gol.init();
 }
 
-fn update(_app: &App, _m: &mut Model, _update: Update) {}
+fn update(_app: &App, _m: &mut Model) {}
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
     m.gol.display(&draw, &app.window_rect());
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_08_fractals/8_1_recursion.rs b/nature_of_code/chp_08_fractals/8_1_recursion.rs
index cecbab2ef..661bd4a12 100644
--- a/nature_of_code/chp_08_fractals/8_1_recursion.rs
+++ b/nature_of_code/chp_08_fractals/8_1_recursion.rs
@@ -12,20 +12,17 @@ fn main() {
 struct Model;
 
 fn model(app: &App) -> Model {
-    app.set_loop_mode(LoopMode::loop_once());
-    let _window = app.new_window().size(640, 360).view(view).build().unwrap();
+    app.set_update_mode(UpdateMode::freeze());
+    let _window = app.new_window().size(640, 360).view(view).build();
     Model
 }
 
-fn view(app: &App, _model: &Model, frame: Frame) {
+fn view(app: &App, _model: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
     draw_circle(&draw, 0.0, 0.0, app.window_rect().w());
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn draw_circle(draw: &Draw, x: f32, y: f32, mut r: f32) {
@@ -39,6 +36,6 @@ fn draw_circle(draw: &Draw, x: f32, y: f32, mut r: f32) {
     if r > 2.0 {
         r *= 0.75;
         // Call the function insie the function! (recursion!)
-        draw_circle(&draw, x, y, r);
+        draw_circle(draw, x, y, r);
     }
 }
diff --git a/nature_of_code/chp_08_fractals/8_2_recursion.rs b/nature_of_code/chp_08_fractals/8_2_recursion.rs
index 8adbdd2d6..2d58055b5 100644
--- a/nature_of_code/chp_08_fractals/8_2_recursion.rs
+++ b/nature_of_code/chp_08_fractals/8_2_recursion.rs
@@ -12,20 +12,17 @@ fn main() {
 struct Model;
 
 fn model(app: &App) -> Model {
-    app.set_loop_mode(LoopMode::loop_once());
-    let _window = app.new_window().size(640, 360).view(view).build().unwrap();
+    app.set_update_mode(UpdateMode::freeze());
+    let _window = app.new_window().size(640, 360).view(view).build();
     Model
 }
 
-fn view(app: &App, _model: &Model, frame: Frame) {
+fn view(app: &App, _model: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
     draw_circle(&draw, 0.0, 0.0, 200.0);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 // Recursive function
@@ -39,7 +36,7 @@ fn draw_circle(draw: &Draw, x: f32, y: f32, r: f32) {
     if r > 2.0 {
         // Now we draw two more circles, one to the left
         // and one to the right
-        draw_circle(&draw, x + r, y, r / 2.0);
-        draw_circle(&draw, x - r, y, r / 2.0);
+        draw_circle(draw, x + r, y, r / 2.0);
+        draw_circle(draw, x - r, y, r / 2.0);
     }
 }
diff --git a/nature_of_code/chp_08_fractals/8_3_recursion.rs b/nature_of_code/chp_08_fractals/8_3_recursion.rs
index bd139a27f..d6ddcabeb 100644
--- a/nature_of_code/chp_08_fractals/8_3_recursion.rs
+++ b/nature_of_code/chp_08_fractals/8_3_recursion.rs
@@ -12,20 +12,17 @@ fn main() {
 struct Model;
 
 fn model(app: &App) -> Model {
-    app.set_loop_mode(LoopMode::loop_once());
-    let _window = app.new_window().size(640, 360).view(view).build().unwrap();
+    app.set_update_mode(UpdateMode::freeze());
+    let _window = app.new_window().size(640, 360).view(view).build();
     Model
 }
 
-fn view(app: &App, _model: &Model, frame: Frame) {
+fn view(app: &App, _model: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
     draw_circle(&draw, 0.0, 0.0, 200.0);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 // Recursive function
@@ -39,9 +36,9 @@ fn draw_circle(draw: &Draw, x: f32, y: f32, r: f32) {
 
     if r > 8.0 {
         // Four circles! left right, up and down
-        draw_circle(&draw, x + r, y, r / 2.0);
-        draw_circle(&draw, x - r, y, r / 2.0);
-        draw_circle(&draw, x, y + r, r / 2.0);
-        draw_circle(&draw, x, y - r, r / 2.0);
+        draw_circle(draw, x + r, y, r / 2.0);
+        draw_circle(draw, x - r, y, r / 2.0);
+        draw_circle(draw, x, y + r, r / 2.0);
+        draw_circle(draw, x, y - r, r / 2.0);
     }
 }
diff --git a/nature_of_code/chp_08_fractals/8_4_cantor_set.rs b/nature_of_code/chp_08_fractals/8_4_cantor_set.rs
index e88c4209d..17feb91c8 100644
--- a/nature_of_code/chp_08_fractals/8_4_cantor_set.rs
+++ b/nature_of_code/chp_08_fractals/8_4_cantor_set.rs
@@ -13,21 +13,18 @@ fn main() {
 struct Model;
 
 fn model(app: &App) -> Model {
-    app.set_loop_mode(LoopMode::loop_once());
-    let _window = app.new_window().size(800, 200).view(view).build().unwrap();
+    app.set_update_mode(UpdateMode::freeze());
+    let _window = app.new_window().size(800, 200).view(view).build();
     Model
 }
 
-fn view(app: &App, _model: &Model, frame: Frame) {
+fn view(app: &App, _model: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
     let win = app.window_rect();
     cantor(&draw, 0.0, win.top(), 730.0);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 // Recursive function
@@ -46,7 +43,7 @@ fn cantor(draw: &Draw, x: f32, mut y: f32, len: f32) {
         y -= h;
         // Draw 2 more lines 1/3rd the length (without the middle section)
         let length = len / 3.0;
-        cantor(&draw, x - length, y, length);
-        cantor(&draw, (x + len * 2.0 / 3.0) - length, y, length);
+        cantor(draw, x - length, y, length);
+        cantor(draw, (x + len * 2.0 / 3.0) - length, y, length);
     }
 }
diff --git a/nature_of_code/chp_08_fractals/8_4_tree.rs b/nature_of_code/chp_08_fractals/8_4_tree.rs
index ca48a7fd1..0154859b8 100644
--- a/nature_of_code/chp_08_fractals/8_4_tree.rs
+++ b/nature_of_code/chp_08_fractals/8_4_tree.rs
@@ -18,25 +18,23 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    let _window = app.new_window().size(300, 200).view(view).build().unwrap();
+    let _window = app.new_window().size(300, 200).view(view).build();
     Model { theta: 0.0 }
 }
 
-fn update(app: &App, model: &mut Model, _update: Update) {
+fn update(app: &App, model: &mut Model) {
     let win = app.window_rect();
-    model.theta = map_range(app.mouse.x, win.left(), win.right(), 0.0, PI / 2.0);
+    model.theta = map_range(app.mouse().x, win.left(), win.right(), 0.0, PI / 2.0);
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
-    frame.clear(WHITE);
+fn view(app: &App, model: &Model) {
+    let draw = app.draw();
+    draw.background().color(WHITE);
 
     let win = app.window_rect();
     let draw = app.draw().x_y(0.0, win.bottom());
 
     branch(&draw, 60.0, model.theta);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn branch(draw: &Draw, len: f32, theta: f32) {
diff --git a/nature_of_code/chp_09_genetic_algorithms/9_1_ga_shakespeare.rs b/nature_of_code/chp_09_genetic_algorithms/9_1_ga_shakespeare.rs
index 17be51f0a..66594807b 100644
--- a/nature_of_code/chp_09_genetic_algorithms/9_1_ga_shakespeare.rs
+++ b/nature_of_code/chp_09_genetic_algorithms/9_1_ga_shakespeare.rs
@@ -217,7 +217,7 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    app.new_window().size(640, 360).view(view).build().unwrap();
+    app.new_window().size(640, 360).view(view).build();
     let target = "To be or not to be.".to_string();
     let pop_max = 150;
     let mutation_rate = 0.01;
@@ -232,7 +232,7 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(_app: &App, model: &mut Model, _update: Update) {
+fn update(_app: &App, model: &mut Model) {
     // Generate mating pool
     model.population.natural_selection();
     // Create next generation
@@ -243,13 +243,14 @@ fn update(_app: &App, model: &mut Model, _update: Update) {
     model.answer = model.population.get_best();
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
-    frame.clear(WHITE);
+fn view(app: &App, model: &Model) {
+    let draw = app.draw();
+    draw.background().color(WHITE);
 
     let win = app.window_rect();
     let draw = app.draw();
 
-    draw.text(&"Best Phrase:".to_string())
+    draw.text("Best Phrase:")
         .color(BLACK)
         .left_justify()
         .align_text_top()
@@ -316,10 +317,7 @@ fn view(app: &App, model: &Model, frame: Frame) {
         .y(-10.0)
         .wh(win.wh());
 
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
-
     if model.population.finished {
-        app.set_loop_mode(LoopMode::loop_once());
+        app.set_update_mode(UpdateMode::freeze());
     }
 }
diff --git a/nature_of_code/chp_10_neural_networks/10_01_simple_perceptron.rs b/nature_of_code/chp_10_neural_networks/10_01_simple_perceptron.rs
index be8eb707e..cca51ac10 100644
--- a/nature_of_code/chp_10_neural_networks/10_01_simple_perceptron.rs
+++ b/nature_of_code/chp_10_neural_networks/10_01_simple_perceptron.rs
@@ -92,7 +92,7 @@ fn f(x: f32) -> f32 {
 }
 
 fn model(app: &App) -> Model {
-    app.new_window().size(640, 360).view(view).build().unwrap();
+    app.new_window().size(640, 360).view(view).build();
 
     let x_min = -400.0;
     let y_min = -100.0;
@@ -122,14 +122,14 @@ fn model(app: &App) -> Model {
     }
 }
 
-fn update(_app: &App, m: &mut Model, _update: Update) {
+fn update(_app: &App, m: &mut Model) {
     // Train the Perceptron with one "training" point at a time
     m.ptron
         .train(&m.training[m.count].inputs, m.training[m.count].answer);
     m.count = (m.count + 1) % m.training.len();
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -169,7 +169,4 @@ fn view(app: &App, m: &Model, frame: Frame) {
             draw.ellipse().x_y(x, y).radius(4.0).color(BLACK);
         }
     }
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/nature_of_code/chp_10_neural_networks/10_02_seeking_neural.rs b/nature_of_code/chp_10_neural_networks/10_02_seeking_neural.rs
index b61566a0a..7a3af13ab 100644
--- a/nature_of_code/chp_10_neural_networks/10_02_seeking_neural.rs
+++ b/nature_of_code/chp_10_neural_networks/10_02_seeking_neural.rs
@@ -6,7 +6,6 @@
 //
 // example 10-02: Seeking Neural
 use nannou::prelude::*;
-use nannou::Draw;
 
 fn main() {
     nannou::app(model).update(update).run();
@@ -71,7 +70,7 @@ impl Vehicle {
     }
 
     // Method to update position
-    fn update(&mut self, win: Rect) {
+    fn update(&mut self, win: geom::Rect) {
         // Update velocity
         self.velocity += self.acceleration;
         // Limit speed
@@ -119,8 +118,8 @@ impl Vehicle {
         desired *= self.max_speed;
         // Steering = Desired minus velocity
         // Limit to maximum steering force
-        let steer = (desired - self.velocity).clamp_length_max(self.max_force);
-        steer
+
+        (desired - self.velocity).clamp_length_max(self.max_force)
     }
 
     fn display(&self, draw: &Draw) {
@@ -136,7 +135,7 @@ impl Vehicle {
             .stroke(BLACK)
             .points(points)
             .xy(self.position)
-            .rgb(0.5, 0.5, 0.5)
+            .srgb(0.5, 0.5, 0.5)
             .rotate(theta);
     }
 }
@@ -153,8 +152,7 @@ fn model(app: &App) -> Model {
         .size(640, 360)
         .view(view)
         .mouse_pressed(mouse_pressed)
-        .build()
-        .unwrap();
+        .build();
 
     let num_targets = 8;
 
@@ -184,7 +182,7 @@ fn model(app: &App) -> Model {
 }
 
 // Make a random ArrayList of targets to steer towards
-fn make_targets(m: &mut Model, win: &Rect) {
+fn make_targets(m: &mut Model, win: &geom::Rect) {
     m.targets = (0..m.num_targets)
         .map(|_| {
             vec2(
@@ -195,13 +193,13 @@ fn make_targets(m: &mut Model, win: &Rect) {
         .collect();
 }
 
-fn update(app: &App, m: &mut Model, _update: Update) {
+fn update(app: &App, m: &mut Model) {
     // Update the Vehicle
     m.v.steer(&m.targets, &m.desired);
     m.v.update(app.window_rect());
 }
 
-fn view(app: &App, m: &Model, frame: Frame) {
+fn view(app: &App, m: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
@@ -210,7 +208,7 @@ fn view(app: &App, m: &Model, frame: Frame) {
     draw.ellipse()
         .xy(m.desired)
         .radius(18.0)
-        .rgba(0.0, 0.0, 0.0, 0.4)
+        .srgba(0.0, 0.0, 0.0, 0.4)
         .stroke(BLACK)
         .stroke_weight(2.0);
 
@@ -236,9 +234,6 @@ fn view(app: &App, m: &Model, frame: Frame) {
             .stroke_weight(2.0);
     }
     m.v.display(&draw);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
 
 fn mouse_pressed(app: &App, m: &mut Model, _button: MouseButton) {
diff --git a/nature_of_code/chp_10_neural_networks/10_03_network_viz.rs b/nature_of_code/chp_10_neural_networks/10_03_network_viz.rs
index 322a887e1..77b0ec997 100644
--- a/nature_of_code/chp_10_neural_networks/10_03_network_viz.rs
+++ b/nature_of_code/chp_10_neural_networks/10_03_network_viz.rs
@@ -39,7 +39,7 @@ impl Neuron {
             .stroke(BLACK);
 
         for c in &self.connections {
-            c.display(&draw);
+            c.display(draw);
         }
     }
 }
@@ -96,7 +96,7 @@ impl Network {
     // We can draw the network
     fn display(&self, draw: &Draw) {
         for n in &self.neurons {
-            n.display(&draw);
+            n.display(draw);
         }
     }
 }
@@ -106,7 +106,7 @@ struct Model {
 }
 
 fn model(app: &App) -> Model {
-    app.new_window().size(640, 360).view(view).build().unwrap();
+    app.new_window().size(640, 360).view(view).build();
 
     // Create an empty network
     let mut network = Network::new();
@@ -132,13 +132,10 @@ fn model(app: &App) -> Model {
     Model { network }
 }
 
-fn view(app: &App, model: &Model, frame: Frame) {
+fn view(app: &App, model: &Model) {
     // Begin drawing
     let draw = app.draw();
     draw.background().color(WHITE);
 
     model.network.display(&draw);
-
-    // Write the result of our drawing to the window's frame.
-    draw.to_frame(app, &frame).unwrap();
 }
diff --git a/result b/result
index 9dcb26dd2..4f5542de4 120000
--- a/result
+++ b/result
@@ -1 +1 @@
-/nix/store/l6qwc0cii9g6hzrqcb79wr61jg32nhx6-nannou-0.19.0
\ No newline at end of file
+/nix/store/n8sariy0lymb5i1659v3lmc4i2g51l16-nannou-0.19.0
\ No newline at end of file
diff --git a/scripts/run_all_examples/main.rs b/scripts/run_all_examples/main.rs
index a4439270e..9ab443e77 100644
--- a/scripts/run_all_examples/main.rs
+++ b/scripts/run_all_examples/main.rs
@@ -76,7 +76,7 @@ fn main() {
                 .arg("-p")
                 .arg(&package)
                 .arg("--example")
-                .arg(&name)
+                .arg(name)
                 .spawn()
                 .expect("failed to spawn `cargo run --example` process");
 
diff --git a/scripts/set_version/main.rs b/scripts/set_version/main.rs
index b32f38dba..67d2f3550 100644
--- a/scripts/set_version/main.rs
+++ b/scripts/set_version/main.rs
@@ -44,7 +44,7 @@ fn main() {
     let mut manifest_updates = vec![];
     for relative_path in &package_relative_paths {
         // Read the manifest for each crate into a toml document.
-        let dir_path = workspace_manifest_dir.join(&relative_path);
+        let dir_path = workspace_manifest_dir.join(relative_path);
         let manifest_path = dir_path.join("Cargo.toml");
         let manifest_string =
             std::fs::read_to_string(&manifest_path).expect("failed to read the manifest");
@@ -137,7 +137,7 @@ pub fn safe_file_save(path: &std::path::Path, content: &[u8]) -> std::io::Result
 
     // If there's already a file at `path`, remove it.
     if path.exists() {
-        std::fs::remove_file(&path)?;
+        std::fs::remove_file(path)?;
     }
 
     // Rename the temp file to the original path name.