Merge branch 'master' of https://github.com/adafruit/circuitpython into mixer_voice

60 files changed, 2323 insertions, 806 deletions

diff --git a/shared-module/_pew/PewPew.c b/shared-module/_pew/PewPew.c
index c1d6aa5c3..568dc6425 100644
--- a/shared-module/_pew/PewPew.c
+++ b/shared-module/_pew/PewPew.c
@@ -76,7 +76,7 @@ void pew_init() {
         // Find a spare timer.
         uint8_t index = find_free_timer();
         if (index == 0xff) {
-            mp_raise_RuntimeError(translate(""));
+            mp_raise_RuntimeError(translate("All timers in use"));
         }
         Tc *tc = tc_insts[index];
 
@@ -107,7 +107,7 @@ void pew_init() {
         #endif
 
         tc_set_enable(tc, true);
-        tc->COUNT16.CC[0].reg = 160;
+        tc->COUNT16.CC[0].reg = 64;
 
         // Clear our interrupt in case it was set earlier
         tc->COUNT16.INTFLAG.reg = TC_INTFLAG_MC0;
diff --git a/shared-module/_pew/__init__.c b/shared-module/_pew/__init__.c
index 90fba3990..f3b23c606 100644
--- a/shared-module/_pew/__init__.c
+++ b/shared-module/_pew/__init__.c
@@ -51,7 +51,7 @@ void pew_tick(void) {
         pressed = 0;
         col = 0;
         ++turn;
-        if (turn >= 8) {
+        if (turn > 11) {
             turn = 0;
         }
     }
@@ -68,13 +68,15 @@ void pew_tick(void) {
                 value = true;
                 break;
             case 2:
-                if (turn == 2 || turn == 4 || turn == 6) {
-                    value = true;
+                if (turn == 2 || turn == 5 || turn == 8 || turn == 11) {
+                        value = true;
                 }
+                break;
             case 1:
                 if (turn == 0) {
                     value = true;
                 }
+                break;
             case 0:
                 break;
         }
diff --git a/shared-module/_stage/__init__.c b/shared-module/_stage/__init__.c
index 86f5ee795..1af279e92 100644
--- a/shared-module/_stage/__init__.c
+++ b/shared-module/_stage/__init__.c
@@ -31,10 +31,10 @@
 #include "shared-bindings/_stage/Text.h"
 
 
-bool render_stage(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1,
+void render_stage(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1,
         mp_obj_t *layers, size_t layers_size,
         uint16_t *buffer, size_t buffer_size,
-        busio_spi_obj_t *spi) {
+        displayio_display_obj_t *display) {
 
     size_t index = 0;
     for (uint16_t y = y0; y < y1; ++y) {
@@ -55,19 +55,13 @@ bool render_stage(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1,
             index += 1;
             // The buffer is full, send it.
             if (index >= buffer_size) {
-                if (!common_hal_busio_spi_write(spi,
-                        ((uint8_t*)buffer), buffer_size * 2)) {
-                    return false;
-                }
+                display->send(display->bus, false, ((uint8_t*)buffer), buffer_size * 2);
                 index = 0;
             }
         }
     }
     // Send the remaining data.
     if (index) {
-        if (!common_hal_busio_spi_write(spi, ((uint8_t*)buffer), index * 2)) {
-            return false;
-        }
+        display->send(display->bus, false, ((uint8_t*)buffer), index * 2);
     }
-    return true;
 }
diff --git a/shared-module/_stage/__init__.h b/shared-module/_stage/__init__.h
index d56a26940..d263302b4 100644
--- a/shared-module/_stage/__init__.h
+++ b/shared-module/_stage/__init__.h
@@ -27,16 +27,16 @@
 #ifndef MICROPY_INCLUDED_SHARED_MODULE__STAGE_H
 #define MICROPY_INCLUDED_SHARED_MODULE__STAGE_H
 
-#include "shared-bindings/busio/SPI.h"
+#include "shared-bindings/displayio/Display.h"
 #include <stdint.h>
 #include <stdbool.h>
 #include "py/obj.h"
 
 #define TRANSPARENT (0x1ff8)
 
-bool render_stage(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1,
+void render_stage(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1,
         mp_obj_t *layers, size_t layers_size,
         uint16_t *buffer, size_t buffer_size,
-        busio_spi_obj_t *spi);
+        displayio_display_obj_t *display);
 
 #endif  // MICROPY_INCLUDED_SHARED_MODULE__STAGE
diff --git a/shared-module/audioio/Mixer.c b/shared-module/audiocore/Mixer.c
index dc92ce1da..8c083f419 100644
--- a/shared-module/audioio/Mixer.c
+++ b/shared-module/audiocore/Mixer.c
@@ -24,14 +24,13 @@
  * THE SOFTWARE.
  */
 
-#include "shared-bindings/audioio/Mixer.h"
-#include "shared-bindings/audioio/MixerVoice.h"
+#include "shared-bindings/audiocore/Mixer.h"
 
 #include <stdint.h>
 
 #include "py/runtime.h"
-#include "shared-module/audioio/__init__.h"
-#include "shared-module/audioio/RawSample.h"
+#include "shared-module/audiocore/__init__.h"
+#include "shared-module/audiocore/RawSample.h"
 
 void common_hal_audioio_mixer_construct(audioio_mixer_obj_t* self,
                                         uint8_t voice_count,
diff --git a/shared-module/audioio/Mixer.h b/shared-module/audiocore/Mixer.h
index db5c6ce6f..aaab60e84 100644
--- a/shared-module/audioio/Mixer.h
+++ b/shared-module/audiocore/Mixer.h
@@ -30,7 +30,7 @@
 #include "py/obj.h"
 #include "py/objtuple.h"
 
-#include "shared-module/audioio/__init__.h"
+#include "shared-module/audiocore/__init__.h"
 
 typedef struct {
     mp_obj_base_t base;
diff --git a/shared-module/audioio/RawSample.c b/shared-module/audiocore/RawSample.c
index 6422e346b..d6bf3a567 100644
--- a/shared-module/audioio/RawSample.c
+++ b/shared-module/audiocore/RawSample.c
@@ -24,11 +24,11 @@
  * THE SOFTWARE.
  */
 
-#include "shared-bindings/audioio/RawSample.h"
+#include "shared-bindings/audiocore/RawSample.h"
 
 #include <stdint.h>
 
-#include "shared-module/audioio/RawSample.h"
+#include "shared-module/audiocore/RawSample.h"
 
 void common_hal_audioio_rawsample_construct(audioio_rawsample_obj_t* self,
                                             uint8_t* buffer,
diff --git a/shared-module/audioio/RawSample.h b/shared-module/audiocore/RawSample.h
index fe5283db4..6c2c19c9b 100644
--- a/shared-module/audioio/RawSample.h
+++ b/shared-module/audiocore/RawSample.h
@@ -29,7 +29,7 @@
 
 #include "py/obj.h"
 
-#include "shared-module/audioio/__init__.h"
+#include "shared-module/audiocore/__init__.h"
 
 typedef struct {
     mp_obj_base_t base;
diff --git a/shared-module/audioio/WaveFile.c b/shared-module/audiocore/WaveFile.c
index d5dd9419c..810d9c33b 100644
--- a/shared-module/audioio/WaveFile.c
+++ b/shared-module/audiocore/WaveFile.c
@@ -24,7 +24,7 @@
  * THE SOFTWARE.
  */
 
-#include "shared-bindings/audioio/WaveFile.h"
+#include "shared-bindings/audiocore/WaveFile.h"
 
 #include <stdint.h>
 #include <string.h>
@@ -32,7 +32,7 @@
 #include "py/mperrno.h"
 #include "py/runtime.h"
 
-#include "shared-module/audioio/WaveFile.h"
+#include "shared-module/audiocore/WaveFile.h"
 #include "supervisor/shared/translate.h"
 
 struct wave_format_chunk {
diff --git a/shared-module/audioio/WaveFile.h b/shared-module/audiocore/WaveFile.h
index 75a46c03b..97dd6a46f 100644
--- a/shared-module/audioio/WaveFile.h
+++ b/shared-module/audiocore/WaveFile.h
@@ -29,7 +29,7 @@
 
 #include "py/obj.h"
 
-#include "shared-module/audioio/__init__.h"
+#include "shared-module/audiocore/__init__.h"
 
 typedef struct {
     mp_obj_base_t base;
@@ -44,7 +44,7 @@ typedef struct {
     uint32_t bytes_remaining;
 
     uint8_t channel_count;
-    uint16_t sample_rate;
+    uint32_t sample_rate;
 
     uint32_t len;
     pyb_file_obj_t* file;
diff --git a/shared-module/audiocore/__init__.c b/shared-module/audiocore/__init__.c
new file mode 100644
index 000000000..067cae5dd
--- /dev/null
+++ b/shared-module/audiocore/__init__.c
@@ -0,0 +1,125 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 Scott Shawcroft for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "shared-module/audioio/__init__.h"
+
+#include "py/obj.h"
+#include "shared-bindings/audiocore/Mixer.h"
+#include "shared-bindings/audiocore/RawSample.h"
+#include "shared-bindings/audiocore/WaveFile.h"
+#include "shared-module/audiocore/Mixer.h"
+#include "shared-module/audiocore/RawSample.h"
+#include "shared-module/audiocore/WaveFile.h"
+
+uint32_t audiosample_sample_rate(mp_obj_t sample_obj) {
+    if (MP_OBJ_IS_TYPE(sample_obj, &audioio_rawsample_type)) {
+        audioio_rawsample_obj_t* sample = MP_OBJ_TO_PTR(sample_obj);
+        return sample->sample_rate;
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_wavefile_type)) {
+        audioio_wavefile_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
+        return file->sample_rate;
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_mixer_type)) {
+        audioio_mixer_obj_t* mixer = MP_OBJ_TO_PTR(sample_obj);
+        return mixer->sample_rate;
+    }
+    return 16000;
+}
+
+uint8_t audiosample_bits_per_sample(mp_obj_t sample_obj) {
+    if (MP_OBJ_IS_TYPE(sample_obj, &audioio_rawsample_type)) {
+        audioio_rawsample_obj_t* sample = MP_OBJ_TO_PTR(sample_obj);
+        return sample->bits_per_sample;
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_wavefile_type)) {
+        audioio_wavefile_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
+        return file->bits_per_sample;
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_mixer_type)) {
+        audioio_mixer_obj_t* mixer = MP_OBJ_TO_PTR(sample_obj);
+        return mixer->bits_per_sample;
+    }
+    return 8;
+}
+
+uint8_t audiosample_channel_count(mp_obj_t sample_obj) {
+    if (MP_OBJ_IS_TYPE(sample_obj, &audioio_rawsample_type)) {
+        audioio_rawsample_obj_t* sample = MP_OBJ_TO_PTR(sample_obj);
+        return sample->channel_count;
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_wavefile_type)) {
+        audioio_wavefile_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
+        return file->channel_count;
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_mixer_type)) {
+        audioio_mixer_obj_t* mixer = MP_OBJ_TO_PTR(sample_obj);
+        return mixer->channel_count;
+    }
+    return 1;
+}
+
+void audiosample_reset_buffer(mp_obj_t sample_obj, bool single_channel, uint8_t audio_channel) {
+    if (MP_OBJ_IS_TYPE(sample_obj, &audioio_rawsample_type)) {
+        audioio_rawsample_obj_t* sample = MP_OBJ_TO_PTR(sample_obj);
+        audioio_rawsample_reset_buffer(sample, single_channel, audio_channel);
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_wavefile_type)) {
+        audioio_wavefile_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
+        audioio_wavefile_reset_buffer(file, single_channel, audio_channel);
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_mixer_type)) {
+        audioio_mixer_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
+        audioio_mixer_reset_buffer(file, single_channel, audio_channel);
+    }
+}
+
+audioio_get_buffer_result_t audiosample_get_buffer(mp_obj_t sample_obj,
+                                                   bool single_channel,
+                                                   uint8_t channel,
+                                                   uint8_t** buffer, uint32_t* buffer_length) {
+    if (MP_OBJ_IS_TYPE(sample_obj, &audioio_rawsample_type)) {
+        audioio_rawsample_obj_t* sample = MP_OBJ_TO_PTR(sample_obj);
+        return audioio_rawsample_get_buffer(sample, single_channel, channel, buffer, buffer_length);
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_wavefile_type)) {
+        audioio_wavefile_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
+        return audioio_wavefile_get_buffer(file, single_channel, channel, buffer, buffer_length);
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_mixer_type)) {
+        audioio_mixer_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
+        return audioio_mixer_get_buffer(file, single_channel, channel, buffer, buffer_length);
+    }
+    return GET_BUFFER_DONE;
+}
+
+void audiosample_get_buffer_structure(mp_obj_t sample_obj, bool single_channel,
+                                      bool* single_buffer, bool* samples_signed,
+                                      uint32_t* max_buffer_length, uint8_t* spacing) {
+    if (MP_OBJ_IS_TYPE(sample_obj, &audioio_rawsample_type)) {
+        audioio_rawsample_obj_t* sample = MP_OBJ_TO_PTR(sample_obj);
+        audioio_rawsample_get_buffer_structure(sample, single_channel, single_buffer,
+                                               samples_signed, max_buffer_length, spacing);
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_wavefile_type)) {
+        audioio_wavefile_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
+        audioio_wavefile_get_buffer_structure(file, single_channel, single_buffer, samples_signed,
+                                              max_buffer_length, spacing);
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_mixer_type)) {
+        audioio_mixer_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
+        audioio_mixer_get_buffer_structure(file, single_channel, single_buffer, samples_signed,
+                                              max_buffer_length, spacing);
+    }
+}
diff --git a/shared-module/audiocore/__init__.h b/shared-module/audiocore/__init__.h
new file mode 100644
index 000000000..7aa0c1824
--- /dev/null
+++ b/shared-module/audiocore/__init__.h
@@ -0,0 +1,53 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 Dan Halbert for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MICROPY_INCLUDED_SHARED_MODULE_AUDIOCORE__INIT__H
+#define MICROPY_INCLUDED_SHARED_MODULE_AUDIOCORE__INIT__H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "py/obj.h"
+
+typedef enum {
+    GET_BUFFER_DONE,            // No more data to read
+    GET_BUFFER_MORE_DATA,       // More data to read.
+    GET_BUFFER_ERROR,           // Error while reading data.
+} audioio_get_buffer_result_t;
+
+uint32_t audiosample_sample_rate(mp_obj_t sample_obj);
+uint8_t audiosample_bits_per_sample(mp_obj_t sample_obj);
+uint8_t audiosample_channel_count(mp_obj_t sample_obj);
+void audiosample_reset_buffer(mp_obj_t sample_obj, bool single_channel, uint8_t audio_channel);
+audioio_get_buffer_result_t audiosample_get_buffer(mp_obj_t sample_obj,
+                                                   bool single_channel,
+                                                   uint8_t channel,
+                                                   uint8_t** buffer, uint32_t* buffer_length);
+void audiosample_get_buffer_structure(mp_obj_t sample_obj, bool single_channel,
+                                      bool* single_buffer, bool* samples_signed,
+                                      uint32_t* max_buffer_length, uint8_t* spacing);
+
+#endif  // MICROPY_INCLUDED_SHARED_MODULE_AUDIOCORE__INIT__H
diff --git a/shared-module/audioio/__init__.c b/shared-module/audioio/__init__.c
index b87b06a83..e69de29bb 100644
--- a/shared-module/audioio/__init__.c
+++ b/shared-module/audioio/__init__.c
@@ -1,125 +0,0 @@
-/*
- * This file is part of the MicroPython project, http://micropython.org/
- *
- * The MIT License (MIT)
- *
- * Copyright (c) 2018 Scott Shawcroft for Adafruit Industries
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include "shared-module/audioio/__init__.h"
-
-#include "py/obj.h"
-#include "shared-bindings/audioio/Mixer.h"
-#include "shared-bindings/audioio/RawSample.h"
-#include "shared-bindings/audioio/WaveFile.h"
-#include "shared-module/audioio/Mixer.h"
-#include "shared-module/audioio/RawSample.h"
-#include "shared-module/audioio/WaveFile.h"
-
-uint32_t audiosample_sample_rate(mp_obj_t sample_obj) {
-    if (MP_OBJ_IS_TYPE(sample_obj, &audioio_rawsample_type)) {
-        audioio_rawsample_obj_t* sample = MP_OBJ_TO_PTR(sample_obj);
-        return sample->sample_rate;
-    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_wavefile_type)) {
-        audioio_wavefile_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
-        return file->sample_rate;
-    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_mixer_type)) {
-        audioio_mixer_obj_t* mixer = MP_OBJ_TO_PTR(sample_obj);
-        return mixer->sample_rate;
-    }
-    return 16000;
-}
-
-uint8_t audiosample_bits_per_sample(mp_obj_t sample_obj) {
-    if (MP_OBJ_IS_TYPE(sample_obj, &audioio_rawsample_type)) {
-        audioio_rawsample_obj_t* sample = MP_OBJ_TO_PTR(sample_obj);
-        return sample->bits_per_sample;
-    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_wavefile_type)) {
-        audioio_wavefile_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
-        return file->bits_per_sample;
-    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_mixer_type)) {
-        audioio_mixer_obj_t* mixer = MP_OBJ_TO_PTR(sample_obj);
-        return mixer->bits_per_sample;
-    }
-    return 8;
-}
-
-uint8_t audiosample_channel_count(mp_obj_t sample_obj) {
-    if (MP_OBJ_IS_TYPE(sample_obj, &audioio_rawsample_type)) {
-        audioio_rawsample_obj_t* sample = MP_OBJ_TO_PTR(sample_obj);
-        return sample->channel_count;
-    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_wavefile_type)) {
-        audioio_wavefile_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
-        return file->channel_count;
-    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_mixer_type)) {
-        audioio_mixer_obj_t* mixer = MP_OBJ_TO_PTR(sample_obj);
-        return mixer->channel_count;
-    }
-    return 1;
-}
-
-void audiosample_reset_buffer(mp_obj_t sample_obj, bool single_channel, uint8_t audio_channel) {
-    if (MP_OBJ_IS_TYPE(sample_obj, &audioio_rawsample_type)) {
-        audioio_rawsample_obj_t* sample = MP_OBJ_TO_PTR(sample_obj);
-        audioio_rawsample_reset_buffer(sample, single_channel, audio_channel);
-    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_wavefile_type)) {
-        audioio_wavefile_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
-        audioio_wavefile_reset_buffer(file, single_channel, audio_channel);
-    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_mixer_type)) {
-        audioio_mixer_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
-        audioio_mixer_reset_buffer(file, single_channel, audio_channel);
-    }
-}
-
-audioio_get_buffer_result_t audiosample_get_buffer(mp_obj_t sample_obj,
-                                                   bool single_channel,
-                                                   uint8_t channel,
-                                                   uint8_t** buffer, uint32_t* buffer_length) {
-    if (MP_OBJ_IS_TYPE(sample_obj, &audioio_rawsample_type)) {
-        audioio_rawsample_obj_t* sample = MP_OBJ_TO_PTR(sample_obj);
-        return audioio_rawsample_get_buffer(sample, single_channel, channel, buffer, buffer_length);
-    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_wavefile_type)) {
-        audioio_wavefile_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
-        return audioio_wavefile_get_buffer(file, single_channel, channel, buffer, buffer_length);
-    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_mixer_type)) {
-        audioio_mixer_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
-        return audioio_mixer_get_buffer(file, single_channel, channel, buffer, buffer_length);
-    }
-    return GET_BUFFER_DONE;
-}
-
-void audiosample_get_buffer_structure(mp_obj_t sample_obj, bool single_channel,
-                                      bool* single_buffer, bool* samples_signed,
-                                      uint32_t* max_buffer_length, uint8_t* spacing) {
-    if (MP_OBJ_IS_TYPE(sample_obj, &audioio_rawsample_type)) {
-        audioio_rawsample_obj_t* sample = MP_OBJ_TO_PTR(sample_obj);
-        audioio_rawsample_get_buffer_structure(sample, single_channel, single_buffer,
-                                               samples_signed, max_buffer_length, spacing);
-    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_wavefile_type)) {
-        audioio_wavefile_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
-        audioio_wavefile_get_buffer_structure(file, single_channel, single_buffer, samples_signed,
-                                              max_buffer_length, spacing);
-    } else if (MP_OBJ_IS_TYPE(sample_obj, &audioio_mixer_type)) {
-        audioio_mixer_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
-        audioio_mixer_get_buffer_structure(file, single_channel, single_buffer, samples_signed,
-                                              max_buffer_length, spacing);
-    }
-}
diff --git a/shared-module/audioio/__init__.h b/shared-module/audioio/__init__.h
index c805f3116..53b2d4a16 100644
--- a/shared-module/audioio/__init__.h
+++ b/shared-module/audioio/__init__.h
@@ -27,27 +27,6 @@
 #ifndef MICROPY_INCLUDED_SHARED_MODULE_AUDIOIO__INIT__H
 #define MICROPY_INCLUDED_SHARED_MODULE_AUDIOIO__INIT__H
 
-#include <stdbool.h>
-#include <stdint.h>
-
-#include "py/obj.h"
-
-typedef enum {
-    GET_BUFFER_DONE,            // No more data to read
-    GET_BUFFER_MORE_DATA,       // More data to read.
-    GET_BUFFER_ERROR,           // Error while reading data.
-} audioio_get_buffer_result_t;
-
-uint32_t audiosample_sample_rate(mp_obj_t sample_obj);
-uint8_t audiosample_bits_per_sample(mp_obj_t sample_obj);
-uint8_t audiosample_channel_count(mp_obj_t sample_obj);
-void audiosample_reset_buffer(mp_obj_t sample_obj, bool single_channel, uint8_t audio_channel);
-audioio_get_buffer_result_t audiosample_get_buffer(mp_obj_t sample_obj,
-                                                   bool single_channel,
-                                                   uint8_t channel,
-                                                   uint8_t** buffer, uint32_t* buffer_length);
-void audiosample_get_buffer_structure(mp_obj_t sample_obj, bool single_channel,
-                                      bool* single_buffer, bool* samples_signed,
-                                      uint32_t* max_buffer_length, uint8_t* spacing);
+#include "shared-module/audiocore/__init__.h"
 
 #endif  // MICROPY_INCLUDED_SHARED_MODULE_AUDIOIO__INIT__H
diff --git a/shared-module/bleio/Address.c b/shared-module/bleio/Address.c
new file mode 100644
index 000000000..6bc458b7c
--- /dev/null
+++ b/shared-module/bleio/Address.c
@@ -0,0 +1,45 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Dan Halbert for Adafruit Industries
+ * Copyright (c) 2018 Artur Pacholec
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <string.h>
+
+#include "py/objstr.h"
+#include "shared-bindings/bleio/Address.h"
+#include "shared-module/bleio/Address.h"
+
+void common_hal_bleio_address_construct(bleio_address_obj_t *self, uint8_t *bytes, uint8_t address_type) {
+    self->bytes = mp_obj_new_bytes(bytes, NUM_BLEIO_ADDRESS_BYTES);
+    self->type = address_type;
+}
+
+mp_obj_t common_hal_bleio_address_get_address_bytes(bleio_address_obj_t *self) {
+    return self->bytes;
+}
+
+uint8_t common_hal_bleio_address_get_type(bleio_address_obj_t *self) {
+    return self->type;
+}
diff --git a/shared-module/bleio/Address.h b/shared-module/bleio/Address.h
index f0998c163..39789842f 100644
--- a/shared-module/bleio/Address.h
+++ b/shared-module/bleio/Address.h
@@ -3,6 +3,7 @@
  *
  * The MIT License (MIT)
  *
+ * Copyright (c) 2019 Dan Halbert for Adafruit Industries
  * Copyright (c) 2018 Artur Pacholec
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -27,14 +28,14 @@
 #ifndef MICROPY_INCLUDED_SHARED_MODULE_BLEIO_ADDRESS_H
 #define MICROPY_INCLUDED_SHARED_MODULE_BLEIO_ADDRESS_H
 
-#include "shared-bindings/bleio/AddressType.h"
+#include "py/obj.h"
 
-#define BLEIO_ADDRESS_BYTES 6
+#define NUM_BLEIO_ADDRESS_BYTES 6
 
 typedef struct {
     mp_obj_base_t base;
-    bleio_address_type_t type;
-    uint8_t value[BLEIO_ADDRESS_BYTES];
+    uint8_t type;
+    mp_obj_t bytes;    // a bytes() object
 } bleio_address_obj_t;
 
 #endif // MICROPY_INCLUDED_SHARED_MODULE_BLEIO_ADDRESS_H
diff --git a/shared-module/bleio/AdvertisementData.h b/shared-module/bleio/AdvertisementData.h
deleted file mode 100644
index 738d53b23..000000000
--- a/shared-module/bleio/AdvertisementData.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * This file is part of the MicroPython project, http://micropython.org/
- *
- * The MIT License (MIT)
- *
- * Copyright (c) 2018 Artur Pacholec
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#ifndef MICROPY_INCLUDED_SHARED_MODULE_BLEIO_ADVERTISEMENTDATA_H
-#define MICROPY_INCLUDED_SHARED_MODULE_BLEIO_ADVERTISEMENTDATA_H
-
-#include "py/obj.h"
-
-// Taken from https://www.bluetooth.com/specifications/assigned-numbers/generic-access-profile
-enum {
-    AdFlags = 0x01,
-    AdIncompleteListOf16BitServiceClassUUIDs = 0x02,
-    AdCompleteListOf16BitServiceClassUUIDs = 0x03,
-    AdIncompleteListOf32BitServiceClassUUIDs = 0x04,
-    AdCompleteListOf32BitServiceClassUUIDs = 0x05,
-    AdIncompleteListOf128BitServiceClassUUIDs = 0x06,
-    AdCompleteListOf128BitServiceClassUUIDs = 0x07,
-    AdShortenedLocalName = 0x08,
-    AdCompleteLocalName = 0x09,
-    AdTxPowerLevel = 0x0A,
-    AdClassOfDevice = 0x0D,
-    AdSimplePairingHashC = 0x0E,
-    AdSimplePairingRandomizerR = 0x0F,
-    AdSecurityManagerTKValue = 0x10,
-    AdSecurityManagerOOBFlags = 0x11,
-    AdSlaveConnectionIntervalRange = 0x12,
-    AdListOf16BitServiceSolicitationUUIDs = 0x14,
-    AdListOf128BitServiceSolicitationUUIDs = 0x15,
-    AdServiceData = 0x16,
-    AdPublicTargetAddress = 0x17,
-    AdRandomTargetAddress = 0x18,
-    AdAppearance = 0x19,
-    AdAdvertisingInterval = 0x1A,
-    AdLEBluetoothDeviceAddress = 0x1B,
-    AdLERole = 0x1C,
-    AdSimplePairingHashC256 = 0x1D,
-    AdSimplePairingRandomizerR256 = 0x1E,
-    AdListOf32BitServiceSolicitationUUIDs = 0x1F,
-    AdServiceData32BitUUID = 0x20,
-    AdServiceData128BitUUID = 0x21,
-    AdLESecureConnectionsConfirmationValue = 0x22,
-    AdLESecureConnectionsRandomValue = 0x23,
-    AdURI = 0x24,
-    AdIndoorPositioning = 0x25,
-    AdTransportDiscoveryData = 0x26,
-    AdLESupportedFeatures = 0x27,
-    AdChannelMapUpdateIndication = 0x28,
-    AdPBADV = 0x29,
-    AdMeshMessage = 0x2A,
-    AdMeshBeacon = 0x2B,
-    Ad3DInformationData = 0x3D,
-    AdManufacturerSpecificData = 0xFF,
-};
-
-typedef struct {
-    mp_obj_t device_name;
-    mp_obj_t services;
-    mp_obj_t data;
-    bool connectable;
-} bleio_advertisement_data_t;
-
-#endif // MICROPY_INCLUDED_SHARED_MODULE_BLEIO_ADVERTISEMENTDATA_H
diff --git a/shared-module/bleio/Characteristic.h b/shared-module/bleio/Characteristic.h
index 958837e64..27b43588f 100644
--- a/shared-module/bleio/Characteristic.h
+++ b/shared-module/bleio/Characteristic.h
@@ -3,7 +3,7 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2018 Artur Pacholec
+ * Copyright (c) 2019 Dan Halbert for Adafruit Industries
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -37,5 +37,4 @@ typedef struct {
         bool indicate : 1;
 } bleio_characteristic_properties_t;
 
-
 #endif // MICROPY_INCLUDED_SHARED_MODULE_BLEIO_CHARACTERISTIC_H
diff --git a/shared-module/bleio/ScanEntry.c b/shared-module/bleio/ScanEntry.c
new file mode 100644
index 000000000..306ac33c5
--- /dev/null
+++ b/shared-module/bleio/ScanEntry.c
@@ -0,0 +1,45 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Dan Halbert for Adafruit Industries
+ * Copyright (c) 2018 Artur Pacholec
+ * Copyright (c) 2017 Glenn Ruben Bakke
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <string.h>
+
+#include "shared-bindings/bleio/Address.h"
+#include "shared-module/bleio/Address.h"
+#include "shared-module/bleio/ScanEntry.h"
+
+mp_obj_t common_hal_bleio_scanentry_get_address(bleio_scanentry_obj_t *self) {
+    return MP_OBJ_FROM_PTR(self->address);
+}
+
+mp_obj_t common_hal_bleio_scanentry_get_advertisement_bytes(bleio_scanentry_obj_t *self) {
+    return self->data;
+}
+
+mp_int_t common_hal_bleio_scanentry_get_rssi(bleio_scanentry_obj_t *self) {
+    return self->rssi;
+}
diff --git a/shared-module/bleio/ScanEntry.h b/shared-module/bleio/ScanEntry.h
index 2f01669e2..b302460e6 100644
--- a/shared-module/bleio/ScanEntry.h
+++ b/shared-module/bleio/ScanEntry.h
@@ -3,6 +3,7 @@
  *
  * The MIT License (MIT)
  *
+ * Copyright (c) 2019 Dan Halbert for Adafruit Industries
  * Copyright (c) 2018 Artur Pacholec
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -27,13 +28,14 @@
 #ifndef MICROPY_INCLUDED_SHARED_MODULE_BLEIO_SCANENTRY_H
 #define MICROPY_INCLUDED_SHARED_MODULE_BLEIO_SCANENTRY_H
 
-#include "shared-module/bleio/Address.h"
+#include "py/obj.h"
+#include "shared-bindings/bleio/Address.h"
 
 typedef struct {
     mp_obj_base_t base;
-    bleio_address_obj_t address;
     bool connectable;
     int8_t rssi;
+    bleio_address_obj_t *address;
     mp_obj_t data;
 } bleio_scanentry_obj_t;
 
diff --git a/shared-module/board/__init__.c b/shared-module/board/__init__.c
new file mode 100644
index 000000000..5a1dead78
--- /dev/null
+++ b/shared-module/board/__init__.c
@@ -0,0 +1,123 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 Scott Shawcroft for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "shared-bindings/microcontroller/Pin.h"
+#include "supervisor/shared/translate.h"
+#include "mpconfigboard.h"
+#include "py/runtime.h"
+
+#if CIRCUITPY_BUSIO
+#include "shared-bindings/busio/I2C.h"
+#include "shared-bindings/busio/SPI.h"
+#include "shared-bindings/busio/UART.h"
+#endif
+
+#if CIRCUITPY_DISPLAYIO
+#include "shared-module/displayio/__init__.h"
+#endif
+
+#if BOARD_I2C
+mp_obj_t common_hal_board_get_i2c(void) {
+    return MP_STATE_VM(shared_i2c_bus);
+}
+
+mp_obj_t common_hal_board_create_i2c(void) {
+    busio_i2c_obj_t *self = m_new_ll_obj(busio_i2c_obj_t);
+    self->base.type = &busio_i2c_type;
+
+    common_hal_busio_i2c_construct(self, DEFAULT_I2C_BUS_SCL, DEFAULT_I2C_BUS_SDA, 400000, 0);
+    MP_STATE_VM(shared_i2c_bus) = MP_OBJ_FROM_PTR(self);
+    return MP_STATE_VM(shared_i2c_bus);
+}
+#endif
+
+
+#if BOARD_SPI
+// Statically allocate the SPI object so it can live past the end of the heap and into the next VM.
+// That way it can be used by built-in FourWire displays and be accessible through board.SPI().
+STATIC busio_spi_obj_t spi_obj;
+STATIC mp_obj_t spi_singleton = NULL;
+
+mp_obj_t common_hal_board_get_spi(void) {
+    return spi_singleton;
+}
+
+mp_obj_t common_hal_board_create_spi(void) {
+    if (spi_singleton != NULL) {
+        return spi_singleton;
+    }
+    busio_spi_obj_t *self = &spi_obj;
+    self->base.type = &busio_spi_type;
+
+    const mcu_pin_obj_t* clock = MP_OBJ_TO_PTR(DEFAULT_SPI_BUS_SCK);
+    const mcu_pin_obj_t* mosi = MP_OBJ_TO_PTR(DEFAULT_SPI_BUS_MOSI);
+    const mcu_pin_obj_t* miso = MP_OBJ_TO_PTR(DEFAULT_SPI_BUS_MISO);
+    common_hal_busio_spi_construct(self, clock, mosi, miso);
+    spi_singleton = (mp_obj_t)self;
+    return spi_singleton;
+}
+#endif
+
+#if BOARD_UART
+mp_obj_t common_hal_board_get_uart(void) {
+    return MP_STATE_VM(shared_uart_bus);
+}
+
+mp_obj_t common_hal_board_create_uart(void) {
+    busio_uart_obj_t *self = m_new_ll_obj(busio_uart_obj_t);
+    self->base.type = &busio_uart_type;
+
+    const mcu_pin_obj_t* rx = MP_OBJ_TO_PTR(DEFAULT_UART_BUS_RX);
+    const mcu_pin_obj_t* tx = MP_OBJ_TO_PTR(DEFAULT_UART_BUS_TX);
+
+    common_hal_busio_uart_construct(self, tx, rx, 9600, 8, PARITY_NONE, 1, 1000, 64);
+    MP_STATE_VM(shared_uart_bus) = MP_OBJ_FROM_PTR(self);
+    return MP_STATE_VM(shared_uart_bus);
+}
+#endif
+
+void reset_board_busses(void) {
+#if BOARD_I2C
+    MP_STATE_VM(shared_i2c_bus) = NULL;
+#endif
+#if BOARD_SPI
+    bool display_using_spi = false;
+    #if CIRCUITPY_DISPLAYIO
+    for (uint8_t i = 0; i < CIRCUITPY_DISPLAY_LIMIT; i++) {
+        if (displays[i].fourwire_bus.bus == spi_singleton) {
+            display_using_spi = true;
+            break;
+        }
+    }
+    #endif
+    if (!display_using_spi) {
+        spi_singleton = NULL;
+    }
+#endif
+#if BOARD_UART
+    MP_STATE_VM(shared_uart_bus) = NULL;
+#endif
+}
diff --git a/shared-module/bleio/Scanner.h b/shared-module/board/__init__.h
index 76f5e5866..f7eecd417 100644
--- a/shared-module/bleio/Scanner.h
+++ b/shared-module/board/__init__.h
@@ -3,7 +3,7 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2018 Artur Pacholec
+ * Copyright (c) 2019 Scott Shawcroft for Adafruit Industries
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -24,16 +24,9 @@
  * THE SOFTWARE.
  */
 
-#ifndef MICROPY_INCLUDED_SHARED_MODULE_BLEIO_SCANNER_H
-#define MICROPY_INCLUDED_SHARED_MODULE_BLEIO_SCANNER_H
+#ifndef MICROPY_INCLUDED_SHARED_MODULE_BOARD__INIT__H
+#define MICROPY_INCLUDED_SHARED_MODULE_BOARD__INIT__H
 
-#include "py/obj.h"
+void reset_board_busses(void);
 
-typedef struct {
-    mp_obj_base_t base;
-    mp_obj_t adv_reports;
-    uint16_t interval;
-    uint16_t window;
-} bleio_scanner_obj_t;
-
-#endif // MICROPY_INCLUDED_SHARED_MODULE_BLEIO_SCANNER_H
+#endif  // MICROPY_INCLUDED_SHARED_MODULE_BOARD__INIT__H
diff --git a/shared-module/displayio/Bitmap.c b/shared-module/displayio/Bitmap.c
index 2b2c70ab6..f8dc24c15 100644
--- a/shared-module/displayio/Bitmap.c
+++ b/shared-module/displayio/Bitmap.c
@@ -33,20 +33,21 @@
 void common_hal_displayio_bitmap_construct(displayio_bitmap_t *self, uint32_t width,
     uint32_t height, uint32_t bits_per_value) {
     uint32_t row_width = width * bits_per_value;
-    // word align
-    if (row_width % 32 != 0) {
-        self->stride = (row_width / 32 + 1);
+    // align to size_t
+    uint8_t align_bits = 8 * sizeof(size_t);
+    if (row_width % align_bits != 0) {
+        self->stride = (row_width / align_bits + 1);
     } else {
-        self->stride = row_width / 32;
+        self->stride = row_width / align_bits;
     }
     self->width = width;
     self->height = height;
-    self->data = m_malloc(self->stride * height * sizeof(uint32_t), false);
+    self->data = m_malloc(self->stride * height * sizeof(size_t), false);
     self->read_only = false;
     self->bits_per_value = bits_per_value;
 
-    if (bits_per_value > 8) {
-        mp_raise_NotImplementedError(translate("Only bit maps of 8 bit color or less are supported"));
+    if (bits_per_value > 8 && bits_per_value != 16 && bits_per_value != 32) {
+        mp_raise_NotImplementedError(translate("Invalid bits per value"));
     }
 
     // Division and modulus can be slow because it has to handle any integer. We know bits_per_value
@@ -56,7 +57,7 @@ void common_hal_displayio_bitmap_construct(displayio_bitmap_t *self, uint32_t wi
     self->x_shift = 0; // Used to divide the index by the number of pixels per word. Its used in a
                        // shift which effectively divides by 2 ** x_shift.
     uint32_t power_of_two = 1;
-    while (power_of_two < 32 / bits_per_value ) {
+    while (power_of_two < align_bits / bits_per_value ) {
         self->x_shift++;
         power_of_two <<= 1;
     }
@@ -76,41 +77,27 @@ uint32_t common_hal_displayio_bitmap_get_bits_per_value(displayio_bitmap_t *self
     return self->bits_per_value;
 }
 
-void common_hal_displayio_bitmap_load_row(displayio_bitmap_t *self, uint16_t y, uint8_t* data, uint16_t len) {
-    if (len != self->stride * sizeof(uint32_t)) {
-        mp_raise_ValueError(translate("row must be packed and word aligned"));
-    }
-    uint32_t* row_value = self->data + (y * self->stride);
-    // Do the memcpy ourselves since we may want to flip endianness.
-    for (uint32_t i = 0; i < self->stride; i++) {
-        #pragma GCC diagnostic push
-        #pragma GCC diagnostic ignored "-Wcast-align"
-        uint32_t value = ((uint32_t *)data)[i];
-        #pragma GCC diagnostic pop
-        if (self->bits_per_value < 16) {
-            value = ((value >> 24) & 0xff) |
-                    ((value << 8) & 0xff0000) |
-                    ((value >> 8) & 0xff00) |
-                    ((value << 24) & 0xff000000);
-        }
-        *row_value = value;
-        row_value++;
-    }
-}
-
 uint32_t common_hal_displayio_bitmap_get_pixel(displayio_bitmap_t *self, int16_t x, int16_t y) {
     if (x >= self->width || x < 0 || y >= self->height || y < 0) {
         return 0;
     }
     int32_t row_start = y * self->stride;
-    if (self->bits_per_value < 8) {
-        uint32_t word = self->data[row_start + (x >> self->x_shift)];
+    uint32_t bytes_per_value = self->bits_per_value / 8;
+    if (bytes_per_value < 1) {
+        size_t word = self->data[row_start + (x >> self->x_shift)];
 
-        return (word >> (32 - ((x & self->x_mask) + 1) * self->bits_per_value)) & self->bitmask;
+        return (word >> (sizeof(size_t) * 8 - ((x & self->x_mask) + 1) * self->bits_per_value)) & self->bitmask;
     } else {
-        uint32_t bytes_per_value = self->bits_per_value / 8;
-        return self->data[row_start + x * bytes_per_value];
+        size_t* row = self->data + row_start;
+        if (bytes_per_value == 1) {
+            return ((uint8_t*) row)[x];
+        } else if (bytes_per_value == 2) {
+            return ((uint16_t*) row)[x];
+        } else if (bytes_per_value == 4) {
+            return ((uint32_t*) row)[x];
+        }
     }
+    return 0;
 }
 
 void common_hal_displayio_bitmap_set_pixel(displayio_bitmap_t *self, int16_t x, int16_t y, uint32_t value) {
@@ -118,15 +105,22 @@ void common_hal_displayio_bitmap_set_pixel(displayio_bitmap_t *self, int16_t x,
         mp_raise_RuntimeError(translate("Read-only object"));
     }
     int32_t row_start = y * self->stride;
-    if (self->bits_per_value < 8) {
-        uint32_t bit_position = (32 - ((x & self->x_mask) + 1) * self->bits_per_value);
+    uint32_t bytes_per_value = self->bits_per_value / 8;
+    if (bytes_per_value < 1) {
+        uint32_t bit_position = (sizeof(size_t) * 8 - ((x & self->x_mask) + 1) * self->bits_per_value);
         uint32_t index = row_start + (x >> self->x_shift);
         uint32_t word = self->data[index];
         word &= ~(self->bitmask << bit_position);
         word |= (value & self->bitmask) << bit_position;
         self->data[index] = word;
     } else {
-        uint32_t bytes_per_value = self->bits_per_value / 8;
-        self->data[row_start + x * bytes_per_value] = value;
+        size_t* row = self->data + row_start;
+        if (bytes_per_value == 1) {
+            ((uint8_t*) row)[x] = value;
+        } else if (bytes_per_value == 2) {
+            ((uint16_t*) row)[x] = value;
+        } else if (bytes_per_value == 4) {
+            ((uint32_t*) row)[x] = value;
+        }
     }
 }
diff --git a/shared-module/displayio/Bitmap.h b/shared-module/displayio/Bitmap.h
index 485b57daf..48ca9e2cf 100644
--- a/shared-module/displayio/Bitmap.h
+++ b/shared-module/displayio/Bitmap.h
@@ -36,11 +36,11 @@ typedef struct {
     mp_obj_base_t base;
     uint16_t width;
     uint16_t height;
-    uint32_t* data;
-    uint16_t stride; // words
+    size_t* data;
+    uint16_t stride; // size_t's
     uint8_t bits_per_value;
     uint8_t x_shift;
-    uint8_t x_mask;
+    size_t x_mask;
     uint16_t bitmask;
     bool read_only;
 } displayio_bitmap_t;
diff --git a/shared-module/displayio/ColorConverter.c b/shared-module/displayio/ColorConverter.c
index d20b24c01..6b9bd5840 100644
--- a/shared-module/displayio/ColorConverter.c
+++ b/shared-module/displayio/ColorConverter.c
@@ -29,13 +29,42 @@
 void common_hal_displayio_colorconverter_construct(displayio_colorconverter_t* self) {
 }
 
-bool common_hal_displayio_colorconverter_convert(displayio_colorconverter_t *self, uint32_t input_color, uint16_t* output_color) {
-    // TODO(tannewt): Validate the color input against the input format.
-    uint32_t r5 = (input_color >> 19);
-    uint32_t g6 = (input_color >> 10) & 0x3f;
-    uint32_t b5 = (input_color >> 3) & 0x1f;
+uint16_t displayio_colorconverter_compute_rgb565(uint32_t color_rgb888) {
+    uint32_t r5 = (color_rgb888 >> 19);
+    uint32_t g6 = (color_rgb888 >> 10) & 0x3f;
+    uint32_t b5 = (color_rgb888 >> 3) & 0x1f;
     uint32_t packed = r5 << 11 | g6 << 5 | b5;
     // swap bytes
-    *output_color = __builtin_bswap16(packed);
-    return true;
+    return __builtin_bswap16(packed);
+}
+
+uint8_t displayio_colorconverter_compute_luma(uint32_t color_rgb888) {
+    uint32_t r8 = (color_rgb888 >> 16);
+    uint32_t g8 = (color_rgb888 >> 8) & 0xff;
+    uint32_t b8 = color_rgb888 & 0xff;
+    return (r8 * 19) / 255 + (g8 * 182) / 255 + (b8 + 54) / 255;
+}
+
+bool displayio_colorconverter_convert(displayio_colorconverter_t *self, const _displayio_colorspace_t* colorspace, uint32_t input_color, uint32_t* output_color) {
+    if (colorspace->depth == 16) {
+        *output_color = displayio_colorconverter_compute_rgb565(input_color);
+        return true;
+    } else if (colorspace->grayscale && colorspace->depth <= 8) {
+        uint8_t luma = displayio_colorconverter_compute_luma(input_color);
+        *output_color = luma >> (8 - colorspace->depth);
+        return true;
+    }
+    return false;
+}
+
+void common_hal_displayio_colorconverter_convert(displayio_colorconverter_t *self, const _displayio_colorspace_t* colorspace, uint32_t input_color, uint32_t* output_color) {
+    displayio_colorconverter_convert(self, colorspace, input_color, output_color);
+}
+
+// Currently no refresh logic is needed for a ColorConverter.
+bool displayio_colorconverter_needs_refresh(displayio_colorconverter_t *self) {
+    return false;
+}
+
+void displayio_colorconverter_finish_refresh(displayio_colorconverter_t *self) {
 }
diff --git a/shared-module/displayio/ColorConverter.h b/shared-module/displayio/ColorConverter.h
index 62ef2eaab..c48b98e6d 100644
--- a/shared-module/displayio/ColorConverter.h
+++ b/shared-module/displayio/ColorConverter.h
@@ -31,9 +31,16 @@
 #include <stdint.h>
 
 #include "py/obj.h"
+#include "shared-module/displayio/Palette.h"
 
 typedef struct {
     mp_obj_base_t base;
 } displayio_colorconverter_t;
 
+bool displayio_colorconverter_needs_refresh(displayio_colorconverter_t *self);
+void displayio_colorconverter_finish_refresh(displayio_colorconverter_t *self);
+bool displayio_colorconverter_convert(displayio_colorconverter_t *self, const _displayio_colorspace_t* colorspace, uint32_t input_color, uint32_t* output_color);
+uint16_t displayio_colorconverter_compute_rgb565(uint32_t color_rgb888);
+uint8_t displayio_colorconverter_compute_luma(uint32_t color_rgb888);
+
 #endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_COLORCONVERTER_H
diff --git a/shared-module/displayio/Display.c b/shared-module/displayio/Display.c
index 0e76a868f..51c6f292a 100644
--- a/shared-module/displayio/Display.c
+++ b/shared-module/displayio/Display.c
@@ -28,6 +28,7 @@
 
 #include "py/runtime.h"
 #include "shared-bindings/displayio/FourWire.h"
+#include "shared-bindings/displayio/I2CDisplay.h"
 #include "shared-bindings/displayio/ParallelBus.h"
 #include "shared-bindings/microcontroller/Pin.h"
 #include "shared-bindings/time/__init__.h"
@@ -35,6 +36,7 @@
 #include "supervisor/shared/display.h"
 
 #include <stdint.h>
+#include <string.h>
 
 #include "tick.h"
 
@@ -42,10 +44,16 @@
 
 void common_hal_displayio_display_construct(displayio_display_obj_t* self,
         mp_obj_t bus, uint16_t width, uint16_t height, int16_t colstart, int16_t rowstart, uint16_t rotation,
-        uint16_t color_depth, uint8_t set_column_command, uint8_t set_row_command,
+        uint16_t color_depth, bool grayscale, bool pixels_in_byte_share_row, uint8_t bytes_per_cell, bool reverse_pixels_in_byte,
+        uint8_t set_column_command, uint8_t set_row_command,
         uint8_t write_ram_command, uint8_t set_vertical_scroll, uint8_t* init_sequence, uint16_t init_sequence_len,
-        const mcu_pin_obj_t* backlight_pin) {
-    self->color_depth = color_depth;
+        const mcu_pin_obj_t* backlight_pin, uint16_t brightness_command, mp_float_t brightness, bool auto_brightness,
+        bool single_byte_bounds, bool data_as_commands) {
+    self->colorspace.depth = color_depth;
+    self->colorspace.grayscale = grayscale;
+    self->colorspace.pixels_in_byte_share_row = pixels_in_byte_share_row;
+    self->colorspace.bytes_per_cell = bytes_per_cell;
+    self->colorspace.reverse_pixels_in_byte = reverse_pixels_in_byte;
     self->set_column_command = set_column_command;
     self->set_row_command = set_row_command;
     self->write_ram_command = write_ram_command;
@@ -53,7 +61,10 @@ void common_hal_displayio_display_construct(displayio_display_obj_t* self,
     self->current_group = NULL;
     self->colstart = colstart;
     self->rowstart = rowstart;
-    self->auto_brightness = false;
+    self->brightness_command = brightness_command;
+    self->auto_brightness = auto_brightness;
+    self->data_as_commands = data_as_commands;
+    self->single_byte_bounds = single_byte_bounds;
 
     if (MP_OBJ_IS_TYPE(bus, &displayio_parallelbus_type)) {
         self->begin_transaction = common_hal_displayio_parallelbus_begin_transaction;
@@ -63,6 +74,10 @@ void common_hal_displayio_display_construct(displayio_display_obj_t* self,
         self->begin_transaction = common_hal_displayio_fourwire_begin_transaction;
         self->send = common_hal_displayio_fourwire_send;
         self->end_transaction = common_hal_displayio_fourwire_end_transaction;
+    } else if (MP_OBJ_IS_TYPE(bus, &displayio_i2cdisplay_type)) {
+        self->begin_transaction = common_hal_displayio_i2cdisplay_begin_transaction;
+        self->send = common_hal_displayio_i2cdisplay_send;
+        self->end_transaction = common_hal_displayio_i2cdisplay_end_transaction;
     } else {
         mp_raise_ValueError(translate("Unsupported display bus type"));
     }
@@ -80,8 +95,15 @@ void common_hal_displayio_display_construct(displayio_display_obj_t* self,
         bool delay = (data_size & DELAY) != 0;
         data_size &= ~DELAY;
         uint8_t *data = cmd + 2;
-        self->send(self->bus, true, cmd, 1);
-        self->send(self->bus, false, data, data_size);
+        if (self->data_as_commands) {
+            uint8_t full_command[data_size + 1];
+            full_command[0] = cmd[0];
+            memcpy(full_command + 1, data, data_size);
+            self->send(self->bus, true, full_command, data_size + 1);
+        } else {
+            self->send(self->bus, true, cmd, 1);
+            self->send(self->bus, false, data, data_size);
+        }
         uint16_t delay_length_ms = 10;
         if (delay) {
             data_size++;
@@ -97,28 +119,26 @@ void common_hal_displayio_display_construct(displayio_display_obj_t* self,
 
     supervisor_start_terminal(width, height);
 
-    // Set the group after initialization otherwise we may send pixels while we delay in
-    // initialization.
-    self->refresh = true;
-    self->current_group = &circuitpython_splash;
-
     self->width = width;
     self->height = height;
     rotation = rotation % 360;
-    self->mirror_x = false;
-    self->mirror_y = false;
-    self->transpose_xy = false;
+    self->transform.x = 0;
+    self->transform.y = 0;
+    self->transform.scale = 1;
+    self->transform.mirror_x = false;
+    self->transform.mirror_y = false;
+    self->transform.transpose_xy = false;
     if (rotation == 0 || rotation == 180) {
         if (rotation == 180) {
-            self->mirror_x = true;
-            self->mirror_y = true;
+            self->transform.mirror_x = true;
+            self->transform.mirror_y = true;
         }
     } else {
-        self->transpose_xy = true;
-        if (rotation == 90) {
-            self->mirror_y = true;
+        self->transform.transpose_xy = true;
+        if (rotation == 270) {
+            self->transform.mirror_y = true;
         } else {
-            self->mirror_x = true;
+            self->transform.mirror_x = true;
         }
     }
 
@@ -135,20 +155,82 @@ void common_hal_displayio_display_construct(displayio_display_obj_t* self,
             common_hal_pulseio_pwmout_never_reset(&self->backlight_pwm);
         }
     }
+    if (!self->auto_brightness && (self->backlight_inout.base.type != &mp_type_NoneType ||
+                                   brightness_command != NO_BRIGHTNESS_COMMAND)) {
+        common_hal_displayio_display_set_brightness(self, brightness);
+    } else {
+        self->current_brightness = -1.0;
+    }
+
+    self->area.x1 = 0;
+    self->area.y1 = 0;
+    self->area.next = NULL;
+
+    self->transform.dx = 1;
+    self->transform.dy = 1;
+    if (self->transform.transpose_xy) {
+        self->area.x2 = height;
+        self->area.y2 = width;
+        if (self->transform.mirror_x) {
+            self->transform.x = height;
+            self->transform.dx = -1;
+        }
+        if (self->transform.mirror_y) {
+            self->transform.y = width;
+            self->transform.dy = -1;
+        }
+    } else {
+        self->area.x2 = width;
+        self->area.y2 = height;
+        if (self->transform.mirror_x) {
+            self->transform.x = width;
+            self->transform.dx = -1;
+        }
+        if (self->transform.mirror_y) {
+            self->transform.y = height;
+            self->transform.dy = -1;
+        }
+    }
+
+    // Set the group after initialization otherwise we may send pixels while we delay in
+    // initialization.
+    common_hal_displayio_display_show(self, &circuitpython_splash);
 }
 
-void common_hal_displayio_display_show(displayio_display_obj_t* self, displayio_group_t* root_group) {
+bool common_hal_displayio_display_show(displayio_display_obj_t* self, displayio_group_t* root_group) {
     if (root_group == NULL) {
         root_group = &circuitpython_splash;
     }
+    if (root_group == self->current_group) {
+        return true;
+    }
+    if (root_group->in_group) {
+        return false;
+    }
+    if (self->current_group != NULL) {
+        self->current_group->in_group = false;
+    }
+    displayio_group_update_transform(root_group, &self->transform);
+    root_group->in_group = true;
     self->current_group = root_group;
+    self->full_refresh = true;
     common_hal_displayio_display_refresh_soon(self);
+    return true;
 }
 
 void common_hal_displayio_display_refresh_soon(displayio_display_obj_t* self) {
     self->refresh = true;
 }
 
+const displayio_area_t* displayio_display_get_refresh_areas(displayio_display_obj_t *self) {
+    if (self->full_refresh) {
+        self->area.next = NULL;
+        return &self->area;
+    } else {
+        return displayio_group_get_refresh_areas(self->current_group, NULL);
+    }
+}
+
 int32_t common_hal_displayio_display_wait_for_frame(displayio_display_obj_t* self) {
     uint64_t last_refresh = self->last_refresh;
     // Don't try to refresh if we got an exception.
@@ -175,17 +257,7 @@ void common_hal_displayio_display_set_auto_brightness(displayio_display_obj_t* s
 }
 
 mp_float_t common_hal_displayio_display_get_brightness(displayio_display_obj_t* self) {
-    if (self->backlight_pwm.base.type == &pulseio_pwmout_type) {
-        uint16_t duty_cycle = common_hal_pulseio_pwmout_get_duty_cycle(&self->backlight_pwm);
-        return duty_cycle / ((mp_float_t) 0xffff);
-    } else if (self->backlight_inout.base.type == &digitalio_digitalinout_type) {
-        if (common_hal_digitalio_digitalinout_get_value(&self->backlight_inout)) {
-            return 1.0;
-        } else {
-            return 0.0;
-        }
-    }
-    return -1.0;
+    return self->current_brightness;
 }
 
 bool common_hal_displayio_display_set_brightness(displayio_display_obj_t* self, mp_float_t brightness) {
@@ -197,8 +269,26 @@ bool common_hal_displayio_display_set_brightness(displayio_display_obj_t* self,
     } else if (self->backlight_inout.base.type == &digitalio_digitalinout_type) {
         common_hal_digitalio_digitalinout_set_value(&self->backlight_inout, brightness > 0.99);
         ok = true;
+    } else if (self->brightness_command != NO_BRIGHTNESS_COMMAND) {
+        ok = self->begin_transaction(self->bus);
+        if (ok) {
+            if (self->data_as_commands) {
+                uint8_t set_brightness[2] = {self->brightness_command, (uint8_t) (0xff * brightness)};
+                self->send(self->bus, true, set_brightness, 2);
+            } else {
+                uint8_t command = self->brightness_command;
+                uint8_t hex_brightness = 0xff * brightness;
+                self->send(self->bus, true, &command, 1);
+                self->send(self->bus, false, &hex_brightness, 1);
+            }
+            self->end_transaction(self->bus);
+        }
+
     }
     self->updating_backlight = false;
+    if (ok) {
+        self->current_brightness = brightness;
+    }
     return ok;
 }
 
@@ -210,27 +300,75 @@ void displayio_display_end_transaction(displayio_display_obj_t* self) {
     self->end_transaction(self->bus);
 }
 
-void displayio_display_set_region_to_update(displayio_display_obj_t* self, uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1) {
-    // TODO(tannewt): Handle displays with single byte bounds.
-    uint16_t data[2];
-    self->send(self->bus, true, &self->set_column_command, 1);
-    data[0] = __builtin_bswap16(x0 + self->colstart);
-    data[1] = __builtin_bswap16(x1 - 1 + self->colstart);
-    self->send(self->bus, false, (uint8_t*) data, 4);
-    self->send(self->bus, true, &self->set_row_command, 1);
-    data[0] = __builtin_bswap16(y0  + self->rowstart);
-    data[1] = __builtin_bswap16(y1 - 1 + self->rowstart);
-    self->send(self->bus, false, (uint8_t*) data, 4);
-    self->send(self->bus, true, &self->write_ram_command, 1);
+void displayio_display_set_region_to_update(displayio_display_obj_t* self, displayio_area_t* area) {
+    uint16_t x1 = area->x1;
+    uint16_t x2 = area->x2;
+    uint16_t y1 = area->y1;
+    uint16_t y2 = area->y2;
+    // Collapse down the dimension where multiple pixels are in a byte.
+    if (self->colorspace.depth < 8) {
+        uint8_t pixels_per_byte = 8 / self->colorspace.depth;
+        if (self->colorspace.pixels_in_byte_share_row) {
+            x1 /= pixels_per_byte * self->colorspace.bytes_per_cell;
+            x2 /= pixels_per_byte * self->colorspace.bytes_per_cell;
+        } else {
+            y1 /= pixels_per_byte * self->colorspace.bytes_per_cell;
+            y2 /= pixels_per_byte * self->colorspace.bytes_per_cell;
+        }
+    }
+
+    // Set column.
+    uint8_t data[5];
+    data[0] = self->set_column_command;
+    uint8_t data_length = 1;
+    if (!self->data_as_commands) {
+        self->send(self->bus, true, data, 1);
+        data_length = 0;
+    }
+    if (self->single_byte_bounds) {
+        data[data_length++] = x1 + self->colstart;
+        data[data_length++] = x2 - 1 + self->colstart;
+    } else {
+        x1 += self->colstart;
+        x2 += self->colstart - 1;
+        data[data_length++] = x1 >> 8;
+        data[data_length++] = x1 & 0xff;
+        data[data_length++] = x2 >> 8;
+        data[data_length++] = x2 & 0xff;
+    }
+    self->send(self->bus, self->data_as_commands, data, data_length);
+
+    // Set row.
+    data[0] = self->set_row_command;
+    data_length = 1;
+    if (!self->data_as_commands) {
+        self->send(self->bus, true, data, 1);
+        data_length = 0;
+    }
+    if (self->single_byte_bounds) {
+        data[data_length++] = y1 + self->rowstart;
+        data[data_length++] = y2 - 1 + self->rowstart;
+    } else {
+        y1 += self->rowstart;
+        y2 += self->rowstart - 1;
+        data[data_length++] = y1 >> 8;
+        data[data_length++] = y1 & 0xff;
+        data[data_length++] = y2 >> 8;
+        data[data_length++] = y2 & 0xff;
+    }
+    self->send(self->bus, self->data_as_commands, data, data_length);
 }
 
-bool displayio_display_frame_queued(displayio_display_obj_t* self) {
-    // Refresh at ~30 fps.
-    return (ticks_ms - self->last_refresh) > 32;
+void displayio_display_start_refresh(displayio_display_obj_t* self) {
+    self->last_refresh = ticks_ms;
 }
 
-bool displayio_display_refresh_queued(displayio_display_obj_t* self) {
-    return self->refresh || (self->current_group != NULL && displayio_group_needs_refresh(self->current_group));
+bool displayio_display_frame_queued(displayio_display_obj_t* self) {
+    if (self->current_group == NULL) {
+        return false;
+    }
+    // Refresh at ~60 fps.
+    return (ticks_ms - self->last_refresh) > 16;
 }
 
 void displayio_display_finish_refresh(displayio_display_obj_t* self) {
@@ -238,11 +376,15 @@ void displayio_display_finish_refresh(displayio_display_obj_t* self) {
         displayio_group_finish_refresh(self->current_group);
     }
     self->refresh = false;
+    self->full_refresh = false;
     self->last_refresh = ticks_ms;
 }
 
-void displayio_display_send_pixels(displayio_display_obj_t* self, uint32_t* pixels, uint32_t length) {
-    self->send(self->bus, false, (uint8_t*) pixels, length * 4);
+void displayio_display_send_pixels(displayio_display_obj_t* self, uint8_t* pixels, uint32_t length) {
+    if (!self->data_as_commands) {
+        self->send(self->bus, true, &self->write_ram_command, 1);
+    }
+    self->send(self->bus, false, pixels, length);
 }
 
 void displayio_display_update_backlight(displayio_display_obj_t* self) {
@@ -267,3 +409,35 @@ void release_display(displayio_display_obj_t* self) {
         common_hal_digitalio_digitalinout_deinit(&self->backlight_inout);
     }
 }
+
+bool displayio_display_fill_area(displayio_display_obj_t *self, displayio_area_t* area, uint32_t* mask, uint32_t *buffer) {
+    return displayio_group_fill_area(self->current_group, &self->colorspace, area, mask, buffer);
+}
+
+bool displayio_display_clip_area(displayio_display_obj_t *self, const displayio_area_t* area, displayio_area_t* clipped) {
+    bool overlaps = displayio_area_compute_overlap(&self->area, area, clipped);
+    if (!overlaps) {
+        return false;
+    }
+    // Expand the area if we have multiple pixels per byte and we need to byte
+    // align the bounds.
+    if (self->colorspace.depth < 8) {
+        uint8_t pixels_per_byte = 8 / self->colorspace.depth * self->colorspace.bytes_per_cell;
+        if (self->colorspace.pixels_in_byte_share_row) {
+            if (clipped->x1 % pixels_per_byte != 0) {
+                clipped->x1 -= clipped->x1 % pixels_per_byte;
+            }
+            if (clipped->x2 % pixels_per_byte != 0) {
+                clipped->x2 += pixels_per_byte - clipped->x2 % pixels_per_byte;
+            }
+        } else {
+            if (clipped->y1 % pixels_per_byte != 0) {
+                clipped->y1 -= clipped->y1 % pixels_per_byte;
+            }
+            if (clipped->y2 % pixels_per_byte != 0) {
+                clipped->y2 += pixels_per_byte - clipped->y2 % pixels_per_byte;
+            }
+        }
+    }
+    return true;
+}
diff --git a/shared-module/displayio/Display.h b/shared-module/displayio/Display.h
index 04da68b63..96d1c06d5 100644
--- a/shared-module/displayio/Display.h
+++ b/shared-module/displayio/Display.h
@@ -31,6 +31,8 @@
 #include "shared-bindings/displayio/Group.h"
 #include "shared-bindings/pulseio/PWMOut.h"
 
+#include "shared-module/displayio/area.h"
+
 typedef bool (*display_bus_begin_transaction)(mp_obj_t bus);
 typedef void (*display_bus_send)(mp_obj_t bus, bool command, uint8_t *data, uint32_t data_length);
 typedef void (*display_bus_end_transaction)(mp_obj_t bus);
@@ -38,17 +40,8 @@ typedef void (*display_bus_end_transaction)(mp_obj_t bus);
 typedef struct {
     mp_obj_base_t base;
     mp_obj_t bus;
-    uint16_t width;
-    uint16_t height;
-    uint16_t color_depth;
-    uint8_t set_column_command;
-    uint8_t set_row_command;
-    uint8_t write_ram_command;
     displayio_group_t *current_group;
-    bool refresh;
     uint64_t last_refresh;
-    int16_t colstart;
-    int16_t rowstart;
     display_bus_begin_transaction begin_transaction;
     display_bus_send send;
     display_bus_end_transaction end_transaction;
@@ -57,14 +50,31 @@ typedef struct {
         pulseio_pwmout_obj_t backlight_pwm;
     };
     uint64_t last_backlight_refresh;
-    bool auto_brightness:1;
-    bool updating_backlight:1;
-    bool mirror_x;
-    bool mirror_y;
-    bool transpose_xy;
+    displayio_buffer_transform_t transform;
+    displayio_area_t area;
+    mp_float_t current_brightness;
+    uint16_t width;
+    uint16_t height;
+    _displayio_colorspace_t colorspace;
+    int16_t colstart;
+    int16_t rowstart;
+    uint16_t brightness_command;
+    uint8_t set_column_command;
+    uint8_t set_row_command;
+    uint8_t write_ram_command;
+    bool refresh;
+    bool single_byte_bounds;
+    bool data_as_commands;
+    bool auto_brightness;
+    bool updating_backlight;
+    bool full_refresh; // New group means we need to refresh the whole display.
 } displayio_display_obj_t;
 
+void displayio_display_start_refresh(displayio_display_obj_t* self);
+const displayio_area_t* displayio_display_get_refresh_areas(displayio_display_obj_t *self);
+bool displayio_display_fill_area(displayio_display_obj_t *self, displayio_area_t* area, uint32_t* mask, uint32_t *buffer);
 void displayio_display_update_backlight(displayio_display_obj_t* self);
+bool displayio_display_clip_area(displayio_display_obj_t *self, const displayio_area_t* area, displayio_area_t* clipped);
 void release_display(displayio_display_obj_t* self);
 
 #endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_DISPLAY_H
diff --git a/shared-module/displayio/FourWire.c b/shared-module/displayio/FourWire.c
index 9da5c0701..913635db8 100644
--- a/shared-module/displayio/FourWire.c
+++ b/shared-module/displayio/FourWire.c
@@ -28,17 +28,27 @@
 
 #include <stdint.h>
 
+#include "py/gc.h"
 #include "shared-bindings/busio/SPI.h"
 #include "shared-bindings/digitalio/DigitalInOut.h"
+#include "shared-bindings/microcontroller/__init__.h"
+#include "shared-bindings/time/__init__.h"
 
 #include "tick.h"
 
 void common_hal_displayio_fourwire_construct(displayio_fourwire_obj_t* self,
     busio_spi_obj_t* spi, const mcu_pin_obj_t* command,
-    const mcu_pin_obj_t* chip_select, const mcu_pin_obj_t* reset) {
+    const mcu_pin_obj_t* chip_select, const mcu_pin_obj_t* reset, uint32_t baudrate) {
 
     self->bus = spi;
     common_hal_busio_spi_never_reset(self->bus);
+    // Our object is statically allocated off the heap so make sure the bus object lives to the end
+    // of the heap as well.
+    gc_never_free(self->bus);
+
+    self->frequency = baudrate;
+    self->polarity = common_hal_busio_spi_get_polarity(spi);
+    self->phase = common_hal_busio_spi_get_phase(spi);
 
     common_hal_digitalio_digitalinout_construct(&self->command, command);
     common_hal_digitalio_digitalinout_switch_to_output(&self->command, true, DRIVE_MODE_PUSH_PULL);
@@ -49,6 +59,11 @@ void common_hal_displayio_fourwire_construct(displayio_fourwire_obj_t* self,
         common_hal_digitalio_digitalinout_construct(&self->reset, reset);
         common_hal_digitalio_digitalinout_switch_to_output(&self->reset, true, DRIVE_MODE_PUSH_PULL);
         never_reset_pin_number(reset->number);
+
+        common_hal_digitalio_digitalinout_set_value(&self->reset, false);
+        common_hal_mcu_delay_us(10);
+        common_hal_digitalio_digitalinout_set_value(&self->reset, true);
+        common_hal_mcu_delay_us(10);
     }
 
     never_reset_pin_number(command->number);
@@ -70,8 +85,8 @@ bool common_hal_displayio_fourwire_begin_transaction(mp_obj_t obj) {
     if (!common_hal_busio_spi_try_lock(self->bus)) {
         return false;
     }
-    // TODO(tannewt): Stop hardcoding SPI frequency, polarity and phase.
-    common_hal_busio_spi_configure(self->bus, 12000000, 0, 0, 8);
+    common_hal_busio_spi_configure(self->bus, self->frequency, self->polarity,
+                                   self->phase, 8);
     common_hal_digitalio_digitalinout_set_value(&self->chip_select, false);
     return true;
 }
@@ -79,7 +94,18 @@ bool common_hal_displayio_fourwire_begin_transaction(mp_obj_t obj) {
 void common_hal_displayio_fourwire_send(mp_obj_t obj, bool command, uint8_t *data, uint32_t data_length) {
     displayio_fourwire_obj_t* self = MP_OBJ_TO_PTR(obj);
     common_hal_digitalio_digitalinout_set_value(&self->command, !command);
-    common_hal_busio_spi_write(self->bus, data, data_length);
+    if (command) {
+        // Toggle chip select after each command byte in case the display driver
+        // IC latches commands based on it.
+        for (size_t i = 0; i < data_length; i++) {
+            common_hal_busio_spi_write(self->bus, &data[i], 1);
+            common_hal_digitalio_digitalinout_set_value(&self->chip_select, true);
+            common_hal_mcu_delay_us(1);
+            common_hal_digitalio_digitalinout_set_value(&self->chip_select, false);
+        }
+    } else {
+        common_hal_busio_spi_write(self->bus, data, data_length);
+    }
 }
 
 void common_hal_displayio_fourwire_end_transaction(mp_obj_t obj) {
diff --git a/shared-module/displayio/FourWire.h b/shared-module/displayio/FourWire.h
index 234bcf794..a4260a3ac 100644
--- a/shared-module/displayio/FourWire.h
+++ b/shared-module/displayio/FourWire.h
@@ -24,8 +24,8 @@
  * THE SOFTWARE.
  */
 
-#ifndef MICROPY_INCLUDED_ATMEL_SAMD_COMMON_HAL_DISPLAYIO_FOURWIRE_H
-#define MICROPY_INCLUDED_ATMEL_SAMD_COMMON_HAL_DISPLAYIO_FOURWIRE_H
+#ifndef MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_FOURWIRE_H
+#define MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_FOURWIRE_H
 
 #include "common-hal/busio/SPI.h"
 #include "common-hal/digitalio/DigitalInOut.h"
@@ -38,6 +38,9 @@ typedef struct {
     digitalio_digitalinout_obj_t command;
     digitalio_digitalinout_obj_t chip_select;
     digitalio_digitalinout_obj_t reset;
+    uint32_t frequency;
+    uint8_t polarity;
+    uint8_t phase;
 } displayio_fourwire_obj_t;
 
-#endif // MICROPY_INCLUDED_ATMEL_SAMD_COMMON_HAL_DISPLAYIO_FOURWIRE_H
+#endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_FOURWIRE_H
diff --git a/shared-module/displayio/Group.c b/shared-module/displayio/Group.c
index f6bc92dc7..38418a029 100644
--- a/shared-module/displayio/Group.c
+++ b/shared-module/displayio/Group.c
@@ -29,18 +29,94 @@
 #include "py/runtime.h"
 #include "shared-bindings/displayio/TileGrid.h"
 
-void common_hal_displayio_group_construct(displayio_group_t* self, uint32_t max_size, uint32_t scale) {
+void common_hal_displayio_group_construct(displayio_group_t* self, uint32_t max_size, uint32_t scale, mp_int_t x, mp_int_t y) {
     displayio_group_child_t* children = m_new(displayio_group_child_t, max_size);
-    displayio_group_construct(self, children, max_size, scale);
+    displayio_group_construct(self, children, max_size, scale, x, y);
 }
 
 uint32_t common_hal_displayio_group_get_scale(displayio_group_t* self) {
     return self->scale;
 }
 
+bool displayio_group_get_previous_area(displayio_group_t *self, displayio_area_t* area) {
+    bool first = true;
+    for (size_t i = 0; i < self->size; i++) {
+        mp_obj_t layer = self->children[i].native;
+        displayio_area_t layer_area;
+        if (MP_OBJ_IS_TYPE(layer, &displayio_tilegrid_type)) {
+            if (!displayio_tilegrid_get_previous_area(layer, &layer_area)) {
+                continue;
+            }
+        } else if (MP_OBJ_IS_TYPE(layer, &displayio_group_type)) {
+            if (!displayio_group_get_previous_area(layer, &layer_area)) {
+                continue;
+            }
+        }
+        if (first) {
+            displayio_area_copy(&layer_area, area);
+            first = false;
+        } else {
+            displayio_area_expand(area, &layer_area);
+        }
+    }
+    if (self->item_removed) {
+        if (first) {
+            displayio_area_copy(&self->dirty_area, area);
+            first = false;
+        } else {
+            displayio_area_expand(area, &self->dirty_area);
+        }
+    }
+    return !first;
+}
+
+static void _update_child_transforms(displayio_group_t* self) {
+    if (!self->in_group) {
+        return;
+    }
+    for (size_t i = 0; i < self->size; i++) {
+        mp_obj_t layer = self->children[i].native;
+        if (MP_OBJ_IS_TYPE(layer, &displayio_tilegrid_type)) {
+            displayio_tilegrid_update_transform(layer, &self->absolute_transform);
+        } else if (MP_OBJ_IS_TYPE(layer, &displayio_group_type)) {
+            displayio_group_update_transform(layer, &self->absolute_transform);
+        }
+    }
+}
+
+void displayio_group_update_transform(displayio_group_t *self,
+                                      const displayio_buffer_transform_t* parent_transform) {
+    self->in_group = parent_transform != NULL;
+    if (self->in_group) {
+        int16_t x = self->x;
+        int16_t y = self->y;
+        if (parent_transform->transpose_xy) {
+            x = y;
+            y = self->x;
+        }
+        self->absolute_transform.x = parent_transform->x + parent_transform->dx * x;
+        self->absolute_transform.y = parent_transform->y + parent_transform->dy * y;
+        self->absolute_transform.dx = parent_transform->dx * self->scale;
+        self->absolute_transform.dy = parent_transform->dy * self->scale;
+        self->absolute_transform.transpose_xy = parent_transform->transpose_xy;
+        self->absolute_transform.mirror_x = parent_transform->mirror_x;
+        self->absolute_transform.mirror_y = parent_transform->mirror_y;
+
+        self->absolute_transform.scale = parent_transform->scale * self->scale;
+    }
+    _update_child_transforms(self);
+}
+
 void common_hal_displayio_group_set_scale(displayio_group_t* self, uint32_t scale) {
-    self->needs_refresh = self->scale != scale;
+    if (self->scale == scale) {
+        return;
+    }
+    uint8_t parent_scale = self->absolute_transform.scale / self->scale;
+    self->absolute_transform.dx = self->absolute_transform.dx / self->scale * scale;
+    self->absolute_transform.dy = self->absolute_transform.dy / self->scale * scale;
+    self->absolute_transform.scale = parent_scale * scale;
     self->scale = scale;
+    _update_child_transforms(self);
 }
 
 mp_int_t common_hal_displayio_group_get_x(displayio_group_t* self) {
@@ -48,8 +124,19 @@ mp_int_t common_hal_displayio_group_get_x(displayio_group_t* self) {
 }
 
 void common_hal_displayio_group_set_x(displayio_group_t* self, mp_int_t x) {
-    self->needs_refresh = self->x != x;
+    if (self->x == x) {
+        return;
+    }
+    if (self->absolute_transform.transpose_xy) {
+        int16_t dy = self->absolute_transform.dy / self->scale;
+        self->absolute_transform.y += dy * (x - self->x);
+    } else  {
+        int16_t dx = self->absolute_transform.dx / self->scale;
+        self->absolute_transform.x += dx * (x - self->x);
+    }
+
     self->x = x;
+    _update_child_transforms(self);
 }
 
 mp_int_t common_hal_displayio_group_get_y(displayio_group_t* self) {
@@ -57,44 +144,107 @@ mp_int_t common_hal_displayio_group_get_y(displayio_group_t* self) {
 }
 
 void common_hal_displayio_group_set_y(displayio_group_t* self, mp_int_t y) {
-    self->needs_refresh = self->y != y;
+    if (self->y == y) {
+        return;
+    }
+    if (self->absolute_transform.transpose_xy) {
+        int8_t dx = self->absolute_transform.dx / self->scale;
+        self->absolute_transform.x += dx * (y - self->y);
+    } else  {
+        int8_t dy = self->absolute_transform.dy / self->scale;
+        self->absolute_transform.y += dy * (y - self->y);
+    }
     self->y = y;
+    _update_child_transforms(self);
 }
 
-void common_hal_displayio_group_insert(displayio_group_t* self, size_t index, mp_obj_t layer) {
-    if (self->size == self->max_size) {
-        mp_raise_RuntimeError(translate("Group full"));
-    }
+static mp_obj_t _add_layer(displayio_group_t* self, mp_obj_t layer) {
     mp_obj_t native_layer = mp_instance_cast_to_native_base(layer, &displayio_group_type);
     if (native_layer == MP_OBJ_NULL) {
         native_layer = mp_instance_cast_to_native_base(layer, &displayio_tilegrid_type);
+        if (native_layer == MP_OBJ_NULL) {
+            mp_raise_ValueError(translate("Layer must be a Group or TileGrid subclass."));
+        }
+        displayio_tilegrid_t* tilegrid = native_layer;
+        if (tilegrid->in_group) {
+            mp_raise_ValueError(translate("Layer already in a group."));
+        } else {
+            tilegrid->in_group = true;
+        }
+        displayio_tilegrid_update_transform(tilegrid, &self->absolute_transform);
+    } else {
+        displayio_group_t* group = native_layer;
+        if (group->in_group) {
+            mp_raise_ValueError(translate("Layer already in a group."));
+        } else {
+            group->in_group = true;
+        }
+        displayio_group_update_transform(group, &self->absolute_transform);
     }
-    if (native_layer == MP_OBJ_NULL) {
-        mp_raise_ValueError(translate("Layer must be a Group or TileGrid subclass."));
+    return native_layer;
+}
+
+static void _remove_layer(displayio_group_t* self, size_t index) {
+    mp_obj_t layer = self->children[index].native;
+    displayio_area_t layer_area;
+    bool rendered_last_frame = false;
+    if (MP_OBJ_IS_TYPE(layer, &displayio_tilegrid_type)) {
+        displayio_tilegrid_t* tilegrid = layer;
+        rendered_last_frame = displayio_tilegrid_get_previous_area(tilegrid, &layer_area);
+        displayio_tilegrid_update_transform(tilegrid, NULL);
+    } else if (MP_OBJ_IS_TYPE(layer, &displayio_group_type)) {
+        displayio_group_t* group = layer;
+        rendered_last_frame = displayio_group_get_previous_area(group, &layer_area);
+        displayio_group_update_transform(group, NULL);
+    }
+    if (!rendered_last_frame) {
+        return;
+    }
+    if (!self->item_removed) {
+        displayio_area_copy(&layer_area, &self->dirty_area);
+    } else {
+        displayio_area_expand(&self->dirty_area, &layer_area);
     }
+    self->item_removed = true;
+}
+
+void common_hal_displayio_group_insert(displayio_group_t* self, size_t index, mp_obj_t layer) {
+    if (self->size == self->max_size) {
+        mp_raise_RuntimeError(translate("Group full"));
+    }
+    mp_obj_t native_layer = _add_layer(self, layer);
     // Shift everything right.
-    for (size_t i = index; i < self->size; i++) {
-        self->children[i + 1] = self->children[i];
+    for (size_t i = self->size; i > index; i--) {
+        self->children[i] = self->children[i - 1];
     }
     self->children[index].native = native_layer;
     self->children[index].original = layer;
     self->size++;
-    self->needs_refresh = true;
 }
 
 mp_obj_t common_hal_displayio_group_pop(displayio_group_t* self, size_t index) {
     self->size--;
     mp_obj_t item = self->children[index].original;
+    _remove_layer(self, index);
+
     // Shift everything left.
     for (size_t i = index; i < self->size; i++) {
         self->children[i] = self->children[i + 1];
     }
     self->children[self->size].native = NULL;
     self->children[self->size].original = NULL;
-    self->needs_refresh = true;
     return item;
 }
 
+mp_int_t common_hal_displayio_group_index(displayio_group_t* self, mp_obj_t layer) {
+    for (size_t i = 0; i < self->size; i++) {
+        if (self->children[i].original == layer) {
+            return i;
+        }
+    }
+    return -1;
+}
+
 size_t common_hal_displayio_group_get_len(displayio_group_t* self) {
     return self->size;
 }
@@ -104,74 +254,69 @@ mp_obj_t common_hal_displayio_group_get(displayio_group_t* self, size_t index) {
 }
 
 void common_hal_displayio_group_set(displayio_group_t* self, size_t index, mp_obj_t layer) {
-    mp_obj_t native_layer = mp_instance_cast_to_native_base(layer, &displayio_group_type);
-    if (native_layer == MP_OBJ_NULL) {
-        native_layer = mp_instance_cast_to_native_base(layer, &displayio_tilegrid_type);
-    }
-    if (native_layer == MP_OBJ_NULL) {
-        mp_raise_ValueError(translate("Layer must be a Group or TileGrid subclass."));
-    }
+    mp_obj_t native_layer = _add_layer(self, layer);
+    _remove_layer(self, index);
     self->children[index].native = native_layer;
     self->children[index].original = layer;
-    self->needs_refresh = true;
 }
 
-void displayio_group_construct(displayio_group_t* self, displayio_group_child_t* child_array, uint32_t max_size, uint32_t scale) {
-    self->x = 0;
-    self->y = 0;
+void displayio_group_construct(displayio_group_t* self, displayio_group_child_t* child_array, uint32_t max_size, uint32_t scale, mp_int_t x, mp_int_t y) {
+    self->x = x;
+    self->y = y;
     self->children = child_array;
     self->max_size = max_size;
-    self->needs_refresh = false;
+    self->item_removed = false;
     self->scale = scale;
+    self->in_group = false;
 }
 
-bool displayio_group_get_pixel(displayio_group_t *self, int16_t x, int16_t y, uint16_t* pixel) {
-    x -= self->x;
-    y -= self->y;
-    x /= self->scale;
-    y /= self->scale;
+bool displayio_group_fill_area(displayio_group_t *self, const _displayio_colorspace_t* colorspace, const displayio_area_t* area, uint32_t* mask, uint32_t* buffer) {
+    // Track if any of the layers finishes filling in the given area. We can ignore any remaining
+    // layers at that point.
+    bool full_coverage = false;
     for (int32_t i = self->size - 1; i >= 0 ; i--) {
         mp_obj_t layer = self->children[i].native;
         if (MP_OBJ_IS_TYPE(layer, &displayio_tilegrid_type)) {
-            if (displayio_tilegrid_get_pixel(layer, x, y, pixel)) {
-                return true;
+            if (displayio_tilegrid_fill_area(layer, colorspace, area, mask, buffer)) {
+                full_coverage = true;
+                break;
             }
         } else if (MP_OBJ_IS_TYPE(layer, &displayio_group_type)) {
-            if (displayio_group_get_pixel(layer, x, y, pixel)) {
-                return true;
+            if (displayio_group_fill_area(layer, colorspace, area, mask, buffer)) {
+                full_coverage = true;
+                break;
             }
         }
     }
-    return false;
+    return full_coverage;
 }
 
-bool displayio_group_needs_refresh(displayio_group_t *self) {
-    if (self->needs_refresh) {
-        return true;
-    }
+void displayio_group_finish_refresh(displayio_group_t *self) {
+    self->item_removed = false;
     for (int32_t i = self->size - 1; i >= 0 ; i--) {
         mp_obj_t layer = self->children[i].native;
         if (MP_OBJ_IS_TYPE(layer, &displayio_tilegrid_type)) {
-            if (displayio_tilegrid_needs_refresh(layer)) {
-                return true;
-            }
+            displayio_tilegrid_finish_refresh(layer);
         } else if (MP_OBJ_IS_TYPE(layer, &displayio_group_type)) {
-            if (displayio_group_needs_refresh(layer)) {
-                return true;
-            }
+            displayio_group_finish_refresh(layer);
         }
     }
-    return false;
 }
 
-void displayio_group_finish_refresh(displayio_group_t *self) {
-    self->needs_refresh = false;
+displayio_area_t* displayio_group_get_refresh_areas(displayio_group_t *self, displayio_area_t* tail) {
+    if (self->item_removed) {
+        self->dirty_area.next = tail;
+        tail = &self->dirty_area;
+    }
+
     for (int32_t i = self->size - 1; i >= 0 ; i--) {
         mp_obj_t layer = self->children[i].native;
         if (MP_OBJ_IS_TYPE(layer, &displayio_tilegrid_type)) {
-            displayio_tilegrid_finish_refresh(layer);
+            tail = displayio_tilegrid_get_refresh_areas(layer, tail);
         } else if (MP_OBJ_IS_TYPE(layer, &displayio_group_type)) {
-            displayio_group_finish_refresh(layer);
+            tail = displayio_group_get_refresh_areas(layer, tail);
         }
     }
+
+    return tail;
 }
diff --git a/shared-module/displayio/Group.h b/shared-module/displayio/Group.h
index 61409959d..4e2308e56 100644
--- a/shared-module/displayio/Group.h
+++ b/shared-module/displayio/Group.h
@@ -31,6 +31,8 @@
 #include <stdint.h>
 
 #include "py/obj.h"
+#include "shared-module/displayio/area.h"
+#include "shared-module/displayio/Palette.h"
 
 typedef struct {
     mp_obj_t native;
@@ -39,18 +41,23 @@ typedef struct {
 
 typedef struct {
     mp_obj_base_t base;
+    displayio_group_child_t* children;
     int16_t x;
     int16_t y;
     uint16_t scale;
     uint16_t size;
     uint16_t max_size;
-    displayio_group_child_t* children;
-    bool needs_refresh;
+    bool item_removed;
+    bool in_group;
+    displayio_buffer_transform_t absolute_transform;
+    displayio_area_t dirty_area; // Catch all for changed area
 } displayio_group_t;
 
-void displayio_group_construct(displayio_group_t* self, displayio_group_child_t* child_array, uint32_t max_size, uint32_t scale);
-bool displayio_group_get_pixel(displayio_group_t *group, int16_t x, int16_t y, uint16_t *pixel);
-bool displayio_group_needs_refresh(displayio_group_t *self);
+void displayio_group_construct(displayio_group_t* self, displayio_group_child_t* child_array, uint32_t max_size, uint32_t scale, mp_int_t x, mp_int_t y);
+bool displayio_group_get_previous_area(displayio_group_t *group, displayio_area_t* area);
+bool displayio_group_fill_area(displayio_group_t *group, const _displayio_colorspace_t* colorspace, const displayio_area_t* area, uint32_t* mask, uint32_t *buffer);
+void displayio_group_update_transform(displayio_group_t *group, const displayio_buffer_transform_t* parent_transform);
 void displayio_group_finish_refresh(displayio_group_t *self);
+displayio_area_t* displayio_group_get_refresh_areas(displayio_group_t *self, displayio_area_t* tail);
 
 #endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_GROUP_H
diff --git a/shared-module/displayio/I2CDisplay.c b/shared-module/displayio/I2CDisplay.c
new file mode 100644
index 000000000..9d8949528
--- /dev/null
+++ b/shared-module/displayio/I2CDisplay.c
@@ -0,0 +1,105 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 Scott Shawcroft for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "shared-bindings/displayio/I2CDisplay.h"
+
+#include <stdint.h>
+#include <string.h>
+
+#include "py/gc.h"
+#include "py/runtime.h"
+#include "shared-bindings/busio/I2C.h"
+#include "shared-bindings/digitalio/DigitalInOut.h"
+#include "shared-bindings/microcontroller/__init__.h"
+#include "shared-bindings/time/__init__.h"
+
+#include "tick.h"
+
+void common_hal_displayio_i2cdisplay_construct(displayio_i2cdisplay_obj_t* self,
+    busio_i2c_obj_t* i2c, uint16_t device_address, const mcu_pin_obj_t* reset) {
+
+    // Probe the bus to see if a device acknowledges the given address.
+    if (!common_hal_busio_i2c_probe(i2c, device_address)) {
+        mp_raise_ValueError_varg(translate("Unable to find I2C Display at %x"), device_address);
+    }
+
+        // Write to the device and return 0 on success or an appropriate error code from mperrno.h
+    self->bus = i2c;
+    common_hal_busio_i2c_never_reset(self->bus);
+    // Our object is statically allocated off the heap so make sure the bus object lives to the end
+    // of the heap as well.
+    gc_never_free(self->bus);
+
+    self->address = device_address;
+
+    if (reset != NULL) {
+        common_hal_digitalio_digitalinout_construct(&self->reset, reset);
+        common_hal_digitalio_digitalinout_switch_to_output(&self->reset, true, DRIVE_MODE_PUSH_PULL);
+        never_reset_pin_number(reset->number);
+
+        common_hal_digitalio_digitalinout_set_value(&self->reset, false);
+        common_hal_mcu_delay_us(1);
+        common_hal_digitalio_digitalinout_set_value(&self->reset, true);
+    }
+}
+
+void common_hal_displayio_i2cdisplay_deinit(displayio_i2cdisplay_obj_t* self) {
+    if (self->bus == &self->inline_bus) {
+        common_hal_busio_i2c_deinit(self->bus);
+    }
+
+    reset_pin_number(self->reset.pin->number);
+}
+
+bool common_hal_displayio_i2cdisplay_begin_transaction(mp_obj_t obj) {
+    displayio_i2cdisplay_obj_t* self = MP_OBJ_TO_PTR(obj);
+    if (!common_hal_busio_i2c_try_lock(self->bus)) {
+        return false;
+    }
+    return true;
+}
+
+void common_hal_displayio_i2cdisplay_send(mp_obj_t obj, bool command, uint8_t *data, uint32_t data_length) {
+    displayio_i2cdisplay_obj_t* self = MP_OBJ_TO_PTR(obj);
+    if (command) {
+        uint8_t command_bytes[2 * data_length];
+        for (uint32_t i = 0; i < data_length; i++) {
+            command_bytes[2 * i] = 0x80;
+            command_bytes[2 * i + 1] = data[i];
+        }
+        common_hal_busio_i2c_write(self->bus, self->address, command_bytes, 2 * data_length, true);
+    } else {
+        uint8_t data_bytes[data_length + 1];
+        data_bytes[0] = 0x40;
+        memcpy(data_bytes + 1, data, data_length);
+        common_hal_busio_i2c_write(self->bus, self->address, data_bytes, data_length + 1, true);
+    }
+}
+
+void common_hal_displayio_i2cdisplay_end_transaction(mp_obj_t obj) {
+    displayio_i2cdisplay_obj_t* self = MP_OBJ_TO_PTR(obj);
+    common_hal_busio_i2c_unlock(self->bus);
+}
diff --git a/shared-module/bleio/Device.h b/shared-module/displayio/I2CDisplay.h
index 8d9ece5ef..4636c3f73 100644
--- a/shared-module/bleio/Device.h
+++ b/shared-module/displayio/I2CDisplay.h
@@ -3,7 +3,7 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2018 Artur Pacholec
+ * Copyright (c) 2019 Scott Shawcroft for Adafruit Industries
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -24,22 +24,18 @@
  * THE SOFTWARE.
  */
 
-#ifndef MICROPY_INCLUDED_SHARED_MODULE_BLEIO_DEVICE_H
-#define MICROPY_INCLUDED_SHARED_MODULE_BLEIO_DEVICE_H
+#ifndef MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_I2CDISPLAY_H
+#define MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_I2CDISPLAY_H
 
-#include <stdbool.h>
-
-#include "shared-module/bleio/Address.h"
+#include "common-hal/busio/I2C.h"
+#include "common-hal/digitalio/DigitalInOut.h"
 
 typedef struct {
     mp_obj_base_t base;
-    bool is_peripheral;
-    mp_obj_t name;
-    bleio_address_obj_t address;
-    volatile uint16_t conn_handle;
-    mp_obj_t service_list;
-    mp_obj_t notif_handler;
-    mp_obj_t conn_handler;
-} bleio_device_obj_t;
+    busio_i2c_obj_t* bus;
+    busio_i2c_obj_t inline_bus;
+    digitalio_digitalinout_obj_t reset;
+    uint16_t address;
+} displayio_i2cdisplay_obj_t;
 
-#endif // MICROPY_INCLUDED_SHARED_MODULE_BLEIO_DEVICE_H
+#endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_I2CDISPLAY_H
diff --git a/shared-module/displayio/OnDiskBitmap.c b/shared-module/displayio/OnDiskBitmap.c
index d710bdae0..2b5642437 100644
--- a/shared-module/displayio/OnDiskBitmap.c
+++ b/shared-module/displayio/OnDiskBitmap.c
@@ -68,7 +68,7 @@ void common_hal_displayio_ondiskbitmap_construct(displayio_ondiskbitmap_t *self,
             self->r_bitmask = read_word(bmp_header, 27);
             self->g_bitmask = read_word(bmp_header, 29);
             self->b_bitmask = read_word(bmp_header, 31);
-            
+
         } else { // no compression or short header means 5:5:5
             self->r_bitmask = 0x7c00;
             self->g_bitmask = 0x3e0;
@@ -114,7 +114,7 @@ void common_hal_displayio_ondiskbitmap_construct(displayio_ondiskbitmap_t *self,
         }
         self->stride = (bit_stride / 8);
     }
-   
+
 }
 
 
@@ -123,12 +123,13 @@ uint32_t common_hal_displayio_ondiskbitmap_get_pixel(displayio_ondiskbitmap_t *s
     if (x < 0 || x >= self->width || y < 0 || y >= self->height) {
         return 0;
     }
+
     uint32_t location;
     uint8_t bytes_per_pixel = (self->bits_per_pixel / 8)  ? (self->bits_per_pixel /8) : 1;
     if (self->bits_per_pixel >= 8){
-        location = self->data_offset + (self->height - y) * self->stride + x * bytes_per_pixel;
+        location = self->data_offset + (self->height - y - 1) * self->stride + x * bytes_per_pixel;
     } else {
-        location = self->data_offset + (self->height - y) * self->stride + x / 8;
+        location = self->data_offset + (self->height - y - 1) * self->stride + x / 8;
     }
     // We don't cache here because the underlying FS caches sectors.
     f_lseek(&self->file->fp, location);
@@ -140,7 +141,7 @@ uint32_t common_hal_displayio_ondiskbitmap_get_pixel(displayio_ondiskbitmap_t *s
         uint8_t red;
         uint8_t green;
         uint8_t blue;
-        if (self->bits_per_pixel == 1){
+        if (self->bits_per_pixel == 1) {
             uint8_t bit_offset = x%8;
             tmp = ( pixel_data & (0x80 >> (bit_offset))) >> (7 - bit_offset);
             if (tmp == 1) {
@@ -148,7 +149,7 @@ uint32_t common_hal_displayio_ondiskbitmap_get_pixel(displayio_ondiskbitmap_t *s
             } else {
                 return 0x00000000;
             }
-        } else if (bytes_per_pixel == 1){ 
+        } else if (bytes_per_pixel == 1) {
             blue = ((self->palette_data[pixel_data] & 0xFF) >> 0);
             red = ((self->palette_data[pixel_data] & 0xFF0000) >> 16);
             green = ((self->palette_data[pixel_data] & 0xFF00) >> 8);
diff --git a/shared-module/displayio/Palette.c b/shared-module/displayio/Palette.c
index e810be875..444151b3c 100644
--- a/shared-module/displayio/Palette.c
+++ b/shared-module/displayio/Palette.c
@@ -26,45 +26,49 @@
 
 #include "shared-bindings/displayio/Palette.h"
 
+#include "shared-module/displayio/ColorConverter.h"
+
 void common_hal_displayio_palette_construct(displayio_palette_t* self, uint16_t color_count) {
     self->color_count = color_count;
-    self->colors = (uint32_t *) m_malloc(color_count * sizeof(uint16_t), false);
-    uint32_t opaque_byte_count = color_count / 8;
-    if (color_count % 8 > 0) {
-        opaque_byte_count += 1;
-    }
-    self->opaque = (uint32_t *) m_malloc(opaque_byte_count, false);
+    self->colors = (_displayio_color_t *) m_malloc(color_count * sizeof(_displayio_color_t), false);
 }
 
 void common_hal_displayio_palette_make_opaque(displayio_palette_t* self, uint32_t palette_index) {
-    self->opaque[palette_index / 32] &= ~(0x1 << (palette_index % 32));
+    self->colors[palette_index].transparent = false;
 }
 
 void common_hal_displayio_palette_make_transparent(displayio_palette_t* self, uint32_t palette_index) {
-    self->opaque[palette_index / 32] |= (0x1 << (palette_index % 32));
+    self->colors[palette_index].transparent = true;
+}
+
+uint32_t common_hal_displayio_palette_get_len(displayio_palette_t* self) {
+    return self->color_count;
 }
 
 void common_hal_displayio_palette_set_color(displayio_palette_t* self, uint32_t palette_index, uint32_t color) {
-    uint32_t shift = (palette_index % 2) * 16;
-    uint32_t masked = self->colors[palette_index / 2] & ~(0xffff << shift);
-    uint32_t r5 = (color >> 19);
-    uint32_t g6 = (color >> 10) & 0x3f;
-    uint32_t b5 = (color >> 3) & 0x1f;
-    uint32_t packed = r5 << 11 | g6 << 5 | b5;
-    // swap bytes
-    packed = __builtin_bswap16(packed);
-    self->colors[palette_index / 2] = masked | packed << shift;
+    if (self->colors[palette_index].rgb888 == color) {
+        return;
+    }
+    self->colors[palette_index].rgb888 = color;
+    self->colors[palette_index].luma = displayio_colorconverter_compute_luma(color);
+    self->colors[palette_index].rgb565 = displayio_colorconverter_compute_rgb565(color);
     self->needs_refresh = true;
 }
 
-bool displayio_palette_get_color(displayio_palette_t *self, uint32_t palette_index, uint16_t* color) {
-    if (palette_index > self->color_count) {
-        return false;
+uint32_t common_hal_displayio_palette_get_color(displayio_palette_t* self, uint32_t palette_index) {
+    return self->colors[palette_index].rgb888;
+}
+
+bool displayio_palette_get_color(displayio_palette_t *self, const _displayio_colorspace_t* colorspace, uint32_t palette_index, uint32_t* color) {
+    if (palette_index > self->color_count || self->colors[palette_index].transparent) {
+        return false; // returns opaque
     }
-    if ((self->opaque[palette_index / 32] & (0x1 << (palette_index % 32))) != 0) {
-        return false;
+
+    if (colorspace->grayscale) {
+        *color = self->colors[palette_index].luma >> (8 - colorspace->depth);
+    } else {
+        *color = self->colors[palette_index].rgb565;
     }
-    *color = (self->colors[palette_index / 2] >> (16 * (palette_index % 2))) & 0xffff;
 
     return true;
 }
diff --git a/shared-module/displayio/Palette.h b/shared-module/displayio/Palette.h
index 5a5f1d287..a917e2432 100644
--- a/shared-module/displayio/Palette.h
+++ b/shared-module/displayio/Palette.h
@@ -33,14 +33,31 @@
 #include "py/obj.h"
 
 typedef struct {
+    uint8_t depth;
+    bool grayscale;
+    bool pixels_in_byte_share_row;
+    uint8_t bytes_per_cell;
+    bool reverse_pixels_in_byte;
+    uint8_t hue;
+} _displayio_colorspace_t;
+
+typedef struct {
+    uint32_t rgb888;
+    uint16_t rgb565;
+    uint8_t luma;
+    bool transparent; // This may have additional bits added later for blending.
+} _displayio_color_t;
+
+typedef struct {
     mp_obj_base_t base;
-    uint32_t* opaque;
-    uint32_t* colors;
-    uint8_t color_count;
+    _displayio_color_t* colors;
+    uint32_t color_count;
     bool needs_refresh;
 } displayio_palette_t;
 
-bool displayio_palette_get_color(displayio_palette_t *palette, uint32_t palette_index, uint16_t* color);
+// Returns false if color fetch did not succeed (out of range or transparent).
+// Returns true if color is opaque, and sets color.
+bool displayio_palette_get_color(displayio_palette_t *palette, const _displayio_colorspace_t* colorspace, uint32_t palette_index, uint32_t* color);
 bool displayio_palette_needs_refresh(displayio_palette_t *self);
 void displayio_palette_finish_refresh(displayio_palette_t *self);
 
diff --git a/shared-module/displayio/TileGrid.c b/shared-module/displayio/TileGrid.c
index c2aa9b144..fee2ae978 100644
--- a/shared-module/displayio/TileGrid.c
+++ b/shared-module/displayio/TileGrid.c
@@ -56,25 +56,123 @@ void common_hal_displayio_tilegrid_construct(displayio_tilegrid_t *self, mp_obj_
     self->bitmap_width_in_tiles = bitmap_width_in_tiles;
     self->width_in_tiles = width;
     self->height_in_tiles = height;
-    self->total_width = width * tile_width;
-    self->total_height = height * tile_height;
+    self->x = x;
+    self->y = y;
+    self->pixel_width = width * tile_width;
+    self->pixel_height = height * tile_height;
     self->tile_width = tile_width;
     self->tile_height = tile_height;
     self->bitmap = bitmap;
     self->pixel_shader = pixel_shader;
-    self->x = x;
-    self->y = y;
+    self->in_group = false;
+    self->first_draw = true;
+    self->flip_x = false;
+    self->flip_y = false;
+    self->transpose_xy = false;
+}
+
+bool displayio_tilegrid_get_previous_area(displayio_tilegrid_t *self, displayio_area_t* area) {
+    if (self->first_draw) {
+        return false;
+    }
+    displayio_area_copy(&self->previous_area, area);
+    return true;
+}
+
+void _update_current_x(displayio_tilegrid_t *self) {
+    int16_t width;
+    if (self->transpose_xy) {
+        width = self->pixel_height;
+    } else {
+        width = self->pixel_width;
+    }
+    if (self->absolute_transform->transpose_xy) {
+        self->current_area.y1 = self->absolute_transform->y + self->absolute_transform->dy * self->x;
+        self->current_area.y2 = self->absolute_transform->y + self->absolute_transform->dy * (self->x + width);
+        if (self->current_area.y2 < self->current_area.y1) {
+            int16_t temp = self->current_area.y2;
+            self->current_area.y2 = self->current_area.y1;
+            self->current_area.y1 = temp;
+        }
+    } else {
+        self->current_area.x1 = self->absolute_transform->x + self->absolute_transform->dx * self->x;
+        self->current_area.x2 = self->absolute_transform->x + self->absolute_transform->dx * (self->x + width);
+        if (self->current_area.x2 < self->current_area.x1) {
+            int16_t temp = self->current_area.x2;
+            self->current_area.x2 = self->current_area.x1;
+            self->current_area.x1 = temp;
+        }
+    }
 }
 
-void common_hal_displayio_tilegrid_get_position(displayio_tilegrid_t *self, int16_t* x, int16_t* y) {
-    *x = self->x;
-    *y = self->y;
+void _update_current_y(displayio_tilegrid_t *self) {
+    int16_t height;
+    if (self->transpose_xy) {
+        height = self->pixel_width;
+    } else {
+        height = self->pixel_height;
+    }
+    if (self->absolute_transform->transpose_xy) {
+        self->current_area.x1 = self->absolute_transform->x + self->absolute_transform->dx * self->y;
+        self->current_area.x2 = self->absolute_transform->x + self->absolute_transform->dx * (self->y + height);
+        if (self->current_area.x2 < self->current_area.x1) {
+            int16_t temp = self->current_area.x2;
+            self->current_area.x2 = self->current_area.x1;
+            self->current_area.x1 = temp;
+        }
+    } else {
+        self->current_area.y1 = self->absolute_transform->y + self->absolute_transform->dy * self->y;
+        self->current_area.y2 = self->absolute_transform->y + self->absolute_transform->dy * (self->y + height);
+        if (self->current_area.y2 < self->current_area.y1) {
+            int16_t temp = self->current_area.y2;
+            self->current_area.y2 = self->current_area.y1;
+            self->current_area.y1 = temp;
+        }
+    }
+}
+
+void displayio_tilegrid_update_transform(displayio_tilegrid_t *self,
+                                         const displayio_buffer_transform_t* absolute_transform) {
+    self->in_group = absolute_transform != NULL;
+    self->absolute_transform = absolute_transform;
+    if (absolute_transform != NULL) {
+        self->moved = !self->first_draw;
+
+        _update_current_x(self);
+        _update_current_y(self);
+    } else {
+        self->first_draw = true;
+    }
+}
+
+mp_int_t common_hal_displayio_tilegrid_get_x(displayio_tilegrid_t *self) {
+    return self->x;
 }
+void common_hal_displayio_tilegrid_set_x(displayio_tilegrid_t *self, mp_int_t x) {
+    if (self->x == x) {
+        return;
+    }
+
+    self->moved = !self->first_draw;
 
-void common_hal_displayio_tilegrid_set_position(displayio_tilegrid_t *self, int16_t x, int16_t y) {
-    self->needs_refresh = self->x != x || self->y != y;
     self->x = x;
+    if (self->absolute_transform != NULL) {
+        _update_current_x(self);
+    }
+}
+mp_int_t common_hal_displayio_tilegrid_get_y(displayio_tilegrid_t *self) {
+    return self->y;
+}
+
+void common_hal_displayio_tilegrid_set_y(displayio_tilegrid_t *self, mp_int_t y) {
+    if (self->y == y) {
+        return;
+    }
+    self->moved = !self->first_draw;
     self->y = y;
+    if (self->absolute_transform != NULL) {
+        _update_current_y(self);
+    }
 }
 
 mp_obj_t common_hal_displayio_tilegrid_get_pixel_shader(displayio_tilegrid_t *self) {
@@ -83,50 +181,29 @@ mp_obj_t common_hal_displayio_tilegrid_get_pixel_shader(displayio_tilegrid_t *se
 
 void common_hal_displayio_tilegrid_set_pixel_shader(displayio_tilegrid_t *self, mp_obj_t pixel_shader) {
     self->pixel_shader = pixel_shader;
-    self->needs_refresh = true;
+    self->full_change = true;
 }
 
-bool displayio_tilegrid_get_pixel(displayio_tilegrid_t *self, int16_t x, int16_t y, uint16_t* pixel) {
-    x -= self->x;
-    y -= self->y;
-    if (y < 0 || y >= self->total_height || x >= self->total_width || x < 0) {
-        return false;
-    }
+uint16_t common_hal_displayio_tilegrid_get_width(displayio_tilegrid_t *self) {
+    return self->width_in_tiles;
+}
+
+uint16_t common_hal_displayio_tilegrid_get_height(displayio_tilegrid_t *self) {
+    return self->height_in_tiles;
+}
 
+uint8_t common_hal_displayio_tilegrid_get_tile(displayio_tilegrid_t *self, uint16_t x, uint16_t y) {
     uint8_t* tiles = self->tiles;
     if (self->inline_tiles) {
         tiles = (uint8_t*) &self->tiles;
     }
     if (tiles == NULL) {
-        return false;
-    }
-    uint16_t tile_location = ((y / self->tile_height + self->top_left_y) % self->height_in_tiles) * self->width_in_tiles + (x / self->tile_width + self->top_left_x) % self->width_in_tiles;
-    uint8_t tile = tiles[tile_location];
-    uint16_t tile_x = tile_x = (tile % self->bitmap_width_in_tiles) * self->tile_width + x % self->tile_width;
-    uint16_t tile_y = tile_y = (tile / self->bitmap_width_in_tiles) * self->tile_height + y % self->tile_height;
-
-    uint32_t value = 0;
-    if (MP_OBJ_IS_TYPE(self->bitmap, &displayio_bitmap_type)) {
-        value = common_hal_displayio_bitmap_get_pixel(self->bitmap, tile_x, tile_y);
-    } else if (MP_OBJ_IS_TYPE(self->bitmap, &displayio_shape_type)) {
-        value = common_hal_displayio_shape_get_pixel(self->bitmap, tile_x, tile_y);
-    } else if (MP_OBJ_IS_TYPE(self->bitmap, &displayio_ondiskbitmap_type)) {
-        value = common_hal_displayio_ondiskbitmap_get_pixel(self->bitmap, tile_x, tile_y);
-    }
-
-    if (self->pixel_shader == mp_const_none) {
-        *pixel = value;
-        return true;
-    } else if (MP_OBJ_IS_TYPE(self->pixel_shader, &displayio_palette_type) && displayio_palette_get_color(self->pixel_shader, value, pixel)) {
-        return true;
-    } else if (MP_OBJ_IS_TYPE(self->pixel_shader, &displayio_colorconverter_type) && common_hal_displayio_colorconverter_convert(self->pixel_shader, value, pixel)) {
-        return true;
+        return 0;
     }
-
-    return false;
+    return tiles[y * self->width_in_tiles + x];
 }
 
-void common_hal_displayio_textgrid_set_tile(displayio_tilegrid_t *self, uint16_t x, uint16_t y, uint8_t tile_index) {
+void common_hal_displayio_tilegrid_set_tile(displayio_tilegrid_t *self, uint16_t x, uint16_t y, uint8_t tile_index) {
     uint8_t* tiles = self->tiles;
     if (self->inline_tiles) {
         tiles = (uint8_t*) &self->tiles;
@@ -135,22 +212,311 @@ void common_hal_displayio_textgrid_set_tile(displayio_tilegrid_t *self, uint16_t
         return;
     }
     tiles[y * self->width_in_tiles + x] = tile_index;
-    self->needs_refresh = true;
+    displayio_area_t temp_area;
+    displayio_area_t* tile_area;
+    if (!self->partial_change) {
+        tile_area = &self->dirty_area;
+    } else {
+        tile_area = &temp_area;
+    }
+    int16_t tx = (x - self->top_left_x) % self->width_in_tiles;
+    if (tx < 0) {
+        tx += self->width_in_tiles;
+    }
+    tile_area->x1 = tx * self->tile_width;
+    tile_area->x2 = tile_area->x1 + self->tile_width;
+    int16_t ty = (y - self->top_left_y) % self->height_in_tiles;
+    if (ty < 0) {
+        ty += self->height_in_tiles;
+    }
+    tile_area->y1 = ty * self->tile_height;
+    tile_area->y2 = tile_area->y1 + self->tile_height;
+
+    if (self->partial_change) {
+        displayio_area_expand(&self->dirty_area, &temp_area);
+    }
+
+    self->partial_change = true;
+}
+
+bool common_hal_displayio_tilegrid_get_flip_x(displayio_tilegrid_t *self) {
+    return self->flip_x;
+}
+
+void common_hal_displayio_tilegrid_set_flip_x(displayio_tilegrid_t *self, bool flip_x) {
+    if (self->flip_x == flip_x) {
+        return;
+    }
+    self->flip_x = flip_x;
+    self->full_change = true;
+}
+
+bool common_hal_displayio_tilegrid_get_flip_y(displayio_tilegrid_t *self) {
+    return self->flip_y;
+}
+
+void common_hal_displayio_tilegrid_set_flip_y(displayio_tilegrid_t *self, bool flip_y) {
+    if (self->flip_y == flip_y) {
+        return;
+    }
+    self->flip_y = flip_y;
+    self->full_change = true;
+}
+
+bool common_hal_displayio_tilegrid_get_transpose_xy(displayio_tilegrid_t *self) {
+    return self->transpose_xy;
 }
 
+void common_hal_displayio_tilegrid_set_transpose_xy(displayio_tilegrid_t *self, bool transpose_xy) {
+    if (self->transpose_xy == transpose_xy) {
+        return;
+    }
+    self->transpose_xy = transpose_xy;
+
+    // Square TileGrids do not change dimensions when transposed.
+    if (self->pixel_width == self->pixel_height) {
+        self->full_change = true;
+        return;
+    }
+
+    _update_current_x(self);
+    _update_current_y(self);
+
+    self->moved = true;
+}
 
-void common_hal_displayio_textgrid_set_top_left(displayio_tilegrid_t *self, uint16_t x, uint16_t y) {
+void common_hal_displayio_tilegrid_set_top_left(displayio_tilegrid_t *self, uint16_t x, uint16_t y) {
     self->top_left_x = x;
     self->top_left_y = y;
+    self->full_change = true;
 }
 
-bool displayio_tilegrid_needs_refresh(displayio_tilegrid_t *self) {
-    return self->needs_refresh || displayio_palette_needs_refresh(self->pixel_shader);
+bool displayio_tilegrid_fill_area(displayio_tilegrid_t *self, const _displayio_colorspace_t* colorspace, const displayio_area_t* area, uint32_t* mask, uint32_t *buffer) {
+    // If no tiles are present we have no impact.
+    uint8_t* tiles = self->tiles;
+    if (self->inline_tiles) {
+        tiles = (uint8_t*) &self->tiles;
+    }
+    if (tiles == NULL) {
+        return false;
+    }
+
+    displayio_area_t overlap;
+    if (!displayio_area_compute_overlap(area, &self->current_area, &overlap)) {
+        return false;
+    }
+
+    int16_t x_stride = 1;
+    int16_t y_stride = displayio_area_width(area);
+
+    bool flip_x = self->flip_x;
+    bool flip_y = self->flip_y;
+    if (self->transpose_xy != self->absolute_transform->transpose_xy) {
+        bool temp_flip = flip_x;
+        flip_x = flip_y;
+        flip_y = temp_flip;
+    }
+
+    // How many pixels are outside of our area between us and the start of the row.
+    uint16_t start = 0;
+    if ((self->absolute_transform->dx < 0) != flip_x) {
+        start += (area->x2 - area->x1 - 1) * x_stride;
+        x_stride *= -1;
+    }
+    if ((self->absolute_transform->dy < 0) != flip_y) {
+        start += (area->y2 - area->y1 - 1) * y_stride;
+        y_stride *= -1;
+    }
+
+    // Track if this layer finishes filling in the given area. We can ignore any remaining
+    // layers at that point.
+    bool full_coverage = displayio_area_equal(area, &overlap);
+
+    // TODO(tannewt): Skip coverage tracking if all pixels outside the overlap have already been
+    // set and our palette is all opaque.
+
+    // TODO(tannewt): Check to see if the pixel_shader has any transparency. If it doesn't then we
+    // can either return full coverage or bulk update the mask.
+    displayio_area_t transformed;
+    displayio_area_transform_within(flip_x != (self->absolute_transform->dx < 0), flip_y != (self->absolute_transform->dy < 0), self->transpose_xy != self->absolute_transform->transpose_xy,
+                                    &overlap,
+                                    &self->current_area,
+                                    &transformed);
+
+    int16_t start_x = (transformed.x1 - self->current_area.x1);
+    int16_t end_x = (transformed.x2 - self->current_area.x1);
+    int16_t start_y = (transformed.y1 - self->current_area.y1);
+    int16_t end_y = (transformed.y2 - self->current_area.y1);
+
+    int16_t y_shift = 0;
+    int16_t x_shift = 0;
+    if ((self->absolute_transform->dx < 0) != flip_x) {
+        x_shift = area->x2 - overlap.x2;
+    } else {
+        x_shift = overlap.x1 - area->x1;
+    }
+    if ((self->absolute_transform->dy < 0) != flip_y) {
+        y_shift = area->y2 - overlap.y2;
+    } else {
+        y_shift = overlap.y1 - area->y1;
+    }
+
+    // This untransposes x and y so it aligns with bitmap rows.
+    if (self->transpose_xy != self->absolute_transform->transpose_xy) {
+        int16_t temp_stride = x_stride;
+        x_stride = y_stride;
+        y_stride = temp_stride;
+        int16_t temp_shift = x_shift;
+        x_shift = y_shift;
+        y_shift = temp_shift;
+    }
+
+    uint8_t pixels_per_byte = 8 / colorspace->depth;
+    for (int16_t y = start_y; y < end_y; y++) {
+        int16_t row_start = start + (y - start_y + y_shift) * y_stride; // in pixels
+        int16_t local_y = y / self->absolute_transform->scale;
+        for (int16_t x = start_x; x < end_x; x++) {
+            // Compute the destination pixel in the buffer and mask based on the transformations.
+            int16_t offset = row_start + (x - start_x + x_shift) * x_stride; // in pixels
+
+            // This is super useful for debugging out of range accesses. Uncomment to use.
+            // if (offset < 0 || offset >= (int32_t) displayio_area_size(area)) {
+            //     asm("bkpt");
+            // }
+
+            // Check the mask first to see if the pixel has already been set.
+            if ((mask[offset / 32] & (1 << (offset % 32))) != 0) {
+                continue;
+            }
+            int16_t local_x = x / self->absolute_transform->scale;
+            uint16_t tile_location = ((local_y / self->tile_height + self->top_left_y) % self->height_in_tiles) * self->width_in_tiles + (local_x / self->tile_width + self->top_left_x) % self->width_in_tiles;
+            uint8_t tile = tiles[tile_location];
+            uint16_t tile_x = (tile % self->bitmap_width_in_tiles) * self->tile_width + local_x % self->tile_width;
+            uint16_t tile_y = (tile / self->bitmap_width_in_tiles) * self->tile_height + local_y % self->tile_height;
+
+            uint32_t value = 0;
+            // We always want to read bitmap pixels by row first and then transpose into the destination
+            // buffer because most bitmaps are row associated.
+            if (MP_OBJ_IS_TYPE(self->bitmap, &displayio_bitmap_type)) {
+                value = common_hal_displayio_bitmap_get_pixel(self->bitmap, tile_x, tile_y);
+            } else if (MP_OBJ_IS_TYPE(self->bitmap, &displayio_shape_type)) {
+                value = common_hal_displayio_shape_get_pixel(self->bitmap, tile_x, tile_y);
+            } else if (MP_OBJ_IS_TYPE(self->bitmap, &displayio_ondiskbitmap_type)) {
+                value = common_hal_displayio_ondiskbitmap_get_pixel(self->bitmap, tile_x, tile_y);
+            }
+
+            uint32_t pixel;
+            bool opaque = true;
+            if (self->pixel_shader == mp_const_none) {
+                pixel = value;
+            } else if (MP_OBJ_IS_TYPE(self->pixel_shader, &displayio_palette_type)) {
+                opaque = displayio_palette_get_color(self->pixel_shader, colorspace, value, &pixel);
+            } else if (MP_OBJ_IS_TYPE(self->pixel_shader, &displayio_colorconverter_type)) {
+                opaque = displayio_colorconverter_convert(self->pixel_shader, colorspace, value, &pixel);
+            }
+            if (!opaque) {
+                // A pixel is transparent so we haven't fully covered the area ourselves.
+                full_coverage = false;
+            } else {
+                mask[offset / 32] |= 1 << (offset % 32);
+                if (colorspace->depth == 16) {
+                    *(((uint16_t*) buffer) + offset) = pixel;
+                } else if (colorspace->depth == 8) {
+                    *(((uint8_t*) buffer) + offset) = pixel;
+                } else if (colorspace->depth < 8) {
+                    // Reorder the offsets to pack multiple rows into a byte (meaning they share a column).
+                    if (!colorspace->pixels_in_byte_share_row) {
+                        uint16_t width = displayio_area_width(area);
+                        uint16_t row = offset / width;
+                        uint16_t col = offset % width;
+                        // Dividing by pixels_per_byte does truncated division even if we multiply it back out.
+                        offset = col * pixels_per_byte + (row / pixels_per_byte) * pixels_per_byte * width + row % pixels_per_byte;
+                        // Also useful for validating that the bitpacking worked correctly.
+                        // if (offset > displayio_area_size(area)) {
+                        //     asm("bkpt");
+                        // }
+                    }
+                    uint8_t shift = (offset % pixels_per_byte) * colorspace->depth;
+                    if (colorspace->reverse_pixels_in_byte) {
+                        shift = (pixels_per_byte - 1) * colorspace->depth - shift;
+                    }
+                    ((uint8_t*)buffer)[offset / pixels_per_byte] |= pixel << shift;
+                }
+            }
+        }
+    }
+    return full_coverage;
 }
 
 void displayio_tilegrid_finish_refresh(displayio_tilegrid_t *self) {
-    self->needs_refresh = false;
-    displayio_palette_finish_refresh(self->pixel_shader);
+    if (self->moved || self->first_draw) {
+        displayio_area_copy(&self->current_area, &self->previous_area);
+    }
+
+    self->moved = false;
+    self->full_change = false;
+    self->partial_change = false;
+    self->first_draw = false;
+    if (MP_OBJ_IS_TYPE(self->pixel_shader, &displayio_palette_type)) {
+        displayio_palette_finish_refresh(self->pixel_shader);
+    } else if (MP_OBJ_IS_TYPE(self->pixel_shader, &displayio_colorconverter_type)) {
+        displayio_colorconverter_finish_refresh(self->pixel_shader);
+    }
     // TODO(tannewt): We could double buffer changes to position and move them over here.
     // That way they won't change during a refresh and tear.
 }
+
+displayio_area_t* displayio_tilegrid_get_refresh_areas(displayio_tilegrid_t *self, displayio_area_t* tail) {
+    if (self->moved && !self->first_draw) {
+        displayio_area_union(&self->previous_area, &self->current_area, &self->dirty_area);
+        if (displayio_area_size(&self->dirty_area) <= 2U * self->pixel_width * self->pixel_height) {
+            self->dirty_area.next = tail;
+            return &self->dirty_area;
+        }
+        self->previous_area.next = tail;
+        self->current_area.next = &self->previous_area;
+        return &self->current_area;
+    }
+
+    // We must recheck if our sources require a refresh because needs_refresh may or may not have
+    // been called.
+    self->full_change = self->full_change ||
+        (MP_OBJ_IS_TYPE(self->pixel_shader, &displayio_palette_type) &&
+         displayio_palette_needs_refresh(self->pixel_shader)) ||
+        (MP_OBJ_IS_TYPE(self->pixel_shader, &displayio_colorconverter_type) &&
+         displayio_colorconverter_needs_refresh(self->pixel_shader));
+    if (self->full_change || self->first_draw) {
+        self->current_area.next = tail;
+        return &self->current_area;
+    }
+
+    if (self->partial_change) {
+        if (self->absolute_transform->transpose_xy) {
+            int16_t x1 = self->dirty_area.x1;
+            self->dirty_area.x1 = self->absolute_transform->x + self->absolute_transform->dx * (self->y + self->dirty_area.y1);
+            self->dirty_area.y1 = self->absolute_transform->y + self->absolute_transform->dy * (self->x + x1);
+            int16_t x2 = self->dirty_area.x2;
+            self->dirty_area.x2 = self->absolute_transform->x + self->absolute_transform->dx * (self->y + self->dirty_area.y2);
+            self->dirty_area.y2 = self->absolute_transform->y + self->absolute_transform->dy * (self->x + x2);
+        } else {
+            self->dirty_area.x1 = self->absolute_transform->x + self->absolute_transform->dx * (self->x + self->dirty_area.x1);
+            self->dirty_area.y1 = self->absolute_transform->y + self->absolute_transform->dy * (self->y + self->dirty_area.y1);
+            self->dirty_area.x2 = self->absolute_transform->x + self->absolute_transform->dx * (self->x + self->dirty_area.x2);
+            self->dirty_area.y2 = self->absolute_transform->y + self->absolute_transform->dy * (self->y + self->dirty_area.y2);
+        }
+        if (self->dirty_area.y2 < self->dirty_area.y1) {
+            int16_t temp = self->dirty_area.y2;
+            self->dirty_area.y2 = self->dirty_area.y1;
+            self->dirty_area.y1 = temp;
+        }
+        if (self->dirty_area.x2 < self->dirty_area.x1) {
+            int16_t temp = self->dirty_area.x2;
+            self->dirty_area.x2 = self->dirty_area.x1;
+            self->dirty_area.x1 = temp;
+        }
+
+        self->dirty_area.next = tail;
+        return &self->dirty_area;
+    }
+    return tail;
+}
diff --git a/shared-module/displayio/TileGrid.h b/shared-module/displayio/TileGrid.h
index 59645553d..fb6033e9c 100644
--- a/shared-module/displayio/TileGrid.h
+++ b/shared-module/displayio/TileGrid.h
@@ -31,29 +31,53 @@
 #include <stdint.h>
 
 #include "py/obj.h"
+#include "shared-module/displayio/area.h"
+#include "shared-module/displayio/Palette.h"
 
 typedef struct {
     mp_obj_base_t base;
     mp_obj_t bitmap;
     mp_obj_t pixel_shader;
-    uint16_t x;
-    uint16_t y;
+    int16_t x;
+    int16_t y;
+    uint16_t pixel_width;
+    uint16_t pixel_height;
     uint16_t bitmap_width_in_tiles;
     uint16_t width_in_tiles;
     uint16_t height_in_tiles;
-    uint16_t total_width;
-    uint16_t total_height;
     uint16_t tile_width;
     uint16_t tile_height;
     uint16_t top_left_x;
     uint16_t top_left_y;
     uint8_t* tiles;
-    bool needs_refresh;
+    const displayio_buffer_transform_t* absolute_transform;
+    displayio_area_t dirty_area; // Stored as a relative area until the refresh area is fetched.
+    displayio_area_t previous_area; // Stored as an absolute area.
+    displayio_area_t current_area; // Stored as an absolute area so it applies across frames.
+    bool partial_change;
+    bool full_change;
+    bool first_draw;
+    bool moved;
     bool inline_tiles;
+    bool in_group;
+    bool flip_x;
+    bool flip_y;
+    bool transpose_xy;
 } displayio_tilegrid_t;
 
-bool displayio_tilegrid_get_pixel(displayio_tilegrid_t *self, int16_t x, int16_t y, uint16_t *pixel);
-bool displayio_tilegrid_needs_refresh(displayio_tilegrid_t *self);
+// Updating the screen is a three stage process.
+
+// The first stage is used to determine i
+displayio_area_t* displayio_tilegrid_get_refresh_areas(displayio_tilegrid_t *self, displayio_area_t* tail);
+
+// Area is always in absolute screen coordinates. Update transform is used to inform TileGrids how
+// they relate to it.
+bool displayio_tilegrid_fill_area(displayio_tilegrid_t *self, const _displayio_colorspace_t* colorspace, const displayio_area_t* area, uint32_t* mask, uint32_t *buffer);
+void displayio_tilegrid_update_transform(displayio_tilegrid_t *group, const displayio_buffer_transform_t* parent_transform);
+
+// Fills in area with the maximum bounds of all related pixels in the last rendered frame. Returns
+// false if the tilegrid wasn't rendered in the last frame.
+bool displayio_tilegrid_get_previous_area(displayio_tilegrid_t *self, displayio_area_t* area);
 void displayio_tilegrid_finish_refresh(displayio_tilegrid_t *self);
 
 #endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_TILEGRID_H
diff --git a/shared-module/displayio/__init__.c b/shared-module/displayio/__init__.c
index 546a46b1e..8f6e650a1 100644
--- a/shared-module/displayio/__init__.c
+++ b/shared-module/displayio/__init__.c
@@ -1,25 +1,112 @@
 
 #include <string.h>
+
 #include "shared-module/displayio/__init__.h"
 
 #include "lib/utils/interrupt_char.h"
+#include "py/gc.h"
 #include "py/reload.h"
 #include "py/runtime.h"
+#include "shared-bindings/board/__init__.h"
 #include "shared-bindings/displayio/Bitmap.h"
 #include "shared-bindings/displayio/Display.h"
 #include "shared-bindings/displayio/Group.h"
 #include "shared-bindings/displayio/Palette.h"
+#include "shared-module/displayio/area.h"
 #include "supervisor/shared/autoreload.h"
 #include "supervisor/shared/display.h"
 #include "supervisor/memory.h"
 #include "supervisor/usb.h"
 
 primary_display_t displays[CIRCUITPY_DISPLAY_LIMIT];
+uint32_t frame_count = 0;
+
+bool refresh_area(displayio_display_obj_t* display, const displayio_area_t* area) {
+    uint16_t buffer_size = 128; // In uint32_ts
+
+    displayio_area_t clipped;
+    // Clip the area to the display by overlapping the areas. If there is no overlap then we're done.
+    if (!displayio_display_clip_area(display, area, &clipped)) {
+        return true;
+    }
+    uint16_t subrectangles = 1;
+    uint16_t rows_per_buffer = displayio_area_height(&clipped);
+    uint8_t pixels_per_word = (sizeof(uint32_t) * 8) / display->colorspace.depth;
+    uint16_t pixels_per_buffer = displayio_area_size(&clipped);
+    if (displayio_area_size(&clipped) > buffer_size * pixels_per_word) {
+        rows_per_buffer = buffer_size * pixels_per_word / displayio_area_width(&clipped);
+        if (rows_per_buffer == 0) {
+            rows_per_buffer = 1;
+        }
+        // If pixels are packed by column then ensure rows_per_buffer is on a byte boundary.
+        if (display->colorspace.depth < 8 && !display->colorspace.pixels_in_byte_share_row) {
+            uint8_t pixels_per_byte = 8 / display->colorspace.depth;
+            if (rows_per_buffer % pixels_per_byte != 0) {
+                rows_per_buffer -= rows_per_buffer % pixels_per_byte;
+            }
+        }
+        subrectangles = displayio_area_height(&clipped) / rows_per_buffer;
+        if (displayio_area_height(&clipped) % rows_per_buffer != 0) {
+            subrectangles++;
+        }
+        pixels_per_buffer = rows_per_buffer * displayio_area_width(&clipped);
+        buffer_size = pixels_per_buffer / pixels_per_word;
+        if (pixels_per_buffer % pixels_per_word) {
+            buffer_size += 1;
+        }
+    }
+
+    // Allocated and shared as a uint32_t array so the compiler knows the
+    // alignment everywhere.
+    uint32_t buffer[buffer_size];
+    volatile uint32_t mask_length = (pixels_per_buffer / 32) + 1;
+    uint32_t mask[mask_length];
+    uint16_t remaining_rows = displayio_area_height(&clipped);
+
+    for (uint16_t j = 0; j < subrectangles; j++) {
+        displayio_area_t subrectangle = {
+            .x1 = clipped.x1,
+            .y1 = clipped.y1 + rows_per_buffer * j,
+            .x2 = clipped.x2,
+            .y2 = clipped.y1 + rows_per_buffer * (j + 1)
+        };
+        if (remaining_rows < rows_per_buffer) {
+            subrectangle.y2 = subrectangle.y1 + remaining_rows;
+        }
+        remaining_rows -= rows_per_buffer;
 
-static inline void swap(uint16_t* a, uint16_t* b) {
-    uint16_t temp = *a;
-    *a = *b;
-    *b = temp;
+        displayio_display_begin_transaction(display);
+        displayio_display_set_region_to_update(display, &subrectangle);
+        displayio_display_end_transaction(display);
+
+        uint16_t subrectangle_size_bytes;
+        if (display->colorspace.depth >= 8) {
+            subrectangle_size_bytes = displayio_area_size(&subrectangle) * (display->colorspace.depth / 8);
+        } else {
+            subrectangle_size_bytes = displayio_area_size(&subrectangle) / (8 / display->colorspace.depth);
+        }
+
+        for (uint16_t k = 0; k < mask_length; k++) {
+            mask[k] = 0x00000000;
+        }
+        for (uint16_t k = 0; k < buffer_size; k++) {
+            buffer[k] = 0x00000000;
+        }
+
+        displayio_display_fill_area(display, &subrectangle, mask, buffer);
+
+        if (!displayio_display_begin_transaction(display)) {
+            // Can't acquire display bus; skip the rest of the data. Try next display.
+            return false;
+        }
+        displayio_display_send_pixels(display, (uint8_t*) buffer, subrectangle_size_bytes);
+        displayio_display_end_transaction(display);
+
+        // TODO(tannewt): Make refresh displays faster so we don't starve other
+        // background tasks.
+        usb_background();
+    }
+    return true;
 }
 
 // Check for recursive calls to displayio_refresh_displays.
@@ -29,10 +116,8 @@ void displayio_refresh_displays(void) {
     if (mp_hal_is_interrupted()) {
         return;
     }
-    // Somehow reloads from the sdcard are being lost. So, cheat and reraise.
-    // But don't re-raise if already pending.
-    if (reload_requested && MP_STATE_VM(mp_pending_exception) == MP_OBJ_NULL) {
-        mp_raise_reload_exception();
+    if (reload_requested) {
+        // Reload is about to happen, so don't redisplay.
         return;
     }
 
@@ -56,105 +141,19 @@ void displayio_refresh_displays(void) {
             // Too soon. Try next display.
             continue;
         }
-        if (displayio_display_refresh_queued(display)) {
-            // We compute the pixels. r and c are row and column to match the display memory
-            // structure. x and y match location within the groups.
-            uint16_t c0 = 0;
-            uint16_t r0 = 0;
-            uint16_t c1 = display->width;
-            uint16_t r1 = display->height;
-            if (display->transpose_xy) {
-                swap(&c1, &r1);
-            }
-
-            if (!displayio_display_begin_transaction(display)) {
-                // Can't acquire display bus; skip updating this display. Try next display.
-                continue;
-            }
-            displayio_display_set_region_to_update(display, c0, r0, c1, r1);
-            displayio_display_end_transaction(display);
-
-            uint16_t x0 = 0;
-            uint16_t x1 = display->width - 1;
-            uint16_t startx = 0;
-            int8_t dx = 1;
-            if (display->mirror_x) {
-                dx = -1;
-                startx = x1;
-            }
-            uint16_t y0 = 0;
-            uint16_t y1 = display->height - 1;
-            uint16_t starty = 0;
-            int8_t dy = 1;
-            if (display->mirror_y) {
-                dy = -1;
-                starty = y1;
-            }
-
-            bool transpose = false;
-            if (display->transpose_xy) {
-                transpose = true;
-                int8_t temp_dx = dx;
-                dx = dy;
-                dy = temp_dx;
-
-                swap(&starty, &startx);
-                swap(&x0, &y0);
-                swap(&x1, &y1);
-            }
-
-            size_t index = 0;
-            uint16_t buffer_size = 256;
-            uint32_t buffer[buffer_size / 2];
-            bool skip_this_display = false;
-
-            for (uint16_t y = starty; y0 <= y && y <= y1; y += dy) {
-                for (uint16_t x = startx; x0 <= x && x <= x1; x += dx) {
-                    uint16_t* pixel = &(((uint16_t*)buffer)[index]);
-                    *pixel = 0;
-
-                    if (display->current_group != NULL) {
-                        if (transpose) {
-                            displayio_group_get_pixel(display->current_group, y, x, pixel);
-                        } else {
-                            displayio_group_get_pixel(display->current_group, x, y, pixel);
-                        }
-                    }
-
-                    index += 1;
-                    // The buffer is full, send it.
-                    if (index >= buffer_size) {
-                        if (!displayio_display_begin_transaction(display)) {
-                            // Can't acquire display bus; skip the rest of the data. Try next display.
-                            index = 0;
-                            skip_this_display = true;
-                            break;
-                        }
-                        displayio_display_send_pixels(display, buffer, buffer_size / 2);
-                        displayio_display_end_transaction(display);
-                        // TODO(tannewt): Make refresh displays faster so we don't starve other
-                        // background tasks.
-                        usb_background();
-                        index = 0;
-                    }
-                }
-            }
-
-            if (skip_this_display) {
-                // Go on to next display.
-                continue;
-            }
-            // Send the remaining data.
-            if (index) {
-                if (!displayio_display_begin_transaction(display)) {
-                    // Can't get display bus. Skip the rest of the data. Try next display.
-                    continue;
-                }
-                displayio_display_send_pixels(display, buffer, index * 2);
-            }
-            displayio_display_end_transaction(display);
+        if (!displayio_display_begin_transaction(display)) {
+            // Can't acquire display bus; skip updating this display. Try next display.
+            continue;
+        }
+        displayio_display_end_transaction(display);
+        displayio_display_start_refresh(display);
+        const displayio_area_t* current_area = displayio_display_get_refresh_areas(display);
+        while (current_area != NULL) {
+            refresh_area(display, current_area);
+            current_area = current_area->next;
         }
         displayio_display_finish_refresh(display);
+        frame_count++;
     }
 
     // All done.
@@ -168,6 +167,8 @@ void common_hal_displayio_release_displays(void) {
             continue;
         } else if (bus_type == &displayio_fourwire_type) {
             common_hal_displayio_fourwire_deinit(&displays[i].fourwire_bus);
+        } else if (bus_type == &displayio_i2cdisplay_type) {
+            common_hal_displayio_i2cdisplay_deinit(&displays[i].i2cdisplay_bus);
         } else if (bus_type == &displayio_parallelbus_type) {
             common_hal_displayio_parallelbus_deinit(&displays[i].parallel_bus);
         }
@@ -182,37 +183,210 @@ void common_hal_displayio_release_displays(void) {
 }
 
 void reset_displays(void) {
-    #if CIRCUITPY_DISPLAYIO
     // The SPI buses used by FourWires may be allocated on the heap so we need to move them inline.
     for (uint8_t i = 0; i < CIRCUITPY_DISPLAY_LIMIT; i++) {
-        if (displays[i].fourwire_bus.base.type != &displayio_fourwire_type) {
-            continue;
-        }
-        displayio_fourwire_obj_t* fourwire = &displays[i].fourwire_bus;
-        if (((uint32_t) fourwire->bus) < ((uint32_t) &displays) ||
-            ((uint32_t) fourwire->bus) > ((uint32_t) &displays + CIRCUITPY_DISPLAY_LIMIT)) {
-            busio_spi_obj_t* original_spi = fourwire->bus;
-            if (original_spi == board_spi()) {
-                continue;
+        if (displays[i].fourwire_bus.base.type == &displayio_fourwire_type) {
+            displayio_fourwire_obj_t* fourwire = &displays[i].fourwire_bus;
+            if (((uint32_t) fourwire->bus) < ((uint32_t) &displays) ||
+                ((uint32_t) fourwire->bus) > ((uint32_t) &displays + CIRCUITPY_DISPLAY_LIMIT)) {
+                busio_spi_obj_t* original_spi = fourwire->bus;
+                #if BOARD_SPI
+                    // We don't need to move original_spi if it is the board.SPI object because it is
+                    // statically allocated already. (Doing so would also make it impossible to reference in
+                    // a subsequent VM run.)
+                    if (original_spi == common_hal_board_get_spi()) {
+                        continue;
+                    }
+                #endif
+                memcpy(&fourwire->inline_bus, original_spi, sizeof(busio_spi_obj_t));
+                fourwire->bus = &fourwire->inline_bus;
+                // Check for other displays that use the same spi bus and swap them too.
+                for (uint8_t j = i + 1; j < CIRCUITPY_DISPLAY_LIMIT; j++) {
+                    if (displays[i].fourwire_bus.base.type == &displayio_fourwire_type &&
+                            displays[i].fourwire_bus.bus == original_spi) {
+                        displays[i].fourwire_bus.bus = &fourwire->inline_bus;
+                    }
+                }
             }
-            memcpy(&fourwire->inline_bus, original_spi, sizeof(busio_spi_obj_t));
-            fourwire->bus = &fourwire->inline_bus;
-            // Check for other displays that use the same spi bus and swap them too.
-            for (uint8_t j = i + 1; j < CIRCUITPY_DISPLAY_LIMIT; j++) {
-                if (displays[i].fourwire_bus.bus == original_spi) {
-                    displays[i].fourwire_bus.bus = &fourwire->inline_bus;
+        } else if (displays[i].i2cdisplay_bus.base.type == &displayio_i2cdisplay_type) {
+            displayio_i2cdisplay_obj_t* i2c = &displays[i].i2cdisplay_bus;
+            if (((uint32_t) i2c->bus) < ((uint32_t) &displays) ||
+                ((uint32_t) i2c->bus) > ((uint32_t) &displays + CIRCUITPY_DISPLAY_LIMIT)) {
+                busio_i2c_obj_t* original_i2c = i2c->bus;
+                #if BOARD_I2C
+                    // We don't need to move original_i2c if it is the board.SPI object because it is
+                    // statically allocated already. (Doing so would also make it impossible to reference in
+                    // a subsequent VM run.)
+                    if (original_i2c == common_hal_board_get_i2c()) {
+                        continue;
+                    }
+                #endif
+                memcpy(&i2c->inline_bus, original_i2c, sizeof(busio_i2c_obj_t));
+                i2c->bus = &i2c->inline_bus;
+                // Check for other displays that use the same i2c bus and swap them too.
+                for (uint8_t j = i + 1; j < CIRCUITPY_DISPLAY_LIMIT; j++) {
+                    if (displays[i].i2cdisplay_bus.base.type == &displayio_i2cdisplay_type &&
+                            displays[i].i2cdisplay_bus.bus == original_i2c) {
+                        displays[i].i2cdisplay_bus.bus = &i2c->inline_bus;
+                    }
                 }
             }
+        } else {
+            // Not an active display.
+            continue;
         }
+
+        // Reset the displayed group. Only the first will get the terminal but
+        // that's ok.
+        displayio_display_obj_t* display = &displays[i].display;
+        display->auto_brightness = true;
+        common_hal_displayio_display_show(display, &circuitpython_splash);
     }
+}
 
+void displayio_gc_collect(void) {
     for (uint8_t i = 0; i < CIRCUITPY_DISPLAY_LIMIT; i++) {
         if (displays[i].display.base.type == NULL) {
             continue;
         }
-        displayio_display_obj_t* display = &displays[i].display;
-        display->auto_brightness = true;
-        common_hal_displayio_display_show(display, &circuitpython_splash);
+
+        // Alternatively, we could use gc_collect_root over the whole object,
+        // but this is more precise, and is the only field that needs marking.
+        gc_collect_ptr(displays[i].display.current_group);
+
+    }
+}
+
+void displayio_area_expand(displayio_area_t* original, const displayio_area_t* addition) {
+    if (addition->x1 < original->x1) {
+        original->x1 = addition->x1;
+    }
+    if (addition->y1 < original->y1) {
+        original->y1 = addition->y1;
+    }
+    if (addition->x2 > original->x2) {
+        original->x2 = addition->x2;
+    }
+    if (addition->y2 > original->y2) {
+        original->y2 = addition->y2;
+    }
+}
+
+void displayio_area_copy(const displayio_area_t* src, displayio_area_t* dst) {
+    dst->x1 = src->x1;
+    dst->y1 = src->y1;
+    dst->x2 = src->x2;
+    dst->y2 = src->y2;
+}
+
+void displayio_area_scale(displayio_area_t* area, uint16_t scale) {
+    area->x1 *= scale;
+    area->y1 *= scale;
+    area->x2 *= scale;
+    area->y2 *= scale;
+}
+
+void displayio_area_shift(displayio_area_t* area, int16_t dx, int16_t dy) {
+    area->x1 += dx;
+    area->y1 += dy;
+    area->x2 += dx;
+    area->y2 += dy;
+}
+
+bool displayio_area_compute_overlap(const displayio_area_t* a,
+                                    const displayio_area_t* b,
+                                    displayio_area_t* overlap) {
+    overlap->x1 = a->x1;
+    if (b->x1 > overlap->x1) {
+        overlap->x1 = b->x1;
+    }
+    overlap->x2 = a->x2;
+    if (b->x2 < overlap->x2) {
+        overlap->x2 = b->x2;
+    }
+    if (overlap->x1 >= overlap->x2) {
+        return false;
+    }
+    overlap->y1 = a->y1;
+    if (b->y1 > overlap->y1) {
+        overlap->y1 = b->y1;
+    }
+    overlap->y2 = a->y2;
+    if (b->y2 < overlap->y2) {
+        overlap->y2 = b->y2;
+    }
+    if (overlap->y1 >= overlap->y2) {
+        return false;
+    }
+    return true;
+}
+
+void displayio_area_union(const displayio_area_t* a,
+                          const displayio_area_t* b,
+                          displayio_area_t* u) {
+    u->x1 = a->x1;
+    if (b->x1 < u->x1) {
+        u->x1 = b->x1;
+    }
+    u->x2 = a->x2;
+    if (b->x2 > u->x2) {
+        u->x2 = b->x2;
+    }
+
+    u->y1 = a->y1;
+    if (b->y1 < u->y1) {
+        u->y1 = b->y1;
+    }
+    u->y2 = a->y2;
+    if (b->y2 > u->y2) {
+        u->y2 = b->y2;
+    }
+}
+
+uint16_t displayio_area_width(const displayio_area_t* area) {
+    return area->x2 - area->x1;
+}
+
+uint16_t displayio_area_height(const displayio_area_t* area) {
+    return area->y2 - area->y1;
+}
+
+uint32_t displayio_area_size(const displayio_area_t* area) {
+    return displayio_area_width(area) * displayio_area_height(area);
+}
+
+bool displayio_area_equal(const displayio_area_t* a, const displayio_area_t* b) {
+    return a->x1 == b->x1 &&
+           a->y1 == b->y1 &&
+           a->x2 == b->x2 &&
+           a->y2 == b->y2;
+}
+
+// Original and whole must be in the same coordinate space.
+void displayio_area_transform_within(bool mirror_x, bool mirror_y, bool transpose_xy,
+                                     const displayio_area_t* original,
+                                     const displayio_area_t* whole,
+                                     displayio_area_t* transformed) {
+    if (mirror_x) {
+        transformed->x1 = whole->x1 + (whole->x2 - original->x2);
+        transformed->x2 = whole->x2 - (original->x1 - whole->x1);
+    } else {
+        transformed->x1 = original->x1;
+        transformed->x2 = original->x2;
+    }
+    if (mirror_y) {
+        transformed->y1 = whole->y1 + (whole->y2 - original->y2);
+        transformed->y2 = whole->y2 - (original->y1 - whole->y1);
+    } else {
+        transformed->y1 = original->y1;
+        transformed->y2 = original->y2;
+    }
+    if (transpose_xy) {
+        int16_t y1 = transformed->y1;
+        int16_t y2 = transformed->y2;
+        transformed->y1 = whole->y1 + (transformed->x1 - whole->x1);
+        transformed->y2 = whole->y1 + (transformed->x2 - whole->x1);
+        transformed->x2 = whole->x1 + (y2 - whole->y1);
+        transformed->x1 = whole->x1 + (y1 - whole->y1);
     }
-    #endif
 }
diff --git a/shared-module/displayio/__init__.h b/shared-module/displayio/__init__.h
index 5b56ed55c..caa5ce36d 100644
--- a/shared-module/displayio/__init__.h
+++ b/shared-module/displayio/__init__.h
@@ -24,17 +24,19 @@
  * THE SOFTWARE.
  */
 
-#ifndef MICROPY_INCLUDED_SHARED_BINDINGS_DISPLAYIO___INIT___H
-#define MICROPY_INCLUDED_SHARED_BINDINGS_DISPLAYIO___INIT___H
+#ifndef MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO___INIT___H
+#define MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO___INIT___H
 
 #include "shared-bindings/displayio/Display.h"
 #include "shared-bindings/displayio/FourWire.h"
 #include "shared-bindings/displayio/Group.h"
+#include "shared-bindings/displayio/I2CDisplay.h"
 #include "shared-bindings/displayio/ParallelBus.h"
 
 typedef struct {
     union {
         displayio_fourwire_obj_t fourwire_bus;
+        displayio_i2cdisplay_obj_t i2cdisplay_bus;
         displayio_parallelbus_obj_t parallel_bus;
     };
     displayio_display_obj_t display;
@@ -46,5 +48,6 @@ extern displayio_group_t circuitpython_splash;
 
 void displayio_refresh_displays(void);
 void reset_displays(void);
+void displayio_gc_collect(void);
 
-#endif // MICROPY_INCLUDED_SHARED_BINDINGS_DISPLAYIO___INIT___H
+#endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO___INIT___H
diff --git a/shared-module/displayio/area.h b/shared-module/displayio/area.h
new file mode 100644
index 000000000..ec7c389b4
--- /dev/null
+++ b/shared-module/displayio/area.h
@@ -0,0 +1,73 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Scott Shawcroft for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_AREA_H
+#define MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_AREA_H
+
+// Implementations are in __init__.c
+typedef struct _displayio_area_t displayio_area_t;
+
+struct _displayio_area_t {
+    int16_t x1;
+    int16_t y1;
+    int16_t x2; // Second point is exclusive.
+    int16_t y2;
+    const displayio_area_t* next; // Next area in the linked list.
+};
+
+typedef struct {
+    uint16_t x;
+    uint16_t y;
+    int8_t dx;
+    int8_t dy;
+    uint8_t scale;
+    uint16_t width;
+    uint16_t height;
+    bool mirror_x;
+    bool mirror_y;
+    bool transpose_xy;
+} displayio_buffer_transform_t;
+
+void displayio_area_union(const displayio_area_t* a,
+                          const displayio_area_t* b,
+                          displayio_area_t* u);
+void displayio_area_expand(displayio_area_t* original, const displayio_area_t* addition);
+void displayio_area_copy(const displayio_area_t* src, displayio_area_t* dst);
+void displayio_area_scale(displayio_area_t* area, uint16_t scale);
+void displayio_area_shift(displayio_area_t* area, int16_t dx, int16_t dy);
+bool displayio_area_compute_overlap(const displayio_area_t* a,
+                                    const displayio_area_t* b,
+                                    displayio_area_t* overlap);
+uint16_t displayio_area_width(const displayio_area_t* area);
+uint16_t displayio_area_height(const displayio_area_t* area);
+uint32_t displayio_area_size(const displayio_area_t* area);
+bool displayio_area_equal(const displayio_area_t* a, const displayio_area_t* b);
+void displayio_area_transform_within(bool mirror_x, bool mirror_y, bool transpose_xy,
+                                     const displayio_area_t* original,
+                                     const displayio_area_t* whole,
+                                     displayio_area_t* transformed);
+
+#endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_AREA_H
diff --git a/shared-module/displayio/BuiltinFont.c b/shared-module/fontio/BuiltinFont.c
index ee69b423c..58820d524 100644
--- a/shared-module/displayio/BuiltinFont.c
+++ b/shared-module/fontio/BuiltinFont.c
@@ -24,25 +24,25 @@
  * THE SOFTWARE.
  */
 
-#include "shared-bindings/displayio/BuiltinFont.h"
+#include "shared-bindings/fontio/BuiltinFont.h"
 
 
-#include "shared-bindings/displayio/Glyph.h"
+#include "shared-bindings/fontio/Glyph.h"
 
 #include "py/objnamedtuple.h"
 
-mp_obj_t common_hal_displayio_builtinfont_get_bitmap(const displayio_builtinfont_t *self) {
+mp_obj_t common_hal_fontio_builtinfont_get_bitmap(const fontio_builtinfont_t *self) {
     return MP_OBJ_FROM_PTR(self->bitmap);
 }
 
-mp_obj_t common_hal_displayio_builtinfont_get_bounding_box(const displayio_builtinfont_t *self) {
+mp_obj_t common_hal_fontio_builtinfont_get_bounding_box(const fontio_builtinfont_t *self) {
     mp_obj_t *items = m_new(mp_obj_t, 2);
     items[0] = MP_OBJ_NEW_SMALL_INT(self->width);
     items[1] = MP_OBJ_NEW_SMALL_INT(self->height);
     return mp_obj_new_tuple(2, items);
 }
 
-uint8_t displayio_builtinfont_get_glyph_index(const displayio_builtinfont_t *self, mp_uint_t codepoint) {
+uint8_t fontio_builtinfont_get_glyph_index(const fontio_builtinfont_t *self, mp_uint_t codepoint) {
     if (codepoint >= 0x20 && codepoint <= 0x7e) {
         return codepoint - 0x20;
     }
@@ -60,8 +60,8 @@ uint8_t displayio_builtinfont_get_glyph_index(const displayio_builtinfont_t *sel
     return 0xff;
 }
 
-mp_obj_t common_hal_displayio_builtinfont_get_glyph(const displayio_builtinfont_t *self, mp_uint_t codepoint) {
-    uint8_t glyph_index = displayio_builtinfont_get_glyph_index(self, codepoint);
+mp_obj_t common_hal_fontio_builtinfont_get_glyph(const fontio_builtinfont_t *self, mp_uint_t codepoint) {
+    uint8_t glyph_index = fontio_builtinfont_get_glyph_index(self, codepoint);
     if (glyph_index == 0xff) {
         return mp_const_none;
     }
@@ -75,5 +75,5 @@ mp_obj_t common_hal_displayio_builtinfont_get_glyph(const displayio_builtinfont_
         MP_OBJ_NEW_SMALL_INT(self->width),
         MP_OBJ_NEW_SMALL_INT(0)
     };
-    return namedtuple_make_new((const mp_obj_type_t*) &displayio_glyph_type, 8, field_values, NULL);
+    return namedtuple_make_new((const mp_obj_type_t*) &fontio_glyph_type, 8, field_values, NULL);
 }
diff --git a/shared-module/displayio/BuiltinFont.h b/shared-module/fontio/BuiltinFont.h
index ac69ef9da..30b4ade8c 100644
--- a/shared-module/displayio/BuiltinFont.h
+++ b/shared-module/fontio/BuiltinFont.h
@@ -24,8 +24,8 @@
  * THE SOFTWARE.
  */
 
-#ifndef MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_BUILTINFONT_H
-#define MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_BUILTINFONT_H
+#ifndef MICROPY_INCLUDED_SHARED_MODULE_FONTIO_BUILTINFONT_H
+#define MICROPY_INCLUDED_SHARED_MODULE_FONTIO_BUILTINFONT_H
 
 #include <stdbool.h>
 #include <stdint.h>
@@ -40,8 +40,8 @@ typedef struct {
     uint8_t height;
     const byte* unicode_characters;
     uint16_t unicode_characters_len;
-} displayio_builtinfont_t;
+} fontio_builtinfont_t;
 
-uint8_t displayio_builtinfont_get_glyph_index(const displayio_builtinfont_t *self, mp_uint_t codepoint);
+uint8_t fontio_builtinfont_get_glyph_index(const fontio_builtinfont_t *self, mp_uint_t codepoint);
 
-#endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_BUILTINFONT_H
+#endif // MICROPY_INCLUDED_SHARED_MODULE_FONTIO_BUILTINFONT_H
diff --git a/shared-module/fontio/__init__.c b/shared-module/fontio/__init__.c
new file mode 100644
index 000000000..674343c53
--- /dev/null
+++ b/shared-module/fontio/__init__.c
@@ -0,0 +1,27 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2016 Scott Shawcroft
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+// Nothing now.
diff --git a/shared-module/gamepad/GamePad.c b/shared-module/gamepad/GamePad.c
index 2c14fa02a..fdce0caab 100644
--- a/shared-module/gamepad/GamePad.c
+++ b/shared-module/gamepad/GamePad.c
@@ -24,27 +24,20 @@
  * THE SOFTWARE.
  */
 
-#include <stdbool.h>
-
 #include "py/mpstate.h"
-#include "__init__.h"
-#include "GamePad.h"
-
-#include "shared-bindings/digitalio/Pull.h"
 #include "shared-bindings/digitalio/DigitalInOut.h"
-#include "shared-bindings/util.h"
-
+#include "shared-bindings/gamepad/GamePad.h"
 
-void gamepad_init(size_t n_pins, const mp_obj_t* pins) {
-    gamepad_obj_t* gamepad_singleton = MP_STATE_VM(gamepad_singleton);
+void common_hal_gamepad_gamepad_init(gamepad_obj_t *gamepad,
+                  const mp_obj_t pins[], size_t n_pins) {
     for (size_t i = 0; i < 8; ++i) {
-        gamepad_singleton->pins[i] = NULL;
+        gamepad->pins[i] = NULL;
     }
-    gamepad_singleton->pulls = 0;
+    gamepad->pulls = 0;
     for (size_t i = 0; i < n_pins; ++i) {
         digitalio_digitalinout_obj_t *pin = MP_OBJ_TO_PTR(pins[i]);
-        digitalio_direction_t direction = common_hal_digitalio_digitalinout_get_direction(pin);
-        if (direction != DIRECTION_INPUT) {
+        if (common_hal_digitalio_digitalinout_get_direction(pin) !=
+            DIRECTION_INPUT) {
             common_hal_digitalio_digitalinout_switch_to_input(pin, PULL_UP);
         }
         digitalio_pull_t pull = common_hal_digitalio_digitalinout_get_pull(pin);
@@ -52,9 +45,13 @@ void gamepad_init(size_t n_pins, const mp_obj_t* pins) {
             common_hal_digitalio_digitalinout_set_pull(pin, PULL_UP);
         }
         if (pull != PULL_DOWN) {
-            gamepad_singleton->pulls |= 1 << i;
+            gamepad->pulls |= 1 << i;
         }
-        gamepad_singleton->pins[i] = pin;
+        gamepad->pins[i] = pin;
     }
-    gamepad_singleton->last = 0;
+    gamepad->last = 0;
+}
+
+void common_hal_gamepad_gamepad_deinit(gamepad_obj_t *self) {
+    MP_STATE_VM(gamepad_singleton) = NULL;
 }
diff --git a/shared-module/gamepad/GamePad.h b/shared-module/gamepad/GamePad.h
index 9fd5c9626..048fbcd2b 100644
--- a/shared-module/gamepad/GamePad.h
+++ b/shared-module/gamepad/GamePad.h
@@ -39,6 +39,4 @@ typedef struct {
     uint8_t pulls;
 } gamepad_obj_t;
 
-void gamepad_init(size_t n_pins, const mp_obj_t* pins);
-
 #endif  // MICROPY_INCLUDED_GAMEPAD_GAMEPAD_H
diff --git a/shared-module/gamepad/__init__.c b/shared-module/gamepad/__init__.c
index 8414ddfbe..3e17a0fb5 100644
--- a/shared-module/gamepad/__init__.c
+++ b/shared-module/gamepad/__init__.c
@@ -27,32 +27,35 @@
 #include <stdbool.h>
 
 #include "py/mpstate.h"
-#include "__init__.h"
-#include "GamePad.h"
+#include "shared-bindings/gamepad/__init__.h"
+#include "shared-bindings/gamepad/GamePad.h"
 
 #include "shared-bindings/digitalio/DigitalInOut.h"
 
 
 void gamepad_tick(void) {
-    gamepad_obj_t* gamepad_singleton = MP_STATE_VM(gamepad_singleton);
-    if (!gamepad_singleton) {
+    uint8_t current = 0;
+    uint8_t bit = 1;
+
+    void* singleton = MP_STATE_VM(gamepad_singleton);
+    if (singleton == NULL || !MP_OBJ_IS_TYPE(MP_OBJ_FROM_PTR(singleton), &gamepad_type)) {
         return;
     }
-    uint8_t gamepad_current = 0;
-    uint8_t bit = 1;
+
+    gamepad_obj_t *self = MP_OBJ_TO_PTR(singleton);
     for (int i = 0; i < 8; ++i) {
-        digitalio_digitalinout_obj_t* pin = gamepad_singleton->pins[i];
+        digitalio_digitalinout_obj_t* pin = self->pins[i];
         if (!pin) {
             break;
         }
         if (common_hal_digitalio_digitalinout_get_value(pin)) {
-            gamepad_current |= bit;
+            current |= bit;
         }
         bit <<= 1;
     }
-    gamepad_current ^= gamepad_singleton->pulls;
-    gamepad_singleton->pressed |= gamepad_singleton->last & gamepad_current;
-    gamepad_singleton->last = gamepad_current;
+    current ^= self->pulls;
+    self->pressed |= self->last & current;
+    self->last = current;
 }
 
 void gamepad_reset(void) {
diff --git a/shared-module/gamepadshift/GamePadShift.c b/shared-module/gamepadshift/GamePadShift.c
new file mode 100644
index 000000000..b8fb4d3f4
--- /dev/null
+++ b/shared-module/gamepadshift/GamePadShift.c
@@ -0,0 +1,49 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2016 Radomir Dopieralski for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "py/mpstate.h"
+#include "shared-bindings/digitalio/DigitalInOut.h"
+#include "shared-module/gamepadshift/GamePadShift.h"
+
+void common_hal_gamepadshift_gamepadshift_init(gamepadshift_obj_t *gamepadshift,
+                                                digitalio_digitalinout_obj_t *clock_pin,
+                                                digitalio_digitalinout_obj_t *data_pin,
+                                                digitalio_digitalinout_obj_t *latch_pin) {
+    common_hal_digitalio_digitalinout_switch_to_input(data_pin, PULL_NONE);
+    gamepadshift->data_pin = data_pin;
+    common_hal_digitalio_digitalinout_switch_to_output(clock_pin, 0,
+                                                       DRIVE_MODE_PUSH_PULL);
+    gamepadshift->clock_pin = clock_pin;
+    common_hal_digitalio_digitalinout_switch_to_output(latch_pin, 1,
+                                                       DRIVE_MODE_PUSH_PULL);
+    gamepadshift->latch_pin = latch_pin;
+
+    gamepadshift->last = 0;
+}
+
+void common_hal_gamepadshift_gamepadshift_deinit(gamepadshift_obj_t *gamepadshift) {
+    MP_STATE_VM(gamepad_singleton) = NULL;
+}
diff --git a/shared-module/bleio/Service.h b/shared-module/gamepadshift/GamePadShift.h
index 828d4cdc8..b4b26b7a9 100644
--- a/shared-module/bleio/Service.h
+++ b/shared-module/gamepadshift/GamePadShift.h
@@ -3,7 +3,7 @@
  *
  * The MIT License (MIT)
  *
- * Copyright (c) 2018 Artur Pacholec
+ * Copyright (c) 2016 Radomir Dopieralski for Adafruit Industries
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -24,21 +24,20 @@
  * THE SOFTWARE.
  */
 
-#ifndef MICROPY_INCLUDED_SHARED_MODULE_BLEIO_SERVICE_H
-#define MICROPY_INCLUDED_SHARED_MODULE_BLEIO_SERVICE_H
+#ifndef MICROPY_INCLUDED_GAMEPADSHIFT_GAMEPADSHIFT_H
+#define MICROPY_INCLUDED_GAMEPADSHIFT_GAMEPADSHIFT_H
 
-#include "common-hal/bleio/UUID.h"
+#include <stdint.h>
+
+#include "shared-bindings/digitalio/DigitalInOut.h"
 
 typedef struct {
     mp_obj_base_t base;
-    uint16_t handle;
-    bool is_secondary;
-    bleio_uuid_obj_t *uuid;
-    // May be a Peripheral, Central, etc.
-    mp_obj_t *device;
-    mp_obj_t char_list;
-    uint16_t start_handle;
-    uint16_t end_handle;
-} bleio_service_obj_t;
+    digitalio_digitalinout_obj_t* data_pin;
+    digitalio_digitalinout_obj_t* clock_pin;
+    digitalio_digitalinout_obj_t* latch_pin;
+    volatile uint8_t pressed;
+    volatile uint8_t last;
+} gamepadshift_obj_t;
 
-#endif // MICROPY_INCLUDED_SHARED_MODULE_BLEIO_SERVICE_H
+#endif  // MICROPY_INCLUDED_GAMEPADSHIFT_GAMEPADSHIFT_H
diff --git a/shared-module/gamepadshift/__init__.c b/shared-module/gamepadshift/__init__.c
new file mode 100644
index 000000000..47a008c50
--- /dev/null
+++ b/shared-module/gamepadshift/__init__.c
@@ -0,0 +1,57 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2019 Scott Shawcroft
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "shared-module/gamepadshift/__init__.h"
+
+#include "py/mpstate.h"
+#include "shared-bindings/gamepadshift/GamePadShift.h"
+
+void gamepadshift_tick(void) {
+    void* singleton = MP_STATE_VM(gamepad_singleton);
+    if (singleton == NULL || !MP_OBJ_IS_TYPE(MP_OBJ_FROM_PTR(singleton), &gamepadshift_type)) {
+        return;
+    }
+
+    gamepadshift_obj_t *self = MP_OBJ_TO_PTR(singleton);
+    uint8_t current = 0;
+    uint8_t bit = 1;
+    common_hal_digitalio_digitalinout_set_value(self->latch_pin, 1);
+    for (int i = 0; i < 8; ++i) {
+        common_hal_digitalio_digitalinout_set_value(self->clock_pin, 0);
+        if (common_hal_digitalio_digitalinout_get_value(self->data_pin)) {
+            current |= bit;
+        }
+        common_hal_digitalio_digitalinout_set_value(self->clock_pin, 1);
+        bit <<= 1;
+    }
+    common_hal_digitalio_digitalinout_set_value(self->latch_pin, 0);
+    self->pressed |= self->last & current;
+    self->last = current;
+}
+
+void gamepadshift_reset(void) {
+    MP_STATE_VM(gamepad_singleton) = NULL;
+}
diff --git a/shared-module/gamepadshift/__init__.h b/shared-module/gamepadshift/__init__.h
new file mode 100644
index 000000000..225db7336
--- /dev/null
+++ b/shared-module/gamepadshift/__init__.h
@@ -0,0 +1,33 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2016 Scott Shawcroft for Adafruit Industries
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef MICROPY_INCLUDED_GAMEPADSHIFT___INIT___H
+#define MICROPY_INCLUDED_GAMEPADSHIFT___INIT___H
+
+void gamepadshift_tick(void);
+void gamepadshift_reset(void);
+
+#endif  // MICROPY_INCLUDED_GAMEPADSHIFT___INIT___H
diff --git a/shared-module/network/__init__.c b/shared-module/network/__init__.c
index a674e8478..96648b260 100644
--- a/shared-module/network/__init__.c
+++ b/shared-module/network/__init__.c
@@ -43,6 +43,12 @@ void network_module_init(void) {
 }
 
 void network_module_deinit(void) {
+    for (mp_uint_t i = 0; i < MP_STATE_PORT(mod_network_nic_list).len; i++) {
+        mp_obj_t nic = MP_STATE_PORT(mod_network_nic_list).items[i];
+        mod_network_nic_type_t *nic_type = (mod_network_nic_type_t*)mp_obj_get_type(nic); 
+        if (nic_type->deinit != NULL) nic_type->deinit(nic);
+    }
+    mp_obj_list_set_len(&MP_STATE_PORT(mod_network_nic_list), 0);
 }
 
 void network_module_background(void) {
@@ -93,3 +99,7 @@ void network_module_create_random_mac_address(uint8_t *mac) {
     mac[4] = (uint8_t)(rb2 >> 8);
     mac[5] = (uint8_t)(rb2);
 }
+
+uint16_t network_module_create_random_source_tcp_port(void) {
+    return 0xc000 | shared_modules_random_getrandbits(14);
+}
diff --git a/shared-module/network/__init__.h b/shared-module/network/__init__.h
index 00a3c3957..f4eb05bb5 100644
--- a/shared-module/network/__init__.h
+++ b/shared-module/network/__init__.h
@@ -25,11 +25,12 @@
  * THE SOFTWARE.
  */
 
-void network_module_create_random_mac_address(uint8_t *mac);
-
 #ifndef MICROPY_INCLUDED_SHARED_MODULE_NETWORK___INIT___H
 #define MICROPY_INCLUDED_SHARED_MODULE_NETWORK___INIT___H
 
+void network_module_create_random_mac_address(uint8_t *mac);
+uint16_t network_module_create_random_source_tcp_port(void);
+
 #define MOD_NETWORK_IPADDR_BUF_SIZE (4)
 
 #define MOD_NETWORK_AF_INET (2)
@@ -62,6 +63,7 @@ typedef struct _mod_network_nic_type_t {
     int (*settimeout)(struct _mod_network_socket_obj_t *socket, mp_uint_t timeout_ms, int *_errno);
     int (*ioctl)(struct _mod_network_socket_obj_t *socket, mp_uint_t request, mp_uint_t arg, int *_errno);
     void (*timer_tick)(struct _mod_network_socket_obj_t *socket);
+    void (*deinit)(struct _mod_network_socket_obj_t *socket);
 } mod_network_nic_type_t;
 
 typedef struct _mod_network_socket_obj_t {
diff --git a/shared-module/terminalio/Terminal.c b/shared-module/terminalio/Terminal.c
index 85bbee293..86c3e903e 100644
--- a/shared-module/terminalio/Terminal.c
+++ b/shared-module/terminalio/Terminal.c
@@ -26,16 +26,17 @@
 
 #include "shared-module/terminalio/Terminal.h"
 
-#include "shared-module/displayio/__init__.h"
-#include "shared-module/displayio/BuiltinFont.h"
+#include "shared-module/fontio/BuiltinFont.h"
 #include "shared-bindings/displayio/TileGrid.h"
 
-void common_hal_terminalio_terminal_construct(terminalio_terminal_obj_t *self, displayio_tilegrid_t* tilegrid, const displayio_builtinfont_t* font) {
+void common_hal_terminalio_terminal_construct(terminalio_terminal_obj_t *self, displayio_tilegrid_t* tilegrid, const fontio_builtinfont_t* font) {
     self->cursor_x = 0;
     self->cursor_y = 0;
     self->font = font;
     self->tilegrid = tilegrid;
     self->first_row = 0;
+
+    common_hal_displayio_tilegrid_set_top_left(self->tilegrid, 0, 1);
 }
 
 size_t common_hal_terminalio_terminal_write(terminalio_terminal_obj_t *self, const byte *data, size_t len, int *errcode) {
@@ -47,8 +48,8 @@ size_t common_hal_terminalio_terminal_write(terminalio_terminal_obj_t *self, con
         // Always handle ASCII.
         if (c < 128) {
             if (c >= 0x20 && c <= 0x7e) {
-                uint8_t tile_index = displayio_builtinfont_get_glyph_index(self->font, c);
-                common_hal_displayio_textgrid_set_tile(self->tilegrid, self->cursor_x, self->cursor_y, tile_index);
+                uint8_t tile_index = fontio_builtinfont_get_glyph_index(self->font, c);
+                common_hal_displayio_tilegrid_set_tile(self->tilegrid, self->cursor_x, self->cursor_y, tile_index);
                 self->cursor_x++;
             } else if (c == '\r') {
                 self->cursor_x = 0;
@@ -64,7 +65,7 @@ size_t common_hal_terminalio_terminal_write(terminalio_terminal_obj_t *self, con
                     if (i[1] == 'K') {
                         // Clear the rest of the line.
                         for (uint16_t j = self->cursor_x; j < self->tilegrid->width_in_tiles; j++) {
-                            common_hal_displayio_textgrid_set_tile(self->tilegrid, j, self->cursor_y, 0);
+                            common_hal_displayio_tilegrid_set_tile(self->tilegrid, j, self->cursor_y, 0);
                         }
                         i += 2;
                     } else {
@@ -92,9 +93,9 @@ size_t common_hal_terminalio_terminal_write(terminalio_terminal_obj_t *self, con
                 }
             }
         } else {
-            uint8_t tile_index = displayio_builtinfont_get_glyph_index(self->font, c);
+            uint8_t tile_index = fontio_builtinfont_get_glyph_index(self->font, c);
             if (tile_index != 0xff) {
-                common_hal_displayio_textgrid_set_tile(self->tilegrid, self->cursor_x, self->cursor_y, tile_index);
+                common_hal_displayio_tilegrid_set_tile(self->tilegrid, self->cursor_x, self->cursor_y, tile_index);
                 self->cursor_x++;
 
             }
@@ -109,10 +110,10 @@ size_t common_hal_terminalio_terminal_write(terminalio_terminal_obj_t *self, con
         if (self->cursor_y != start_y) {
             // clear the new row
             for (uint16_t j = 0; j < self->tilegrid->width_in_tiles; j++) {
-                common_hal_displayio_textgrid_set_tile(self->tilegrid, j, self->cursor_y, 0);
+                common_hal_displayio_tilegrid_set_tile(self->tilegrid, j, self->cursor_y, 0);
                 start_y = self->cursor_y;
             }
-            common_hal_displayio_textgrid_set_top_left(self->tilegrid, 0, (start_y + self->tilegrid->height_in_tiles + 1) % self->tilegrid->height_in_tiles);
+            common_hal_displayio_tilegrid_set_top_left(self->tilegrid, 0, (start_y + self->tilegrid->height_in_tiles + 1) % self->tilegrid->height_in_tiles);
         }
     }
     return i - data;
diff --git a/shared-module/terminalio/Terminal.h b/shared-module/terminalio/Terminal.h
index 145b42f3f..c31392cc4 100644
--- a/shared-module/terminalio/Terminal.h
+++ b/shared-module/terminalio/Terminal.h
@@ -31,12 +31,12 @@
 #include <stdbool.h>
 
 #include "py/obj.h"
-#include "shared-module/displayio/BuiltinFont.h"
+#include "shared-module/fontio/BuiltinFont.h"
 #include "shared-module/displayio/TileGrid.h"
 
 typedef struct  {
     mp_obj_base_t base;
-    const displayio_builtinfont_t* font;
+    const fontio_builtinfont_t* font;
     uint16_t cursor_x;
     uint16_t cursor_y;
     displayio_tilegrid_t* tilegrid;
diff --git a/shared-module/usb_hid/Device.c b/shared-module/usb_hid/Device.c
index 820e14ad0..a5a57419c 100644
--- a/shared-module/usb_hid/Device.c
+++ b/shared-module/usb_hid/Device.c
@@ -47,40 +47,46 @@ void common_hal_usb_hid_device_send_report(usb_hid_device_obj_t *self, uint8_t*
 
     // Wait until interface is ready, timeout = 2 seconds
     uint64_t end_ticks = ticks_ms + 2000;
-    while ( (ticks_ms < end_ticks) && !tud_hid_generic_ready() ) { }
+    while ( (ticks_ms < end_ticks) && !tud_hid_ready() ) { }
 
-    if ( !tud_hid_generic_ready() ) {
+    if ( !tud_hid_ready() ) {
         mp_raise_msg(&mp_type_OSError,  translate("USB Busy"));
     }
 
     memcpy(self->report_buffer, report, len);
 
-    if ( !tud_hid_generic_report(self->report_id, self->report_buffer, len) ) {
+    if ( !tud_hid_report(self->report_id, self->report_buffer, len) ) {
         mp_raise_msg(&mp_type_OSError, translate("USB Error"));
     }
 }
 
+static usb_hid_device_obj_t* get_hid_device(uint8_t report_id) {
+    for (uint8_t i = 0; i < USB_HID_NUM_DEVICES; i++) {
+        if (usb_hid_devices[i].report_id == report_id) {
+            return &usb_hid_devices[i];
+        }
+    }
+    return NULL;
+}
+
 // Callbacks invoked when receive Get_Report request through control endpoint
-uint16_t tud_hid_generic_get_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen) {
+uint16_t tud_hid_get_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t* buffer, uint16_t reqlen) {
     // only support Input Report
     if ( report_type != HID_REPORT_TYPE_INPUT ) return 0;
 
-    // index is ID-1
-    uint8_t idx =  ( report_id ? (report_id-1) : 0 );
-
     // fill buffer with current report
-    memcpy(buffer, usb_hid_devices[idx].report_buffer, reqlen);
+    memcpy(buffer, get_hid_device(report_id)->report_buffer, reqlen);
     return reqlen;
 }
 
 // Callbacks invoked when receive Set_Report request through control endpoint
-void tud_hid_generic_set_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t const* buffer, uint16_t bufsize) {
-    // index is ID-1
-    uint8_t idx =  ( report_id ? (report_id-1) : 0 );
+void tud_hid_set_report_cb(uint8_t report_id, hid_report_type_t report_type, uint8_t const* buffer, uint16_t bufsize) {
+    usb_hid_device_obj_t* hid_device = get_hid_device(report_id);
 
     if ( report_type == HID_REPORT_TYPE_OUTPUT ) {
         // Check if it is Keyboard device
-        if ( (usb_hid_devices[idx].usage_page == HID_USAGE_PAGE_DESKTOP) && (usb_hid_devices[idx].usage == HID_USAGE_DESKTOP_KEYBOARD) ) {
+        if (hid_device->usage_page == HID_USAGE_PAGE_DESKTOP &&
+                hid_device->usage == HID_USAGE_DESKTOP_KEYBOARD) {
             // This is LED indicator (CapsLock, NumLock)
             // TODO Light up some LED here
         }
diff --git a/shared-module/usb_midi/PortOut.c b/shared-module/usb_midi/PortOut.c
index 99a4fad43..0b37dcfd4 100644
--- a/shared-module/usb_midi/PortOut.c
+++ b/shared-module/usb_midi/PortOut.c
@@ -33,5 +33,5 @@ size_t common_hal_usb_midi_portout_write(usb_midi_portout_obj_t *self, const uin
 }
 
 bool common_hal_usb_midi_portout_ready_to_tx(usb_midi_portout_obj_t *self) {
-    return tud_midi_connected();
+    return tud_midi_mounted();
 }
diff --git a/shared-module/wiznet/wiznet5k.c b/shared-module/wiznet/wiznet5k.c
index ee732859a..3c5c5f0c8 100644
--- a/shared-module/wiznet/wiznet5k.c
+++ b/shared-module/wiznet/wiznet5k.c
@@ -93,6 +93,16 @@ int wiznet5k_gethostbyname(mp_obj_t nic, const char *name, mp_uint_t len, uint8_
     }
 }
 
+int get_available_socket(wiznet5k_obj_t *wiz) {
+    for (uint8_t sn = 0; sn < _WIZCHIP_SOCK_NUM_; sn++) {
+        if ((wiz->socket_used & (1 << sn)) == 0) {
+            wiz->socket_used |= (1 << sn);
+            return sn;
+        }
+    }
+    return -1;
+}
+
 int wiznet5k_socket_socket(mod_network_socket_obj_t *socket, int *_errno) {
     if (socket->u_param.domain != MOD_NETWORK_AF_INET) {
         *_errno = MP_EAFNOSUPPORT;
@@ -107,13 +117,7 @@ int wiznet5k_socket_socket(mod_network_socket_obj_t *socket, int *_errno) {
 
     if (socket->u_param.fileno == -1) {
         // get first unused socket number
-        for (mp_uint_t sn = 0; sn < _WIZCHIP_SOCK_NUM_; sn++) {
-            if ((wiznet5k_obj.socket_used & (1 << sn)) == 0) {
-                wiznet5k_obj.socket_used |= (1 << sn);
-                socket->u_param.fileno = sn;
-                break;
-            }
-        }
+        socket->u_param.fileno = get_available_socket(&wiznet5k_obj);
         if (socket->u_param.fileno == -1) {
             // too many open sockets
             *_errno = MP_EMFILE;
@@ -199,8 +203,12 @@ int wiznet5k_socket_accept(mod_network_socket_obj_t *socket, mod_network_socket_
 }
 
 int wiznet5k_socket_connect(mod_network_socket_obj_t *socket, byte *ip, mp_uint_t port, int *_errno) {
+    uint16_t src_port = network_module_create_random_source_tcp_port();
+    // make sure same outgoing port number can't be in use by two different sockets.
+    src_port = (src_port & ~(_WIZCHIP_SOCK_NUM_ - 1)) | socket->u_param.fileno;
+
     // use "bind" function to open the socket in client mode
-    if (wiznet5k_socket_bind(socket, ip, 0, _errno) != 0) {
+    if (wiznet5k_socket_bind(socket, NULL, src_port, _errno) != 0) {
         return -1;
     }
 
@@ -318,33 +326,56 @@ int wiznet5k_socket_ioctl(mod_network_socket_obj_t *socket, mp_uint_t request, m
 }
 
 void wiznet5k_socket_timer_tick(mod_network_socket_obj_t *socket) {
-    if (wiznet5k_obj.dhcp_active) {
+    if (wiznet5k_obj.dhcp_socket >= 0) {
         DHCP_time_handler();
         DHCP_run();
     }
 }
 
-void wiznet5k_start_dhcp(void) {
+int wiznet5k_start_dhcp(void) {
+    // XXX this should throw an error if DHCP fails
     static DHCP_INIT_BUFFER_TYPE dhcp_buf[DHCP_INIT_BUFFER_SIZE];
 
-    if (!wiznet5k_obj.dhcp_active) {
+    if (wiznet5k_obj.dhcp_socket < 0) {
         // Set up the socket to listen on UDP 68 before calling DHCP_init
-        WIZCHIP_EXPORT(socket)(0, MOD_NETWORK_SOCK_DGRAM, DHCP_CLIENT_PORT, 0);
-        DHCP_init(0, dhcp_buf);
-        wiznet5k_obj.dhcp_active = 1;
+        wiznet5k_obj.dhcp_socket = get_available_socket(&wiznet5k_obj);
+        if (wiznet5k_obj.dhcp_socket < 0) return MP_EMFILE;
+
+        WIZCHIP_EXPORT(socket)(wiznet5k_obj.dhcp_socket, MOD_NETWORK_SOCK_DGRAM, DHCP_CLIENT_PORT, 0);
+        DHCP_init(wiznet5k_obj.dhcp_socket, dhcp_buf);
     }
+    return 0;
 }
 
-void wiznet5k_stop_dhcp(void) {
-    if (wiznet5k_obj.dhcp_active) {
-        wiznet5k_obj.dhcp_active = 0;
+int wiznet5k_stop_dhcp(void) {
+    if (wiznet5k_obj.dhcp_socket >= 0) {
         DHCP_stop();
-        WIZCHIP_EXPORT(close)(0);
+        WIZCHIP_EXPORT(close)(wiznet5k_obj.dhcp_socket);
+        wiznet5k_obj.socket_used &= ~(1 << wiznet5k_obj.dhcp_socket);
+        wiznet5k_obj.dhcp_socket = -1;
     }
+    return 0;
 }
 
 bool wiznet5k_check_dhcp(void) {
-    return wiznet5k_obj.dhcp_active;
+    return wiznet5k_obj.dhcp_socket >= 0;
+}
+
+void wiznet5k_reset(void) {
+    if (wiznet5k_obj.rst.pin) {
+        // hardware reset if using RST pin
+        common_hal_digitalio_digitalinout_set_value(&wiznet5k_obj.rst, 0);
+        mp_hal_delay_us(10); // datasheet says 2us
+        common_hal_digitalio_digitalinout_set_value(&wiznet5k_obj.rst, 1);
+        mp_hal_delay_ms(150); // datasheet says 150ms
+    } else {
+        // otherwise, software reset
+        wizchip_sw_reset();
+    }
+}
+
+void wiznet5k_socket_deinit(mod_network_socket_obj_t *socket) {
+    wiznet5k_reset();
 }
 
 /// Create and return a WIZNET5K object.
@@ -354,9 +385,8 @@ mp_obj_t wiznet5k_create(mp_obj_t spi_in, mp_obj_t cs_in, mp_obj_t rst_in) {
     wiznet5k_obj.base.type = (mp_obj_type_t*)&mod_network_nic_type_wiznet5k;
     wiznet5k_obj.cris_state = 0;
     wiznet5k_obj.spi = MP_OBJ_TO_PTR(spi_in);
-    common_hal_digitalio_digitalinout_construct(&wiznet5k_obj.cs, cs_in);
-    common_hal_digitalio_digitalinout_construct(&wiznet5k_obj.rst, rst_in);
     wiznet5k_obj.socket_used = 0;
+    wiznet5k_obj.dhcp_socket = -1;
 
     /*!< SPI configuration */
     // XXX probably should check if the provided SPI is already configured, and
@@ -369,13 +399,11 @@ mp_obj_t wiznet5k_create(mp_obj_t spi_in, mp_obj_t cs_in, mp_obj_t rst_in) {
         8 // 8 BITS
     );
 
+    common_hal_digitalio_digitalinout_construct(&wiznet5k_obj.cs, cs_in);
     common_hal_digitalio_digitalinout_switch_to_output(&wiznet5k_obj.cs, 1, DRIVE_MODE_PUSH_PULL);
-    common_hal_digitalio_digitalinout_switch_to_output(&wiznet5k_obj.rst, 1, DRIVE_MODE_PUSH_PULL); 
 
-    common_hal_digitalio_digitalinout_set_value(&wiznet5k_obj.rst, 0);
-    mp_hal_delay_us(10); // datasheet says 2us
-    common_hal_digitalio_digitalinout_set_value(&wiznet5k_obj.rst, 1);
-    mp_hal_delay_ms(160); // datasheet says 150ms
+    if (rst_in) common_hal_digitalio_digitalinout_construct(&wiznet5k_obj.rst, rst_in);
+    wiznet5k_reset();
 
     reg_wizchip_cris_cbfunc(wiz_cris_enter, wiz_cris_exit);
     reg_wizchip_cs_cbfunc(wiz_cs_select, wiz_cs_deselect);
@@ -394,8 +422,6 @@ mp_obj_t wiznet5k_create(mp_obj_t spi_in, mp_obj_t cs_in, mp_obj_t rst_in) {
     // seems we need a small delay after init
     mp_hal_delay_ms(250);
 
-    wiznet5k_start_dhcp();
-
     // register with network module
     network_module_register_nic(&wiznet5k_obj);
 
diff --git a/shared-module/wiznet/wiznet5k.h b/shared-module/wiznet/wiznet5k.h
index 1284a44fd..0154831c7 100644
--- a/shared-module/wiznet/wiznet5k.h
+++ b/shared-module/wiznet/wiznet5k.h
@@ -39,7 +39,7 @@ typedef struct _wiznet5k_obj_t {
     digitalio_digitalinout_obj_t cs;
     digitalio_digitalinout_obj_t rst;
     uint8_t socket_used;
-    bool dhcp_active;
+    int8_t dhcp_socket; // -1 for DHCP not in use
 } wiznet5k_obj_t;
 
 int wiznet5k_gethostbyname(mp_obj_t nic, const char *name, mp_uint_t len, uint8_t *out_ip);
@@ -57,11 +57,12 @@ int wiznet5k_socket_setsockopt(mod_network_socket_obj_t *socket, mp_uint_t level
 int wiznet5k_socket_settimeout(mod_network_socket_obj_t *socket, mp_uint_t timeout_ms, int *_errno);
 int wiznet5k_socket_ioctl(mod_network_socket_obj_t *socket, mp_uint_t request, mp_uint_t arg, int *_errno);
 void wiznet5k_socket_timer_tick(mod_network_socket_obj_t *socket);
+void wiznet5k_socket_deinit(mod_network_socket_obj_t *socket);
 mp_obj_t wiznet5k_socket_disconnect(mp_obj_t self_in);
 mp_obj_t wiznet5k_create(mp_obj_t spi_in, mp_obj_t cs_in, mp_obj_t rst_in);
 
-void wiznet5k_start_dhcp(void);
-void wiznet5k_stop_dhcp(void);
+int wiznet5k_start_dhcp(void);
+int wiznet5k_stop_dhcp(void);
 bool wiznet5k_check_dhcp(void);
 
 extern const mod_network_nic_type_t mod_network_nic_type_wiznet5k;