diff --git a/.gitignore b/.gitignore
index a3eef56dc..af4b1171c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,3 +7,4 @@ target/
 **/*.rs.bk
 .DS_Store
 .idea/
+result/
diff --git a/Cargo.lock b/Cargo.lock
index 3878820db..28731f041 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -585,7 +585,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f48b9bbe4ec605e4910b5cd1e1a0acbfbe0b80af5f3bcc4489a9fdd1e80058c"
 dependencies = [
  "bevy_macro_utils",
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 2.0.48",
 ]
@@ -699,7 +699,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a8843aa489f159f25cdcd9fee75cd7d221a7098a71eaa72cb2d6b40ac4e3f1ba"
 dependencies = [
  "bevy_macro_utils",
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 2.0.48",
 ]
@@ -792,7 +792,7 @@ dependencies = [
  "bevy_log",
  "bevy_reflect",
  "bevy_utils",
- "smallvec 1.12.0",
+ "smallvec 1.13.1",
 ]
 
 [[package]]
@@ -870,7 +870,7 @@ version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e566640c6b6dced73d2006c764c2cffebe1a82be4809486c4a5d7b4b50efed4d"
 dependencies = [
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "rustc-hash",
  "syn 2.0.48",
@@ -883,7 +883,7 @@ version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "58ddc2b76783939c530178f88e5711a1b01044d7b02db4033e2eb8b43b6cf4ec"
 dependencies = [
- "glam 0.24.2",
+ "glam",
  "serde",
 ]
 
@@ -893,7 +893,7 @@ version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8ec4962977a746d870170532fc92759e04d3dbcae8b7b82e7ca3bb83b1d75277"
 dependencies = [
- "glam 0.24.2",
+ "glam",
 ]
 
 [[package]]
@@ -910,6 +910,11 @@ name = "bevy_nannou_draw"
 version = "0.1.0"
 dependencies = [
  "bevy",
+ "lyon",
+ "nannou_core",
+ "nannou_mesh",
+ "num-traits",
+ "rusttype",
 ]
 
 [[package]]
@@ -917,6 +922,11 @@ name = "bevy_nannou_render"
 version = "0.1.0"
 dependencies = [
  "bevy",
+ "bevy_nannou_draw",
+ "bevy_nannou_wgpu",
+ "lyon",
+ "nannou_core",
+ "wgpu-types",
 ]
 
 [[package]]
@@ -924,6 +934,7 @@ name = "bevy_nannou_wgpu"
 version = "0.1.0"
 dependencies = [
  "bevy",
+ "wgpu-types",
 ]
 
 [[package]]
@@ -948,7 +959,7 @@ dependencies = [
  "fixedbitset 0.4.2",
  "naga_oil",
  "radsort",
- "smallvec 1.12.0",
+ "smallvec 1.13.1",
  "thread_local",
 ]
 
@@ -970,9 +981,9 @@ dependencies = [
  "bevy_utils",
  "downcast-rs",
  "erased-serde",
- "glam 0.24.2",
+ "glam",
  "serde",
- "smallvec 1.12.0",
+ "smallvec 1.13.1",
  "smol_str",
  "thiserror",
 ]
@@ -984,10 +995,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4a8c5475f216e751ef4452a1306b00711f33d2d04d9f149e4c845dfeb6753a0"
 dependencies = [
  "bevy_macro_utils",
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 2.0.48",
- "uuid 1.6.1",
+ "uuid 1.7.0",
 ]
 
 [[package]]
@@ -1028,7 +1039,7 @@ dependencies = [
  "naga_oil",
  "ruzstd",
  "serde",
- "smallvec 1.12.0",
+ "smallvec 1.13.1",
  "thiserror",
  "thread_local",
  "wasm-bindgen",
@@ -1043,7 +1054,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "64d86bfc5a1e7fbeeaec0c4ceab18155530f5506624670965db3415f75826bea"
 dependencies = [
  "bevy_macro_utils",
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 2.0.48",
 ]
@@ -1066,7 +1077,7 @@ dependencies = [
  "ron",
  "serde",
  "thiserror",
- "uuid 1.6.1",
+ "uuid 1.7.0",
 ]
 
 [[package]]
@@ -1184,7 +1195,7 @@ dependencies = [
  "bevy_window",
  "bytemuck",
  "serde",
- "smallvec 1.12.0",
+ "smallvec 1.13.1",
  "taffy",
  "thiserror",
 ]
@@ -1204,7 +1215,7 @@ dependencies = [
  "petgraph 0.6.4",
  "thiserror",
  "tracing",
- "uuid 1.6.1",
+ "uuid 1.7.0",
 ]
 
 [[package]]
@@ -1213,7 +1224,7 @@ version = "0.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7aafecc952b6b8eb1a93c12590bd867d25df2f4ae1033a01dfdfc3c35ebccfff"
 dependencies = [
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 2.0.48",
 ]
@@ -1274,7 +1285,7 @@ dependencies = [
  "lazycell",
  "log",
  "peeking_take_while",
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "regex",
  "rustc-hash",
@@ -1294,11 +1305,11 @@ dependencies = [
  "lazy_static",
  "lazycell",
  "peeking_take_while",
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "regex",
  "rustc-hash",
- "shlex 1.2.0",
+ "shlex 1.3.0",
  "syn 2.0.48",
 ]
 
@@ -1437,9 +1448,9 @@ checksum = "e1e5f035d16fc623ae5f74981db80a439803888314e3a555fd6f04acd51a3205"
 
 [[package]]
 name = "bytemuck"
-version = "1.14.0"
+version = "1.14.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "374d28ec25809ee0e23827c2ab573d729e293f281dfe393500e7ad618baa61c6"
+checksum = "ed2490600f404f2b94c167e31d3ed1d5f3c225a0f3b80230053b3e0b7b962bd9"
 dependencies = [
  "bytemuck_derive",
 ]
@@ -1450,7 +1461,7 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "965ab7eb5f8f97d2a083c799f3a1b994fc397b2fe2da5d1da1626ce15a39f2b1"
 dependencies = [
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 2.0.48",
 ]
@@ -1670,16 +1681,16 @@ checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e"
 
 [[package]]
 name = "chrono"
-version = "0.4.31"
+version = "0.4.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f2c685bad3eb3d45a01354cedb7d5faa66194d1d58ba6e267a8de788f79db38"
+checksum = "9f13690e35a5e4ace198e7beea2895d29f3a9cc55015fcebe6336bd2010af9eb"
 dependencies = [
  "android-tzdata",
  "iana-time-zone",
  "js-sys",
  "num-traits",
  "wasm-bindgen",
- "windows-targets 0.48.5",
+ "windows-targets 0.52.0",
 ]
 
 [[package]]
@@ -2185,7 +2196,7 @@ checksum = "859d65a907b6852c9361e3185c862aae7fafd2887876799fa55f5f99dc40d610"
 dependencies = [
  "fnv",
  "ident_case",
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "strsim 0.10.0",
  "syn 1.0.109",
@@ -2356,7 +2367,7 @@ checksum = "8fce2eeef77fd4a293a54b62aa00ac9daebfbcda4bf8998c5a815635b004aa1c"
 dependencies = [
  "const_panic",
  "encase_derive",
- "glam 0.24.2",
+ "glam",
  "thiserror",
 ]
 
@@ -2375,7 +2386,7 @@ version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3fe2568f851fd6144a45fa91cfed8fe5ca8fc0b56ba6797bfc1ed2771b90e37c"
 dependencies = [
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 2.0.48",
 ]
@@ -2405,7 +2416,7 @@ version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f282cfdfe92516eb26c2af8589c274c7c17681f5ecc03c18255fe741c6aa64eb"
 dependencies = [
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 2.0.48",
 ]
@@ -2416,7 +2427,7 @@ version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6fd000fd6988e73bbe993ea3db9b1aa64906ab88766d654973924340c8cddb42"
 dependencies = [
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 2.0.48",
 ]
@@ -2602,7 +2613,7 @@ version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "aa4da3c766cd7a0db8242e326e9e4e081edd567072893ed320008189715366a4"
 dependencies = [
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 1.0.109",
  "synstructure",
@@ -2722,7 +2733,7 @@ version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1a5c6c585bc94aaf2c7b51dd4c2ba22680844aba4c687be581871a6f518c5742"
 dependencies = [
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 2.0.48",
 ]
@@ -2887,7 +2898,7 @@ version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac"
 dependencies = [
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 2.0.48",
 ]
@@ -2984,7 +2995,7 @@ dependencies = [
  "fnv",
  "gilrs-core",
  "log",
- "uuid 1.6.1",
+ "uuid 1.7.0",
  "vec_map",
 ]
 
@@ -3002,7 +3013,7 @@ dependencies = [
  "libudev-sys",
  "log",
  "nix 0.27.1",
- "uuid 1.6.1",
+ "uuid 1.7.0",
  "vec_map",
  "wasm-bindgen",
  "web-sys",
@@ -3042,17 +3053,6 @@ dependencies = [
  "url 2.5.0",
 ]
 
-[[package]]
-name = "glam"
-version = "0.17.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e01732b97afd8508eee3333a541b9f7610f454bb818669e66e90f5f57c93a776"
-dependencies = [
- "num-traits",
- "rand 0.8.5",
- "serde",
-]
-
 [[package]]
 name = "glam"
 version = "0.24.2"
@@ -3060,6 +3060,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b5418c17512bdf42730f9032c74e1ae39afc408745ebb2acf72fbc4691c17945"
 dependencies = [
  "bytemuck",
+ "libm",
+ "rand 0.8.5",
  "serde",
 ]
 
@@ -3078,7 +3080,7 @@ dependencies = [
  "aho-corasick",
  "bstr",
  "log",
- "regex-automata 0.4.3",
+ "regex-automata 0.4.5",
  "regex-syntax 0.8.2",
 ]
 
@@ -3113,7 +3115,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "438ffe1a5540d75403feaf23636b164e816e93f6f03131674722b3886ce32a57"
 dependencies = [
  "inflections",
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 2.0.48",
 ]
@@ -3293,7 +3295,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7cb3df16a7bcb1b5bc092abd55e14f77ca70aea14445026e264586fc62889a10"
 dependencies = [
  "constgebra",
- "glam 0.24.2",
+ "glam",
 ]
 
 [[package]]
@@ -3498,7 +3500,7 @@ dependencies = [
  "globset",
  "log",
  "memchr",
- "regex-automata 0.4.3",
+ "regex-automata 0.4.5",
  "same-file",
  "walkdir",
  "winapi-util",
@@ -3574,9 +3576,9 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.1.0"
+version = "2.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d530e1a18b1cb4c484e6e34556a0d948706958449fca0cab753d649f2bce3d1f"
+checksum = "433de089bd45971eecf4668ee0ee8f4cec17db4f8bd8f7bc3197a6ce37aa7d9b"
 dependencies = [
  "equivalent",
  "hashbrown 0.14.3",
@@ -3828,9 +3830,9 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.152"
+version = "0.2.153"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13e3bf6590cbc649f4d1a3eefc9d5d6eb746f5200ffb04e5e142700b8faa56e7"
+checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"
 
 [[package]]
 name = "libflate"
@@ -3931,9 +3933,9 @@ dependencies = [
 
 [[package]]
 name = "libz-sys"
-version = "1.1.14"
+version = "1.1.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "295c17e837573c8c821dbaeb3cceb3d745ad082f7572191409e69cbc1b3fd050"
+checksum = "037731f5d3aaa87a5675e895b63ddff1a87624bc29f77004ea829809654e48f6"
 dependencies = [
  "cc",
  "libc",
@@ -4291,7 +4293,7 @@ checksum = "ae585df4b6514cf8842ac0f1ab4992edc975892704835b549cf818dc0191249e"
 dependencies = [
  "bit-set",
  "bitflags 2.4.2",
- "indexmap 2.1.0",
+ "indexmap 2.2.1",
  "log",
  "num-traits",
  "pp-rs",
@@ -4371,7 +4373,7 @@ dependencies = [
 name = "nannou_core"
 version = "0.19.0"
 dependencies = [
- "glam 0.17.3",
+ "glam",
  "num-traits",
  "palette",
  "rand 0.8.5",
@@ -4545,7 +4547,7 @@ checksum = "0df7ac00c4672f9d5aece54ee3347520b7e20f158656c7db2e6de01902eb7a6c"
 dependencies = [
  "darling",
  "proc-macro-crate",
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 1.0.109",
 ]
@@ -4772,7 +4774,7 @@ version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "876a53fff98e03a936a674b29568b0e605f06b29372c2489ff4de23f1949743d"
 dependencies = [
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 1.0.109",
 ]
@@ -4866,7 +4868,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dcbff9bc912032c62bf65ef1d5aea88983b420f4f839db1e9b0c281a25c9c799"
 dependencies = [
  "proc-macro-crate",
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 1.0.109",
 ]
@@ -4878,7 +4880,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "96667db765a921f7b295ffee8b60472b686a51d4f21c2ee4ffdb94c7013b65a6"
 dependencies = [
  "proc-macro-crate",
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 2.0.48",
 ]
@@ -5018,9 +5020,9 @@ dependencies = [
 
 [[package]]
 name = "openssl"
-version = "0.10.62"
+version = "0.10.63"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8cde4d2d9200ad5909f8dac647e29482e07c3a35de8a13fce7c9c7747ad9f671"
+checksum = "15c9d69dd87a29568d4d017cfe8ec518706046a05184e5aea92d0af890b803c8"
 dependencies = [
  "bitflags 2.4.2",
  "cfg-if 1.0.0",
@@ -5037,7 +5039,7 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
 dependencies = [
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 2.0.48",
 ]
@@ -5050,9 +5052,9 @@ checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
 
 [[package]]
 name = "openssl-sys"
-version = "0.9.98"
+version = "0.9.99"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1665caf8ab2dc9aef43d1c0023bd904633a6a05cb30b0ad59bec2ae986e57a7"
+checksum = "22e1bf214306098e4832460f797824c05d25aacdf896f64a985fb0fd992454ae"
 dependencies = [
  "cc",
  "libc",
@@ -5111,7 +5113,7 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b4b5f600e60dd3a147fb57b4547033d382d1979eb087af310e91cb45a63b1f4"
 dependencies = [
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 1.0.109",
 ]
@@ -5179,7 +5181,7 @@ dependencies = [
  "instant",
  "libc",
  "redox_syscall 0.2.16",
- "smallvec 1.12.0",
+ "smallvec 1.13.1",
  "winapi 0.3.9",
 ]
 
@@ -5192,7 +5194,7 @@ dependencies = [
  "cfg-if 1.0.0",
  "libc",
  "redox_syscall 0.4.1",
- "smallvec 1.12.0",
+ "smallvec 1.13.1",
  "windows-targets 0.48.5",
 ]
 
@@ -5246,7 +5248,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e1d3afd2628e69da2be385eb6f2fd57c8ac7977ceeff6dc166ff1657b0e386a9"
 dependencies = [
  "fixedbitset 0.4.2",
- "indexmap 2.1.0",
+ "indexmap 2.2.1",
 ]
 
 [[package]]
@@ -5374,18 +5376,18 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.76"
+version = "1.0.78"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95fc56cda0b5c3325f5fbbd7ff9fda9e02bb00bb3dac51252d2f1bfa1cb8cc8c"
+checksum = "e2422ad645d89c99f8f3e6b88a9fdeca7fabeac836b1002371c4367c8f984aae"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "profiling"
-version = "1.0.13"
+version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d135ede8821cf6376eb7a64148901e1690b788c11ae94dc297ae917dbc91dc0e"
+checksum = "0f0f7f43585c34e4fdd7497d746bc32e14458cf11c69341cc0587b1d825dde42"
 
 [[package]]
 name = "publicsuffix"
@@ -5427,7 +5429,7 @@ version = "1.0.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef"
 dependencies = [
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
 ]
 
 [[package]]
@@ -5751,13 +5753,13 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.10.2"
+version = "1.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "380b951a9c5e80ddfd6136919eef32310721aa4aacd4889a8d39124b026ab343"
+checksum = "b62dbe01f0b06f9d8dc7d49e05a0785f153b00b2c227856282f671e0318c9b15"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-automata 0.4.3",
+ "regex-automata 0.4.5",
  "regex-syntax 0.8.2",
 ]
 
@@ -5772,9 +5774,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.4.3"
+version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f804c7828047e88b2d32e2d7fe5a105da8ee3264f01902f796c8e067dc2483f"
+checksum = "5bb987efffd3c6d0d8f5f89510bb458559eab11e4f869acb20bf845e016259cd"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -6137,20 +6139,20 @@ checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
 
 [[package]]
 name = "serde"
-version = "1.0.195"
+version = "1.0.196"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "63261df402c67811e9ac6def069e4786148c4563f4b50fd4bf30aa370d626b02"
+checksum = "870026e60fa08c69f064aa766c10f10b1d62db9ccd4d0abb206472bee0ce3b32"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.195"
+version = "1.0.196"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46fe8f8603d81ba86327b23a2e9cdf49e1255fb94a4c5f297f6ee0547178ea2c"
+checksum = "33c85360c95e7d137454dc81d9a4ed2b8efd8fbe19cee57357b32b9771fccb67"
 dependencies = [
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 2.0.48",
 ]
@@ -6166,9 +6168,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.111"
+version = "1.0.113"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "176e46fa42316f18edd598015a5166857fc835ec732f5215eac6b7bdbf0a84f4"
+checksum = "69801b70b1c3dac963ecb03a364ba0ceda9cf60c71cfe475e99864759c8b8a79"
 dependencies = [
  "itoa 1.0.10",
  "ryu",
@@ -6218,9 +6220,9 @@ checksum = "7fdf1b9db47230893d76faad238fd6097fd6d6a9245cd7a4d90dbd639536bbd2"
 
 [[package]]
 name = "shlex"
-version = "1.2.0"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7cee0529a6d40f580e7a5e6c495c8fbfe21b7b52795ed4bb5e62cdf92bc6380"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
 name = "sid"
@@ -6311,9 +6313,9 @@ dependencies = [
 
 [[package]]
 name = "smallvec"
-version = "1.12.0"
+version = "1.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2593d31f82ead8df961d8bd23a64c2ccf2eb5dd34b0a34bfb4dd54011c72009e"
+checksum = "e6ecd384b10a64542d77071bd64bd7b231f4ed5940fba55e98c3de13824cf3d7"
 dependencies = [
  "serde",
 ]
@@ -6485,7 +6487,7 @@ version = "1.0.109"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
 dependencies = [
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "unicode-ident",
 ]
@@ -6496,7 +6498,7 @@ version = "2.0.48"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0f3531638e407dfc0814761abb7c00a5b54992b849452a0646b7f65c9f770f3f"
 dependencies = [
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "unicode-ident",
 ]
@@ -6507,7 +6509,7 @@ version = "0.12.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f36bdaa60a83aca3921b5259d5400cbf5e90fc51931376a9bd4a0eb79aa7210f"
 dependencies = [
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 1.0.109",
  "unicode-xid 0.2.4",
@@ -6620,7 +6622,7 @@ version = "1.0.50"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e4c60d69f36615a077cc7663b9cb8e42275722d23e58a7fa3d2c7f2915d09d04"
 dependencies = [
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 2.0.48",
 ]
@@ -6631,7 +6633,7 @@ version = "1.0.56"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fa0faa943b50f3db30a20aa7e265dbc66076993efed8463e8de414e5d06d3471"
 dependencies = [
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 2.0.48",
 ]
@@ -6814,7 +6816,7 @@ version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5b8a1e28f2deaa14e508979454cb3a223b10b938b45af148bc0986de36f1923b"
 dependencies = [
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 2.0.48",
 ]
@@ -6923,7 +6925,7 @@ version = "0.19.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
 dependencies = [
- "indexmap 2.1.0",
+ "indexmap 2.2.1",
  "toml_datetime",
  "winnow",
 ]
@@ -6934,7 +6936,7 @@ version = "0.20.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "70f427fce4d84c72b5b732388bf4a9f4531b53f74e2887e3ecb2481f68f66d81"
 dependencies = [
- "indexmap 2.1.0",
+ "indexmap 2.2.1",
  "toml_datetime",
  "winnow",
 ]
@@ -6956,7 +6958,7 @@ version = "0.1.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
 dependencies = [
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 2.0.48",
 ]
@@ -7004,7 +7006,7 @@ dependencies = [
  "once_cell",
  "regex",
  "sharded-slab",
- "smallvec 1.12.0",
+ "smallvec 1.13.1",
  "thread_local",
  "tracing",
  "tracing-core",
@@ -7201,9 +7203,9 @@ dependencies = [
 
 [[package]]
 name = "uuid"
-version = "1.6.1"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e395fcf16a7a3d8127ec99782007af141946b4795001f876d54fb0d55978560"
+checksum = "f00cc9702ca12d3c81455259621e676d0f7251cec66a21e98fe2e9a37db93b2a"
 dependencies = [
  "getrandom 0.2.12",
  "serde",
@@ -7256,7 +7258,7 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d257817081c7dffcdbab24b9e62d2def62e2ff7d00b1c20062551e6cccc145ff"
 dependencies = [
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
 ]
 
@@ -7324,7 +7326,7 @@ dependencies = [
  "bumpalo",
  "log",
  "once_cell",
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 2.0.48",
  "wasm-bindgen-shared",
@@ -7358,7 +7360,7 @@ version = "0.2.90"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bae1abb6806dc1ad9e560ed242107c0f6c84335f1749dd4e8ddb012ebd5e25a7"
 dependencies = [
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 2.0.48",
  "wasm-bindgen-backend",
@@ -7395,7 +7397,7 @@ checksum = "8691f134d584a33a6606d9d717b95c4fa20065605f798a3f350d78dced02a902"
 dependencies = [
  "nix 0.24.3",
  "once_cell",
- "smallvec 1.12.0",
+ "smallvec 1.13.1",
  "wayland-sys",
 ]
 
@@ -7428,7 +7430,7 @@ version = "0.29.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8f4303d8fa22ab852f789e75a967f0a2cdc430a607751c0499bada3e451cbd53"
 dependencies = [
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "xml-rs",
 ]
@@ -7446,9 +7448,9 @@ dependencies = [
 
 [[package]]
 name = "web-sys"
-version = "0.3.64"
+version = "0.3.67"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b85cbef8c220a6abc02aefd892dfc0fc23afb1c6a426316ec33253a3877249b"
+checksum = "58cd2333b6e0be7a39605f0e255892fd7418a682d8da8fe042fe25128794d2ed"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -7456,15 +7458,15 @@ dependencies = [
 
 [[package]]
 name = "weezl"
-version = "0.1.7"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9193164d4de03a926d909d3bc7c30543cecb35400c02114792c2cae20d5e2dbb"
+checksum = "53a85b86a771b1c87058196170769dd264f66c0782acf1ae6cc51bfd64b39082"
 
 [[package]]
 name = "wgpu"
-version = "0.17.1"
+version = "0.17.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed547920565c56c7a29afb4538ac5ae5048865a5d2f05bff3ad4fbeb921a9a2c"
+checksum = "752e44d3998ef35f71830dd1ad3da513e628e2e4d4aedb0ab580f850827a0b41"
 dependencies = [
  "arrayvec 0.7.4",
  "cfg-if 1.0.0",
@@ -7475,7 +7477,7 @@ dependencies = [
  "profiling",
  "raw-window-handle",
  "serde",
- "smallvec 1.12.0",
+ "smallvec 1.13.1",
  "static_assertions",
  "wasm-bindgen",
  "wasm-bindgen-futures",
@@ -7503,7 +7505,7 @@ dependencies = [
  "ron",
  "rustc-hash",
  "serde",
- "smallvec 1.12.0",
+ "smallvec 1.13.1",
  "thiserror",
  "web-sys",
  "wgpu-hal",
@@ -7543,7 +7545,7 @@ dependencies = [
  "raw-window-handle",
  "renderdoc-sys",
  "rustc-hash",
- "smallvec 1.12.0",
+ "smallvec 1.13.1",
  "thiserror",
  "wasm-bindgen",
  "web-sys",
@@ -7687,7 +7689,7 @@ version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5e2ee588991b9e7e6c8338edf3333fbe4da35dc72092643958ebb43f0ab2c49c"
 dependencies = [
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 1.0.109",
 ]
@@ -7698,7 +7700,7 @@ version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6fb8df20c9bcaa8ad6ab513f7b40104840c8867d5751126e4df3b08388d0cc7"
 dependencies = [
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 1.0.109",
 ]
@@ -7938,9 +7940,9 @@ dependencies = [
 
 [[package]]
 name = "winnow"
-version = "0.5.34"
+version = "0.5.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7cf47b659b318dccbd69cc4797a39ae128f533dce7902a1096044d1967b9c16"
+checksum = "818ce546a11a9986bc24f93d0cdf38a8a1a400f1473ea8c82e59f6e0ffab9249"
 dependencies = [
  "memchr",
 ]
@@ -8024,7 +8026,7 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d498dbd1fd7beb83c86709ae1c33ca50942889473473d287d56ce4770a18edfb"
 dependencies = [
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "syn 1.0.109",
  "synstructure",
 ]
@@ -8035,7 +8037,7 @@ version = "0.7.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6"
 dependencies = [
- "proc-macro2 1.0.76",
+ "proc-macro2 1.0.78",
  "quote 1.0.35",
  "syn 2.0.48",
 ]
diff --git a/bevy_nannou/assets/images/nannou.png b/bevy_nannou/assets/images/nannou.png
new file mode 100644
index 000000000..20bf502fb
Binary files /dev/null and b/bevy_nannou/assets/images/nannou.png differ
diff --git a/bevy_nannou/src/lib.rs b/bevy_nannou/src/lib.rs
index 1d0232049..482548264 100644
--- a/bevy_nannou/src/lib.rs
+++ b/bevy_nannou/src/lib.rs
@@ -1,6 +1,6 @@
 use bevy::prelude::*;
 
-struct NannouPlugin;
+pub struct NannouPlugin;
 
 impl Plugin for NannouPlugin {
     fn build(&self, app: &mut App) {
@@ -10,15 +10,3 @@ impl Plugin for NannouPlugin {
         ));
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use bevy::app::App;
-
-    #[test]
-    fn it_works() {
-        let mut app = App::new();
-        app.add_plugins(super::NannouPlugin);
-        app.update();
-    }
-}
diff --git a/bevy_nannou/src/main.rs b/bevy_nannou/src/main.rs
new file mode 100644
index 000000000..73dac8049
--- /dev/null
+++ b/bevy_nannou/src/main.rs
@@ -0,0 +1,88 @@
+use bevy::core_pipeline::clear_color::ClearColorConfig;
+use bevy::prelude::shape::Torus;
+use bevy::prelude::*;
+use bevy_nannou::NannouPlugin;
+use bevy_nannou_draw::color::{RED, SALMON, SEAGREEN, SEASHELL, SKYBLUE};
+
+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(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: false,
+                ..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),
+            projection: OrthographicProjection {
+                scale: 1.0,
+                ..Default::default()
+            }
+            .into(),
+            ..Default::default()
+        }),
+    );
+
+    let handle = assets.load("images/nannou.png");
+    commands.insert_resource(MyTexture(handle));
+}
+
+fn update_mesh(mut handles: Query<(&Handle<Mesh>, &mut Transform)>) {
+    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(SALMON);
+    draw.ellipse()
+        .x(100.0 + time.elapsed().as_millis() as f32 / 100.0)
+        .w_h(100.0, 100.0)
+        .color(SEASHELL);
+    draw.ellipse().x(-100.0).w_h(100.0, 100.0).color(SKYBLUE);
+}
diff --git a/bevy_nannou_draw/Cargo.toml b/bevy_nannou_draw/Cargo.toml
index d2853ab1e..c7598ca38 100644
--- a/bevy_nannou_draw/Cargo.toml
+++ b/bevy_nannou_draw/Cargo.toml
@@ -4,4 +4,9 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-bevy = { workspace = true }
\ No newline at end of file
+bevy = { workspace = true }
+lyon = "0.17"
+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
diff --git a/bevy_nannou_draw/src/draw/background.rs b/bevy_nannou_draw/src/draw/background.rs
new file mode 100644
index 000000000..99c1f3de6
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/background.rs
@@ -0,0 +1,96 @@
+use crate::draw::properties::ColorScalar;
+use crate::draw::Draw;
+use nannou_core::color::{self, IntoLinSrgba, Srgb, Srgba};
+
+/// 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_write() {
+            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/bevy_nannou_draw/src/draw/drawing.rs b/bevy_nannou_draw/src/draw/drawing.rs
new file mode 100644
index 000000000..c273f5a4d
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/drawing.rs
@@ -0,0 +1,710 @@
+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 bevy::prelude::*;
+use lyon::path::PathEvent;
+use lyon::tessellation::{FillOptions, LineCap, LineJoin, StrokeOptions};
+use nannou_core::color::IntoLinSrgba;
+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<(Vec2, Color)>,
+    /// A re-usable buffer for collecting textured polyline points.
+    pub path_points_textured_buffer: &'a mut Vec<(Vec2, 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_write() {
+            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_write() {
+            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_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 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: Vec2) -> Self {
+        self.map_ty(|ty| SetPosition::xy(ty, p))
+    }
+
+    /// Set the **Position** with some three-dimensional point.
+    pub fn xyz(self, p: Vec3) -> 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: Vec3) -> 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/bevy_nannou_draw/src/draw/mesh/builder.rs b/bevy_nannou_draw/src/draw/mesh/builder.rs
new file mode 100644
index 000000000..8e3233548
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/mesh/builder.rs
@@ -0,0 +1,233 @@
+//! 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 lyon::tessellation::{FillVertex, GeometryBuilderError, StrokeVertex, VertexId};
+use lyon::tessellation::geometry_builder::{
+    self, FillGeometryBuilder, GeometryBuilder, StrokeGeometryBuilder,
+};
+use lyon::tessellation::{FillVertex, GeometryBuilderError, StrokeVertex, VertexId};
+
+use bevy::prelude::*;
+use nannou_mesh::{Indices, Points, PushIndex, PushVertex};
+
+pub struct MeshBuilder<'a, A> {
+    /// The mesh that is to be extended.
+    mesh: &'a mut crate::draw::mesh::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(crate::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 crate::draw::mesh::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 crate::draw::mesh::Mesh,
+        transform: Mat4,
+        color: crate::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 crate::draw::mesh::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 crate::draw::mesh::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 = Vec2::new(position.x, position.y).extend(0.0);
+        let point = self.transform.transform_point3(p);
+        let SingleColor(color) = self.attributes;
+        let tex_coords = crate::draw::mesh::vertex::default_tex_coords();
+        let vertex = crate::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 = Vec2::new(position.x, position.y).extend(0.0);
+        let point = self.transform.transform_point3(p);
+        let SingleColor(color) = self.attributes;
+        let tex_coords = crate::draw::mesh::vertex::default_tex_coords();
+        let vertex = crate::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 = Vec2::new(position.x, position.y).extend(0.0);
+        let point = self.transform.transform_point3(p);
+        let col = vertex.interpolated_attributes();
+        let color: crate::draw::mesh::vertex::Color = (col[0], col[1], col[2], col[3]).into();
+        let tex_coords = crate::draw::mesh::vertex::default_tex_coords();
+        let vertex = crate::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 = Vec2::new(position.x, position.y).extend(0.0);
+        let point = self.transform.transform_point3(p);
+        let col = vertex.interpolated_attributes();
+        let color: crate::draw::mesh::vertex::Color = (col[0], col[1], col[2], col[3]).into();
+        let tex_coords = crate::draw::mesh::vertex::default_tex_coords();
+        let vertex = crate::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 = Vec2::new(position.x, position.y).extend(0.0);
+        let point = self.transform.transform_point3(p);
+        let tc = vertex.interpolated_attributes();
+        let tex_coords: crate::draw::mesh::vertex::TexCoords = (tc[0], tc[1]).into();
+        let color = crate::draw::mesh::vertex::DEFAULT_VERTEX_COLOR;
+        let vertex = crate::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 = Vec2::new(position.x, position.y).extend(0.0);
+        let point = self.transform.transform_point3(p);
+        let tc = vertex.interpolated_attributes();
+        let tex_coords: crate::draw::mesh::vertex::TexCoords = (tc[0], tc[1]).into();
+        let color = crate::draw::mesh::vertex::DEFAULT_VERTEX_COLOR;
+        let vertex = crate::draw::mesh::vertex::new(point, color, tex_coords);
+        self.mesh.push_vertex(vertex);
+
+        // 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
new file mode 100644
index 000000000..a8d71d4f8
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/mesh/mod.rs
@@ -0,0 +1,281 @@
+//! Items related to the custom mesh type used by the `Draw` API.
+
+use bevy::prelude::*;
+use bevy::render::extract_component::ExtractComponent;
+use nannou_mesh as mesh;
+use nannou_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 = Vec2;
+    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/bevy_nannou_draw/src/draw/mesh/vertex.rs b/bevy_nannou_draw/src/draw/mesh/vertex.rs
new file mode 100644
index 000000000..add835ba6
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/mesh/vertex.rs
@@ -0,0 +1,177 @@
+use bevy::prelude::*;
+use nannou_core::color;
+use nannou_mesh::vertex::{WithColor, WithTexCoords};
+
+pub type Point = Vec3;
+pub type Color = color::LinSrgba;
+pub type TexCoords = Vec2;
+pub type Normal = Vec3;
+pub type ColoredPoint = WithColor<Point, Color>;
+pub type ColoredVec2 = WithColor<Vec2, 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 IterFromVec2s<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 = Vec3>,
+    {
+        let points = points.into_iter();
+        IterFromPoints {
+            points,
+            default_color,
+        }
+    }
+}
+
+impl<I> IterFromVec2s<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 = Vec2>,
+        I: Iterator<Item = Vec2>,
+    {
+        let points = points.into_iter();
+        IterFromVec2s {
+            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 IterFromVec2s<I>
+where
+    I: Iterator<Item = Vec2>,
+{
+    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/bevy_nannou_draw/src/draw/mod.rs b/bevy_nannou_draw/src/draw/mod.rs
new file mode 100644
index 000000000..a8e35f51b
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/mod.rs
@@ -0,0 +1,677 @@
+//! A simple API for drawing 2D and 3D graphics.
+//!
+//! See the [**Draw** type](./struct.Draw.html) for more details.
+
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::mem;
+use std::rc::Rc;
+use std::sync::{Arc, RwLock};
+
+use bevy::prelude::*;
+use bevy::render::render_resource as wgpu;
+use lyon::path::PathEvent;
+use nannou_core::geom;
+use nannou_mesh::Clear;
+
+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::theme::Theme;
+
+pub mod background;
+mod drawing;
+pub mod mesh;
+pub mod primitive;
+pub mod properties;
+pub 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
+/// 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.
+    pub state: Arc<RwLock<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,
+}
+
+/// 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`.
+    pub intermediary_state: Arc<RwLock<IntermediaryState>>,
+    /// The theme containing default values.
+    pub 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.
+    pub intermediary_mesh: crate::draw::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, TexCoords)>,
+    /// A buffer containing all text.
+    pub 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
+            .write()
+            .expect("lock poisoned")
+            .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.write().expect("lock poisoned").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::new(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::new(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::new(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::new(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::new(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::new(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::new(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::new(
+            v.x.to_radians(),
+            v.y.to_radians(),
+            v.z.to_radians(),
+        ))
+    }
+
+    /// Specify the orientation around the *x* axis in degrees.
+    pub fn x_degrees(&self, x: f32) -> Self {
+        self.x_radians(x.to_radians())
+    }
+
+    /// Specify the orientation around the *y* axis in degrees.
+    pub fn y_degrees(&self, y: f32) -> Self {
+        self.y_radians(y.to_radians())
+    }
+
+    /// Specify the orientation around the *z* axis in degrees.
+    pub fn z_degrees(&self, z: f32) -> Self {
+        self.z_radians(z.to_radians())
+    }
+
+    /// Specify the orientation along each axis with the given **Vector** of degrees.
+    pub fn turns(&self, v: Vec3) -> Self {
+        self.radians(v * std::f32::consts::TAU)
+    }
+
+    /// 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(x * std::f32::consts::TAU)
+    }
+
+    /// 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(y * std::f32::consts::TAU)
+    }
+
+    /// 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(z * std::f32::consts::TAU)
+    }
+
+    /// 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.write().expect("lock poisoned");
+            // 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.read().expect("lock poisoned");
+            let mut intermediary_state = state.intermediary_state.write().expect("lock poisoned");
+            let ctxt = DrawingContext::from_intermediary_state(&mut *intermediary_state);
+            primitive::text::Text::new(ctxt, s)
+        };
+        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 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
+            .write()
+            .expect("lock poisoned")
+            .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 = Arc::new(RwLock::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: 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,
+        }
+    }
+}
diff --git a/bevy_nannou_draw/src/draw/primitive/arrow.rs b/bevy_nannou_draw/src/draw/primitive/arrow.rs
new file mode 100644
index 000000000..d4d56273c
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/primitive/arrow.rs
@@ -0,0 +1,262 @@
+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 bevy::prelude::*;
+use lyon::tessellation::StrokeOptions;
+use nannou_core::color::LinSrgba;
+
+/// 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: Vec2) -> Self {
+        self.map_line(|l| l.start(start))
+    }
+
+    /// Specify the end point of the arrow.
+    pub fn end(self, end: Vec2) -> Self {
+        self.map_line(|l| l.end(end))
+    }
+
+    /// Specify the start and end points of the arrow.
+    pub fn points(self, start: Vec2, end: Vec2) -> 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: Vec2) -> Self {
+        self.map_ty(|ty| ty.start(start))
+    }
+
+    /// Specify the end point of the arrow.
+    pub fn end(self, end: Vec2) -> Self {
+        self.map_ty(|ty| ty.end(end))
+    }
+
+    /// Specify the start and end points of the arrow.
+    pub fn points(self, start: Vec2, end: Vec2) -> 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::render::RenderPrimitive for Arrow {
+    fn render_primitive(
+        self,
+        mut ctxt: draw::render::RenderContext,
+        mesh: &mut draw::Mesh,
+    ) -> draw::render::PrimitiveRender {
+        let Arrow {
+            line,
+            head_length,
+            head_width,
+        } = self;
+        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();
+        }
+
+        // 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::new(-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::render::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/bevy_nannou_draw/src/draw/primitive/ellipse.rs b/bevy_nannou_draw/src/draw/primitive/ellipse.rs
new file mode 100644
index 000000000..7dbd70901
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/primitive/ellipse.rs
@@ -0,0 +1,188 @@
+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 bevy::prelude::*;
+use lyon::tessellation::StrokeOptions;
+use nannou_core::color::conv::IntoLinSrgba;
+use nannou_core::geom;
+
+/// 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::render::RenderPrimitive for Ellipse {
+    fn render_primitive(
+        self,
+        ctxt: draw::render::RenderContext,
+        mesh: &mut draw::Mesh,
+    ) -> draw::render::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::render::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/bevy_nannou_draw/src/draw/primitive/line.rs b/bevy_nannou_draw/src/draw/primitive/line.rs
new file mode 100644
index 000000000..5f0ada968
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/primitive/line.rs
@@ -0,0 +1,165 @@
+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 bevy::prelude::*;
+use lyon::tessellation::StrokeOptions;
+use nannou_core::color::LinSrgba;
+
+/// 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<Vec2>,
+    pub end: Option<Vec2>,
+}
+
+/// 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: Vec2) -> Self {
+        self.start = Some(start);
+        self
+    }
+
+    /// Specify the end point of the line.
+    pub fn end(mut self, end: Vec2) -> Self {
+        self.end = Some(end);
+        self
+    }
+
+    /// Specify the start and end points of the line.
+    pub fn points(self, start: Vec2, end: Vec2) -> 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: Vec2) -> Self {
+        self.map_ty(|ty| ty.start(start))
+    }
+
+    /// Specify the end point of the line.
+    pub fn end(self, end: Vec2) -> Self {
+        self.map_ty(|ty| ty.end(end))
+    }
+
+    /// Specify the start and end points of the line.
+    pub fn points(self, start: Vec2, end: Vec2) -> 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::render::RenderPrimitive for Line {
+    fn render_primitive(
+        self,
+        mut ctxt: draw::render::RenderContext,
+        mesh: &mut draw::Mesh,
+    ) -> draw::render::PrimitiveRender {
+        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();
+        }
+        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::render::PrimitiveRender::default()
+    }
+}
diff --git a/bevy_nannou_draw/src/draw/primitive/mesh.rs b/bevy_nannou_draw/src/draw/primitive/mesh.rs
new file mode 100644
index 000000000..1cedc5b53
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/primitive/mesh.rs
@@ -0,0 +1,613 @@
+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 bevy::prelude::*;
+use nannou_core::color::conv::IntoLinSrgba;
+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;
+
+/// 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::render::VertexMode,
+    fill_color: Option<FillColor>,
+    texture_handle: Option<Handle<Image>>,
+}
+
+#[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<Vec3>` and `tex_coords` may be of any type that implements
+    /// `Into<Vec2>`.
+    pub fn points_textured<I, P, T>(
+        self,
+        inner_mesh: &mut draw::Mesh,
+        texture_handle: Handle<Image>,
+        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::render::VertexMode::Texture;
+        self.points_inner(inner_mesh, points, vertex_mode, Some(texture_handle))
+    }
+
+    /// 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<Vec3>` 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::render::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 `Vec3`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::render::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::render::VertexMode,
+        texture_handle: Option<Handle<Image>>,
+    ) -> 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_handle)
+    }
+
+    /// 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<Vec3>` and `tex_coords` may be of any type that implements
+    /// `Into<Vec2>`.
+    pub fn tris_textured<I, P, T>(
+        self,
+        inner_mesh: &mut draw::Mesh,
+        texture_handle: Handle<Image>,
+        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_handle, 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<Vec3>`
+    /// 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
+    /// `Vec3`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<Vec3>` and `tex_coords` may be of any type that implements
+    /// `Into<Vec2>`.
+    pub fn indexed_textured<V, I, P, T>(
+        self,
+        inner_mesh: &mut draw::Mesh,
+        texture_handle: Handle<Image>,
+        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::render::VertexMode::Texture;
+        self.indexed_inner(
+            inner_mesh,
+            vertices,
+            indices,
+            vertex_mode,
+            Some(texture_handle),
+        )
+    }
+
+    /// 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<Vec3>` 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::render::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 `Vec3` 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::render::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::render::VertexMode,
+        texture_handle: Option<Handle<Image>>,
+    ) -> 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_handle)
+    }
+}
+
+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::render::VertexMode,
+        texture_handle: Option<Handle<Image>>,
+    ) -> 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_handle: texture_handle,
+        }
+    }
+}
+
+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 `Vec3`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<Vec3>` 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<Vec3>` and `tex_coords` may be of any type that implements
+    /// `Into<Vec2>`.
+    pub fn points_textured<I, P, T>(
+        self,
+        texture_handle: Handle<Image>,
+        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, texture_handle, points))
+    }
+
+    /// Describe the mesh with a sequence of triangles.
+    ///
+    /// Each triangle may be composed of any vertex type that may be converted directly into
+    /// `Vec3`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<Vec3>`
+    /// 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<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>
+    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, texture_handle, 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 `Vec3` 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<Vec3>` 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<Vec3>` and `tex_coords` may be of any type that implements
+    /// `Into<Vec2>`.
+    pub fn indexed_textured<V, I, P, T>(
+        self,
+        texture_handle: Handle<Image>,
+        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, texture_handle, points, indices)
+        })
+    }
+}
+
+impl draw::render::RenderPrimitive for Mesh {
+    fn render_primitive(
+        self,
+        ctxt: draw::render::RenderContext,
+        mesh: &mut draw::Mesh,
+    ) -> draw::render::PrimitiveRender {
+        let Mesh {
+            orientation,
+            position,
+            vertex_range,
+            index_range,
+            vertex_mode,
+            fill_color,
+            texture_handle: texture_handle,
+        } = 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: Vec3| -> Vec3 { 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::render::PrimitiveRender {
+            texture_handle,
+            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/bevy_nannou_draw/src/draw/primitive/mod.rs b/bevy_nannou_draw/src/draw/primitive/mod.rs
new file mode 100644
index 000000000..60272a10f
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/primitive/mod.rs
@@ -0,0 +1,48 @@
+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/bevy_nannou_draw/src/draw/primitive/path.rs b/bevy_nannou_draw/src/draw/primitive/path.rs
new file mode 100644
index 000000000..1fb446bab
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/primitive/path.rs
@@ -0,0 +1,923 @@
+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 bevy::prelude::*;
+use lyon::path::PathEvent;
+use lyon::tessellation::{FillOptions, FillTessellator, StrokeOptions, StrokeTessellator};
+use nannou_core::color::conv::IntoLinSrgba;
+use nannou_core::color::LinSrgba;
+
+/// 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 = (Vec2, Color)>,
+        close: bool,
+    },
+    TexturedPoints {
+        points: &'a mut dyn Iterator<Item = (Vec2, 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::render::VertexMode,
+    texture_handle: Option<Handle<Image>>,
+}
+
+/// 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::render::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<Vec2>,
+    {
+        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<Vec2>,
+    {
+        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<Vec2>,
+        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<Vec2>,
+        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_handle: Handle<Image>,
+        points: I,
+    ) -> Path
+    where
+        I: IntoIterator<Item = (P, TC)>,
+        P: Into<Vec2>,
+        TC: Into<TexCoords>,
+    {
+        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<TexCoords>,
+    {
+        self.points_textured_inner(ctxt, texture_handle, 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<Vec2>,
+    {
+        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<Vec2>,
+        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::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<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::render::VertexMode::Texture,
+            Some(texture_handle),
+        )
+    }
+}
+
+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 = (Vec2, 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 = (Vec2, 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::render::RenderPrimitive for Path {
+    fn render_primitive(
+        self,
+        mut ctxt: draw::render::RenderContext,
+        mesh: &mut draw::Mesh,
+    ) -> draw::render::PrimitiveRender {
+        let Path {
+            color,
+            position,
+            orientation,
+            path_event_src,
+            options,
+            vertex_mode,
+            texture_handle,
+        } = 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::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>
+where
+    I: IntoIterator<Item = (Vec2, 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 = (Vec2, 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::render::VertexMode,
+        texture_handle: Option<Handle<Image>>,
+    ) -> Self {
+        Path {
+            color,
+            orientation,
+            position,
+            path_event_src,
+            options,
+            vertex_mode,
+            texture_handle,
+        }
+    }
+}
+
+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<Vec2>,
+    {
+        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<Vec2>,
+    {
+        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<Vec2>,
+        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<Vec2>,
+        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,
+        texture_handle: Handle<Image>,
+        points: I,
+    ) -> DrawingPath<'a>
+    where
+        I: IntoIterator<Item = (P, TC)>,
+        P: Into<Vec2>,
+        TC: Into<TexCoords>,
+    {
+        self.map_ty_with_context(|ty, ctxt| ty.points_textured(ctxt, texture_handle, 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,
+        texture_handle: Handle<Image>,
+        points: I,
+    ) -> DrawingPath<'a>
+    where
+        I: IntoIterator<Item = (P, TC)>,
+        P: Into<Vec2>,
+        TC: Into<TexCoords>,
+    {
+        self.map_ty_with_context(|ty, ctxt| ty.points_textured_closed(ctxt, texture_handle, 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/bevy_nannou_draw/src/draw/primitive/polygon.rs b/bevy_nannou_draw/src/draw/primitive/polygon.rs
new file mode 100644
index 000000000..e8aaf68e3
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/primitive/polygon.rs
@@ -0,0 +1,606 @@
+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 bevy::prelude::*;
+use lyon::path::PathEvent;
+use lyon::tessellation::StrokeOptions;
+use nannou_core::color::conv::IntoLinSrgba;
+
+/// 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_handle: Option<Handle<Image>>,
+}
+
+/// 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_handle: 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<Vec2>,
+    {
+        let points = points.into_iter().map(|p| {
+            let p: Vec2 = 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<Vec2>,
+        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_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<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_handle: Some(texture_handle),
+        }
+    }
+}
+
+pub fn render_events_themed<F, I>(
+    opts: PolygonOptions,
+    events: F,
+    mut ctxt: draw::render::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::render::RenderContext,
+    theme_primitive: &draw::theme::Primitive,
+    mesh: &mut draw::Mesh,
+) where
+    I: Clone + Iterator<Item = Vec2>,
+{
+    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::render::RenderContext,
+        mesh: &mut draw::Mesh,
+        theme_primitive: &draw::theme::Primitive,
+    ) -> draw::render::PrimitiveRender {
+        let Polygon {
+            path_event_src,
+            opts:
+                PolygonOptions {
+                    position,
+                    orientation,
+                    no_fill,
+                    stroke_color,
+                    color,
+                    stroke,
+                },
+            texture_handle,
+        } = self;
+        let draw::render::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_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 draw::Mesh,
+    ) -> draw::render::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<Vec2>,
+    {
+        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<Vec2>,
+        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,
+        texture_handle: Handle<Image>,
+        points: I,
+    ) -> DrawingPolygon<'a>
+    where
+        I: IntoIterator<Item = (P, T)>,
+        P: Into<Vec2>,
+        T: Into<TexCoords>,
+    {
+        self.map_ty_with_context(|ty, ctxt| ty.points_textured(ctxt, texture_handle, 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/bevy_nannou_draw/src/draw/primitive/quad.rs b/bevy_nannou_draw/src/draw/primitive/quad.rs
new file mode 100644
index 000000000..d1eb33c7f
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/primitive/quad.rs
@@ -0,0 +1,183 @@
+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 bevy::prelude::*;
+use lyon::tessellation::StrokeOptions;
+use nannou_core::color::conv::IntoLinSrgba;
+use nannou_core::geom;
+
+/// Properties related to drawing a **Quad**.
+#[derive(Clone, Debug)]
+pub struct Quad {
+    quad: geom::Quad<Vec2>,
+    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<Vec2>,
+    {
+        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::render::RenderPrimitive for Quad {
+    fn render_primitive(
+        self,
+        ctxt: draw::render::RenderContext,
+        mesh: &mut draw::Mesh,
+    ) -> draw::render::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::new(x_scale, y_scale);
+            let (a, b, c, d) = quad.into();
+            let translate = |v: Vec2| 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::render::PrimitiveRender::default()
+    }
+}
+
+impl From<geom::Quad<Vec2>> for Quad {
+    fn from(quad: geom::Quad<Vec2>) -> 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 = Vec2::new(left, bottom);
+        let b = Vec2::new(left, top);
+        let c = Vec2::new(right, top);
+        let d = Vec2::new(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<Vec2>,
+    {
+        self.map_ty(|ty| ty.points(a, b, c, d))
+    }
+}
diff --git a/bevy_nannou_draw/src/draw/primitive/rect.rs b/bevy_nannou_draw/src/draw/primitive/rect.rs
new file mode 100644
index 000000000..92e6b4338
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/primitive/rect.rs
@@ -0,0 +1,147 @@
+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 bevy::prelude::*;
+use lyon::tessellation::StrokeOptions;
+use nannou_core::color::conv::IntoLinSrgba;
+use nannou_core::geom;
+
+/// 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::render::RenderPrimitive for Rect {
+    fn render_primitive(
+        self,
+        ctxt: draw::render::RenderContext,
+        mesh: &mut draw::Mesh,
+    ) -> draw::render::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::render::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/bevy_nannou_draw/src/draw/primitive/text.rs b/bevy_nannou_draw/src/draw/primitive/text.rs
new file mode 100644
index 000000000..4474319ec
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/primitive/text.rs
@@ -0,0 +1,459 @@
+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::text::{self, Align, Font, FontSize, Justify, Layout, Scalar, Wrap};
+use bevy::prelude::*;
+use nannou_core::color::conv::IntoLinSrgba;
+use nannou_core::geom;
+
+/// 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::render::RenderPrimitive for Text {
+    fn render_primitive(
+        self,
+        ctxt: draw::render::RenderContext,
+        mesh: &mut draw::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_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::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]| -> 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::render::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/bevy_nannou_draw/src/draw/primitive/texture.rs b/bevy_nannou_draw/src/draw/primitive/texture.rs
new file mode 100644
index 000000000..899c0814d
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/primitive/texture.rs
@@ -0,0 +1,161 @@
+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 draw::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
new file mode 100644
index 000000000..b817a33ea
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/primitive/tri.rs
@@ -0,0 +1,184 @@
+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 bevy::prelude::*;
+use lyon::tessellation::StrokeOptions;
+use nannou_core::color::conv::IntoLinSrgba;
+use nannou_core::geom;
+
+/// Properties related to drawing a **Tri**.
+#[derive(Clone, Debug)]
+pub struct Tri {
+    tri: geom::Tri<Vec2>,
+    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<Vec2>,
+    {
+        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<Vec2>,
+    {
+        self.map_ty(|ty| ty.points(a, b, c))
+    }
+}
+
+// Trait implementations.
+
+impl draw::render::RenderPrimitive for Tri {
+    fn render_primitive(
+        self,
+        ctxt: draw::render::RenderContext,
+        mesh: &mut draw::Mesh,
+    ) -> draw::render::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::new(x_scale, y_scale);
+            let (a, b, c) = tri.into();
+            let translate = |v: Vec2| 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::render::PrimitiveRender::default()
+    }
+}
+
+impl From<geom::Tri<Vec2>> for Tri {
+    fn from(tri: geom::Tri<Vec2>) -> 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 = Vec2::new(-fifty, thirty_three);
+        let b = Vec2::new(fifty, 0.0);
+        let c = Vec2::new(-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/bevy_nannou_draw/src/draw/properties/color.rs b/bevy_nannou_draw/src/draw/properties/color.rs
new file mode 100644
index 000000000..dea093690
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/properties/color.rs
@@ -0,0 +1,152 @@
+use nannou_core::color::{self, Component, IntoLinSrgba, LinSrgba};
+use 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/bevy_nannou_draw/src/draw/properties/fill.rs b/bevy_nannou_draw/src/draw/properties/fill.rs
new file mode 100644
index 000000000..090bf7222
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/properties/fill.rs
@@ -0,0 +1,56 @@
+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/bevy_nannou_draw/src/draw/properties/mod.rs b/bevy_nannou_draw/src/draw/properties/mod.rs
new file mode 100644
index 000000000..8aa8bcf9d
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/properties/mod.rs
@@ -0,0 +1,28 @@
+//! 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 = nannou_core::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/bevy_nannou_draw/src/draw/properties/spatial/dimension.rs b/bevy_nannou_draw/src/draw/properties/spatial/dimension.rs
new file mode 100644
index 000000000..a9486c5fe
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/properties/spatial/dimension.rs
@@ -0,0 +1,73 @@
+use bevy::prelude::*;
+/// 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/bevy_nannou_draw/src/draw/properties/spatial/mod.rs b/bevy_nannou_draw/src/draw/properties/spatial/mod.rs
new file mode 100644
index 000000000..d7aa8fa57
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/properties/spatial/mod.rs
@@ -0,0 +1,50 @@
+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/bevy_nannou_draw/src/draw/properties/spatial/orientation.rs b/bevy_nannou_draw/src/draw/properties/spatial/orientation.rs
new file mode 100644
index 000000000..7502bc8a0
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/properties/spatial/orientation.rs
@@ -0,0 +1,187 @@
+use bevy::prelude::*;
+
+/// 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(Vec3),
+    /// 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: Vec3) -> 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(x.to_radians())
+    }
+
+    /// Specify the orientation around the *y* axis as an absolute value in degrees.
+    fn y_degrees(self, y: f32) -> Self {
+        self.y_radians(y.to_radians())
+    }
+
+    /// Specify the orientation around the *z* axis as an absolute value in degrees.
+    fn z_degrees(self, z: f32) -> Self {
+        self.z_radians(z.to_radians())
+    }
+
+    /// 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(x * std::f32::consts::TAU)
+    }
+
+    /// 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(y * std::f32::consts::TAU)
+    }
+
+    /// 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(z * std::f32::consts::TAU)
+    }
+
+    /// 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/bevy_nannou_draw/src/draw/properties/spatial/position.rs b/bevy_nannou_draw/src/draw/properties/spatial/position.rs
new file mode 100644
index 000000000..0857ee29c
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/properties/spatial/position.rs
@@ -0,0 +1,71 @@
+//! Items related to describing positioning along each axis as
+use bevy::prelude::*;
+
+/// Position properties for **Drawing** a **Primitive**.
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub struct Properties {
+    pub point: Vec3,
+}
+
+/// 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: Vec2) -> Self {
+        self.x(p.x).y(p.y)
+    }
+
+    /// Set the **Position** with some three-dimensional point.
+    fn xyz(self, p: Vec3) -> 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 = Vec3::ZERO;
+        Self { point }
+    }
+}
diff --git a/bevy_nannou_draw/src/draw/properties/stroke.rs b/bevy_nannou_draw/src/draw/properties/stroke.rs
new file mode 100644
index 000000000..20009f67c
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/properties/stroke.rs
@@ -0,0 +1,158 @@
+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/bevy_nannou_draw/src/draw/render/mod.rs b/bevy_nannou_draw/src/draw/render/mod.rs
new file mode 100644
index 000000000..c53758076
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/render/mod.rs
@@ -0,0 +1,166 @@
+use crate::draw::mesh::vertex::{Color, TexCoords};
+use crate::{draw, text};
+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};
+
+/// 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_handle: Option<Handle<Image>>,
+    /// 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 [(Vec2, Color)],
+    pub path_points_textured_buffer: &'a [(Vec2, 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,
+}
+
+#[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 {
+    pub left: u32,
+    pub bottom: u32,
+    pub width: u32,
+    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 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_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
new file mode 100644
index 000000000..381e2b0a6
--- /dev/null
+++ b/bevy_nannou_draw/src/draw/theme.rs
@@ -0,0 +1,93 @@
+use nannou_core::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/bevy_nannou_draw/src/lib.rs b/bevy_nannou_draw/src/lib.rs
index dd91d0a20..7bcf14a06 100644
--- a/bevy_nannou_draw/src/lib.rs
+++ b/bevy_nannou_draw/src/lib.rs
@@ -1,7 +1,24 @@
 use bevy::prelude::*;
+use bevy::render::extract_component::ExtractComponent;
+
+pub use nannou_core::color;
+
+pub mod draw;
+pub mod text;
 
 pub struct NannouDrawPlugin;
 
 impl Plugin for NannouDrawPlugin {
-    fn build(&self, _app: &mut App) {}
+    fn build(&self, app: &mut App) {
+        app.add_systems(PreUpdate, spawn_draw);
+    }
 }
+
+fn spawn_draw(mut commands: Commands, query: Query<(Entity, &Camera), Added<Camera>>) {
+    for (entity, _camera) in query.iter() {
+        commands.entity(entity).insert(Draw(draw::Draw::new()));
+    }
+}
+
+#[derive(Component, Clone, Deref, DerefMut, ExtractComponent)]
+pub struct Draw(pub draw::Draw);
diff --git a/bevy_nannou_draw/src/text/cursor.rs b/bevy_nannou_draw/src/text/cursor.rs
new file mode 100644
index 000000000..b75b58b82
--- /dev/null
+++ b/bevy_nannou_draw/src/text/cursor.rs
@@ -0,0 +1,461 @@
+//! Logic related to the positioning of the cursor within text.
+
+use crate::text::{self, FontSize, Point, Scalar};
+use nannou_core::geom::{Range, Rect};
+
+/// 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/bevy_nannou_draw/src/text/font.rs b/bevy_nannou_draw/src/text/font.rs
new file mode 100644
index 000000000..f2c62fdcc
--- /dev/null
+++ b/bevy_nannou_draw/src/text/font.rs
@@ -0,0 +1,229 @@
+//! 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());
+    }
+
+    // TODO: load this via bevy's asset system
+    // 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/bevy_nannou_draw/src/text/glyph.rs b/bevy_nannou_draw/src/text/glyph.rs
new file mode 100644
index 000000000..d531476b1
--- /dev/null
+++ b/bevy_nannou_draw/src/text/glyph.rs
@@ -0,0 +1,344 @@
+//! Logic and types specific to individual glyph layout.
+
+use crate::text::{self, FontSize, Scalar, ScaledGlyph};
+use nannou_core::geom::{Range, Rect};
+
+/// 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/bevy_nannou_draw/src/text/layout.rs b/bevy_nannou_draw/src/text/layout.rs
new file mode 100644
index 000000000..785064d58
--- /dev/null
+++ b/bevy_nannou_draw/src/text/layout.rs
@@ -0,0 +1,159 @@
+//! 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/bevy_nannou_draw/src/text/line.rs b/bevy_nannou_draw/src/text/line.rs
new file mode 100644
index 000000000..697c241dc
--- /dev/null
+++ b/bevy_nannou_draw/src/text/line.rs
@@ -0,0 +1,807 @@
+//! Text handling logic related to individual lines of text.
+//!
+//! This module is the core of multi-line text handling.
+
+use crate::text::{self, FontSize, Scalar, Wrap};
+use nannou_core::geom::{Range, Rect};
+
+/// 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/bevy_nannou_draw/src/text/mod.rs b/bevy_nannou_draw/src/text/mod.rs
new file mode 100644
index 000000000..59a8520d8
--- /dev/null
+++ b/bevy_nannou_draw/src/text/mod.rs
@@ -0,0 +1,680 @@
+//! 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 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.
+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 = nannou_core::geom::scalar::Default;
+
+/// The point type used when working with text.
+pub type Point = nannou_core::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 = nannou_core::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,
+        //     }
+        todo!()
+    }
+}
+
+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/bevy_nannou_render/Cargo.toml b/bevy_nannou_render/Cargo.toml
index ddc52fbc0..eea5aa563 100644
--- a/bevy_nannou_render/Cargo.toml
+++ b/bevy_nannou_render/Cargo.toml
@@ -5,3 +5,8 @@ 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
index bf04d53a1..5cbfc111e 100644
--- a/bevy_nannou_render/src/lib.rs
+++ b/bevy_nannou_render/src/lib.rs
@@ -1,7 +1,479 @@
+use std::collections::HashMap;
+use std::ops::Deref;
+
+use bevy::asset::load_internal_asset;
+use bevy::core_pipeline::core_3d;
+use bevy::core_pipeline::core_3d::CORE_3D;
 use bevy::prelude::*;
+use bevy::render::camera::{ExtractedCamera, NormalizedRenderTarget};
+use bevy::render::extract_component::{ExtractComponent, ExtractComponentPlugin};
+use bevy::render::extract_resource::{ExtractResource, ExtractResourcePlugin};
+use bevy::render::render_asset::{RenderAsset, RenderAssets};
+use bevy::render::render_graph::{RenderGraphApp, ViewNode, ViewNodeRunner};
+use bevy::render::render_resource::{
+    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, RenderSet};
+use bevy::render::{Render, RenderApp};
+use lyon::lyon_tessellation::{FillTessellator, StrokeTessellator};
+
+use bevy_nannou_draw::draw::render::{GlyphCache, RenderContext, RenderPrimitive, Scissor};
+use bevy_nannou_draw::{draw, Draw};
+use nannou_core::geom;
+use nannou_core::math::map_range;
+
+use crate::pipeline::{NannouPipeline, NannouPipelineKey, NannouViewNode, TextureBindGroupCache};
+
+mod pipeline;
 
 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) {}
+    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_systems(Update, texture_event_handler)
+            .add_plugins((
+                ExtractComponentPlugin::<Draw>::default(),
+                ExtractComponentPlugin::<NannouTextureHandle>::default(),
+            ))
+            .add_plugins(ExtractResourcePlugin::<DefaultTextureHandle>::default());
+
+        app.get_sub_app_mut(RenderApp)
+            .unwrap()
+            // TODO: how are these parameters defined? should they be configurable?
+            .insert_resource(GlyphCache::new([1024; 2], 0.1, 0.1))
+            .init_resource::<SpecializedRenderPipelines<NannouPipeline>>()
+            .init_resource::<TextureBindGroupCache>()
+            .add_systems(
+                Render,
+                (
+                    prepare_default_texture_bind_group.in_set(RenderSet::PrepareBindGroups),
+                    prepare_texture_bind_groups.in_set(RenderSet::PrepareBindGroups),
+                    prepare_view_mesh
+                        .after(prepare_default_texture_bind_group)
+                        .in_set(RenderSet::Prepare),
+                    prepare_view_uniform.in_set(RenderSet::PrepareBindGroups),
+                ),
+            )
+            // Register the NannouViewNode with the render graph
+            // The node runs at the last stage of the main 3d pass
+            .add_render_graph_node::<ViewNodeRunner<NannouViewNode>>(
+                core_3d::graph::NAME,
+                NannouViewNode::NAME,
+            )
+            .add_render_graph_edges(
+                CORE_3D,
+                &[
+                    core_3d::graph::node::MAIN_TRANSPARENT_PASS,
+                    NannouViewNode::NAME,
+                    core_3d::graph::node::END_MAIN_PASS,
+                ],
+            );
+    }
+
+    fn finish(&self, app: &mut App) {
+        let Ok(render_app) = app.get_sub_app_mut(RenderApp) else {
+            return;
+        };
+
+        render_app.init_resource::<NannouPipeline>();
+    }
 }
+
+#[derive(Resource, Deref, DerefMut, ExtractResource, Clone)]
+struct DefaultTextureHandle(Handle<Image>);
+
+#[derive(Component, Deref, DerefMut, ExtractComponent, Clone)]
+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));
+}
+
+fn prepare_default_texture_bind_group(
+    images: Res<RenderAssets<Image>>,
+    default_texture_handle: Res<DefaultTextureHandle>,
+    render_device: Res<RenderDevice>,
+    nannou_pipeline: Res<NannouPipeline>,
+    mut texture_bind_group_cache: ResMut<TextureBindGroupCache>,
+) {
+    let texture = images.get(&**default_texture_handle).unwrap();
+    let bind_group = NannouPipeline::create_texture_bind_group(
+        &render_device,
+        &nannou_pipeline.texture_bind_group_layout,
+        &texture.sampler,
+        &texture.texture_view,
+    );
+    texture_bind_group_cache.insert((**default_texture_handle).clone(), bind_group);
+}
+
+fn prepare_texture_bind_groups(
+    gpu_images: Res<RenderAssets<Image>>,
+    mut texture_bind_group_cache: ResMut<TextureBindGroupCache>,
+    render_device: Res<RenderDevice>,
+    nannou_textures: Query<&NannouTextureHandle>,
+) {
+    // TODO: maybe don't use components for this? we don't really
+    // need to run this on every frame, just when the textures change
+    for texture in nannou_textures.iter() {
+        if !texture_bind_group_cache.contains_key(&**texture) {
+            if let Some(gpu_image) = gpu_images.get(&**texture) {
+                let bind_group_layout = NannouPipeline::create_texture_bind_group_layout(
+                    &render_device,
+                    true,
+                    wgpu::TextureSampleType::Float { filterable: true },
+                );
+                let bind_group = NannouPipeline::create_texture_bind_group(
+                    &render_device,
+                    &bind_group_layout,
+                    &gpu_image.sampler,
+                    &gpu_image.texture_view,
+                );
+                texture_bind_group_cache.insert((**texture).clone(), bind_group);
+            }
+        }
+    }
+}
+
+// Prepare our mesh for rendering
+fn prepare_view_mesh(
+    mut commands: Commands,
+    mut pipeline: ResMut<NannouPipeline>,
+    mut glyph_cache: ResMut<GlyphCache>,
+    mut texture_bind_group_cache: ResMut<TextureBindGroupCache>,
+    mut pipelines: ResMut<SpecializedRenderPipelines<NannouPipeline>>,
+    windows: Res<ExtractedWindows>,
+    msaa: Res<Msaa>,
+    pipeline_cache: Res<PipelineCache>,
+    default_texture_handle: Res<DefaultTextureHandle>,
+    draw: Query<(
+        Entity,
+        &Draw,
+        &ExtractedView,
+        &ExtractedCamera,
+        &ViewDepthTexture,
+    )>,
+) {
+    for (entity, draw, view, camera, depth) in &draw {
+        let mut render_commands = ViewRenderCommands::default();
+        let mut mesh = ViewMesh::default();
+
+        // 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 window = if let Some(NormalizedRenderTarget::Window(window_ref)) = camera.target {
+            let window_entity = window_ref.entity();
+            if let Some(window) = windows.windows.get(&window_entity) {
+                window
+            } else {
+                continue;
+            }
+        } else {
+            // TODO: handle other render targets
+            // For now, we only support rendering to a window
+            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();
+        let mut curr_start_index = 0;
+        // Track whether new commands are required.
+        let mut curr_pipeline_id = None;
+        let mut curr_scissor = None;
+        let mut curr_texture_handle: Option<Handle<Image>> = None;
+
+        // 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 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 = mesh.indices().len() as u32;
+                    let prev_vert_count = 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 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 mesh);
+
+                    // If the mesh indices are unchanged, there's nothing to be drawn.
+                    if prev_index_count == mesh.indices().len() as u32 {
+                        assert_eq!(
+                            prev_vert_count,
+                            mesh.vertex_count(),
+                            "vertices were submitted during `render` without submitting indices",
+                        );
+                        continue;
+                    }
+
+                    let new_texture_handle = match render.texture_handle {
+                        Some(handle) => handle,
+                        None => {
+                            // If there is no texture, use the default texture.
+                            (**default_texture_handle).clone()
+                        }
+                    };
+
+                    let new_pipeline_key = {
+                        let topology = curr_ctxt.topology;
+                        NannouPipelineKey {
+                            output_color_format: if view.hdr {
+                                ViewTarget::TEXTURE_FORMAT_HDR
+                            } else {
+                                wgpu::TextureFormat::bevy_default()
+                            },
+                            sample_count: msaa.samples(),
+                            depth_format: depth.texture.format(),
+                            topology,
+                            blend_state: curr_ctxt.blend,
+                        }
+                    };
+
+                    let new_pipeline_id =
+                        pipelines.specialize(&pipeline_cache, &pipeline, new_pipeline_key);
+                    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 texture_changed = Some(new_texture_handle.clone()) != curr_texture_handle;
+                    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 || texture_changed {
+                        push_draw_cmd(
+                            &mut curr_start_index,
+                            prev_index_count,
+                            &mut render_commands,
+                        );
+                    }
+
+                    // If necessary, push a new pipeline command.
+                    if pipeline_changed {
+                        curr_pipeline_id = Some(new_pipeline_id);
+                        let cmd = RenderCommand::SetPipeline(new_pipeline_id);
+                        render_commands.push(cmd);
+                    }
+
+                    // If necessary, push a new bind group command.
+                    // Because the texture is loaded asynchronously, we need to check if the
+                    // bind group is already in the cache.
+                    if texture_changed && texture_bind_group_cache.contains_key(&new_texture_handle)
+                    {
+                        let cmd = RenderCommand::SetBindGroup(new_texture_handle.clone());
+                        render_commands.push(cmd);
+                    // If the texture is not in the cache and we haven't set a bind group yet,
+                    // we need to use the default texture. This happens when a user texture
+                    // is the first draw command.
+                    } else if curr_texture_handle.is_none() {
+                        curr_texture_handle = Some(new_texture_handle.clone());
+                        let cmd = RenderCommand::SetBindGroup((**default_texture_handle).clone());
+                        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);
+                        render_commands.push(cmd);
+                    }
+
+                    // Extend the vertex mode channel.
+                    let mode = render.vertex_mode;
+                    let new_vs = mesh
+                        .points()
+                        .len()
+                        .saturating_sub(pipeline.vertex_mode_buffer.len());
+                    pipeline
+                        .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,
+            mesh.indices().len() as u32,
+            &mut render_commands,
+        );
+        commands.entity(entity).insert((mesh, render_commands));
+    }
+}
+
+// Prepare our uniform bind group from Bevy's view uniforms
+fn prepare_view_uniform(
+    mut commands: Commands,
+    render_device: Res<RenderDevice>,
+    pipline: Res<NannouPipeline>,
+    view_uniforms: Res<ViewUniforms>,
+) {
+    if let Some(binding) = view_uniforms.uniforms.binding() {
+        commands.insert_resource(ViewUniformBindGroup::new(
+            &render_device,
+            &pipline.view_bind_group_layout,
+            binding,
+        ));
+    }
+}
+
+// Resource wrapper for our view uniform bind group
+#[derive(Resource)]
+struct ViewUniformBindGroup {
+    bind_group: wgpu::BindGroup,
+}
+
+impl ViewUniformBindGroup {
+    fn new(
+        device: &RenderDevice,
+        layout: &wgpu::BindGroupLayout,
+        binding: wgpu::BindingResource,
+    ) -> ViewUniformBindGroup {
+        let bind_group = bevy_nannou_wgpu::BindGroupBuilder::new()
+            .binding(binding)
+            .build(device, layout);
+
+        ViewUniformBindGroup { bind_group }
+    }
+}
+
+#[derive(Component, Deref, DerefMut, Default, Debug)]
+pub struct ViewMesh(draw::Mesh);
+
+/// Commands that map to wgpu encodable commands.
+#[derive(Debug, Clone)]
+pub enum RenderCommand {
+    /// Change pipeline for the new blend mode and topology.
+    SetPipeline(CachedRenderPipelineId),
+    /// Change bind group for a new image.
+    SetBindGroup(Handle<Image>),
+    /// Set the rectangular scissor.
+    SetScissor(Scissor),
+    /// Draw the given vertex range.
+    DrawIndexed {
+        start_vertex: i32,
+        index_range: std::ops::Range<u32>,
+    },
+}
+
+#[derive(Component, Deref, DerefMut, Default)]
+pub struct ViewRenderCommands(Vec<RenderCommand>);
diff --git a/bevy_nannou_render/src/pipeline.rs b/bevy_nannou_render/src/pipeline.rs
new file mode 100644
index 000000000..844e1c168
--- /dev/null
+++ b/bevy_nannou_render/src/pipeline.rs
@@ -0,0 +1,421 @@
+use std::collections::HashMap;
+use std::hash::Hash;
+use std::ops::Deref;
+
+use bevy::core::cast_slice;
+use bevy::ecs::query::QueryItem;
+use bevy::prelude::*;
+use bevy::render::render_graph::{NodeRunError, RenderGraphContext, ViewNode};
+use bevy::render::render_resource as wgpu;
+use bevy::render::render_resource::{
+    BufferInitDescriptor, LoadOp, Operations, PipelineCache, RenderPassDescriptor,
+    RenderPipelineDescriptor, SpecializedRenderPipeline,
+};
+use bevy::render::renderer::{RenderContext, RenderDevice};
+use bevy::render::view::{ViewDepthTexture, ViewTarget, ViewUniform, ViewUniformOffset};
+
+use bevy_nannou_draw::draw::mesh;
+use bevy_nannou_draw::draw::mesh::vertex::Point;
+use bevy_nannou_draw::draw::render::VertexMode;
+
+use crate::ViewMesh;
+use crate::{
+    RenderCommand, Scissor, ViewRenderCommands, ViewUniformBindGroup, NANNOU_SHADER_HANDLE,
+};
+
+#[derive(Resource)]
+pub struct NannouPipeline {
+    glyph_cache_texture: wgpu::Texture,
+    text_bind_group_layout: wgpu::BindGroupLayout,
+    text_bind_group: wgpu::BindGroup,
+    pub(crate) texture_bind_group_layout: wgpu::BindGroupLayout,
+    texture_bind_group: wgpu::BindGroup,
+    pub(crate) view_bind_group_layout: wgpu::BindGroupLayout,
+    view_bind_group: wgpu::BindGroup,
+    view_buffer: wgpu::Buffer,
+    pub(crate) vertex_mode_buffer: Vec<VertexMode>,
+}
+
+// This key is computed and used to cache the pipeline.
+#[derive(Eq, PartialEq, Hash, Clone, Copy, Debug)]
+pub struct NannouPipelineKey {
+    pub output_color_format: wgpu::TextureFormat,
+    pub sample_count: u32,
+    pub depth_format: wgpu::TextureFormat,
+    pub blend_state: wgpu::BlendState,
+    pub topology: wgpu::PrimitiveTopology,
+}
+
+impl NannouPipeline {
+    /// The default sample count
+    pub const DEFAULT_SAMPLE_COUNT: u32 = 1;
+    /// The default depth format
+    pub const DEFAULT_DEPTH_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Depth32Float;
+    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,
+    };
+    /// The default color blend state
+    pub const DEFAULT_BLEND_STATE: wgpu::BlendState = wgpu::BlendState {
+        color: Self::DEFAULT_COLOR_BLEND,
+        alpha: Self::DEFAULT_ALPHA_BLEND,
+    };
+    /// The default primitive topology
+    pub const DEFAULT_PRIMITIVE_TOPOLOGY: wgpu::PrimitiveTopology =
+        wgpu::PrimitiveTopology::TriangleList;
+    pub const GLYPH_CACHE_TEXTURE_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::R8Unorm;
+
+    fn render_pipeline(
+        &self,
+        color_format: wgpu::TextureFormat,
+        depth_format: wgpu::TextureFormat,
+        sample_count: u32,
+        blend_state: wgpu::BlendState,
+        topology: wgpu::PrimitiveTopology,
+    ) -> RenderPipelineDescriptor {
+        bevy_nannou_wgpu::RenderPipelineBuilder::from_layout(
+            &[
+                self.view_bind_group_layout.clone(),
+                self.text_bind_group_layout.clone(),
+                self.texture_bind_group_layout.clone(),
+            ],
+            NANNOU_SHADER_HANDLE,
+        )
+        .vertex_entry_point("vertex")
+        .fragment_shader(NANNOU_SHADER_HANDLE)
+        .fragment_entry_point("fragment")
+        .color_format(color_format)
+        .add_vertex_buffer::<Point>(&[wgpu::VertexAttribute {
+            format: wgpu::VertexFormat::Float32x3,
+            offset: 0,
+            shader_location: 0,
+        }])
+        .add_vertex_buffer::<mesh::vertex::Color>(&[wgpu::VertexAttribute {
+            format: wgpu::VertexFormat::Float32x4,
+            offset: 0,
+            shader_location: 1,
+        }])
+        .add_vertex_buffer::<mesh::vertex::TexCoords>(&[wgpu::VertexAttribute {
+            format: wgpu::VertexFormat::Float32x2,
+            offset: 0,
+            shader_location: 2,
+        }])
+        .add_vertex_buffer::<VertexMode>(&[wgpu::VertexAttribute {
+            format: wgpu::VertexFormat::Uint32,
+            offset: 0,
+            shader_location: 3,
+        }])
+        .depth_format(depth_format)
+        .sample_count(sample_count)
+        .color_blend(blend_state.color)
+        .alpha_blend(blend_state.alpha)
+        .primitive_topology(topology)
+        .build()
+    }
+
+    pub(crate) fn create_texture_bind_group_layout(
+        device: &RenderDevice,
+        filtering: bool,
+        texture_sample_type: wgpu::TextureSampleType,
+    ) -> wgpu::BindGroupLayout {
+        bevy_nannou_wgpu::BindGroupLayoutBuilder::new()
+            .sampler(wgpu::ShaderStages::FRAGMENT, filtering)
+            .texture(
+                wgpu::ShaderStages::FRAGMENT,
+                false,
+                wgpu::TextureViewDimension::D2,
+                texture_sample_type,
+            )
+            .build(device)
+    }
+
+    pub fn create_texture_bind_group(
+        device: &RenderDevice,
+        layout: &wgpu::BindGroupLayout,
+        sampler: &wgpu::Sampler,
+        texture_view: &wgpu::TextureView,
+    ) -> wgpu::BindGroup {
+        bevy_nannou_wgpu::BindGroupBuilder::new()
+            .sampler(sampler)
+            .texture_view(texture_view)
+            .build(device, layout)
+    }
+
+    fn create_text_bind_group_layout(
+        device: &RenderDevice,
+        filtering: bool,
+    ) -> wgpu::BindGroupLayout {
+        bevy_nannou_wgpu::BindGroupLayoutBuilder::new()
+            .sampler(wgpu::ShaderStages::FRAGMENT, filtering)
+            .texture(
+                wgpu::ShaderStages::FRAGMENT,
+                false,
+                wgpu::TextureViewDimension::D2,
+                wgpu::TextureFormat::R8Unorm
+                    .sample_type(None)
+                    .expect("Expected format to have sample type"),
+            )
+            .build(device)
+    }
+
+    fn create_text_bind_group(
+        device: &RenderDevice,
+        layout: &wgpu::BindGroupLayout,
+        sampler: &wgpu::Sampler,
+        glyph_cache_texture_view: &wgpu::TextureView,
+    ) -> wgpu::BindGroup {
+        bevy_nannou_wgpu::BindGroupBuilder::new()
+            .sampler(sampler)
+            .texture_view(glyph_cache_texture_view)
+            .build(device, layout)
+    }
+}
+
+impl SpecializedRenderPipeline for NannouPipeline {
+    type Key = NannouPipelineKey;
+
+    fn specialize(&self, key: Self::Key) -> RenderPipelineDescriptor {
+        self.render_pipeline(
+            key.output_color_format,
+            key.depth_format,
+            key.sample_count,
+            key.blend_state,
+            key.topology,
+        )
+    }
+}
+
+impl FromWorld for NannouPipeline {
+    fn from_world(render_world: &mut World) -> Self {
+        let device = render_world.get_resource::<RenderDevice>().unwrap();
+
+        // Create the glyph cache texture.
+        let text_sampler_desc = bevy_nannou_wgpu::SamplerBuilder::new().into_descriptor();
+        let text_sampler_filtering = bevy_nannou_wgpu::sampler_filtering(&text_sampler_desc);
+        let text_sampler = device.create_sampler(&text_sampler_desc);
+        let glyph_cache_texture = bevy_nannou_wgpu::TextureBuilder::new()
+            .size([1024; 2])
+            .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());
+
+        // The default texture for the case where the user has not specified one.
+        let default_texture = bevy_nannou_wgpu::TextureBuilder::new()
+            .size([64; 2])
+            .usage(wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST)
+            .build(device);
+
+        // Bind group for text.
+        let text_bind_group_layout =
+            Self::create_text_bind_group_layout(device, text_sampler_filtering);
+        let text_bind_group = Self::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 = bevy_nannou_wgpu::SamplerBuilder::new().into_descriptor();
+        let texture_sampler = device.create_sampler(&sampler_desc);
+
+        let texture_bind_group_layout = Self::create_texture_bind_group_layout(
+            device,
+            bevy_nannou_wgpu::sampler_filtering(&sampler_desc),
+            wgpu::TextureSampleType::Float { filterable: true },
+        );
+        let texture_bind_group = Self::create_texture_bind_group(
+            device,
+            &texture_bind_group_layout,
+            &texture_sampler,
+            &default_texture.create_view(&wgpu::TextureViewDescriptor::default()),
+        );
+
+        // Create the view bind group.
+        let usage = wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST;
+        let view_buffer = device.create_buffer(&wgpu::BufferDescriptor {
+            label: Some("nannou Renderer uniform_buffer"),
+            usage,
+            size: std::mem::size_of::<ViewUniform>() as u64,
+            mapped_at_creation: false,
+        });
+        let view_bind_group_layout = bevy_nannou_wgpu::BindGroupLayoutBuilder::new()
+            .uniform_buffer(wgpu::ShaderStages::VERTEX, true)
+            .build(device);
+        let view_bind_group = bevy_nannou_wgpu::BindGroupBuilder::new()
+            .buffer::<ViewUniform>(&view_buffer, 0..1)
+            .build(device, &view_bind_group_layout);
+
+        let vertex_mode_buffer = Vec::new();
+
+        NannouPipeline {
+            glyph_cache_texture,
+            text_bind_group_layout,
+            text_bind_group,
+            texture_bind_group_layout,
+            texture_bind_group,
+            view_bind_group_layout,
+            view_bind_group,
+            view_buffer,
+            vertex_mode_buffer,
+        }
+    }
+}
+
+#[derive(Resource, Deref, DerefMut, Default)]
+pub struct TextureBindGroupCache(HashMap<Handle<Image>, wgpu::BindGroup>);
+
+pub struct NannouViewNode;
+
+impl NannouViewNode {
+    pub const NAME: &'static str = "nannou";
+}
+
+impl FromWorld for NannouViewNode {
+    fn from_world(_world: &mut World) -> Self {
+        NannouViewNode
+    }
+}
+
+impl ViewNode for NannouViewNode {
+    type ViewQuery = (
+        &'static ViewTarget,
+        &'static ViewUniformOffset,
+        &'static ViewMesh,
+        &'static ViewRenderCommands,
+        &'static ViewDepthTexture,
+    );
+
+    fn run(
+        &self,
+        _graph: &mut RenderGraphContext,
+        render_context: &mut RenderContext,
+        (target, uniform_offset, mesh, render_commands, depth): QueryItem<Self::ViewQuery>,
+        world: &World,
+    ) -> Result<(), NodeRunError> {
+        let nannou_pipeline = world.resource::<NannouPipeline>();
+        let pipeline_cache = world.resource::<PipelineCache>();
+        let bind_group_cache = world.resource::<TextureBindGroupCache>();
+
+        let render_device = render_context.render_device();
+
+        // TODO: we should just be able to cast the color slice
+        let colors = mesh
+            .colors()
+            .iter()
+            .map(|c| Vec4::new(c.red, c.green, c.blue, c.alpha))
+            .collect::<Vec<Vec4>>();
+        let modes = nannou_pipeline
+            .vertex_mode_buffer
+            .iter()
+            .map(|vm| *vm as u32)
+            .collect::<Vec<u32>>();
+        let vertex_usage = wgpu::BufferUsages::VERTEX;
+        let points_bytes = cast_slice(&mesh.points()[..]);
+        let colors_bytes = cast_slice(&colors);
+        let tex_coords_bytes = cast_slice(mesh.tex_coords());
+        let modes_bytes = cast_slice(&modes);
+        let indices_bytes = cast_slice(mesh.indices());
+        let point_buffer = render_device.create_buffer_with_data(&BufferInitDescriptor {
+            label: Some("nannou Renderer point_buffer"),
+            contents: points_bytes,
+            usage: vertex_usage,
+        });
+        let color_buffer = render_device.create_buffer_with_data(&BufferInitDescriptor {
+            label: Some("nannou Renderer color_buffer"),
+            contents: colors_bytes,
+            usage: vertex_usage,
+        });
+        let tex_coords_buffer = render_device.create_buffer_with_data(&BufferInitDescriptor {
+            label: Some("nannou Renderer tex_coords_buffer"),
+            contents: tex_coords_bytes,
+            usage: vertex_usage,
+        });
+        let mode_buffer = render_device.create_buffer_with_data(&BufferInitDescriptor {
+            label: Some("nannou Renderer mode_buffer"),
+            contents: modes_bytes,
+            usage: vertex_usage,
+        });
+        let index_buffer = render_device.create_buffer_with_data(&BufferInitDescriptor {
+            label: Some("nannou Renderer index_buffer"),
+            contents: indices_bytes,
+            usage: wgpu::BufferUsages::INDEX,
+        });
+
+        // Create render pass builder.
+        let render_pass_descriptor = RenderPassDescriptor {
+            label: None,
+            color_attachments: &[Some(target.get_color_attachment(Operations {
+                load: LoadOp::Load,
+                store: true,
+            }))],
+            depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
+                view: &depth.view,
+                depth_ops: Some(Operations {
+                    load: LoadOp::Clear(0.0),
+                    store: false,
+                }),
+                stencil_ops: None,
+            }),
+        };
+        let mut render_pass = render_context.begin_tracked_render_pass(render_pass_descriptor);
+
+        // Set the buffers.
+        render_pass.set_index_buffer(index_buffer.slice(..), 0, wgpu::IndexFormat::Uint32);
+        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.
+        let uniform_bind_group = world.resource::<ViewUniformBindGroup>();
+        render_pass.set_bind_group(0, &uniform_bind_group.bind_group, &[uniform_offset.offset]);
+        render_pass.set_bind_group(1, &nannou_pipeline.text_bind_group, &[]);
+
+        // Follow the render commands.
+        // todo: can we get mutable access in `view`?
+        for cmd in render_commands.deref().clone() {
+            match cmd {
+                RenderCommand::SetPipeline(id) => {
+                    let pipeline = pipeline_cache
+                        .get_render_pipeline(id)
+                        .expect("Expected pipeline to exist");
+                    render_pass.set_render_pipeline(pipeline);
+                }
+
+                RenderCommand::SetBindGroup(texture) => {
+                    let bind_group = bind_group_cache
+                        .get(&texture)
+                        .expect("Expected texture bind group to exist");
+                    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);
+                }
+            }
+        }
+
+        Ok(())
+    }
+}
diff --git a/bevy_nannou_render/src/shaders/nannou.wgsl b/bevy_nannou_render/src/shaders/nannou.wgsl
new file mode 100644
index 000000000..2d8e9be7a
--- /dev/null
+++ b/bevy_nannou_render/src/shaders/nannou.wgsl
@@ -0,0 +1,68 @@
+#import bevy_render::view::View
+
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ VERTEX ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //
+
+@group(0) @binding(0) var<uniform> view: View;
+
+struct VertexInput {
+    @location(0) position: vec3<f32>,
+    @location(1) color: vec4<f32>,
+    @location(2) tex_coords: vec2<f32>,
+    @location(3) mode: u32,
+};
+
+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, input.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(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 fragment(
+    input: FragmentInput,
+) -> FragmentOutput {
+    let tex_color: vec4<f32> = textureSample(tex, tex_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 = tex_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_wgpu/Cargo.toml b/bevy_nannou_wgpu/Cargo.toml
index 02eae7eac..939489a4d 100644
--- a/bevy_nannou_wgpu/Cargo.toml
+++ b/bevy_nannou_wgpu/Cargo.toml
@@ -5,3 +5,5 @@ 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
new file mode 100644
index 000000000..743957e20
--- /dev/null
+++ b/bevy_nannou_wgpu/src/bind_group_builder.rs
@@ -0,0 +1,219 @@
+use bevy::prelude::*;
+use bevy::render::render_resource as wgpu;
+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(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 {
+            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
index 3ccd53493..dff61894c 100644
--- a/bevy_nannou_wgpu/src/lib.rs
+++ b/bevy_nannou_wgpu/src/lib.rs
@@ -1,4 +1,30 @@
+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;
diff --git a/bevy_nannou_wgpu/src/render_pass.rs b/bevy_nannou_wgpu/src/render_pass.rs
new file mode 100644
index 000000000..71f85f5a7
--- /dev/null
+++ b/bevy_nannou_wgpu/src/render_pass.rs
@@ -0,0 +1,225 @@
+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
new file mode 100644
index 000000000..0a187a928
--- /dev/null
+++ b/bevy_nannou_wgpu/src/render_pipeline_builder.rs
@@ -0,0 +1,509 @@
+//! 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
new file mode 100644
index 000000000..f787c1b10
--- /dev/null
+++ b/bevy_nannou_wgpu/src/sampler_builder.rs
@@ -0,0 +1,153 @@
+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
new file mode 100644
index 000000000..b21924ba0
--- /dev/null
+++ b/bevy_nannou_wgpu/src/texture.rs
@@ -0,0 +1,203 @@
+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/nannou_core/Cargo.toml b/nannou_core/Cargo.toml
index cd9d62211..7c505066e 100644
--- a/nannou_core/Cargo.toml
+++ b/nannou_core/Cargo.toml
@@ -10,7 +10,7 @@ homepage = "https://nannou.cc"
 edition = "2018"
 
 [dependencies]
-glam = { version = "0.17", default-features = false, features = ["num-traits", "rand"] }
+glam = { version = "0.24.2", default-features = false, features = ["rand"] }
 # TODO: Awaiting `no-std` to be published.
 # noise = 0.6
 num-traits = { version = "0.2.14", default-features = false }
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 29ad6d4eb..bf691d273 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
@@ -46,14 +46,14 @@ fn view(app: &App, model: &Model, frame: Frame) {
         .rotate(model.angle);
 
     draw.ellipse()
-        .xy(pt2(60.0, 0.0).rotate(model.angle))
+        .xy(pt2(60.0, 0.0).rotate(Vec2::from_angle(model.angle)))
         .w_h(16.0, 16.0)
         .gray(0.5)
         .stroke_weight(2.0)
         .stroke_color(BLACK);
 
     draw.ellipse()
-        .xy(pt2(-60.0, 0.0).rotate(model.angle))
+        .xy(pt2(-60.0, 0.0).rotate(Vec2::from_angle(model.angle)))
         .w_h(16.0, 16.0)
         .gray(0.5)
         .stroke_weight(2.0)