Merge branch 'master' into new-pixelbuf-api

57 files changed, 2864 insertions, 953 deletions

diff --git a/shared-module/bleio/Address.c b/shared-module/_bleio/Address.c
index 6bc458b7c..8c8b043fe 100644
--- a/shared-module/bleio/Address.c
+++ b/shared-module/_bleio/Address.c
@@ -28,8 +28,8 @@
 #include <string.h>
 
 #include "py/objstr.h"
-#include "shared-bindings/bleio/Address.h"
-#include "shared-module/bleio/Address.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);
diff --git a/shared-module/bleio/Address.h b/shared-module/_bleio/Address.h
index 39789842f..39789842f 100644
--- a/shared-module/bleio/Address.h
+++ b/shared-module/_bleio/Address.h
diff --git a/shared-module/_bleio/Attribute.c b/shared-module/_bleio/Attribute.c
new file mode 100644
index 000000000..3acfcf1f5
--- /dev/null
+++ b/shared-module/_bleio/Attribute.c
@@ -0,0 +1,46 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * 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
+ * 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/runtime.h"
+#include "shared-bindings/_bleio/Attribute.h"
+
+void common_hal_bleio_attribute_security_mode_check_valid(bleio_attribute_security_mode_t security_mode) {
+    switch (security_mode) {
+        case SECURITY_MODE_NO_ACCESS:
+        case SECURITY_MODE_OPEN:
+        case SECURITY_MODE_ENC_NO_MITM:
+        case SECURITY_MODE_ENC_WITH_MITM:
+        case SECURITY_MODE_LESC_ENC_WITH_MITM:
+        case SECURITY_MODE_SIGNED_NO_MITM:
+        case SECURITY_MODE_SIGNED_WITH_MITM:
+            break;
+        default:
+            mp_raise_ValueError(translate("Invalid security_mode"));
+            break;
+    }
+}
diff --git a/shared-module/_bleio/Attribute.h b/shared-module/_bleio/Attribute.h
new file mode 100644
index 000000000..a498a14a5
--- /dev/null
+++ b/shared-module/_bleio/Attribute.h
@@ -0,0 +1,41 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * 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
+ * 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_ATTRIBUTE_H
+#define MICROPY_INCLUDED_SHARED_MODULE_BLEIO_ATTRIBUTE_H
+
+// BLE security modes: 0x<level><mode>
+typedef enum {
+    SECURITY_MODE_NO_ACCESS = 0x00,
+    SECURITY_MODE_OPEN = 0x11,
+    SECURITY_MODE_ENC_NO_MITM = 0x21,
+    SECURITY_MODE_ENC_WITH_MITM = 0x31,
+    SECURITY_MODE_LESC_ENC_WITH_MITM = 0x41,
+    SECURITY_MODE_SIGNED_NO_MITM = 0x12,
+    SECURITY_MODE_SIGNED_WITH_MITM = 0x22,
+} bleio_attribute_security_mode_t;
+
+#endif // MICROPY_INCLUDED_SHARED_MODULE_BLEIO_ATTRIBUTE_H
diff --git a/shared-module/bleio/Characteristic.h b/shared-module/_bleio/Characteristic.h
index 27b43588f..409a57c76 100644
--- a/shared-module/bleio/Characteristic.h
+++ b/shared-module/_bleio/Characteristic.h
@@ -27,14 +27,17 @@
 #ifndef MICROPY_INCLUDED_SHARED_MODULE_BLEIO_CHARACTERISTIC_H
 #define MICROPY_INCLUDED_SHARED_MODULE_BLEIO_CHARACTERISTIC_H
 
-// Flags for each characteristic property. Common across ports.
-typedef struct {
-        bool broadcast : 1;
-        bool read : 1;
-        bool write_no_response : 1;
-        bool write : 1;
-        bool notify : 1;
-        bool indicate : 1;
-} bleio_characteristic_properties_t;
+typedef enum {
+    CHAR_PROP_NONE =              0,
+    CHAR_PROP_BROADCAST =         1u << 0,
+    CHAR_PROP_INDICATE =          1u << 1,
+    CHAR_PROP_NOTIFY =            1u << 2,
+    CHAR_PROP_READ =              1u << 3,
+    CHAR_PROP_WRITE =             1u << 4,
+    CHAR_PROP_WRITE_NO_RESPONSE = 1u << 5,
+    CHAR_PROP_ALL =               (CHAR_PROP_BROADCAST | CHAR_PROP_INDICATE | CHAR_PROP_NOTIFY |
+                                   CHAR_PROP_READ | CHAR_PROP_WRITE | CHAR_PROP_WRITE_NO_RESPONSE)
+} bleio_characteristic_properties_enum_t;
+typedef uint8_t 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
index 306ac33c5..8dfa17f31 100644
--- a/shared-module/bleio/ScanEntry.c
+++ b/shared-module/_bleio/ScanEntry.c
@@ -28,9 +28,9 @@
 
 #include <string.h>
 
-#include "shared-bindings/bleio/Address.h"
-#include "shared-module/bleio/Address.h"
-#include "shared-module/bleio/ScanEntry.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);
diff --git a/shared-module/bleio/ScanEntry.h b/shared-module/_bleio/ScanEntry.h
index b302460e6..1e798d78f 100644
--- a/shared-module/bleio/ScanEntry.h
+++ b/shared-module/_bleio/ScanEntry.h
@@ -29,7 +29,7 @@
 #define MICROPY_INCLUDED_SHARED_MODULE_BLEIO_SCANENTRY_H
 
 #include "py/obj.h"
-#include "shared-bindings/bleio/Address.h"
+#include "shared-bindings/_bleio/Address.h"
 
 typedef struct {
     mp_obj_base_t base;
diff --git a/shared-module/_stage/__init__.c b/shared-module/_stage/__init__.c
index 1af279e92..d5da74272 100644
--- a/shared-module/_stage/__init__.c
+++ b/shared-module/_stage/__init__.c
@@ -34,34 +34,60 @@
 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,
-        displayio_display_obj_t *display) {
+        displayio_display_obj_t *display, uint8_t scale) {
 
+
+    displayio_area_t area;
+    area.x1 = x0;
+    area.y1 = y0;
+    area.x2 = x1;
+    area.y2 = y1;
+    displayio_display_core_set_region_to_update(
+        &display->core, display->set_column_command, display->set_row_command,
+        NO_COMMAND, NO_COMMAND, display->data_as_commands, false, &area);
+
+    while (!displayio_display_core_begin_transaction(&display->core)) {
+        RUN_BACKGROUND_TASKS;
+    }
+    display->core.send(display->core.bus, DISPLAY_COMMAND,
+                      CHIP_SELECT_TOGGLE_EVERY_BYTE,
+                      &display->write_ram_command, 1);
     size_t index = 0;
     for (uint16_t y = y0; y < y1; ++y) {
-        for (uint16_t x = x0; x < x1; ++x) {
-            for (size_t layer = 0; layer < layers_size; ++layer) {
+        for (uint8_t yscale = 0; yscale < scale; ++yscale) {
+            for (uint16_t x = x0; x < x1; ++x) {
                 uint16_t c = TRANSPARENT;
-                layer_obj_t *obj = MP_OBJ_TO_PTR(layers[layer]);
-                if (obj->base.type == &mp_type_layer) {
-                    c = get_layer_pixel(obj, x, y);
-                } else if (obj->base.type == &mp_type_text) {
-                    c = get_text_pixel((text_obj_t *)obj, x, y);
+                for (size_t layer = 0; layer < layers_size; ++layer) {
+                    layer_obj_t *obj = MP_OBJ_TO_PTR(layers[layer]);
+                    if (obj->base.type == &mp_type_layer) {
+                        c = get_layer_pixel(obj, x, y);
+                    } else if (obj->base.type == &mp_type_text) {
+                        c = get_text_pixel((text_obj_t *)obj, x, y);
+                    }
+                    if (c != TRANSPARENT) {
+                        break;
+                    }
                 }
-                if (c != TRANSPARENT) {
+                for (uint8_t xscale = 0; xscale < scale; ++xscale) {
                     buffer[index] = c;
-                    break;
+                    index += 1;
+                    // The buffer is full, send it.
+                    if (index >= buffer_size) {
+                        display->core.send(display->core.bus, DISPLAY_DATA,
+                                           CHIP_SELECT_UNTOUCHED,
+                                           ((uint8_t*)buffer), buffer_size * 2);
+                        index = 0;
+                    }
                 }
             }
-            index += 1;
-            // The buffer is full, send it.
-            if (index >= buffer_size) {
-                display->send(display->bus, false, ((uint8_t*)buffer), buffer_size * 2);
-                index = 0;
-            }
         }
     }
     // Send the remaining data.
     if (index) {
-        display->send(display->bus, false, ((uint8_t*)buffer), index * 2);
+        display->core.send(display->core.bus, DISPLAY_DATA,
+                           CHIP_SELECT_UNTOUCHED,
+                           ((uint8_t*)buffer), index * 2);
     }
+
+    displayio_display_core_end_transaction(&display->core);
 }
diff --git a/shared-module/_stage/__init__.h b/shared-module/_stage/__init__.h
index d263302b4..5af2124ae 100644
--- a/shared-module/_stage/__init__.h
+++ b/shared-module/_stage/__init__.h
@@ -37,6 +37,6 @@
 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,
-        displayio_display_obj_t *display);
+        displayio_display_obj_t *display, uint8_t scale);
 
 #endif  // MICROPY_INCLUDED_SHARED_MODULE__STAGE
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..0248d42e2 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 {
@@ -46,7 +46,9 @@ struct wave_format_chunk {
 };
 
 void common_hal_audioio_wavefile_construct(audioio_wavefile_obj_t* self,
-                                           pyb_file_obj_t* file) {
+                                           pyb_file_obj_t* file,
+                                           uint8_t *buffer,
+                                           size_t buffer_size) {
     // Load the wave
     self->file = file;
     uint8_t chunk_header[16];
@@ -84,7 +86,6 @@ void common_hal_audioio_wavefile_construct(audioio_wavefile_obj_t* self,
     }
     // Get the sample_rate
     self->sample_rate = format.sample_rate;
-    self->len = 256;
     self->channel_count = format.num_channels;
     self->bits_per_sample = format.bits_per_sample;
 
@@ -111,21 +112,31 @@ void common_hal_audioio_wavefile_construct(audioio_wavefile_obj_t* self,
 
     // Try to allocate two buffers, one will be loaded from file and the other
     // DMAed to DAC.
-    self->buffer = m_malloc(self->len, false);
-    if (self->buffer == NULL) {
-        common_hal_audioio_wavefile_deinit(self);
-        mp_raise_msg(&mp_type_MemoryError, translate("Couldn't allocate first buffer"));
-    }
+    if (buffer_size) {
+        self->len = buffer_size / 2;
+        self->buffer = buffer;
+        self->second_buffer = buffer + self->len;
+    } else {
+        self->len = 256;
+        self->buffer = m_malloc(self->len, false);
+        if (self->buffer == NULL) {
+            common_hal_audioio_wavefile_deinit(self);
+            mp_raise_msg(&mp_type_MemoryError,
+                         translate("Couldn't allocate first buffer"));
+        }
 
-    self->second_buffer = m_malloc(self->len, false);
-    if (self->second_buffer == NULL) {
-        common_hal_audioio_wavefile_deinit(self);
-        mp_raise_msg(&mp_type_MemoryError, translate("Couldn't allocate second buffer"));
+        self->second_buffer = m_malloc(self->len, false);
+        if (self->second_buffer == NULL) {
+            common_hal_audioio_wavefile_deinit(self);
+            mp_raise_msg(&mp_type_MemoryError,
+                         translate("Couldn't allocate second buffer"));
+        }
     }
 }
 
 void common_hal_audioio_wavefile_deinit(audioio_wavefile_obj_t* self) {
     self->buffer = NULL;
+    self->second_buffer = NULL;
 }
 
 bool common_hal_audioio_wavefile_deinited(audioio_wavefile_obj_t* self) {
@@ -205,7 +216,7 @@ audioio_get_buffer_result_t audioio_wavefile_get_buffer(audioio_wavefile_obj_t*
         } else {
             *buffer = self->buffer;
         }
-        if (f_read(&self->file->fp, *buffer, num_bytes_to_load, &length_read) != FR_OK) {
+        if (f_read(&self->file->fp, *buffer, num_bytes_to_load, &length_read) != FR_OK || length_read != num_bytes_to_load) {
             return GET_BUFFER_ERROR;
         }
         self->bytes_remaining -= length_read;
diff --git a/shared-module/audioio/WaveFile.h b/shared-module/audiocore/WaveFile.h
index 2cee2b1d2..3eecbf15c 100644
--- a/shared-module/audioio/WaveFile.h
+++ b/shared-module/audiocore/WaveFile.h
@@ -27,9 +27,10 @@
 #ifndef MICROPY_INCLUDED_SHARED_MODULE_AUDIOIO_WAVEFILE_H
 #define MICROPY_INCLUDED_SHARED_MODULE_AUDIOIO_WAVEFILE_H
 
+#include "extmod/vfs_fat.h"
 #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/audiocore/__init__.c b/shared-module/audiocore/__init__.c
new file mode 100644
index 000000000..f9762676f
--- /dev/null
+++ b/shared-module/audiocore/__init__.c
@@ -0,0 +1,138 @@
+/*
+ * 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/RawSample.h"
+#include "shared-bindings/audiocore/WaveFile.h"
+#include "shared-module/audiocore/RawSample.h"
+#include "shared-module/audiocore/WaveFile.h"
+
+#include "shared-bindings/audiomixer/Mixer.h"
+#include "shared-module/audiomixer/Mixer.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;
+    #if CIRCUITPY_AUDIOMIXER
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audiomixer_mixer_type)) {
+        audiomixer_mixer_obj_t* mixer = MP_OBJ_TO_PTR(sample_obj);
+        return mixer->sample_rate;
+    #endif
+    }
+    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;
+    #if CIRCUITPY_AUDIOMIXER
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audiomixer_mixer_type)) {
+        audiomixer_mixer_obj_t* mixer = MP_OBJ_TO_PTR(sample_obj);
+        return mixer->bits_per_sample;
+    #endif
+    }
+    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;
+    #if CIRCUITPY_AUDIOMIXER
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audiomixer_mixer_type)) {
+        audiomixer_mixer_obj_t* mixer = MP_OBJ_TO_PTR(sample_obj);
+        return mixer->channel_count;
+    #endif
+    }
+    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);
+    #if CIRCUITPY_AUDIOMIXER
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audiomixer_mixer_type)) {
+        audiomixer_mixer_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
+        audiomixer_mixer_reset_buffer(file, single_channel, audio_channel);
+    #endif
+    }
+}
+
+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);
+    #if CIRCUITPY_AUDIOMIXER
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audiomixer_mixer_type)) {
+        audiomixer_mixer_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
+        return audiomixer_mixer_get_buffer(file, single_channel, channel, buffer, buffer_length);
+    #endif
+    }
+    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);
+    #if CIRCUITPY_AUDIOMIXER
+    } else if (MP_OBJ_IS_TYPE(sample_obj, &audiomixer_mixer_type)) {
+        audiomixer_mixer_obj_t* file = MP_OBJ_TO_PTR(sample_obj);
+        audiomixer_mixer_get_buffer_structure(file, single_channel, single_buffer, samples_signed,
+                                              max_buffer_length, spacing);
+    #endif
+    }
+}
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/audioio/Mixer.c b/shared-module/audiomixer/Mixer.c
index 8020a621e..a52489f85 100644
--- a/shared-module/audioio/Mixer.c
+++ b/shared-module/audiomixer/Mixer.c
@@ -4,6 +4,8 @@
  * The MIT License (MIT)
  *
  * Copyright (c) 2018 Scott Shawcroft for Adafruit Industries
+ *               2018 DeanM for Adafruit Industries
+ *               2019 Michael Schroeder
  *
  * 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,32 +26,33 @@
  * THE SOFTWARE.
  */
 
-#include "shared-bindings/audioio/Mixer.h"
+#include "shared-bindings/audiomixer/Mixer.h"
+#include "shared-bindings/audiomixer/MixerVoice.h"
 
 #include <stdint.h>
 
 #include "py/runtime.h"
-#include "shared-module/audioio/__init__.h"
-#include "shared-module/audioio/RawSample.h"
-
-void common_hal_audioio_mixer_construct(audioio_mixer_obj_t* self,
-                                        uint8_t voice_count,
-                                        uint32_t buffer_size,
-                                        uint8_t bits_per_sample,
-                                        bool samples_signed,
-                                        uint8_t channel_count,
-                                        uint32_t sample_rate) {
+#include "shared-module/audiocore/__init__.h"
+#include "shared-module/audiocore/RawSample.h"
+
+void common_hal_audiomixer_mixer_construct(audiomixer_mixer_obj_t* self,
+                                           uint8_t voice_count,
+                                           uint32_t buffer_size,
+                                           uint8_t bits_per_sample,
+                                           bool samples_signed,
+                                           uint8_t channel_count,
+                                           uint32_t sample_rate) {
     self->len = buffer_size / 2 / sizeof(uint32_t) * sizeof(uint32_t);
 
     self->first_buffer = m_malloc(self->len, false);
     if (self->first_buffer == NULL) {
-        common_hal_audioio_mixer_deinit(self);
+        common_hal_audiomixer_mixer_deinit(self);
         mp_raise_msg(&mp_type_MemoryError, translate("Couldn't allocate first buffer"));
     }
 
     self->second_buffer = m_malloc(self->len, false);
     if (self->second_buffer == NULL) {
-        common_hal_audioio_mixer_deinit(self);
+        common_hal_audiomixer_mixer_deinit(self);
         mp_raise_msg(&mp_type_MemoryError, translate("Couldn't allocate second buffer"));
     }
 
@@ -58,130 +61,85 @@ void common_hal_audioio_mixer_construct(audioio_mixer_obj_t* self,
     self->channel_count = channel_count;
     self->sample_rate = sample_rate;
     self->voice_count = voice_count;
-
-    for (uint8_t i = 0; i < self->voice_count; i++) {
-        self->voice[i].sample = NULL;
-    }
 }
 
-void common_hal_audioio_mixer_deinit(audioio_mixer_obj_t* self) {
+void common_hal_audiomixer_mixer_deinit(audiomixer_mixer_obj_t* self) {
     self->first_buffer = NULL;
     self->second_buffer = NULL;
 }
 
-bool common_hal_audioio_mixer_deinited(audioio_mixer_obj_t* self) {
+bool common_hal_audiomixer_mixer_deinited(audiomixer_mixer_obj_t* self) {
     return self->first_buffer == NULL;
 }
 
-uint32_t common_hal_audioio_mixer_get_sample_rate(audioio_mixer_obj_t* self) {
+uint32_t common_hal_audiomixer_mixer_get_sample_rate(audiomixer_mixer_obj_t* self) {
     return self->sample_rate;
 }
 
-void common_hal_audioio_mixer_play(audioio_mixer_obj_t* self, mp_obj_t sample, uint8_t v, bool loop) {
-    if (v >= self->voice_count) {
-        mp_raise_ValueError(translate("Voice index too high"));
-    }
-    if (audiosample_sample_rate(sample) != self->sample_rate) {
-        mp_raise_ValueError(translate("The sample's sample rate does not match the mixer's"));
-    }
-    if (audiosample_channel_count(sample) != self->channel_count) {
-        mp_raise_ValueError(translate("The sample's channel count does not match the mixer's"));
-    }
-    if (audiosample_bits_per_sample(sample) != self->bits_per_sample) {
-        mp_raise_ValueError(translate("The sample's bits_per_sample does not match the mixer's"));
-    }
-    bool single_buffer;
-    bool samples_signed;
-    uint32_t max_buffer_length;
-    uint8_t spacing;
-    audiosample_get_buffer_structure(sample, false, &single_buffer, &samples_signed,
-                                     &max_buffer_length, &spacing);
-    if (samples_signed != self->samples_signed) {
-        mp_raise_ValueError(translate("The sample's signedness does not match the mixer's"));
-    }
-    audioio_mixer_voice_t* voice = &self->voice[v];
-    voice->sample = sample;
-    voice->loop = loop;
-
-    audiosample_reset_buffer(sample, false, 0);
-    audioio_get_buffer_result_t result = audiosample_get_buffer(sample, false, 0, (uint8_t**) &voice->remaining_buffer, &voice->buffer_length);
-    // Track length in terms of words.
-    voice->buffer_length /= sizeof(uint32_t);
-    voice->more_data = result == GET_BUFFER_MORE_DATA;
-}
-
-void common_hal_audioio_mixer_stop_voice(audioio_mixer_obj_t* self, uint8_t voice) {
-    self->voice[voice].sample = NULL;
-}
-
-bool common_hal_audioio_mixer_get_playing(audioio_mixer_obj_t* self) {
-    for (int32_t v = 0; v < self->voice_count; v++) {
-        if (self->voice[v].sample != NULL) {
+bool common_hal_audiomixer_mixer_get_playing(audiomixer_mixer_obj_t* self) {
+    for (uint8_t v = 0; v < self->voice_count; v++) {
+        if (common_hal_audiomixer_mixervoice_get_playing(MP_OBJ_TO_PTR(self->voice[v]))) {
             return true;
         }
     }
     return false;
 }
 
-void audioio_mixer_reset_buffer(audioio_mixer_obj_t* self,
-                                bool single_channel,
-                                uint8_t channel) {
-    for (int32_t i = 0; i < self->voice_count; i++) {
-        self->voice[i].sample = NULL;
+void audiomixer_mixer_reset_buffer(audiomixer_mixer_obj_t* self,
+                                   bool single_channel,
+                                   uint8_t channel) {
+    for (uint8_t i = 0; i < self->voice_count; i++) {
+        common_hal_audiomixer_mixervoice_stop(self->voice[i]);
     }
 }
 
 uint32_t add8signed(uint32_t a, uint32_t b) {
-    #if (defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1))
-    return __QADD8(a, b);
+    #if (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1)) //Cortex-M4 w/FPU
+    return __SHADD8(a, b);
     #else
     uint32_t result = 0;
     for (int8_t i = 0; i < 4; i++) {
         int8_t ai = a >> (sizeof(int8_t) * 8 * i);
         int8_t bi = b >> (sizeof(int8_t) * 8 * i);
-        int32_t intermediate = (int32_t) ai + bi;
+        int32_t intermediate = (int32_t) ai + bi / 2;
         if (intermediate > CHAR_MAX) {
             intermediate = CHAR_MAX;
         } else if (intermediate < CHAR_MIN) {
-            //intermediate = CHAR_MIN;
+            intermediate = CHAR_MIN;
         }
-        result |= (((uint32_t) intermediate) & 0xff) << (sizeof(int8_t) * 8 * i);
+        result |= ((uint32_t) intermediate & 0xff) << (sizeof(int8_t) * 8 * i);
     }
     return result;
     #endif
 }
 
 uint32_t add8unsigned(uint32_t a, uint32_t b) {
-    #if (defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1))
-    // Subtract out the DC offset, add and then shift back.
-    a = __USUB8(a, 0x80808080);
-    b = __USUB8(b, 0x80808080);
-    uint32_t sum = __QADD8(a, b);
-    return __UADD8(sum, 0x80808080);
+    #if (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1)) //Cortex-M4 w/FPU
+    return __UHADD8(a, b);
     #else
     uint32_t result = 0;
     for (int8_t i = 0; i < 4; i++) {
-        int8_t ai = (a >> (sizeof(uint8_t) * 8 * i)) - 128;
-        int8_t bi = (b >> (sizeof(uint8_t) * 8 * i)) - 128;
-        int32_t intermediate = (int32_t) ai + bi;
+        uint8_t ai = (a >> (sizeof(uint8_t) * 8 * i));
+        uint8_t bi = (b >> (sizeof(uint8_t) * 8 * i));
+        int32_t intermediate = (int32_t) (ai + bi) / 2;
         if (intermediate > UCHAR_MAX) {
             intermediate = UCHAR_MAX;
         }
-        result |= ((uint8_t) intermediate + 128) << (sizeof(uint8_t) * 8 * i);
+        result |= ((uint32_t) intermediate & 0xff) << (sizeof(uint8_t) * 8 * i);
     }
     return result;
     #endif
 }
 
 uint32_t add16signed(uint32_t a, uint32_t b) {
-    #if (defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1))
-    return __QADD16(a, b);
+    #if (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1)) //Cortex-M4 w/FPU
+    return __SHADD16(a, b);
     #else
     uint32_t result = 0;
     for (int8_t i = 0; i < 2; i++) {
         int16_t ai = a >> (sizeof(int16_t) * 8 * i);
         int16_t bi = b >> (sizeof(int16_t) * 8 * i);
-        int32_t intermediate = (int32_t) ai + bi;
+        int32_t intermediate = (int32_t) ai + bi / 2;
         if (intermediate > SHRT_MAX) {
             intermediate = SHRT_MAX;
         } else if (intermediate < SHRT_MIN) {
@@ -194,32 +152,146 @@ uint32_t add16signed(uint32_t a, uint32_t b) {
 }
 
 uint32_t add16unsigned(uint32_t a, uint32_t b) {
-    #if (defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1))
-    // Subtract out the DC offset, add and then shift back.
-    a = __USUB16(a, 0x80008000);
-    b = __USUB16(b, 0x80008000);
-    uint32_t sum = __QADD16(a, b);
-    return __UADD16(sum, 0x80008000);
+    #if (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1)) //Cortex-M4 w/FPU
+    return __UHADD16(a, b);
     #else
     uint32_t result = 0;
     for (int8_t i = 0; i < 2; i++) {
         int16_t ai = (a >> (sizeof(uint16_t) * 8 * i)) - 0x8000;
         int16_t bi = (b >> (sizeof(uint16_t) * 8 * i)) - 0x8000;
-        int32_t intermediate = (int32_t) ai + bi;
+        int32_t intermediate = (int32_t) ai + bi / 2;
         if (intermediate > USHRT_MAX) {
             intermediate = USHRT_MAX;
         }
-        result |= ((uint16_t) intermediate + 0x8000) << (sizeof(int16_t) * 8 * i);
+        result |= ((uint32_t) intermediate & 0xffff) << (sizeof(int16_t) * 8 * i);
+    }
+    return result;
+    #endif
+}
+
+static inline uint32_t mult8unsigned(uint32_t val, int32_t mul) {
+    // if mul == 0, no need in wasting cycles
+    if (mul == 0) {
+        return 0;
+    }
+    /* TODO: workout ARMv7 instructions
+    #if (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1)) //Cortex-M4 w/FPU
+    return val;
+    #else*/
+    uint32_t result = 0;
+    float mod_mul = (float) mul / (float) ((1<<15)-1);
+    for (int8_t i = 0; i < 4; i++) {
+        uint8_t ai = val >> (sizeof(uint8_t) * 8 * i);
+        int32_t intermediate = ai * mod_mul;
+        if (intermediate > SHRT_MAX) {
+            intermediate = SHRT_MAX;
+        }
+        result |= ((uint32_t) intermediate & 0xff) << (sizeof(uint8_t) * 8 * i);
+    }
+
+    return result;
+    //#endif
+}
+
+static inline uint32_t mult8signed(uint32_t val, int32_t mul) {
+    // if mul == 0, no need in wasting cycles
+    if (mul == 0) {
+        return 0;
+    }
+    /* TODO: workout ARMv7 instructions
+    #if (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1)) //Cortex-M4 w/FPU
+    return val;
+    #else
+    */
+    uint32_t result = 0;
+    float mod_mul = (float)mul / (float)((1<<15)-1);
+    for (int8_t i = 0; i < 4; i++) {
+        int16_t ai = val >> (sizeof(int8_t) * 8 * i);
+        int32_t intermediate = ai * mod_mul;
+        if (intermediate > CHAR_MAX) {
+            intermediate = CHAR_MAX;
+        } else if (intermediate < CHAR_MIN) {
+            intermediate = CHAR_MIN;
+        }
+        result |= (((uint32_t) intermediate) & 0xff) << (sizeof(int16_t) * 8 * i);
+    }
+    return result;
+    //#endif
+}
+
+//TODO:
+static inline uint32_t mult16unsigned(uint32_t val, int32_t mul) {
+    // if mul == 0, no need in wasting cycles
+    if (mul == 0) {
+        return 0;
+    }
+    /* TODO: the below ARMv7m instructions "work", but the amplitude is much higher/louder
+    #if (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1)) //Cortex-M4 w/FPU
+    // there is no unsigned equivalent to the 'SMULWx' ARMv7 Thumb function,
+    // so we have to do it by hand.
+    uint32_t lo = val & 0xffff;
+    uint32_t hi = val >> 16;
+    //mp_printf(&mp_plat_print, "pre-asm: (mul: %d)\n\tval: %x\tlo: %x\thi: %x\n", mul, val, lo, hi);
+    uint32_t val_lo;
+    asm volatile("mul %0, %1, %2" : "=r" (val_lo) : "r" (mul), "r" (lo));
+    asm volatile("mla %0, %1, %2, %3" : "=r" (val) : "r" (mul), "r" (hi), "r" (val_lo));
+    //mp_printf(&mp_plat_print, "post-asm:\n\tval: %x\tlo: %x\n\n", val, val_lo);
+    return val;
+    #else
+    */
+    uint32_t result = 0;
+    float mod_mul = (float)mul / (float)((1<<15)-1);
+    for (int8_t i = 0; i < 2; i++) {
+        int16_t ai = (val >> (sizeof(uint16_t) * 8 * i)) - 0x8000;
+        int32_t intermediate = ai * mod_mul;
+        if (intermediate > SHRT_MAX) {
+            intermediate = SHRT_MAX;
+        } else if (intermediate < SHRT_MIN) {
+            intermediate = SHRT_MIN;
+        }
+        result |= (((uint32_t) intermediate) + 0x8000) << (sizeof(int16_t) * 8 * i);
+    }
+    return result;
+    //#endif
+}
+
+static inline uint32_t mult16signed(uint32_t val, int32_t mul) {
+    // if mul == 0, no need in wasting cycles
+    if (mul == 0) {
+        return 0;
+    }
+    #if (defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1)) //Cortex-M4 w/FPU
+    int32_t hi, lo;
+    enum { bits = 16 }; // saturate to 16 bits
+    enum { shift = 0 }; // shift is done automatically
+    asm volatile("smulwb %0, %1, %2" : "=r" (lo) : "r" (mul), "r" (val));
+    asm volatile("smulwt %0, %1, %2" : "=r" (hi) : "r" (mul), "r" (val));
+    asm volatile("ssat %0, %1, %2, asr %3" : "=r" (lo) : "I" (bits), "r" (lo), "I" (shift));
+    asm volatile("ssat %0, %1, %2, asr %3" : "=r" (hi) : "I" (bits), "r" (hi), "I" (shift));
+    asm volatile("pkhbt %0, %1, %2, lsl #16" : "=r" (val) : "r" (lo), "r" (hi)); // pack
+    return val;
+    #else
+    uint32_t result = 0;
+    float mod_mul = (float)mul / (float)((1<<15)-1);
+    for (int8_t i = 0; i < 2; i++) {
+        int16_t ai = val >> (sizeof(int16_t) * 8 * i);
+        int32_t intermediate = ai * mod_mul;
+        if (intermediate > SHRT_MAX) {
+            intermediate = SHRT_MAX;
+        } else if (intermediate < SHRT_MIN) {
+            intermediate = SHRT_MIN;
+        }
+        result |= (((uint32_t) intermediate) & 0xffff) << (sizeof(int16_t) * 8 * i);
     }
     return result;
     #endif
 }
 
-audioio_get_buffer_result_t audioio_mixer_get_buffer(audioio_mixer_obj_t* self,
-                                                     bool single_channel,
-                                                     uint8_t channel,
-                                                     uint8_t** buffer,
-                                                     uint32_t* buffer_length) {
+audioio_get_buffer_result_t audiomixer_mixer_get_buffer(audiomixer_mixer_obj_t* self,
+                                                        bool single_channel,
+                                                        uint8_t channel,
+                                                        uint8_t** buffer,
+                                                        uint32_t* buffer_length) {
     if (!single_channel) {
         channel = 0;
     }
@@ -243,7 +315,7 @@ audioio_get_buffer_result_t audioio_mixer_get_buffer(audioio_mixer_obj_t* self,
         self->use_first_buffer = !self->use_first_buffer;
         bool voices_active = false;
         for (int32_t v = 0; v < self->voice_count; v++) {
-            audioio_mixer_voice_t* voice = &self->voice[v];
+            audiomixer_mixervoice_obj_t* voice = MP_OBJ_TO_PTR(self->voice[v]);
 
             uint32_t j = 0;
             bool voice_done = voice->sample == NULL;
@@ -285,6 +357,21 @@ audioio_get_buffer_result_t audioio_mixer_get_buffer(audioio_mixer_obj_t* self,
                     sample_value = voice->remaining_buffer[j];
                 }
 
+                // apply the mixer level
+            	if (!self->samples_signed) {
+                    if (self->bits_per_sample == 8) {
+                        sample_value = mult8unsigned(sample_value, voice->level);
+                    } else {
+                        sample_value = mult16unsigned(sample_value, voice->level);
+                    }
+                } else {
+                    if (self->bits_per_sample == 8) {
+                        sample_value = mult8signed(sample_value, voice->level);
+                    } else {
+                        sample_value = mult16signed(sample_value, voice->level);
+                    }
+                }
+
                 if (!voices_active) {
                     word_buffer[i] = sample_value;
                 } else {
@@ -327,7 +414,7 @@ audioio_get_buffer_result_t audioio_mixer_get_buffer(audioio_mixer_obj_t* self,
     return GET_BUFFER_MORE_DATA;
 }
 
-void audioio_mixer_get_buffer_structure(audioio_mixer_obj_t* self, bool single_channel,
+void audiomixer_mixer_get_buffer_structure(audiomixer_mixer_obj_t* self, bool single_channel,
                                         bool* single_buffer, bool* samples_signed,
                                         uint32_t* max_buffer_length, uint8_t* spacing) {
     *single_buffer = false;
diff --git a/shared-module/audioio/Mixer.h b/shared-module/audiomixer/Mixer.h
index 6a88fe0bd..ab4780efc 100644
--- a/shared-module/audioio/Mixer.h
+++ b/shared-module/audiomixer/Mixer.h
@@ -24,20 +24,13 @@
  * THE SOFTWARE.
  */
 
-#ifndef MICROPY_INCLUDED_SHARED_MODULE_AUDIOIO_MIXER_H
-#define MICROPY_INCLUDED_SHARED_MODULE_AUDIOIO_MIXER_H
+#ifndef MICROPY_INCLUDED_SHARED_MODULE_AUDIOMIXER_MIXER_H
+#define MICROPY_INCLUDED_SHARED_MODULE_AUDIOMIXER_MIXER_H
 
 #include "py/obj.h"
+#include "py/objtuple.h"
 
-#include "shared-module/audioio/__init__.h"
-
-typedef struct {
-    mp_obj_t sample;
-    bool loop;
-    bool more_data;
-    uint32_t* remaining_buffer;
-    uint32_t buffer_length;
-} audioio_mixer_voice_t;
+#include "shared-module/audiocore/__init__.h"
 
 typedef struct {
     mp_obj_base_t base;
@@ -55,21 +48,22 @@ typedef struct {
     uint32_t right_read_count;
 
     uint8_t voice_count;
-    audioio_mixer_voice_t voice[];
-} audioio_mixer_obj_t;
+    mp_obj_tuple_t *voice_tuple;
+    mp_obj_t voice[];
+} audiomixer_mixer_obj_t;
 
 
 // These are not available from Python because it may be called in an interrupt.
-void audioio_mixer_reset_buffer(audioio_mixer_obj_t* self,
+void audiomixer_mixer_reset_buffer(audiomixer_mixer_obj_t* self,
                                     bool single_channel,
                                     uint8_t channel);
-audioio_get_buffer_result_t audioio_mixer_get_buffer(audioio_mixer_obj_t* self,
+audioio_get_buffer_result_t audiomixer_mixer_get_buffer(audiomixer_mixer_obj_t* self,
                                                          bool single_channel,
                                                          uint8_t channel,
                                                          uint8_t** buffer,
                                                          uint32_t* buffer_length); // length in bytes
-void audioio_mixer_get_buffer_structure(audioio_mixer_obj_t* self, bool single_channel,
+void audiomixer_mixer_get_buffer_structure(audiomixer_mixer_obj_t* self, bool single_channel,
                                             bool* single_buffer, bool* samples_signed,
                                             uint32_t* max_buffer_length, uint8_t* spacing);
 
-#endif // MICROPY_INCLUDED_SHARED_MODULE_AUDIOIO_MIXER_H
+#endif // MICROPY_INCLUDED_SHARED_MODULE_AUDIOMIXER_MIXER_H
diff --git a/shared-module/audiomixer/MixerVoice.c b/shared-module/audiomixer/MixerVoice.c
new file mode 100644
index 000000000..ff05dc93e
--- /dev/null
+++ b/shared-module/audiomixer/MixerVoice.c
@@ -0,0 +1,87 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 DeanM 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/audiomixer/Mixer.h"
+#include "shared-module/audiomixer/MixerVoice.h"
+
+#include <stdint.h>
+
+#include "py/runtime.h"
+#include "shared-module/audiomixer/__init__.h"
+#include "shared-module/audiocore/RawSample.h"
+
+void common_hal_audiomixer_mixervoice_construct(audiomixer_mixervoice_obj_t *self) {
+    self->sample = NULL;
+    self->level = ((1 << 15) - 1);
+}
+
+void common_hal_audiomixer_mixervoice_set_parent(audiomixer_mixervoice_obj_t* self, audiomixer_mixer_obj_t *parent) {
+	self->parent = parent;
+}
+
+float common_hal_audiomixer_mixervoice_get_level(audiomixer_mixervoice_obj_t* self) {
+	return ((float) self->level / ((1 << 15) - 1));
+}
+
+void common_hal_audiomixer_mixervoice_set_level(audiomixer_mixervoice_obj_t* self, float level) {
+	self->level = level * ((1 << 15)-1);
+}
+
+void common_hal_audiomixer_mixervoice_play(audiomixer_mixervoice_obj_t* self, mp_obj_t sample, bool loop) {
+    if (audiosample_sample_rate(sample) != self->parent->sample_rate) {
+        mp_raise_ValueError(translate("The sample's sample rate does not match the mixer's"));
+    }
+    if (audiosample_channel_count(sample) != self->parent->channel_count) {
+        mp_raise_ValueError(translate("The sample's channel count does not match the mixer's"));
+    }
+    if (audiosample_bits_per_sample(sample) != self->parent->bits_per_sample) {
+        mp_raise_ValueError(translate("The sample's bits_per_sample does not match the mixer's"));
+    }
+    bool single_buffer;
+    bool samples_signed;
+    uint32_t max_buffer_length;
+    uint8_t spacing;
+    audiosample_get_buffer_structure(sample, false, &single_buffer, &samples_signed,
+                                     &max_buffer_length, &spacing);
+    if (samples_signed != self->parent->samples_signed) {
+        mp_raise_ValueError(translate("The sample's signedness does not match the mixer's"));
+    }
+    self->sample = sample;
+    self->loop = loop;
+
+    audiosample_reset_buffer(sample, false, 0);
+    audioio_get_buffer_result_t result = audiosample_get_buffer(sample, false, 0, (uint8_t**) &self->remaining_buffer, &self->buffer_length);
+    // Track length in terms of words.
+    self->buffer_length /= sizeof(uint32_t);
+    self->more_data = result == GET_BUFFER_MORE_DATA;
+}
+
+bool common_hal_audiomixer_mixervoice_get_playing(audiomixer_mixervoice_obj_t* self) {
+	return self->sample != NULL;
+}
+
+void common_hal_audiomixer_mixervoice_stop(audiomixer_mixervoice_obj_t* self) {
+    self->sample = NULL;
+}
diff --git a/shared-module/audiomixer/MixerVoice.h b/shared-module/audiomixer/MixerVoice.h
new file mode 100644
index 000000000..efac19156
--- /dev/null
+++ b/shared-module/audiomixer/MixerVoice.h
@@ -0,0 +1,46 @@
+/*
+ * This file is part of the Micro Python project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 DeanM 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 SHARED_MODULE_AUDIOMIXER_MIXERVOICE_H_
+#define SHARED_MODULE_AUDIOMIXER_MIXERVOICE_H_
+
+#include "py/obj.h"
+
+#include "shared-module/audiomixer/__init__.h"
+#include "shared-module/audiomixer/Mixer.h"
+
+typedef struct {
+	mp_obj_base_t base;
+	audiomixer_mixer_obj_t *parent;
+    mp_obj_t sample;
+    bool loop;
+    bool more_data;
+    uint32_t* remaining_buffer;
+    uint32_t buffer_length;
+    int16_t level;
+} audiomixer_mixervoice_obj_t;
+
+
+#endif /* SHARED_MODULE_AUDIOMIXER_MIXERVOICE_H_ */
diff --git a/shared-module/audiomixer/__init__.c b/shared-module/audiomixer/__init__.c
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/shared-module/audiomixer/__init__.c
diff --git a/shared-module/bleio/__init__.h b/shared-module/audiomixer/__init__.h
index 07d148594..35b731558 100644
--- a/shared-module/bleio/__init__.h
+++ b/shared-module/audiomixer/__init__.h
@@ -24,15 +24,9 @@
  * THE SOFTWARE.
  */
 
-#ifndef MICROPY_INCLUDED_SHARED_MODULE_BLEIO_INIT_H
-#define MICROPY_INCLUDED_SHARED_MODULE_BLEIO_INIT_H
+#ifndef MICROPY_INCLUDED_SHARED_MODULE_AUDIOMIXER__INIT__H
+#define MICROPY_INCLUDED_SHARED_MODULE_AUDIOMIXER__INIT__H
 
-typedef enum {
-    GATT_ROLE_NONE,
-    GATT_ROLE_SERVER,
-    GATT_ROLE_CLIENT,
-} gatt_role_t;
+#include "shared-module/audiocore/__init__.h"
 
-extern void bleio_reset(void);
-
-#endif // MICROPY_INCLUDED_SHARED_MODULE_BLEIO_INIT_H
+#endif  // MICROPY_INCLUDED_SHARED_MODULE_AUDIOMIXER__INIT__H
diff --git a/shared-module/audiopwmio/__init__.c b/shared-module/audiopwmio/__init__.c
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/shared-module/audiopwmio/__init__.c
diff --git a/shared-module/audiopwmio/__init__.h b/shared-module/audiopwmio/__init__.h
new file mode 100644
index 000000000..964e4aafe
--- /dev/null
+++ b/shared-module/audiopwmio/__init__.h
@@ -0,0 +1,32 @@
+/*
+ * 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_AUDIOPWMIO__INIT__H
+#define MICROPY_INCLUDED_SHARED_MODULE_AUDIOPWMIO__INIT__H
+
+#include "shared-module/audiocore/__init__.h"
+
+#endif  // MICROPY_INCLUDED_SHARED_MODULE_AUDIOPWMIO__INIT__H
diff --git a/shared-module/board/__init__.c b/shared-module/board/__init__.c
index be8502bc0..dd07d7190 100644
--- a/shared-module/board/__init__.c
+++ b/shared-module/board/__init__.c
@@ -24,31 +24,41 @@
  * THE SOFTWARE.
  */
 
-#include "shared-bindings/busio/I2C.h"
-#include "shared-bindings/busio/SPI.h"
-#include "shared-bindings/busio/UART.h"
-
 #include "shared-bindings/microcontroller/Pin.h"
 #include "supervisor/shared/translate.h"
 #include "mpconfigboard.h"
 #include "py/runtime.h"
 
-#ifdef CIRCUITPY_DISPLAYIO
+#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
+// Statically allocate the I2C 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 I2CDisplay displays and be accessible through board.I2C().
+STATIC busio_i2c_obj_t i2c_obj;
+STATIC mp_obj_t i2c_singleton = NULL;
+
 mp_obj_t common_hal_board_get_i2c(void) {
-    return MP_STATE_VM(shared_i2c_bus);
+    return i2c_singleton;
 }
 
 mp_obj_t common_hal_board_create_i2c(void) {
-    busio_i2c_obj_t *self = m_new_ll_obj(busio_i2c_obj_t);
+    if (i2c_singleton != NULL) {
+        return i2c_singleton;
+    }
+    busio_i2c_obj_t *self = &i2c_obj;
     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);
+    i2c_singleton = (mp_obj_t)self;
+    return i2c_singleton;
 }
 #endif
 
@@ -99,7 +109,18 @@ mp_obj_t common_hal_board_create_uart(void) {
 
 void reset_board_busses(void) {
 #if BOARD_I2C
-    MP_STATE_VM(shared_i2c_bus) = NULL;
+    bool display_using_i2c = false;
+    #if CIRCUITPY_DISPLAYIO
+    for (uint8_t i = 0; i < CIRCUITPY_DISPLAY_LIMIT; i++) {
+        if (displays[i].i2cdisplay_bus.bus == i2c_singleton) {
+            display_using_i2c = true;
+            break;
+        }
+    }
+    #endif
+    if (!display_using_i2c) {
+        i2c_singleton = NULL;
+    }
 #endif
 #if BOARD_SPI
     bool display_using_spi = false;
diff --git a/shared-module/displayio/Bitmap.c b/shared-module/displayio/Bitmap.c
index f8dc24c15..59971d25c 100644
--- a/shared-module/displayio/Bitmap.c
+++ b/shared-module/displayio/Bitmap.c
@@ -63,6 +63,11 @@ void common_hal_displayio_bitmap_construct(displayio_bitmap_t *self, uint32_t wi
     }
     self->x_mask = (1 << self->x_shift) - 1; // Used as a modulus on the x value
     self->bitmask = (1 << bits_per_value) - 1;
+
+    self->dirty_area.x1 = 0;
+    self->dirty_area.x2 = width;
+    self->dirty_area.y1 = 0;
+    self->dirty_area.y2 = height;
 }
 
 uint16_t common_hal_displayio_bitmap_get_height(displayio_bitmap_t *self) {
@@ -104,6 +109,26 @@ void common_hal_displayio_bitmap_set_pixel(displayio_bitmap_t *self, int16_t x,
     if (self->read_only) {
         mp_raise_RuntimeError(translate("Read-only object"));
     }
+    // Update the dirty area.
+    if (self->dirty_area.x1 == self->dirty_area.x2) {
+        self->dirty_area.x1 = x;
+        self->dirty_area.x2 = x + 1;
+        self->dirty_area.y1 = y;
+        self->dirty_area.y2 = y + 1;
+    } else {
+        if (x < self->dirty_area.x1) {
+            self->dirty_area.x1 = x;
+        } else if (x >= self->dirty_area.x2) {
+            self->dirty_area.x2 = x + 1;
+        }
+        if (y < self->dirty_area.y1) {
+            self->dirty_area.y1 = y;
+        } else if (y >= self->dirty_area.y2) {
+            self->dirty_area.y2 = y + 1;
+        }
+    }
+
+    // Update our data
     int32_t row_start = y * self->stride;
     uint32_t bytes_per_value = self->bits_per_value / 8;
     if (bytes_per_value < 1) {
@@ -124,3 +149,16 @@ void common_hal_displayio_bitmap_set_pixel(displayio_bitmap_t *self, int16_t x,
         }
     }
 }
+
+displayio_area_t* displayio_bitmap_get_refresh_areas(displayio_bitmap_t *self, displayio_area_t* tail) {
+    if (self->dirty_area.x1 == self->dirty_area.x2) {
+        return tail;
+    }
+    self->dirty_area.next = tail;
+    return &self->dirty_area;
+}
+
+void displayio_bitmap_finish_refresh(displayio_bitmap_t *self) {
+    self->dirty_area.x1 = 0;
+    self->dirty_area.x2 = 0;
+}
diff --git a/shared-module/displayio/Bitmap.h b/shared-module/displayio/Bitmap.h
index 48ca9e2cf..f4bd7ce4d 100644
--- a/shared-module/displayio/Bitmap.h
+++ b/shared-module/displayio/Bitmap.h
@@ -31,6 +31,7 @@
 #include <stdint.h>
 
 #include "py/obj.h"
+#include "shared-module/displayio/area.h"
 
 typedef struct {
     mp_obj_base_t base;
@@ -41,8 +42,12 @@ typedef struct {
     uint8_t bits_per_value;
     uint8_t x_shift;
     size_t x_mask;
+    displayio_area_t dirty_area;
     uint16_t bitmask;
     bool read_only;
 } displayio_bitmap_t;
 
+void displayio_bitmap_finish_refresh(displayio_bitmap_t *self);
+displayio_area_t* displayio_bitmap_get_refresh_areas(displayio_bitmap_t *self, displayio_area_t* tail);
+
 #endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_BITMAP_H
diff --git a/shared-module/displayio/ColorConverter.c b/shared-module/displayio/ColorConverter.c
index 3928e115a..a5d7f0b05 100644
--- a/shared-module/displayio/ColorConverter.c
+++ b/shared-module/displayio/ColorConverter.c
@@ -26,20 +26,163 @@
 
 #include "shared-bindings/displayio/ColorConverter.h"
 
-void common_hal_displayio_colorconverter_construct(displayio_colorconverter_t* self) {
+#include "py/misc.h"
+
+uint32_t displayio_colorconverter_dither_noise_1 (uint32_t n)
+{
+  n = (n >> 13) ^ n;
+  int nn = (n * (n * n * 60493 + 19990303) + 1376312589) & 0x7fffffff;
+  return (uint32_t) (((float)nn / (1073741824.0f*2)) * 255);
+}
+
+uint32_t displayio_colorconverter_dither_noise_2(uint32_t x, uint32_t y) {
+    return displayio_colorconverter_dither_noise_1(x + y * 0xFFFF);
+}
+
+void common_hal_displayio_colorconverter_construct(displayio_colorconverter_t* self, bool dither) {
+    self->dither = dither;
 }
 
-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;
+}
+
+uint8_t displayio_colorconverter_compute_chroma(uint32_t color_rgb888) {
+    uint32_t r8 = (color_rgb888 >> 16);
+    uint32_t g8 = (color_rgb888 >> 8) & 0xff;
+    uint32_t b8 = color_rgb888 & 0xff;
+    uint8_t max = MAX(r8, MAX(g8, b8));
+    uint8_t min = MIN(r8, MIN(g8, b8));
+    return max - min;
+}
+
+uint8_t displayio_colorconverter_compute_hue(uint32_t color_rgb888) {
+    uint32_t r8 = (color_rgb888 >> 16);
+    uint32_t g8 = (color_rgb888 >> 8) & 0xff;
+    uint32_t b8 = color_rgb888 & 0xff;
+    uint8_t max = MAX(r8, MAX(g8, b8));
+    uint8_t min = MIN(r8, MIN(g8, b8));
+    uint8_t c = max - min;
+    if (c == 0) {
+        return 0;
+    }
+
+    int32_t hue = 0;
+    if (max == r8) {
+        hue = (((int32_t) (g8 - b8) * 40) / c) % 240;
+    } else if (max == g8) {
+        hue = (((int32_t) (b8 - r8) + (2 * c)) * 40) / c;
+    } else if (max == b8) {
+        hue = (((int32_t) (r8 - g8) + (4 * c)) * 40) / c;
+    }
+    if (hue < 0) {
+        hue += 240;
+    }
+
+    return hue;
+}
+
+void displayio_colorconverter_compute_tricolor(const _displayio_colorspace_t* colorspace, uint8_t pixel_hue, uint8_t pixel_luma, uint32_t*  color) {
+
+    int16_t hue_diff = colorspace->tricolor_hue - pixel_hue;
+    if ((-10 <= hue_diff && hue_diff <= 10) || hue_diff <= -220 || hue_diff >= 220) {
+        if (colorspace->grayscale) {
+            *color = 0;
+        } else {
+            *color = 1;
+        }
+    } else if (!colorspace->grayscale) {
+        *color = 0;
+    }
 }
 
+void common_hal_displayio_colorconverter_convert(displayio_colorconverter_t *self, const _displayio_colorspace_t* colorspace, uint32_t input_color, uint32_t* output_color) {
+    displayio_input_pixel_t input_pixel;
+    input_pixel.pixel = input_color;
+    input_pixel.x = input_pixel.y = input_pixel.tile = input_pixel.tile_x = input_pixel.tile_y = 0;
+    
+    displayio_output_pixel_t output_pixel;
+    output_pixel.pixel = 0;
+    output_pixel.opaque = false;
+
+    displayio_colorconverter_convert(self, colorspace, &input_pixel, &output_pixel);
+
+    (*output_color) = output_pixel.pixel;
+}
+
+void common_hal_displayio_colorconverter_set_dither(displayio_colorconverter_t* self, bool dither) {
+    self->dither = dither;
+}
+
+bool common_hal_displayio_colorconverter_get_dither(displayio_colorconverter_t* self) {
+    return self->dither;
+}
+
+void displayio_colorconverter_convert(displayio_colorconverter_t *self, const _displayio_colorspace_t* colorspace, const displayio_input_pixel_t *input_pixel, displayio_output_pixel_t *output_color) {
+    uint32_t pixel = input_pixel->pixel;
+    
+    if (self->dither){
+        uint8_t randr = (displayio_colorconverter_dither_noise_2(input_pixel->tile_x,input_pixel->tile_y));
+        uint8_t randg = (displayio_colorconverter_dither_noise_2(input_pixel->tile_x+33,input_pixel->tile_y));
+        uint8_t randb = (displayio_colorconverter_dither_noise_2(input_pixel->tile_x,input_pixel->tile_y+33));
+
+        uint32_t r8 = (pixel >> 16);
+        uint32_t g8 = (pixel >> 8) & 0xff;
+        uint32_t b8 = pixel & 0xff;
+
+        if (colorspace->depth == 16) {
+            b8 = MIN(255,b8 + (randb&0x07));
+            r8 = MIN(255,r8 + (randr&0x07));
+            g8 = MIN(255,g8 + (randg&0x03));
+        } else {
+            int bitmask = 0xFF >> colorspace->depth;
+            b8 = MIN(255,b8 + (randb&bitmask));
+            r8 = MIN(255,r8 + (randr&bitmask));
+            g8 = MIN(255,g8 + (randg&bitmask));
+        }
+        pixel = r8 << 16 | g8 << 8 | b8;
+    }
+
+    if (colorspace->depth == 16) {
+        output_color->pixel = displayio_colorconverter_compute_rgb565(pixel);
+        output_color->opaque = true;
+        return;
+    } else if (colorspace->tricolor) {
+        uint8_t luma = displayio_colorconverter_compute_luma(pixel);
+        output_color->pixel = luma >> (8 - colorspace->depth);
+        if (displayio_colorconverter_compute_chroma(pixel) <= 16) {
+            if (!colorspace->grayscale) {
+                output_color->pixel = 0;
+            }
+            output_color->opaque = true;
+            return;
+        }
+        uint8_t pixel_hue = displayio_colorconverter_compute_hue(pixel);
+        displayio_colorconverter_compute_tricolor(colorspace, pixel_hue, luma, &output_color->pixel);
+        return;
+    }  else if (colorspace->grayscale && colorspace->depth <= 8) {
+        uint8_t luma = displayio_colorconverter_compute_luma(pixel);
+        output_color->pixel = luma >> (8 - colorspace->depth);
+        output_color->opaque = true;
+        return;
+    }
+    output_color->opaque = false;
+}
+
+
+
 // Currently no refresh logic is needed for a ColorConverter.
 bool displayio_colorconverter_needs_refresh(displayio_colorconverter_t *self) {
     return false;
@@ -47,3 +190,4 @@ bool displayio_colorconverter_needs_refresh(displayio_colorconverter_t *self) {
 
 void displayio_colorconverter_finish_refresh(displayio_colorconverter_t *self) {
 }
+
diff --git a/shared-module/displayio/ColorConverter.h b/shared-module/displayio/ColorConverter.h
index 7f3c1a0a0..10b1604a4 100644
--- a/shared-module/displayio/ColorConverter.h
+++ b/shared-module/displayio/ColorConverter.h
@@ -31,12 +31,24 @@
 #include <stdint.h>
 
 #include "py/obj.h"
+#include "shared-module/displayio/Palette.h"
 
 typedef struct {
     mp_obj_base_t base;
+    bool dither;
 } displayio_colorconverter_t;
 
 bool displayio_colorconverter_needs_refresh(displayio_colorconverter_t *self);
 void displayio_colorconverter_finish_refresh(displayio_colorconverter_t *self);
+void displayio_colorconverter_convert(displayio_colorconverter_t *self, const _displayio_colorspace_t* colorspace, const displayio_input_pixel_t *input_pixel, displayio_output_pixel_t *output_color);
+
+uint32_t displayio_colorconverter_dither_noise_1 (uint32_t n);
+uint32_t displayio_colorconverter_dither_noise_2(uint32_t x, uint32_t y);
+
+uint16_t displayio_colorconverter_compute_rgb565(uint32_t color_rgb888);
+uint8_t displayio_colorconverter_compute_luma(uint32_t color_rgb888);
+uint8_t displayio_colorconverter_compute_chroma(uint32_t color_rgb888);
+uint8_t displayio_colorconverter_compute_hue(uint32_t color_rgb888);
+void displayio_colorconverter_compute_tricolor(const _displayio_colorspace_t* colorspace, uint8_t pixel_hue, uint8_t pixel_luma, uint32_t*  color);
 
 #endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_COLORCONVERTER_H
diff --git a/shared-module/displayio/Display.c b/shared-module/displayio/Display.c
index 0ae88300a..06b81f2f8 100644
--- a/shared-module/displayio/Display.c
+++ b/shared-module/displayio/Display.c
@@ -28,70 +28,70 @@
 
 #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"
 #include "shared-module/displayio/__init__.h"
+#include "shared-module/displayio/display_core.h"
 #include "supervisor/shared/display.h"
+#include "supervisor/usb.h"
 
 #include <stdint.h>
+#include <string.h>
 
 #include "tick.h"
 
-#define DELAY 0x80
-
 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,
-        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, mp_float_t brightness, bool auto_brightness,
-        bool single_byte_bounds, bool data_as_commands) {
-    self->color_depth = color_depth;
+        mp_obj_t bus, uint16_t width, uint16_t height, int16_t colstart, int16_t rowstart,
+        uint16_t rotation, 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,
+        uint16_t brightness_command, mp_float_t brightness, bool auto_brightness,
+        bool single_byte_bounds, bool data_as_commands, bool auto_refresh, uint16_t native_frames_per_second) {
+    // Turn off auto-refresh as we init.
+    self->auto_refresh = false;
+    uint16_t ram_width = 0x100;
+    uint16_t ram_height = 0x100;
+    if (single_byte_bounds) {
+        ram_width = 0xff;
+        ram_height = 0xff;
+    }
+    displayio_display_core_construct(&self->core, bus, width, height, ram_width, ram_height, colstart, rowstart, rotation,
+        color_depth, grayscale, pixels_in_byte_share_row, bytes_per_cell, 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;
-    self->refresh = false;
-    self->current_group = NULL;
-    self->colstart = colstart;
-    self->rowstart = rowstart;
+    self->brightness_command = brightness_command;
     self->auto_brightness = auto_brightness;
+    self->first_manual_refresh = !auto_refresh;
     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;
-        self->send = common_hal_displayio_parallelbus_send;
-        self->end_transaction = common_hal_displayio_parallelbus_end_transaction;
-    } else if (MP_OBJ_IS_TYPE(bus, &displayio_fourwire_type)) {
-        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 {
-        mp_raise_ValueError(translate("Unsupported display bus type"));
-    }
-    self->bus = bus;
+
+    self->native_frames_per_second = native_frames_per_second;
+    self->native_ms_per_frame = 1000 / native_frames_per_second;
 
     uint32_t i = 0;
-    while (!self->begin_transaction(self->bus)) {
-#ifdef MICROPY_VM_HOOK_LOOP
-        MICROPY_VM_HOOK_LOOP ;
-#endif
-    }
     while (i < init_sequence_len) {
         uint8_t *cmd = init_sequence + i;
         uint8_t data_size = *(cmd + 1);
         bool delay = (data_size & DELAY) != 0;
         data_size &= ~DELAY;
         uint8_t *data = cmd + 2;
-        self->send(self->bus, true, cmd, 1);
+        while (!displayio_display_core_begin_transaction(&self->core)) {
+            RUN_BACKGROUND_TASKS;
+        }
         if (self->data_as_commands) {
-            // Loop through each parameter to force a CS toggle
-            for (uint32_t j=0; j < data_size; j++) {
-                self->send(self->bus, true, data + j, 1);
-            }
+            uint8_t full_command[data_size + 1];
+            full_command[0] = cmd[0];
+            memcpy(full_command + 1, data, data_size);
+            self->core.send(self->core.bus, DISPLAY_COMMAND, CHIP_SELECT_TOGGLE_EVERY_BYTE, full_command, data_size + 1);
         } else {
-            self->send(self->bus, false, data, data_size);
+            self->core.send(self->core.bus, DISPLAY_COMMAND, CHIP_SELECT_TOGGLE_EVERY_BYTE, cmd, 1);
+            self->core.send(self->core.bus, DISPLAY_DATA, CHIP_SELECT_UNTOUCHED, data, data_size);
         }
+        displayio_display_core_end_transaction(&self->core);
         uint16_t delay_length_ms = 10;
         if (delay) {
             data_size++;
@@ -103,33 +103,9 @@ void common_hal_displayio_display_construct(displayio_display_obj_t* self,
         common_hal_time_delay_ms(delay_length_ms);
         i += 2 + data_size;
     }
-    self->end_transaction(self->bus);
 
     supervisor_start_terminal(width, height);
 
-    self->width = width;
-    self->height = height;
-    rotation = rotation % 360;
-    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->transform.mirror_x = true;
-            self->transform.mirror_y = true;
-        }
-    } else {
-        self->transform.transpose_xy = true;
-        if (rotation == 270) {
-            self->transform.mirror_y = true;
-        } else {
-            self->transform.mirror_x = true;
-        }
-    }
-
     // Always set the backlight type in case we're reusing memory.
     self->backlight_inout.base.type = &mp_type_NoneType;
     if (backlight_pin != NULL && common_hal_mcu_pin_is_free(backlight_pin)) {
@@ -141,110 +117,43 @@ void common_hal_displayio_display_construct(displayio_display_obj_t* self,
         } else {
             self->backlight_pwm.base.type = &pulseio_pwmout_type;
             common_hal_pulseio_pwmout_never_reset(&self->backlight_pwm);
-            if (!self->auto_brightness) {
-                common_hal_displayio_display_set_brightness(self, brightness);
-            }
         }
     }
-
-    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;
-        }
+    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->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;
-        }
+        self->current_brightness = -1.0;
     }
 
     // Set the group after initialization otherwise we may send pixels while we delay in
     // initialization.
     common_hal_displayio_display_show(self, &circuitpython_splash);
+    self->auto_refresh = auto_refresh;
 }
 
-void 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;
-    }
-    displayio_group_update_transform(root_group, &self->transform);
-    self->current_group = root_group;
-    self->full_refresh = true;
-    common_hal_displayio_display_refresh_soon(self);
-}
-
-void common_hal_displayio_display_refresh_soon(displayio_display_obj_t* self) {
-    self->refresh = true;
+bool common_hal_displayio_display_show(displayio_display_obj_t* self, displayio_group_t* root_group) {
+    return displayio_display_core_show(&self->core, root_group);
 }
 
-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);
-    }
+uint16_t common_hal_displayio_display_get_width(displayio_display_obj_t* self){
+    return displayio_display_core_get_width(&self->core);
 }
 
-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.
-    while (last_refresh == self->last_refresh && MP_STATE_VM(mp_pending_exception) == NULL) {
-        MICROPY_VM_HOOK_LOOP
-    }
-    return 0;
+uint16_t common_hal_displayio_display_get_height(displayio_display_obj_t* self){
+    return displayio_display_core_get_height(&self->core);
 }
 
 bool common_hal_displayio_display_get_auto_brightness(displayio_display_obj_t* self) {
     return self->auto_brightness;
 }
 
-uint16_t common_hal_displayio_display_get_width(displayio_display_obj_t* self){
-    return self->width;
-}
-
-uint16_t common_hal_displayio_display_get_height(displayio_display_obj_t* self){
-    return self->height;
-}
-
 void common_hal_displayio_display_set_auto_brightness(displayio_display_obj_t* self, bool auto_brightness) {
     self->auto_brightness = auto_brightness;
 }
 
 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) {
@@ -256,76 +165,188 @@ 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 = displayio_display_core_begin_transaction(&self->core);
+        if (ok) {
+            if (self->data_as_commands) {
+                uint8_t set_brightness[2] = {self->brightness_command, (uint8_t) (0xff * brightness)};
+                self->core.send(self->core.bus, DISPLAY_COMMAND, CHIP_SELECT_TOGGLE_EVERY_BYTE, set_brightness, 2);
+            } else {
+                uint8_t command = self->brightness_command;
+                uint8_t hex_brightness = 0xff * brightness;
+                self->core.send(self->core.bus, DISPLAY_COMMAND, CHIP_SELECT_TOGGLE_EVERY_BYTE, &command, 1);
+                self->core.send(self->core.bus, DISPLAY_DATA, CHIP_SELECT_UNTOUCHED, &hex_brightness, 1);
+            }
+            displayio_display_core_end_transaction(&self->core);
+        }
+
     }
     self->updating_backlight = false;
+    if (ok) {
+        self->current_brightness = brightness;
+    }
     return ok;
 }
 
-bool displayio_display_begin_transaction(displayio_display_obj_t* self) {
-    return self->begin_transaction(self->bus);
+mp_obj_t common_hal_displayio_display_get_bus(displayio_display_obj_t* self) {
+    return self->core.bus;
 }
 
-void displayio_display_end_transaction(displayio_display_obj_t* self) {
-    self->end_transaction(self->bus);
+STATIC const displayio_area_t* _get_refresh_areas(displayio_display_obj_t *self) {
+    if (self->core.full_refresh) {
+        self->core.area.next = NULL;
+        return &self->core.area;
+    } else if (self->core.current_group != NULL) {
+        return displayio_group_get_refresh_areas(self->core.current_group, NULL);
+    }
+    return NULL;
 }
 
-void displayio_display_set_region_to_update(displayio_display_obj_t* self, uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1) {
-    self->send(self->bus, true, &self->set_column_command, 1);
-    bool isCommand = self->data_as_commands;
-    if (self->single_byte_bounds) {
-        uint8_t data[2];
-        data[0] = x0 + self->colstart;
-        data[1] = x1 - 1 + self->colstart;
-        self->send(self->bus, isCommand, (uint8_t*) data, 2);
-    } else {
-        uint16_t data[2];
-        data[0] = __builtin_bswap16(x0 + self->colstart);
-        data[1] = __builtin_bswap16(x1 - 1 + self->colstart);
-        self->send(self->bus, isCommand, (uint8_t*) data, 4);
-    }
-    self->send(self->bus, true, &self->set_row_command, 1);
-    if (self->single_byte_bounds) {
-        uint8_t data[2];
-        data[0] = y0 + self->rowstart;
-        data[1] = y1 - 1 + self->rowstart;
-        self->send(self->bus, isCommand, (uint8_t*) data, 2);
-    } else {
-        uint16_t data[2];
-        data[0] = __builtin_bswap16(y0  + self->rowstart);
-        data[1] = __builtin_bswap16(y1 - 1 + self->rowstart);
-        self->send(self->bus, isCommand, (uint8_t*) data, 4);
-    }
+STATIC void _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->core.send(self->core.bus, DISPLAY_COMMAND, CHIP_SELECT_TOGGLE_EVERY_BYTE, &self->write_ram_command, 1);
     }
+    self->core.send(self->core.bus, DISPLAY_DATA, CHIP_SELECT_UNTOUCHED, pixels, length);
 }
 
-void displayio_display_start_refresh(displayio_display_obj_t* self) {
-    self->last_refresh = ticks_ms;
+STATIC bool _refresh_area(displayio_display_obj_t* self, 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_core_clip_area(&self->core, 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) / self->core.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 (self->core.colorspace.depth < 8 && !self->core.colorspace.pixels_in_byte_share_row) {
+            uint8_t pixels_per_byte = 8 / self->core.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];
+    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;
+
+        displayio_display_core_set_region_to_update(&self->core, self->set_column_command, self->set_row_command, NO_COMMAND, NO_COMMAND, self->data_as_commands, false, &subrectangle);
+
+        uint16_t subrectangle_size_bytes;
+        if (self->core.colorspace.depth >= 8) {
+            subrectangle_size_bytes = displayio_area_size(&subrectangle) * (self->core.colorspace.depth / 8);
+        } else {
+            subrectangle_size_bytes = displayio_area_size(&subrectangle) / (8 / self->core.colorspace.depth);
+        }
+
+        memset(mask, 0, mask_length * sizeof(mask[0]));
+        memset(buffer, 0, buffer_size * sizeof(buffer[0]));
+
+        displayio_display_core_fill_area(&self->core, &subrectangle, mask, buffer);
+
+        // Can't acquire display bus; skip the rest of the data.
+        if (!displayio_display_core_bus_free(&self->core)) {
+            return false;
+        }
+
+        displayio_display_core_begin_transaction(&self->core);
+        _send_pixels(self, (uint8_t*) buffer, subrectangle_size_bytes);
+        displayio_display_core_end_transaction(&self->core);
+
+        // TODO(tannewt): Make refresh displays faster so we don't starve other
+        // background tasks.
+        usb_background();
+    }
+    return true;
 }
 
-bool displayio_display_frame_queued(displayio_display_obj_t* self) {
-    if (self->current_group == NULL) {
-        return false;
+STATIC void _refresh_display(displayio_display_obj_t* self) {
+    if (!displayio_display_core_bus_free(&self->core)) {
+        // Can't acquire display bus; skip updating this display. Try next display.
+        return;
     }
-    // Refresh at ~60 fps.
-    return (ticks_ms - self->last_refresh) > 16;
+    displayio_display_core_start_refresh(&self->core);
+    const displayio_area_t* current_area = _get_refresh_areas(self);
+    while (current_area != NULL) {
+        _refresh_area(self, current_area);
+        current_area = current_area->next;
+    }
+    displayio_display_core_finish_refresh(&self->core);
 }
 
-void displayio_display_finish_refresh(displayio_display_obj_t* self) {
-    if (self->current_group != NULL) {
-        displayio_group_finish_refresh(self->current_group);
+uint16_t common_hal_displayio_display_get_rotation(displayio_display_obj_t* self){
+    return self->core.rotation;
+}
+
+bool common_hal_displayio_display_refresh(displayio_display_obj_t* self, uint32_t target_ms_per_frame, uint32_t maximum_ms_per_real_frame) {
+    if (!self->auto_refresh && !self->first_manual_refresh) {
+        uint64_t current_time = ticks_ms;
+        uint32_t current_ms_since_real_refresh = current_time - self->core.last_refresh;
+        // Test to see if the real frame time is below our minimum.
+        if (current_ms_since_real_refresh > maximum_ms_per_real_frame) {
+            mp_raise_RuntimeError(translate("Below minimum frame rate"));
+        }
+        uint32_t current_ms_since_last_call = current_time - self->last_refresh_call;
+        self->last_refresh_call = current_time;
+        // Skip the actual refresh to help catch up.
+        if (current_ms_since_last_call > target_ms_per_frame) {
+            return false;
+        }
+        uint32_t remaining_time = target_ms_per_frame - (current_ms_since_real_refresh % target_ms_per_frame);
+        // We're ahead of the game so wait until we align with the frame rate.
+        while (ticks_ms - self->last_refresh_call < remaining_time) {
+            RUN_BACKGROUND_TASKS;
+        }
     }
-    self->refresh = false;
-    self->full_refresh = false;
-    self->last_refresh = ticks_ms;
+    self->first_manual_refresh = false;
+    _refresh_display(self);
+    return true;
+}
+
+bool common_hal_displayio_display_get_auto_refresh(displayio_display_obj_t* self) {
+    return self->auto_refresh;
 }
 
-void displayio_display_send_pixels(displayio_display_obj_t* self, uint8_t* pixels, uint32_t length) {
-    self->send(self->bus, false, pixels, length);
+void common_hal_displayio_display_set_auto_refresh(displayio_display_obj_t* self,
+                                                   bool auto_refresh) {
+    self->first_manual_refresh = !auto_refresh;
+    self->auto_refresh = auto_refresh;
 }
 
-void displayio_display_update_backlight(displayio_display_obj_t* self) {
+STATIC void _update_backlight(displayio_display_obj_t* self) {
     if (!self->auto_brightness || self->updating_backlight) {
         return;
     }
@@ -339,7 +360,16 @@ void displayio_display_update_backlight(displayio_display_obj_t* self) {
     self->last_backlight_refresh = ticks_ms;
 }
 
+void displayio_display_background(displayio_display_obj_t* self) {
+    _update_backlight(self);
+
+    if (self->auto_refresh && (ticks_ms - self->core.last_refresh) > self->native_ms_per_frame) {
+        _refresh_display(self);
+    }
+}
+
 void release_display(displayio_display_obj_t* self) {
+    release_display_core(&self->core);
     if (self->backlight_pwm.base.type == &pulseio_pwmout_type) {
         common_hal_pulseio_pwmout_reset_ok(&self->backlight_pwm);
         common_hal_pulseio_pwmout_deinit(&self->backlight_pwm);
@@ -348,10 +378,12 @@ void release_display(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) {
-    return displayio_group_fill_area(self->current_group, area, mask, buffer);
+void reset_display(displayio_display_obj_t* self) {
+    self->auto_refresh = true;
+    self->auto_brightness = true;
+    common_hal_displayio_display_show(self, NULL);
 }
 
-bool displayio_display_clip_area(displayio_display_obj_t *self, const displayio_area_t* area, displayio_area_t* clipped) {
-    return displayio_area_compute_overlap(&self->area, area, clipped);
+void displayio_display_collect_ptrs(displayio_display_obj_t* self) {
+    displayio_display_core_collect_ptrs(&self->core);
 }
diff --git a/shared-module/displayio/Display.h b/shared-module/displayio/Display.h
index fa8902ced..e5fe0a708 100644
--- a/shared-module/displayio/Display.h
+++ b/shared-module/displayio/Display.h
@@ -32,47 +32,35 @@
 #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);
+#include "shared-module/displayio/display_core.h"
 
 typedef struct {
     mp_obj_base_t base;
-    mp_obj_t bus;
-    displayio_group_t *current_group;
-    uint64_t last_refresh;
-    display_bus_begin_transaction begin_transaction;
-    display_bus_send send;
-    display_bus_end_transaction end_transaction;
+    displayio_display_core_t core;
     union {
         digitalio_digitalinout_obj_t backlight_inout;
         pulseio_pwmout_obj_t backlight_pwm;
     };
     uint64_t last_backlight_refresh;
-    displayio_buffer_transform_t transform;
-    displayio_area_t area;
-    uint16_t width;
-    uint16_t height;
-    uint16_t color_depth;
-    int16_t colstart;
-    int16_t rowstart;
+    uint64_t last_refresh_call;
+    mp_float_t current_brightness;
+    uint16_t brightness_command;
+    uint16_t native_frames_per_second;
+    uint16_t native_ms_per_frame;
     uint8_t set_column_command;
     uint8_t set_row_command;
     uint8_t write_ram_command;
-    bool refresh;
-    bool single_byte_bounds;
+    bool auto_refresh;
+    bool first_manual_refresh;
     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 displayio_display_background(displayio_display_obj_t* self);
 void release_display(displayio_display_obj_t* self);
+void reset_display(displayio_display_obj_t* self);
+
+void displayio_display_collect_ptrs(displayio_display_obj_t* self);
 
 #endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_DISPLAY_H
diff --git a/shared-module/displayio/EPaperDisplay.c b/shared-module/displayio/EPaperDisplay.c
new file mode 100644
index 000000000..efbd9f3dd
--- /dev/null
+++ b/shared-module/displayio/EPaperDisplay.c
@@ -0,0 +1,385 @@
+/*
+ * This file is part of the MicroPython 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.
+ */
+
+#include "shared-bindings/displayio/EPaperDisplay.h"
+
+#include "py/runtime.h"
+#include "shared-bindings/displayio/ColorConverter.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"
+#include "shared-module/displayio/__init__.h"
+#include "supervisor/shared/display.h"
+#include "supervisor/usb.h"
+
+#include <stdint.h>
+#include <string.h>
+
+#include "tick.h"
+
+void common_hal_displayio_epaperdisplay_construct(displayio_epaperdisplay_obj_t* self,
+        mp_obj_t bus, uint8_t* start_sequence, uint16_t start_sequence_len, uint8_t* stop_sequence, uint16_t stop_sequence_len,
+        uint16_t width, uint16_t height, uint16_t ram_width, uint16_t ram_height,
+        int16_t colstart, int16_t rowstart, uint16_t rotation,
+        uint16_t set_column_window_command, uint16_t set_row_window_command,
+        uint16_t set_current_column_command, uint16_t set_current_row_command,
+        uint16_t write_black_ram_command, bool black_bits_inverted, uint16_t write_color_ram_command, bool color_bits_inverted, uint32_t highlight_color, uint16_t refresh_display_command, mp_float_t refresh_time,
+        const mcu_pin_obj_t* busy_pin, bool busy_state, mp_float_t seconds_per_frame, bool chip_select) {
+    if (highlight_color != 0x000000) {
+        self->core.colorspace.tricolor = true;
+        self->core.colorspace.tricolor_hue = displayio_colorconverter_compute_hue(highlight_color);
+        self->core.colorspace.tricolor_luma = displayio_colorconverter_compute_luma(highlight_color);
+    }
+
+    displayio_display_core_construct(&self->core, bus, width, height, ram_width, ram_height, colstart, rowstart, rotation, 1, true, true, 1, true);
+
+    self->set_column_window_command = set_column_window_command;
+    self->set_row_window_command = set_row_window_command;
+    self->set_current_column_command = set_current_column_command;
+    self->set_current_row_command = set_current_row_command;
+    self->write_black_ram_command = write_black_ram_command;
+    self->black_bits_inverted = black_bits_inverted;
+    self->write_color_ram_command = write_color_ram_command;
+    self->color_bits_inverted = color_bits_inverted;
+    self->refresh_display_command = refresh_display_command;
+    self->refresh_time = refresh_time * 1000;
+    self->busy_state = busy_state;
+    self->refreshing = false;
+    self->milliseconds_per_frame = seconds_per_frame * 1000;
+    self->chip_select = chip_select ? CHIP_SELECT_TOGGLE_EVERY_BYTE : CHIP_SELECT_UNTOUCHED;
+
+    self->start_sequence = start_sequence;
+    self->start_sequence_len = start_sequence_len;
+    self->stop_sequence = stop_sequence;
+    self->stop_sequence_len = stop_sequence_len;
+
+    self->busy.base.type = &mp_type_NoneType;
+    if (busy_pin != NULL) {
+        self->busy.base.type = &digitalio_digitalinout_type;
+        common_hal_digitalio_digitalinout_construct(&self->busy, busy_pin);
+        never_reset_pin_number(busy_pin->number);
+    }
+
+    // Clear the color memory if it isn't in use.
+    if (highlight_color == 0x00 && write_color_ram_command != NO_COMMAND) {
+        // TODO: Clear
+    }
+
+    supervisor_start_terminal(width, height);
+
+    // Set the group after initialization otherwise we may send pixels while we delay in
+    // initialization.
+    common_hal_displayio_epaperdisplay_show(self, &circuitpython_splash);
+}
+
+bool common_hal_displayio_epaperdisplay_show(displayio_epaperdisplay_obj_t* self, displayio_group_t* root_group) {
+    return displayio_display_core_show(&self->core, root_group);
+}
+
+const displayio_area_t* displayio_epaperdisplay_get_refresh_areas(displayio_epaperdisplay_obj_t *self) {
+    if (self->core.full_refresh) {
+        self->core.area.next = NULL;
+        return &self->core.area;
+    }
+    const displayio_area_t* first_area = NULL;
+    if (self->core.current_group != NULL) {
+        first_area = displayio_group_get_refresh_areas(self->core.current_group, NULL);
+    }
+    if (first_area != NULL && self->set_row_window_command == NO_COMMAND) {
+        self->core.area.next = NULL;
+        return &self->core.area;
+    }
+    return first_area;
+}
+
+uint16_t common_hal_displayio_epaperdisplay_get_width(displayio_epaperdisplay_obj_t* self){
+    return displayio_display_core_get_width(&self->core);
+}
+
+uint16_t common_hal_displayio_epaperdisplay_get_height(displayio_epaperdisplay_obj_t* self){
+    return displayio_display_core_get_height(&self->core);
+}
+
+STATIC void wait_for_busy(displayio_epaperdisplay_obj_t* self) {
+    if (self->busy.base.type == &mp_type_NoneType) {
+        return;
+    }
+    while (common_hal_digitalio_digitalinout_get_value(&self->busy) == self->busy_state) {
+        RUN_BACKGROUND_TASKS;
+    }
+}
+
+STATIC void send_command_sequence(displayio_epaperdisplay_obj_t* self, bool should_wait_for_busy, uint8_t* sequence, uint32_t sequence_len) {
+    uint32_t i = 0;
+    while (i < sequence_len) {
+        uint8_t *cmd = sequence + i;
+        uint8_t data_size = *(cmd + 1);
+        bool delay = (data_size & DELAY) != 0;
+        data_size &= ~DELAY;
+        uint8_t *data = cmd + 2;
+        displayio_display_core_begin_transaction(&self->core);
+        self->core.send(self->core.bus, DISPLAY_COMMAND, self->chip_select, cmd, 1);
+        self->core.send(self->core.bus, DISPLAY_DATA, self->chip_select, data, data_size);
+        displayio_display_core_end_transaction(&self->core);
+        uint16_t delay_length_ms = 0;
+        if (delay) {
+            data_size++;
+            delay_length_ms = *(cmd + 1 + data_size);
+            if (delay_length_ms == 255) {
+                delay_length_ms = 500;
+            }
+        }
+        common_hal_time_delay_ms(delay_length_ms);
+        if (should_wait_for_busy) {
+            wait_for_busy(self);
+        }
+        i += 2 + data_size;
+    }
+}
+
+void displayio_epaperdisplay_start_refresh(displayio_epaperdisplay_obj_t* self) {
+    // run start sequence
+    self->core.bus_reset(self->core.bus);
+
+    send_command_sequence(self, true, self->start_sequence, self->start_sequence_len);
+    displayio_display_core_start_refresh(&self->core);
+}
+
+uint32_t common_hal_displayio_epaperdisplay_get_time_to_refresh(displayio_epaperdisplay_obj_t* self) {
+    if (self->core.last_refresh == 0) {
+        return 0;
+    }
+    // Refresh at seconds per frame rate.
+    uint32_t elapsed_time = ticks_ms - self->core.last_refresh;
+    if (elapsed_time > self->milliseconds_per_frame) {
+        return 0;
+    }
+    return self->milliseconds_per_frame - elapsed_time;
+}
+
+void displayio_epaperdisplay_finish_refresh(displayio_epaperdisplay_obj_t* self) {
+    // Actually refresh the display now that all pixel RAM has been updated.
+    displayio_display_core_begin_transaction(&self->core);
+    self->core.send(self->core.bus, DISPLAY_COMMAND, self->chip_select, &self->refresh_display_command, 1);
+    displayio_display_core_end_transaction(&self->core);
+    self->refreshing = true;
+
+    displayio_display_core_finish_refresh(&self->core);
+}
+
+mp_obj_t common_hal_displayio_epaperdisplay_get_bus(displayio_epaperdisplay_obj_t* self) {
+    return self->core.bus;
+}
+
+bool displayio_epaperdisplay_refresh_area(displayio_epaperdisplay_obj_t* self, 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_core_clip_area(&self->core, 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) / self->core.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;
+        }
+        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];
+
+    uint8_t passes = 1;
+    if (self->core.colorspace.tricolor) {
+        passes = 2;
+    }
+    for (uint8_t pass = 0; pass < passes; pass++) {
+        uint16_t remaining_rows = displayio_area_height(&clipped);
+
+        if (self->set_row_window_command != NO_COMMAND) {
+            displayio_display_core_set_region_to_update(&self->core, self->set_column_window_command, self->set_row_window_command, self->set_current_column_command, self->set_current_row_command, false, self->chip_select, &clipped);
+        }
+
+        uint8_t write_command = self->write_black_ram_command;
+        if (pass == 1) {
+            write_command = self->write_color_ram_command;
+        }
+        displayio_display_core_begin_transaction(&self->core);
+        self->core.send(self->core.bus, DISPLAY_COMMAND, self->chip_select, &write_command, 1);
+        displayio_display_core_end_transaction(&self->core);
+
+        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;
+
+
+            uint16_t subrectangle_size_bytes = displayio_area_size(&subrectangle) / (8 / self->core.colorspace.depth);
+
+            memset(mask, 0, mask_length * sizeof(mask[0]));
+            memset(buffer, 0, buffer_size * sizeof(buffer[0]));
+
+            self->core.colorspace.grayscale = true;
+            if (pass == 1) {
+                self->core.colorspace.grayscale = false;
+            }
+            displayio_display_core_fill_area(&self->core, &subrectangle, mask, buffer);
+
+            // Invert it all.
+            if ((pass == 1 && self->color_bits_inverted) ||
+                (pass == 0 && self->black_bits_inverted)) {
+                for (uint16_t k = 0; k < buffer_size; k++) {
+                    buffer[k] = ~buffer[k];
+                }
+            }
+
+            if (!displayio_display_core_begin_transaction(&self->core)) {
+                // Can't acquire display bus; skip the rest of the data. Try next display.
+                return false;
+            }
+            self->core.send(self->core.bus, DISPLAY_DATA, self->chip_select, (uint8_t*) buffer, subrectangle_size_bytes);
+            displayio_display_core_end_transaction(&self->core);
+
+            // TODO(tannewt): Make refresh displays faster so we don't starve other
+            // background tasks.
+            usb_background();
+        }
+    }
+
+    return true;
+}
+
+bool common_hal_displayio_epaperdisplay_refresh(displayio_epaperdisplay_obj_t* self) {
+    
+    if (self->refreshing && self->busy.base.type == &digitalio_digitalinout_type) {
+        if (common_hal_digitalio_digitalinout_get_value(&self->busy) != self->busy_state) {
+            self->refreshing = false;
+            // Run stop sequence but don't wait for busy because busy is set when sleeping.
+            send_command_sequence(self, false, self->stop_sequence, self->stop_sequence_len);
+        } else {
+            return false;
+        }
+    }
+    if (self->core.current_group == NULL) {
+        return true;
+    }
+    // Refresh at seconds per frame rate.
+    if (common_hal_displayio_epaperdisplay_get_time_to_refresh(self) > 0) {
+        return false;
+    }
+    if (!displayio_display_core_bus_free(&self->core)) {
+        // Can't acquire display bus; skip updating this display. Try next display.
+        return false;
+    }
+    const displayio_area_t* current_area = displayio_epaperdisplay_get_refresh_areas(self);
+    if (current_area == NULL) {
+        return true;
+    }
+    displayio_epaperdisplay_start_refresh(self);
+    while (current_area != NULL) {
+        displayio_epaperdisplay_refresh_area(self, current_area);
+        current_area = current_area->next;
+    }
+    displayio_epaperdisplay_finish_refresh(self);
+    return true;
+}
+
+void displayio_epaperdisplay_background(displayio_epaperdisplay_obj_t* self) {
+    if (self->refreshing) {
+        bool refresh_done = false;
+        if (self->busy.base.type == &digitalio_digitalinout_type) {
+            bool busy = common_hal_digitalio_digitalinout_get_value(&self->busy);
+            refresh_done = busy != self->busy_state;
+        } else {
+            refresh_done = ticks_ms - self->core.last_refresh > self->refresh_time;
+        }
+        if (refresh_done) {
+            self->refreshing = false;
+            // Run stop sequence but don't wait for busy because busy is set when sleeping.
+            send_command_sequence(self, false, self->stop_sequence, self->stop_sequence_len);
+        }
+    }
+}
+
+void release_epaperdisplay(displayio_epaperdisplay_obj_t* self) {
+    if (self->refreshing) {
+        wait_for_busy(self);
+        self->refreshing = false;
+        // Run stop sequence but don't wait for busy because busy is set when sleeping.
+        send_command_sequence(self, false, self->stop_sequence, self->stop_sequence_len);
+    }
+
+    release_display_core(&self->core);
+    if (self->busy.base.type == &digitalio_digitalinout_type) {
+        common_hal_digitalio_digitalinout_deinit(&self->busy);
+    }
+}
+
+void displayio_epaperdisplay_collect_ptrs(displayio_epaperdisplay_obj_t* self) {
+    displayio_display_core_collect_ptrs(&self->core);
+}
+
+bool maybe_refresh_epaperdisplay(void) {
+    for (uint8_t i = 0; i < CIRCUITPY_DISPLAY_LIMIT; i++) {
+        if (displays[i].epaper_display.base.type != &displayio_epaperdisplay_type ||
+            displays[i].epaper_display.core.current_group != &circuitpython_splash) {
+            // Skip regular displays and those not showing the splash.
+            continue;
+        }
+        displayio_epaperdisplay_obj_t* display = &displays[i].epaper_display;
+        if (common_hal_displayio_epaperdisplay_get_time_to_refresh(display) != 0) {
+            return false;
+        }
+        return common_hal_displayio_epaperdisplay_refresh(display);
+    }
+    // Return true if no ePaper displays are available to pretend it was updated.
+    return true;
+}
diff --git a/shared-module/displayio/EPaperDisplay.h b/shared-module/displayio/EPaperDisplay.h
new file mode 100644
index 000000000..d08bed546
--- /dev/null
+++ b/shared-module/displayio/EPaperDisplay.h
@@ -0,0 +1,68 @@
+/*
+ * This file is part of the MicroPython 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_EPAPERDISPLAY_H
+#define MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_EPAPERDISPLAY_H
+
+#include "shared-bindings/digitalio/DigitalInOut.h"
+#include "shared-bindings/displayio/Group.h"
+#include "shared-bindings/pulseio/PWMOut.h"
+
+#include "shared-module/displayio/area.h"
+#include "shared-module/displayio/display_core.h"
+
+typedef struct {
+    mp_obj_base_t base;
+    displayio_display_core_t core;
+    digitalio_digitalinout_obj_t busy;
+    uint32_t milliseconds_per_frame;
+    uint8_t* start_sequence;
+    uint32_t start_sequence_len;
+    uint8_t* stop_sequence;
+    uint32_t stop_sequence_len;
+    uint16_t refresh_time;
+    uint16_t set_column_window_command;
+    uint16_t set_row_window_command;
+    uint16_t set_current_column_command;
+    uint16_t set_current_row_command;
+    uint16_t write_black_ram_command;
+    uint16_t write_color_ram_command;
+    uint8_t refresh_display_command;
+    uint8_t hue;
+    bool busy_state;
+    bool black_bits_inverted;
+    bool color_bits_inverted;
+    bool refreshing;
+    display_chip_select_behavior_t chip_select;
+} displayio_epaperdisplay_obj_t;
+
+void displayio_epaperdisplay_background(displayio_epaperdisplay_obj_t* self);
+void release_epaperdisplay(displayio_epaperdisplay_obj_t* self);
+bool maybe_refresh_epaperdisplay(void);
+
+void displayio_epaperdisplay_collect_ptrs(displayio_epaperdisplay_obj_t* self);
+
+#endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_EPAPERDISPLAY_H
diff --git a/shared-module/displayio/FourWire.c b/shared-module/displayio/FourWire.c
index d38da56fc..fcc4c1a20 100644
--- a/shared-module/displayio/FourWire.c
+++ b/shared-module/displayio/FourWire.c
@@ -33,6 +33,7 @@
 #include "shared-bindings/digitalio/DigitalInOut.h"
 #include "shared-bindings/microcontroller/__init__.h"
 #include "shared-bindings/time/__init__.h"
+#include "shared-module/displayio/display_core.h"
 
 #include "tick.h"
 
@@ -55,10 +56,13 @@ void common_hal_displayio_fourwire_construct(displayio_fourwire_obj_t* self,
     common_hal_digitalio_digitalinout_construct(&self->chip_select, chip_select);
     common_hal_digitalio_digitalinout_switch_to_output(&self->chip_select, true, DRIVE_MODE_PUSH_PULL);
 
+    self->reset.base.type = &mp_type_NoneType;
     if (reset != NULL) {
+        self->reset.base.type = &digitalio_digitalinout_type;
         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_displayio_fourwire_reset(self);
     }
 
     never_reset_pin_number(command->number);
@@ -75,6 +79,27 @@ void common_hal_displayio_fourwire_deinit(displayio_fourwire_obj_t* self) {
     reset_pin_number(self->reset.pin->number);
 }
 
+bool common_hal_displayio_fourwire_reset(mp_obj_t obj) {
+    displayio_fourwire_obj_t* self = MP_OBJ_TO_PTR(obj);
+    if (self->reset.base.type == &mp_type_NoneType) {
+        return false;
+    }
+    common_hal_digitalio_digitalinout_set_value(&self->reset, false);
+    common_hal_time_delay_ms(1);
+    common_hal_digitalio_digitalinout_set_value(&self->reset, true);
+    common_hal_time_delay_ms(1);
+    return true;
+}
+
+bool common_hal_displayio_fourwire_bus_free(mp_obj_t obj) {
+    displayio_fourwire_obj_t* self = MP_OBJ_TO_PTR(obj);
+    if (!common_hal_busio_spi_try_lock(self->bus)) {
+        return false;
+    }
+    common_hal_busio_spi_unlock(self->bus);
+    return true;
+}
+
 bool common_hal_displayio_fourwire_begin_transaction(mp_obj_t obj) {
     displayio_fourwire_obj_t* self = MP_OBJ_TO_PTR(obj);
     if (!common_hal_busio_spi_try_lock(self->bus)) {
@@ -86,15 +111,21 @@ bool common_hal_displayio_fourwire_begin_transaction(mp_obj_t obj) {
     return true;
 }
 
-void common_hal_displayio_fourwire_send(mp_obj_t obj, bool command, uint8_t *data, uint32_t data_length) {
+void common_hal_displayio_fourwire_send(mp_obj_t obj, display_byte_type_t data_type, display_chip_select_behavior_t chip_select, uint8_t *data, uint32_t data_length) {
     displayio_fourwire_obj_t* self = MP_OBJ_TO_PTR(obj);
-    if (command) {
-        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);
+    common_hal_digitalio_digitalinout_set_value(&self->command, data_type == DISPLAY_DATA);
+    if (chip_select == CHIP_SELECT_TOGGLE_EVERY_BYTE) {
+        // 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);
     }
-    common_hal_digitalio_digitalinout_set_value(&self->command, !command);
-    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 743139e62..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"
@@ -43,4 +43,4 @@ typedef struct {
     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 15060e87b..d69e9f585 100644
--- a/shared-module/displayio/Group.c
+++ b/shared-module/displayio/Group.c
@@ -34,6 +34,47 @@ void common_hal_displayio_group_construct(displayio_group_t* self, uint32_t max_
     displayio_group_construct(self, children, max_size, scale, x, y);
 }
 
+bool common_hal_displayio_group_get_hidden(displayio_group_t* self) {
+    return self->hidden;
+}
+
+void common_hal_displayio_group_set_hidden(displayio_group_t* self, bool hidden) {
+    if (self->hidden == hidden) {
+        return;
+    }
+    self->hidden = hidden;
+    if (self->hidden_by_parent) {
+        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_set_hidden_by_parent(layer, hidden);
+        } else if (MP_OBJ_IS_TYPE(layer, &displayio_group_type)) {
+            displayio_group_set_hidden_by_parent(layer, hidden);
+        }
+    }
+}
+
+void displayio_group_set_hidden_by_parent(displayio_group_t *self, bool hidden) {
+    if (self->hidden_by_parent == hidden) {
+        return;
+    }
+    self->hidden_by_parent = hidden;
+    // If we're already hidden, then we're done.
+    if (self->hidden) {
+        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_set_hidden_by_parent(layer, hidden);
+        } else if (MP_OBJ_IS_TYPE(layer, &displayio_group_type)) {
+            displayio_group_set_hidden_by_parent(layer, hidden);
+        }
+    }
+}
+
 uint32_t common_hal_displayio_group_get_scale(displayio_group_t* self) {
     return self->scale;
 }
@@ -270,19 +311,19 @@ void displayio_group_construct(displayio_group_t* self, displayio_group_child_t*
     self->in_group = false;
 }
 
-bool displayio_group_fill_area(displayio_group_t *self, const displayio_area_t* area, uint32_t* mask, uint32_t* buffer) {
+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_fill_area(layer, area, mask, buffer)) {
+            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_fill_area(layer, area, mask, buffer)) {
+            if (displayio_group_fill_area(layer, colorspace, area, mask, buffer)) {
                 full_coverage = true;
                 break;
             }
diff --git a/shared-module/displayio/Group.h b/shared-module/displayio/Group.h
index 7ce19a4cd..5afaac1ba 100644
--- a/shared-module/displayio/Group.h
+++ b/shared-module/displayio/Group.h
@@ -32,6 +32,7 @@
 
 #include "py/obj.h"
 #include "shared-module/displayio/area.h"
+#include "shared-module/displayio/Palette.h"
 
 typedef struct {
     mp_obj_t native;
@@ -41,20 +42,24 @@ typedef struct {
 typedef struct {
     mp_obj_base_t base;
     displayio_group_child_t* children;
+    displayio_buffer_transform_t absolute_transform;
+    displayio_area_t dirty_area; // Catch all for changed area
     int16_t x;
     int16_t y;
     uint16_t scale;
     uint16_t size;
     uint16_t max_size;
-    bool item_removed;
-    bool in_group;
-    displayio_buffer_transform_t absolute_transform;
-    displayio_area_t dirty_area; // Catch all for changed area
+    bool item_removed :1;
+    bool in_group :1;
+    bool hidden :1;
+    bool hidden_by_parent :1;
+    uint8_t padding :4;
 } displayio_group_t;
 
 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);
+void displayio_group_set_hidden_by_parent(displayio_group_t *self, bool hidden);
 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_area_t* area, uint32_t* mask, uint32_t *buffer);
+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);
diff --git a/shared-module/displayio/I2CDisplay.c b/shared-module/displayio/I2CDisplay.c
new file mode 100644
index 000000000..d9452dc50
--- /dev/null
+++ b/shared-module/displayio/I2CDisplay.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/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 "shared-module/displayio/display_core.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;
+
+    self->reset.base.type = &mp_type_NoneType;
+    if (reset != NULL) {
+        self->reset.base.type = &digitalio_digitalinout_type;
+        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_displayio_i2cdisplay_reset(self);
+    }
+}
+
+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_reset(mp_obj_t obj) {
+    displayio_i2cdisplay_obj_t* self = MP_OBJ_TO_PTR(obj);
+    if (self->reset.base.type == &mp_type_NoneType) {
+        return false;
+    }
+
+    common_hal_digitalio_digitalinout_set_value(&self->reset, false);
+    common_hal_mcu_delay_us(4);
+    common_hal_digitalio_digitalinout_set_value(&self->reset, true);
+    return true;
+}
+
+bool common_hal_displayio_i2cdisplay_bus_free(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;
+    }
+    common_hal_busio_i2c_unlock(self->bus);
+    return true;
+}
+
+bool common_hal_displayio_i2cdisplay_begin_transaction(mp_obj_t obj) {
+    displayio_i2cdisplay_obj_t* self = MP_OBJ_TO_PTR(obj);
+    return common_hal_busio_i2c_try_lock(self->bus);
+}
+
+void common_hal_displayio_i2cdisplay_send(mp_obj_t obj, display_byte_type_t data_type, display_chip_select_behavior_t chip_select, uint8_t *data, uint32_t data_length) {
+    displayio_i2cdisplay_obj_t* self = MP_OBJ_TO_PTR(obj);
+    if (data_type == DISPLAY_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/displayio/I2CDisplay.h b/shared-module/displayio/I2CDisplay.h
new file mode 100644
index 000000000..4636c3f73
--- /dev/null
+++ b/shared-module/displayio/I2CDisplay.h
@@ -0,0 +1,41 @@
+/*
+ * This file is part of the MicroPython 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_I2CDISPLAY_H
+#define MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_I2CDISPLAY_H
+
+#include "common-hal/busio/I2C.h"
+#include "common-hal/digitalio/DigitalInOut.h"
+
+typedef struct {
+    mp_obj_base_t base;
+    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_DISPLAYIO_I2CDISPLAY_H
diff --git a/shared-module/displayio/OnDiskBitmap.c b/shared-module/displayio/OnDiskBitmap.c
index 2b5642437..993fc03de 100644
--- a/shared-module/displayio/OnDiskBitmap.c
+++ b/shared-module/displayio/OnDiskBitmap.c
@@ -74,7 +74,7 @@ void common_hal_displayio_ondiskbitmap_construct(displayio_ondiskbitmap_t *self,
             self->g_bitmask = 0x3e0;
             self->b_bitmask = 0x1f;
         }
-    } else if ((indexed) && (self->bits_per_pixel != 1)) {
+    } else if (indexed && self->bits_per_pixel != 1) {
         uint16_t palette_size = number_of_colors * sizeof(uint32_t);
         uint16_t palette_offset = 0xe + header_size;
 
@@ -90,25 +90,24 @@ void common_hal_displayio_ondiskbitmap_construct(displayio_ondiskbitmap_t *self,
         if (palette_bytes_read != palette_size) {
             mp_raise_ValueError(translate("Unable to read color palette data"));
         }
-
-
     } else if (!(header_size == 12 || header_size == 40 || header_size == 108 || header_size == 124)) {
         mp_raise_ValueError_varg(translate("Only Windows format, uncompressed BMP supported: given header size is %d"), header_size);
     }
 
-    if ((bits_per_pixel == 4 ) || (( bits_per_pixel == 8) && (number_of_colors == 0))) {
-        mp_raise_ValueError_varg(translate("Only monochrome, indexed 8bpp, and 16bpp or greater BMPs supported: %d bpp given"), bits_per_pixel);
+    if (bits_per_pixel == 8 && number_of_colors == 0) {
+        mp_raise_ValueError_varg(translate("Only monochrome, indexed 4bpp or 8bpp, and 16bpp or greater BMPs supported: %d bpp given"), bits_per_pixel);
     }
 
-    if (self->bits_per_pixel >=8){
-        self->stride = (self->width * (bits_per_pixel / 8));
+    uint8_t bytes_per_pixel = (self->bits_per_pixel / 8)  ? (self->bits_per_pixel /8) : 1;
+    uint8_t pixels_per_byte = 8 / self->bits_per_pixel;
+    if (pixels_per_byte == 0){
+        self->stride = (self->width * bytes_per_pixel);
         // Rows are word aligned.
         if (self->stride % 4 != 0) {
             self->stride += 4 - self->stride % 4;
         }
-
     } else {
-        uint32_t bit_stride = self->width;
+        uint32_t bit_stride = self->width * self->bits_per_pixel;
         if (bit_stride % 32 != 0) {
             bit_stride += 32 - bit_stride % 32;
         }
@@ -126,10 +125,11 @@ uint32_t common_hal_displayio_ondiskbitmap_get_pixel(displayio_ondiskbitmap_t *s
 
     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){
+    uint8_t pixels_per_byte = 8 / self->bits_per_pixel;
+    if (pixels_per_byte == 0){
         location = self->data_offset + (self->height - y - 1) * self->stride + x * bytes_per_pixel;
     } else {
-        location = self->data_offset + (self->height - y - 1) * self->stride + x / 8;
+        location = self->data_offset + (self->height - y - 1) * self->stride + x / pixels_per_byte;
     }
     // We don't cache here because the underlying FS caches sectors.
     f_lseek(&self->file->fp, location);
@@ -141,20 +141,19 @@ 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) {
-            uint8_t bit_offset = x%8;
-            tmp = ( pixel_data & (0x80 >> (bit_offset))) >> (7 - bit_offset);
-            if (tmp == 1) {
-                return 0x00FFFFFF;
-            } else {
-                return 0x00000000;
+        if (bytes_per_pixel == 1) {
+            uint8_t offset = (x % pixels_per_byte) * self->bits_per_pixel;
+            uint8_t mask = (1 << self->bits_per_pixel) - 1;
+
+            uint8_t index = (pixel_data >> ((8 - self->bits_per_pixel) - offset)) & mask;
+            if (self->bits_per_pixel == 1) {
+                if (index == 1) {
+                    return 0xFFFFFF;
+                } else {
+                    return 0x000000;
+                }
             }
-        } 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);
-            tmp = (red << 16 | green << 8 | blue );
-            return tmp;
+            return self->palette_data[index];
         } else if (bytes_per_pixel == 2) {
             if (self->g_bitmask == 0x07e0) { // 565
                 red =((pixel_data & self->r_bitmask) >>11);
diff --git a/shared-module/displayio/Palette.c b/shared-module/displayio/Palette.c
index 8dc6e766b..3bce86f48 100644
--- a/shared-module/displayio/Palette.c
+++ b/shared-module/displayio/Palette.c
@@ -26,49 +26,65 @@
 
 #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);
-    uint32_t final_color = masked | packed << shift;
-    if (self->colors[palette_index / 2] == final_color) {
+    if (self->colors[palette_index].rgb888 == color) {
         return;
     }
-    self->colors[palette_index / 2] = final_color;
+    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);
+
+    uint8_t chroma = displayio_colorconverter_compute_chroma(color);
+    self->colors[palette_index].chroma = chroma;
+    self->colors[palette_index].hue = displayio_colorconverter_compute_hue(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->tricolor) {
+        uint8_t luma = self->colors[palette_index].luma;
+        *color = luma >> (8 - colorspace->depth);
+        // Chroma 0 means the color is a gray and has no hue so never color based on it.
+        if (self->colors[palette_index].chroma  <= 16) {
+            if (!colorspace->grayscale) {
+                *color = 0;
+            }
+            return true;
+        }
+        uint8_t pixel_hue = self->colors[palette_index].hue;
+        displayio_colorconverter_compute_tricolor(colorspace, pixel_hue, luma, color);
+    } else 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 3813e8bdd..758fd43fc 100644
--- a/shared-module/displayio/Palette.h
+++ b/shared-module/displayio/Palette.h
@@ -33,14 +33,50 @@
 #include "py/obj.h"
 
 typedef struct {
+    uint8_t depth;
+    uint8_t bytes_per_cell;
+    uint8_t tricolor_hue;
+    uint8_t tricolor_luma;
+    bool grayscale;
+    bool tricolor;
+    bool pixels_in_byte_share_row;
+    bool reverse_pixels_in_byte;
+    bool dither;
+} _displayio_colorspace_t;
+
+typedef struct {
+    uint32_t rgb888;
+    uint16_t rgb565;
+    uint8_t luma;
+    uint8_t hue;
+    uint8_t chroma;
+    bool transparent; // This may have additional bits added later for blending.
+} _displayio_color_t;
+
+typedef struct {
+    uint32_t pixel;
+    uint16_t x;
+    uint16_t y;
+    uint8_t tile;
+    uint16_t tile_x;
+    uint16_t tile_y;
+} displayio_input_pixel_t;
+
+typedef struct {
+    uint32_t pixel;
+    bool opaque;
+} displayio_output_pixel_t;
+
+typedef struct {
     mp_obj_base_t base;
-    uint32_t* opaque;
-    uint32_t* colors;
+    _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 0cd00e0ce..c4855c333 100644
--- a/shared-module/displayio/TileGrid.c
+++ b/shared-module/displayio/TileGrid.c
@@ -26,6 +26,7 @@
 
 #include "shared-bindings/displayio/TileGrid.h"
 
+#include "py/runtime.h"
 #include "shared-bindings/displayio/Bitmap.h"
 #include "shared-bindings/displayio/ColorConverter.h"
 #include "shared-bindings/displayio/OnDiskBitmap.h"
@@ -33,7 +34,7 @@
 #include "shared-bindings/displayio/Shape.h"
 
 void common_hal_displayio_tilegrid_construct(displayio_tilegrid_t *self, mp_obj_t bitmap,
-        uint16_t bitmap_width_in_tiles,
+        uint16_t bitmap_width_in_tiles, uint16_t bitmap_height_in_tiles,
         mp_obj_t pixel_shader, uint16_t width, uint16_t height,
         uint16_t tile_width, uint16_t tile_height, uint16_t x, uint16_t y, uint8_t default_tile) {
     uint32_t total_tiles = width * height;
@@ -54,6 +55,7 @@ void common_hal_displayio_tilegrid_construct(displayio_tilegrid_t *self, mp_obj_
         self->inline_tiles = false;
     }
     self->bitmap_width_in_tiles = bitmap_width_in_tiles;
+    self->tiles_in_bitmap = bitmap_width_in_tiles * bitmap_height_in_tiles;
     self->width_in_tiles = width;
     self->height_in_tiles = height;
     self->x = x;
@@ -65,14 +67,30 @@ void common_hal_displayio_tilegrid_construct(displayio_tilegrid_t *self, mp_obj_
     self->bitmap = bitmap;
     self->pixel_shader = pixel_shader;
     self->in_group = false;
-    self->first_draw = true;
+    self->hidden = false;
+    self->hidden_by_parent = false;
+    self->previous_area.x1 = 0xffff;
+    self->previous_area.x2 = self->previous_area.x1;
     self->flip_x = false;
     self->flip_y = false;
     self->transpose_xy = false;
 }
 
+
+bool common_hal_displayio_tilegrid_get_hidden(displayio_tilegrid_t* self) {
+    return self->hidden;
+}
+
+void common_hal_displayio_tilegrid_set_hidden(displayio_tilegrid_t* self, bool hidden) {
+    self->hidden = hidden;
+}
+
+void displayio_tilegrid_set_hidden_by_parent(displayio_tilegrid_t *self, bool hidden) {
+    self->hidden_by_parent = hidden;
+}
+
 bool displayio_tilegrid_get_previous_area(displayio_tilegrid_t *self, displayio_area_t* area) {
-    if (self->first_draw) {
+    if (self->previous_area.x1 == self->previous_area.x2) {
         return false;
     }
     displayio_area_copy(&self->previous_area, area);
@@ -136,12 +154,10 @@ void displayio_tilegrid_update_transform(displayio_tilegrid_t *self,
     self->in_group = absolute_transform != NULL;
     self->absolute_transform = absolute_transform;
     if (absolute_transform != NULL) {
-        self->moved = !self->first_draw;
+        self->moved = true;
 
         _update_current_x(self);
         _update_current_y(self);
-    } else {
-        self->first_draw = true;
     }
 }
 
@@ -153,7 +169,7 @@ void common_hal_displayio_tilegrid_set_x(displayio_tilegrid_t *self, mp_int_t x)
         return;
     }
 
-    self->moved = !self->first_draw;
+    self->moved = true;
 
     self->x = x;
     if (self->absolute_transform != NULL) {
@@ -168,7 +184,7 @@ 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->moved = true;
     self->y = y;
     if (self->absolute_transform != NULL) {
         _update_current_y(self);
@@ -204,6 +220,9 @@ uint8_t common_hal_displayio_tilegrid_get_tile(displayio_tilegrid_t *self, uint1
 }
 
 void common_hal_displayio_tilegrid_set_tile(displayio_tilegrid_t *self, uint16_t x, uint16_t y, uint8_t tile_index) {
+    if (tile_index >= self->tiles_in_bitmap) {
+        mp_raise_ValueError(translate("Tile index out of bounds"));
+    }
     uint8_t* tiles = self->tiles;
     if (self->inline_tiles) {
         tiles = (uint8_t*) &self->tiles;
@@ -291,7 +310,7 @@ void common_hal_displayio_tilegrid_set_top_left(displayio_tilegrid_t *self, uint
     self->full_change = true;
 }
 
-bool displayio_tilegrid_fill_area(displayio_tilegrid_t *self, const displayio_area_t* area, uint32_t* mask, uint32_t *buffer) {
+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) {
@@ -301,6 +320,11 @@ bool displayio_tilegrid_fill_area(displayio_tilegrid_t *self, const displayio_ar
         return false;
     }
 
+    bool hidden = self->hidden || self->hidden_by_parent;
+    if (hidden) {
+        return false;
+    }
+
     displayio_area_t overlap;
     if (!displayio_area_compute_overlap(area, &self->current_area, &overlap)) {
         return false;
@@ -371,14 +395,19 @@ bool displayio_tilegrid_fill_area(displayio_tilegrid_t *self, const displayio_ar
         y_shift = temp_shift;
     }
 
-    for (int16_t y = start_y; y < end_y; y++) {
-        int16_t row_start = start + (y - start_y + y_shift) * y_stride;
-        int16_t local_y = y / self->absolute_transform->scale;
-        for (int16_t x = start_x; x < end_x; x++) {
+    uint8_t pixels_per_byte = 8 / colorspace->depth;
+
+    displayio_input_pixel_t input_pixel;
+    displayio_output_pixel_t output_pixel;
+
+    for (input_pixel.y = start_y; input_pixel.y < end_y; ++input_pixel.y) {
+        int16_t row_start = start + (input_pixel.y - start_y + y_shift) * y_stride; // in pixels
+        int16_t local_y = input_pixel.y / self->absolute_transform->scale;
+        for (input_pixel.x = start_x; input_pixel.x < end_x; ++input_pixel.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;
+            int16_t offset = row_start + (input_pixel.x - start_x + x_shift) * x_stride; // in pixels
 
-            // This is super useful for debugging out range accesses. Uncomment to use.
+            // 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");
             // }
@@ -387,40 +416,62 @@ bool displayio_tilegrid_fill_area(displayio_tilegrid_t *self, const displayio_ar
             if ((mask[offset / 32] & (1 << (offset % 32))) != 0) {
                 continue;
             }
-            int16_t local_x = x / self->absolute_transform->scale;
+            int16_t local_x = input_pixel.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;
+            input_pixel.tile = tiles[tile_location];
+            input_pixel.tile_x = (input_pixel.tile % self->bitmap_width_in_tiles) * self->tile_width + local_x % self->tile_width;
+            input_pixel.tile_y = (input_pixel.tile / self->bitmap_width_in_tiles) * self->tile_height + local_y % self->tile_height;
+
+            //uint32_t value = 0;
+            output_pixel.pixel = 0;
+            input_pixel.pixel = 0;
 
-            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);
+                input_pixel.pixel = common_hal_displayio_bitmap_get_pixel(self->bitmap, input_pixel.tile_x, input_pixel.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);
+                input_pixel.pixel = common_hal_displayio_shape_get_pixel(self->bitmap, input_pixel.tile_x, input_pixel.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);
+                input_pixel.pixel = common_hal_displayio_ondiskbitmap_get_pixel(self->bitmap, input_pixel.tile_x, input_pixel.tile_y);
             }
-
-            uint16_t* pixel = ((uint16_t*) buffer) + offset;
+            
+            output_pixel.opaque = true;
             if (self->pixel_shader == mp_const_none) {
-                *pixel = value;
-                return true;
+                output_pixel.pixel = input_pixel.pixel;
             } else if (MP_OBJ_IS_TYPE(self->pixel_shader, &displayio_palette_type)) {
-                if (!displayio_palette_get_color(self->pixel_shader, value, pixel)) {
-                    // A pixel is transparent so we haven't fully covered the area ourselves.
-                    full_coverage = false;
-                } else {
-                    mask[offset / 32] |= 1 << (offset % 32);
-                }
+                output_pixel.opaque = displayio_palette_get_color(self->pixel_shader, colorspace, input_pixel.pixel, &output_pixel.pixel);
             } else if (MP_OBJ_IS_TYPE(self->pixel_shader, &displayio_colorconverter_type)) {
-                if (!common_hal_displayio_colorconverter_convert(self->pixel_shader, value, pixel)) {
-                    // A pixel is transparent so we haven't fully covered the area ourselves.
-                    full_coverage = false;
-                } else {
-                    mask[offset / 32] |= 1 << (offset % 32);
+                displayio_colorconverter_convert(self->pixel_shader, colorspace, &input_pixel, &output_pixel);
+            }
+            if (!output_pixel.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) = output_pixel.pixel;
+                } else if (colorspace->depth == 8) {
+                    *(((uint8_t*) buffer) + offset) = output_pixel.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) {
+                        // Reverse the shift by subtracting it from the leftmost shift.
+                        shift = (pixels_per_byte - 1) * colorspace->depth - shift;
+                    }
+                    ((uint8_t*)buffer)[offset / pixels_per_byte] |= output_pixel.pixel << shift;
                 }
             }
         }
@@ -429,25 +480,46 @@ bool displayio_tilegrid_fill_area(displayio_tilegrid_t *self, const displayio_ar
 }
 
 void displayio_tilegrid_finish_refresh(displayio_tilegrid_t *self) {
-    if (self->moved || self->first_draw) {
+    bool first_draw = self->previous_area.x1 == self->previous_area.x2;
+    bool hidden = self->hidden || self->hidden_by_parent;
+    if (!first_draw && hidden) {
+        self->previous_area.x2 = self->previous_area.x1;
+    } else if (self->moved || 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);
     }
+    if (MP_OBJ_IS_TYPE(self->bitmap, &displayio_bitmap_type)) {
+        displayio_bitmap_finish_refresh(self->bitmap);
+    } else if (MP_OBJ_IS_TYPE(self->bitmap, &displayio_shape_type)) {
+        // TODO: Support shape changes.
+    } else if (MP_OBJ_IS_TYPE(self->bitmap, &displayio_ondiskbitmap_type)) {
+        // OnDiskBitmap changes will trigger a complete reload so no need to
+        // track changes.
+    }
     // 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) {
+    bool first_draw = self->previous_area.x1 == self->previous_area.x2;
+    bool hidden = self->hidden || self->hidden_by_parent;
+    // Check hidden first because it trumps all other changes.
+    if (hidden) {
+        if (!first_draw) {
+            self->previous_area.next = tail;
+            return &self->previous_area;
+        } else {
+            return tail;
+        }
+    } else if (self->moved && !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;
@@ -458,14 +530,27 @@ displayio_area_t* displayio_tilegrid_get_refresh_areas(displayio_tilegrid_t *sel
         return &self->current_area;
     }
 
-    // We must recheck if our sources require a refresh because needs_refresh may or may not have
-    // been called.
+    // If we have an in-memory bitmap, then check it for modifications.
+    if (MP_OBJ_IS_TYPE(self->bitmap, &displayio_bitmap_type)) {
+        displayio_area_t* refresh_area = displayio_bitmap_get_refresh_areas(self->bitmap, tail);
+        if (refresh_area != tail) {
+            // Special case a TileGrid that shows a full bitmap and use its
+            // dirty area. Copy it to ours so we can transform it.
+            if (self->tiles_in_bitmap == 1) {
+                displayio_area_copy(refresh_area, &self->dirty_area);
+                self->partial_change = true;
+            } else {
+                self->full_change = true;
+            }
+        }
+    }
+
     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) {
+    if (self->full_change || first_draw) {
         self->current_area.next = tail;
         return &self->current_area;
     }
diff --git a/shared-module/displayio/TileGrid.h b/shared-module/displayio/TileGrid.h
index 4d97eccc2..e97d3dfd4 100644
--- a/shared-module/displayio/TileGrid.h
+++ b/shared-module/displayio/TileGrid.h
@@ -32,6 +32,7 @@
 
 #include "py/obj.h"
 #include "shared-module/displayio/area.h"
+#include "shared-module/displayio/Palette.h"
 
 typedef struct {
     mp_obj_base_t base;
@@ -41,7 +42,8 @@ typedef struct {
     int16_t y;
     uint16_t pixel_width;
     uint16_t pixel_height;
-    uint16_t bitmap_width_in_tiles;
+    uint16_t bitmap_width_in_tiles;;
+    uint16_t tiles_in_bitmap;
     uint16_t width_in_tiles;
     uint16_t height_in_tiles;
     uint16_t tile_width;
@@ -53,17 +55,21 @@ typedef struct {
     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;
+    bool partial_change :1;
+    bool full_change :1;
+    bool moved :1;
+    bool inline_tiles :1;
+    bool in_group :1;
+    bool flip_x :1;
+    bool flip_y :1;
+    bool transpose_xy  :1;
+    bool hidden :1;
+    bool hidden_by_parent :1;
+    uint8_t padding :6;
 } displayio_tilegrid_t;
 
+void displayio_tilegrid_set_hidden_by_parent(displayio_tilegrid_t *self, bool hidden);
+
 // Updating the screen is a three stage process.
 
 // The first stage is used to determine i
@@ -71,7 +77,7 @@ displayio_area_t* displayio_tilegrid_get_refresh_areas(displayio_tilegrid_t *sel
 
 // 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_area_t* area, uint32_t* mask, uint32_t *buffer);
+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
diff --git a/shared-module/displayio/__init__.c b/shared-module/displayio/__init__.c
index b6709e0eb..af22cb0df 100644
--- a/shared-module/displayio/__init__.c
+++ b/shared-module/displayio/__init__.c
@@ -4,7 +4,6 @@
 #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"
@@ -16,89 +15,13 @@
 #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];
 
-bool refresh_area(displayio_display_obj_t* display, const displayio_area_t* area) {
-    uint16_t buffer_size = 512;
+// Check for recursive calls to displayio_background.
+bool displayio_background_in_progress = false;
 
-    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);
-    if (displayio_area_size(area) > buffer_size) {
-        rows_per_buffer = buffer_size / displayio_area_width(&clipped);
-        subrectangles = displayio_area_height(&clipped) / rows_per_buffer;
-        if (displayio_area_height(&clipped) % rows_per_buffer != 0) {
-            subrectangles++;
-        }
-        buffer_size = rows_per_buffer * displayio_area_width(&clipped);
-    }
-    uint32_t buffer[buffer_size / 2];
-    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;
-
-        displayio_display_begin_transaction(display);
-        displayio_display_set_region_to_update(display, subrectangle.x1, subrectangle.y1,
-                                                        subrectangle.x2, subrectangle.y2);
-        displayio_display_end_transaction(display);
-
-        uint32_t mask[(buffer_size / 32) + 1];
-        for (uint16_t k = 0; k < (buffer_size / 32) + 1; k++) {
-            mask[k] = 0x00000000;
-        }
-
-        bool full_coverage = displayio_display_fill_area(display, &subrectangle, mask, buffer);
-        if (!full_coverage) {
-            uint32_t index = 0;
-            uint32_t current_mask = 0;
-            for (int16_t y = subrectangle.y1; y < subrectangle.y2; y++) {
-                for (int16_t x = subrectangle.x1; x < subrectangle.x2; x++) {
-                    if (index % 32 == 0) {
-                        current_mask = mask[index / 32];
-                    }
-                    if ((current_mask & (1 << (index % 32))) == 0) {
-                        ((uint16_t*) buffer)[index] = 0x0000;
-                    }
-                    index++;
-                }
-            }
-        }
-
-        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, displayio_area_size(&subrectangle) * sizeof(uint16_t));
-        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.
-bool refresh_displays_in_progress = false;
-uint32_t frame_count = 0;
-
-void displayio_refresh_displays(void) {
+void displayio_background(void) {
     if (mp_hal_is_interrupted()) {
         return;
     }
@@ -107,61 +30,56 @@ void displayio_refresh_displays(void) {
         return;
     }
 
-    if (refresh_displays_in_progress) {
+    if (displayio_background_in_progress) {
         // Don't allow recursive calls to this routine.
         return;
     }
 
-    refresh_displays_in_progress = true;
+    displayio_background_in_progress = true;
 
     for (uint8_t i = 0; i < CIRCUITPY_DISPLAY_LIMIT; i++) {
         if (displays[i].display.base.type == NULL || displays[i].display.base.type == &mp_type_NoneType) {
             // Skip null display.
             continue;
         }
-        displayio_display_obj_t* display = &displays[i].display;
-        displayio_display_update_backlight(display);
-
-        // Time to refresh at specified frame rate?
-        if (!displayio_display_frame_queued(display)) {
-            // Too soon. Try next display.
-            continue;
+        if (displays[i].display.base.type == &displayio_display_type) {
+            displayio_display_background(&displays[i].display);
+        } else if (displays[i].epaper_display.base.type == &displayio_epaperdisplay_type) {
+            displayio_epaperdisplay_background(&displays[i].epaper_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.
-    refresh_displays_in_progress = false;
+    displayio_background_in_progress = false;
 }
 
 void common_hal_displayio_release_displays(void) {
+    // Release displays before busses so that they can send any final commands to turn the display
+    // off properly.
+    for (uint8_t i = 0; i < CIRCUITPY_DISPLAY_LIMIT; i++) {
+        mp_const_obj_t display_type = displays[i].display.base.type;
+        if (display_type == NULL || display_type == &mp_type_NoneType) {
+            continue;
+        } else if (display_type == &displayio_display_type) {
+            release_display(&displays[i].display);
+        } else if (display_type == &displayio_epaperdisplay_type) {
+            release_epaperdisplay(&displays[i].epaper_display);
+        }
+        displays[i].display.base.type = &mp_type_NoneType;
+    }
     for (uint8_t i = 0; i < CIRCUITPY_DISPLAY_LIMIT; i++) {
         mp_const_obj_t bus_type = displays[i].fourwire_bus.base.type;
-        if (bus_type == NULL) {
+        if (bus_type == NULL || bus_type == &mp_type_NoneType) {
             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);
         }
         displays[i].fourwire_bus.base.type = &mp_type_NoneType;
     }
-    for (uint8_t i = 0; i < CIRCUITPY_DISPLAY_LIMIT; i++) {
-        release_display(&displays[i].display);
-        displays[i].display.base.type = &mp_type_NoneType;
-    }
 
     supervisor_stop_terminal();
 }
@@ -169,39 +87,67 @@ void common_hal_displayio_release_displays(void) {
 void reset_displays(void) {
     // 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 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;
+        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;
+                    }
                 }
-            #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.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.I2C 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 bus.
+            continue;
         }
     }
 
     for (uint8_t i = 0; i < CIRCUITPY_DISPLAY_LIMIT; i++) {
-        if (displays[i].display.base.type == NULL) {
-            continue;
+        // Reset the displayed group. Only the first will get the terminal but
+        // that's ok.
+        if (displays[i].display.base.type == &displayio_display_type) {
+            reset_display(&displays[i].display);
+        } else if (displays[i].epaper_display.base.type == &displayio_epaperdisplay_type) {
+            displayio_epaperdisplay_obj_t* display = &displays[i].epaper_display;
+            common_hal_displayio_epaperdisplay_show(display, NULL);
         }
-        displayio_display_obj_t* display = &displays[i].display;
-        display->auto_brightness = true;
-        common_hal_displayio_display_show(display, &circuitpython_splash);
     }
 }
 
@@ -213,8 +159,11 @@ void displayio_gc_collect(void) {
 
         // 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);
-
+        if (displays[i].display.base.type == &displayio_display_type) {
+            displayio_display_collect_ptrs(&displays[i].display);
+        } else if (displays[i].epaper_display.base.type == &displayio_epaperdisplay_type) {
+            displayio_epaperdisplay_collect_ptrs(&displays[i].epaper_display);
+        }
     }
 }
 
diff --git a/shared-module/displayio/__init__.h b/shared-module/displayio/__init__.h
index 18c1a4f4a..e78bc61ce 100644
--- a/shared-module/displayio/__init__.h
+++ b/shared-module/displayio/__init__.h
@@ -28,23 +28,29 @@
 #define MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO___INIT___H
 
 #include "shared-bindings/displayio/Display.h"
+#include "shared-bindings/displayio/EPaperDisplay.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;
+    union {
+        displayio_display_obj_t display;
+        displayio_epaperdisplay_obj_t epaper_display;
+    };
 } primary_display_t;
 
 extern primary_display_t displays[CIRCUITPY_DISPLAY_LIMIT];
 
 extern displayio_group_t circuitpython_splash;
 
-void displayio_refresh_displays(void);
+void displayio_background(void);
 void reset_displays(void);
 void displayio_gc_collect(void);
 
diff --git a/shared-module/displayio/display_core.c b/shared-module/displayio/display_core.c
new file mode 100644
index 000000000..a73ea81d1
--- /dev/null
+++ b/shared-module/displayio/display_core.c
@@ -0,0 +1,335 @@
+/*
+ * 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/Display.h"
+
+#include "py/gc.h"
+#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"
+#include "shared-module/displayio/__init__.h"
+#include "supervisor/shared/display.h"
+
+#include <stdint.h>
+#include <string.h>
+
+#include "tick.h"
+
+void displayio_display_core_construct(displayio_display_core_t* self,
+        mp_obj_t bus, uint16_t width, uint16_t height, uint16_t ram_width, uint16_t ram_height, int16_t colstart, int16_t rowstart, uint16_t rotation,
+        uint16_t color_depth, bool grayscale, bool pixels_in_byte_share_row, uint8_t bytes_per_cell, bool reverse_pixels_in_byte) {
+    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->colorspace.dither = false;
+    self->current_group = NULL;
+    self->colstart = colstart;
+    self->rowstart = rowstart;
+    self->last_refresh = 0;
+
+    if (MP_OBJ_IS_TYPE(bus, &displayio_parallelbus_type)) {
+        self->bus_reset = common_hal_displayio_parallelbus_reset;
+        self->bus_free = common_hal_displayio_parallelbus_bus_free;
+        self->begin_transaction = common_hal_displayio_parallelbus_begin_transaction;
+        self->send = common_hal_displayio_parallelbus_send;
+        self->end_transaction = common_hal_displayio_parallelbus_end_transaction;
+    } else if (MP_OBJ_IS_TYPE(bus, &displayio_fourwire_type)) {
+        self->bus_reset = common_hal_displayio_fourwire_reset;
+        self->bus_free = common_hal_displayio_fourwire_bus_free;
+        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->bus_reset = common_hal_displayio_i2cdisplay_reset;
+        self->bus_free = common_hal_displayio_i2cdisplay_bus_free;
+        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"));
+    }
+    self->bus = bus;
+
+
+    supervisor_start_terminal(width, height);
+
+    self->width = width;
+    self->height = height;
+    self->ram_width = ram_width;
+    self->ram_height = ram_height;
+    rotation = rotation % 360;
+    self->rotation = rotation;
+    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->transform.mirror_x = true;
+            self->transform.mirror_y = true;
+        }
+    } else {
+        self->transform.transpose_xy = true;
+        if (rotation == 270) {
+            self->transform.mirror_y = true;
+        } else {
+            self->transform.mirror_x = true;
+        }
+    }
+
+    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;
+        }
+    }
+}
+
+bool displayio_display_core_show(displayio_display_core_t* self, displayio_group_t* root_group) {
+    if (root_group == NULL) {
+        if (!circuitpython_splash.in_group) {
+            root_group = &circuitpython_splash;
+        } else if (self->current_group == &circuitpython_splash) {
+            return true;
+        }
+    }
+    if (root_group == self->current_group) {
+        return true;
+    }
+    if (root_group != NULL && root_group->in_group) {
+        return false;
+    }
+    if (self->current_group != NULL) {
+        self->current_group->in_group = false;
+    }
+
+    if (root_group != NULL) {
+        displayio_group_update_transform(root_group, &self->transform);
+        root_group->in_group = true;
+    }
+    self->current_group = root_group;
+    self->full_refresh = true;
+    return true;
+}
+
+uint16_t displayio_display_core_get_width(displayio_display_core_t* self){
+    return self->width;
+}
+
+uint16_t displayio_display_core_get_height(displayio_display_core_t* self){
+    return self->height;
+}
+
+void displayio_display_core_set_dither(displayio_display_core_t* self, bool dither){
+    self->colorspace.dither = dither;
+}
+
+bool displayio_display_core_get_dither(displayio_display_core_t* self){
+    return self->colorspace.dither;
+}
+
+bool displayio_display_core_bus_free(displayio_display_core_t *self) {
+    return self->bus_free(self->bus);
+}
+
+bool displayio_display_core_begin_transaction(displayio_display_core_t* self) {
+    return self->begin_transaction(self->bus);
+}
+
+void displayio_display_core_end_transaction(displayio_display_core_t* self) {
+    self->end_transaction(self->bus);
+}
+
+void displayio_display_core_set_region_to_update(displayio_display_core_t* self, uint8_t column_command, uint8_t row_command, uint16_t set_current_column_command, uint16_t set_current_row_command, bool data_as_commands, bool always_toggle_chip_select, 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;
+        }
+    }
+
+    display_chip_select_behavior_t chip_select = CHIP_SELECT_UNTOUCHED;
+    if (always_toggle_chip_select || data_as_commands) {
+        chip_select = CHIP_SELECT_TOGGLE_EVERY_BYTE;
+    }
+
+    // Set column.
+    displayio_display_core_begin_transaction(self);
+    uint8_t data[5];
+    data[0] = column_command;
+    uint8_t data_length = 1;
+    display_byte_type_t data_type = DISPLAY_DATA;
+    if (!data_as_commands) {
+        self->send(self->bus, DISPLAY_COMMAND, CHIP_SELECT_UNTOUCHED, data, 1);
+        data_length = 0;
+    } else {
+        data_type = DISPLAY_COMMAND;
+    }
+    if (self->ram_width < 0x100) {
+        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, data_type, chip_select, data, data_length);
+    displayio_display_core_end_transaction(self);
+    if (set_current_column_command != NO_COMMAND) {
+        uint8_t command = set_current_column_command;
+        displayio_display_core_begin_transaction(self);
+        self->send(self->bus, DISPLAY_COMMAND, chip_select, &command, 1);
+        self->send(self->bus, DISPLAY_DATA, chip_select, data, data_length / 2);
+        displayio_display_core_end_transaction(self);
+    }
+
+
+    // Set row.
+    displayio_display_core_begin_transaction(self);
+    data[0] = row_command;
+    data_length = 1;
+    if (!data_as_commands) {
+        self->send(self->bus, DISPLAY_COMMAND, CHIP_SELECT_UNTOUCHED, data, 1);
+        data_length = 0;
+    }
+    if (self->ram_height < 0x100) {
+        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, data_type, chip_select, data, data_length);
+    displayio_display_core_end_transaction(self);
+
+    if (set_current_row_command != NO_COMMAND) {
+        uint8_t command = set_current_row_command;
+        displayio_display_core_begin_transaction(self);
+        self->send(self->bus, DISPLAY_COMMAND, chip_select, &command, 1);
+        self->send(self->bus, DISPLAY_DATA, chip_select, data, data_length / 2);
+        displayio_display_core_end_transaction(self);
+    }
+}
+
+void displayio_display_core_start_refresh(displayio_display_core_t* self) {
+    self->last_refresh = ticks_ms;
+}
+
+void displayio_display_core_finish_refresh(displayio_display_core_t* self) {
+    if (self->current_group != NULL) {
+        displayio_group_finish_refresh(self->current_group);
+    }
+    self->full_refresh = false;
+    self->last_refresh = ticks_ms;
+}
+
+void release_display_core(displayio_display_core_t* self) {
+    if (self->current_group != NULL) {
+        self->current_group->in_group = false;
+    }
+}
+
+void displayio_display_core_collect_ptrs(displayio_display_core_t* self) {
+    gc_collect_ptr(self->current_group);
+}
+
+bool displayio_display_core_fill_area(displayio_display_core_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_core_clip_area(displayio_display_core_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_core.h b/shared-module/displayio/display_core.h
new file mode 100644
index 000000000..3a69cd40a
--- /dev/null
+++ b/shared-module/displayio/display_core.h
@@ -0,0 +1,88 @@
+/*
+ * This file is part of the MicroPython 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_DISPLAY_CORE_H
+#define MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_DISPLAY_CORE_H
+
+#include "shared-bindings/displayio/__init__.h"
+#include "shared-bindings/displayio/Group.h"
+
+#include "shared-module/displayio/area.h"
+
+#define NO_COMMAND 0x100
+
+typedef struct {
+    mp_obj_t bus;
+    displayio_group_t *current_group;
+    uint64_t last_refresh;
+    display_bus_bus_reset bus_reset;
+    display_bus_bus_free bus_free;
+    display_bus_begin_transaction begin_transaction;
+    display_bus_send send;
+    display_bus_end_transaction end_transaction;
+    displayio_buffer_transform_t transform;
+    displayio_area_t area;
+    uint16_t width;
+    uint16_t height;
+    uint16_t rotation;
+    uint16_t ram_width;
+    uint16_t ram_height;
+    _displayio_colorspace_t colorspace;
+    int16_t colstart;
+    int16_t rowstart;
+    bool full_refresh; // New group means we need to refresh the whole display.
+} displayio_display_core_t;
+
+void displayio_display_core_construct(displayio_display_core_t* self,
+        mp_obj_t bus, uint16_t width, uint16_t height, uint16_t ram_width, uint16_t ram_height, int16_t colstart, int16_t rowstart, uint16_t rotation,
+        uint16_t color_depth, bool grayscale, bool pixels_in_byte_share_row, uint8_t bytes_per_cell, bool reverse_pixels_in_byte);
+
+bool displayio_display_core_show(displayio_display_core_t* self, displayio_group_t* root_group);
+
+uint16_t displayio_display_core_get_width(displayio_display_core_t* self);
+uint16_t displayio_display_core_get_height(displayio_display_core_t* self);
+
+void displayio_display_core_set_dither(displayio_display_core_t* self, bool dither);
+bool displayio_display_core_get_dither(displayio_display_core_t* self);
+
+bool displayio_display_core_bus_free(displayio_display_core_t *self);
+bool displayio_display_core_begin_transaction(displayio_display_core_t* self);
+void displayio_display_core_end_transaction(displayio_display_core_t* self);
+
+void displayio_display_core_set_region_to_update(displayio_display_core_t* self, uint8_t column_command, uint8_t row_command, uint16_t set_current_column_command, uint16_t set_current_row_command, bool data_as_commands, bool always_toggle_chip_select, displayio_area_t* area);
+
+void release_display_core(displayio_display_core_t* self);
+
+void displayio_display_core_start_refresh(displayio_display_core_t* self);
+void displayio_display_core_finish_refresh(displayio_display_core_t* self);
+
+void displayio_display_core_collect_ptrs(displayio_display_core_t* self);
+
+bool displayio_display_core_fill_area(displayio_display_core_t *self, displayio_area_t* area, uint32_t* mask, uint32_t *buffer);
+
+bool displayio_display_core_clip_area(displayio_display_core_t *self, const displayio_area_t* area, displayio_area_t* clipped);
+
+#endif // MICROPY_INCLUDED_SHARED_MODULE_DISPLAYIO_DISPLAY_CORE_H
diff --git a/shared-module/os/__init__.c b/shared-module/os/__init__.c
index 313893d97..8060eec4f 100644
--- a/shared-module/os/__init__.c
+++ b/shared-module/os/__init__.c
@@ -128,6 +128,7 @@ mp_obj_t common_hal_os_listdir(const char* path) {
     while ((next = mp_iternext(iter_obj)) != MP_OBJ_STOP_ITERATION) {
         // next[0] is the filename.
         mp_obj_list_append(dir_list, mp_obj_subscr(next, MP_OBJ_NEW_SMALL_INT(0), MP_OBJ_SENTINEL));
+        RUN_BACKGROUND_TASKS;
     }
     return dir_list;
 }
diff --git a/shared-module/terminalio/Terminal.c b/shared-module/terminalio/Terminal.c
index 7adf9d032..df92a5dc4 100644
--- a/shared-module/terminalio/Terminal.c
+++ b/shared-module/terminalio/Terminal.c
@@ -35,6 +35,14 @@ void common_hal_terminalio_terminal_construct(terminalio_terminal_obj_t *self, d
     self->font = font;
     self->tilegrid = tilegrid;
     self->first_row = 0;
+
+    for (uint16_t x = 0; x < self->tilegrid->width_in_tiles; x++) {
+        for (uint16_t y = 0; y < self->tilegrid->height_in_tiles; y++) {
+            common_hal_displayio_tilegrid_set_tile(self->tilegrid, x, y, 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) {
diff --git a/shared-module/touchio/TouchIn.c b/shared-module/touchio/TouchIn.c
new file mode 100644
index 000000000..88d12b8b8
--- /dev/null
+++ b/shared-module/touchio/TouchIn.c
@@ -0,0 +1,115 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2016 Scott Shawcroft for Adafruit Industries
+ * Copyright (c) 2018 Nick Moore 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 <string.h>
+#include <stdio.h>
+
+#include "py/runtime.h"
+#include "py/mphal.h"
+#include "shared-bindings/touchio/TouchIn.h"
+
+// This is a capacitive touch sensing routine using a single digital
+// pin.  The pin should be connected to the sensing pad, and to ground
+// via a 1Mohm or thereabout drain resistor.  When a reading is taken,
+// the pin's capacitance is charged by setting it to a digital output
+// 'high' for a few microseconds, and then it is changed to a high
+// impedance input.  We measure how long it takes to discharge through
+// the resistor (around 50us), using a busy-waiting loop, and average
+// over N_SAMPLES cycles to reduce the effects of noise.
+
+#define N_SAMPLES 10
+#define TIMEOUT_TICKS 10000
+
+static uint16_t get_raw_reading(touchio_touchin_obj_t *self) {
+
+    uint16_t ticks = 0;
+
+    for (uint16_t i = 0; i < N_SAMPLES; i++) {
+        // set pad to digital output high for 10us to charge it
+
+        common_hal_digitalio_digitalinout_switch_to_output(self->digitalinout, true, DRIVE_MODE_PUSH_PULL);
+        mp_hal_delay_us(10);
+
+        // set pad back to an input and take some samples
+
+        common_hal_digitalio_digitalinout_switch_to_input(self->digitalinout, PULL_NONE);
+
+        while(common_hal_digitalio_digitalinout_get_value(self->digitalinout)) {
+            if (ticks >= TIMEOUT_TICKS) return TIMEOUT_TICKS;
+            ticks++;
+        }
+    }
+    return ticks;
+}
+
+void common_hal_touchio_touchin_construct(touchio_touchin_obj_t* self, const mcu_pin_obj_t *pin) {
+    claim_pin(pin);
+    self->digitalinout = m_new_obj(digitalio_digitalinout_obj_t);
+    self->digitalinout->base.type = &digitalio_digitalinout_type;
+
+    common_hal_digitalio_digitalinout_construct(self->digitalinout, pin);
+
+    uint16_t raw_reading = get_raw_reading(self);
+    if (raw_reading == TIMEOUT_TICKS) {
+        mp_raise_ValueError(translate("No pulldown on pin; 1Mohm recommended"));
+    }
+    self->threshold = raw_reading * 1.05 + 100;
+}
+
+bool common_hal_touchio_touchin_deinited(touchio_touchin_obj_t* self) {
+    return self->digitalinout == MP_OBJ_NULL;
+}
+
+void common_hal_touchio_touchin_deinit(touchio_touchin_obj_t* self) {
+    if (common_hal_touchio_touchin_deinited(self)) {
+        return;
+    }
+
+    common_hal_digitalio_digitalinout_deinit(self->digitalinout);
+    self->digitalinout = MP_OBJ_NULL;
+}
+
+void touchin_reset() {
+}
+
+bool common_hal_touchio_touchin_get_value(touchio_touchin_obj_t *self) {
+    uint16_t reading = get_raw_reading(self);
+    return reading > self->threshold;
+}
+
+uint16_t common_hal_touchio_touchin_get_raw_value(touchio_touchin_obj_t *self) {
+    return get_raw_reading(self);
+}
+
+uint16_t common_hal_touchio_touchin_get_threshold(touchio_touchin_obj_t *self) {
+    return self->threshold;
+}
+
+void common_hal_touchio_touchin_set_threshold(touchio_touchin_obj_t *self,
+        uint16_t new_threshold) {
+    self->threshold = new_threshold;
+}
diff --git a/shared-module/touchio/TouchIn.h b/shared-module/touchio/TouchIn.h
new file mode 100644
index 000000000..8ff6fda8f
--- /dev/null
+++ b/shared-module/touchio/TouchIn.h
@@ -0,0 +1,44 @@
+/*
+ * This file is part of the MicroPython project, http://micropython.org/
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2016 Scott Shawcroft
+ * Copyright (c) 2018 Nick Moore 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_TOUCHIO_TOUCHIN_H
+#define MICROPY_INCLUDED_SHARED_MODULE_TOUCHIO_TOUCHIN_H
+
+#include "common-hal/microcontroller/Pin.h"
+#include "shared-bindings/digitalio/DigitalInOut.h"
+
+#include "py/obj.h"
+
+typedef struct {
+    mp_obj_base_t base;
+    digitalio_digitalinout_obj_t *digitalinout;
+    uint16_t threshold;
+} touchio_touchin_obj_t;
+
+void touchin_reset(void);
+
+#endif // MICROPY_INCLUDED_SHARED_MODULE_TOUCHIO_TOUCHIN_H
diff --git a/shared-module/touchio/__init__.c b/shared-module/touchio/__init__.c
new file mode 100644
index 000000000..d2290447c
--- /dev/null
+++ b/shared-module/touchio/__init__.c
@@ -0,0 +1 @@
+// No touchio module functions.
diff --git a/shared-module/usb_hid/Device.c b/shared-module/usb_hid/Device.c
index 0e256cb5e..bed7d163f 100644
--- a/shared-module/usb_hid/Device.c
+++ b/shared-module/usb_hid/Device.c
@@ -47,15 +47,17 @@ 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() ) {
+        RUN_BACKGROUND_TASKS;
+    }
 
-    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"));
     }
 }
@@ -70,7 +72,7 @@ static usb_hid_device_obj_t* get_hid_device(uint8_t report_id) {
 }
 
 // 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;
 
@@ -80,7 +82,7 @@ uint16_t tud_hid_generic_get_report_cb(uint8_t report_id, hid_report_type_t repo
 }
 
 // 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) {
+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 ) {
diff --git a/shared-module/usb_hid/__init__.c b/shared-module/usb_hid/__init__.c
index f14fdd41e..d88f9787a 100644
--- a/shared-module/usb_hid/__init__.c
+++ b/shared-module/usb_hid/__init__.c
@@ -24,131 +24,4 @@
  * THE SOFTWARE.
  */
 
-#include "py/obj.h"
-#include "py/mphal.h"
-#include "py/runtime.h"
-
-#include "genhdr/autogen_usb_descriptor.h"
-#include "shared-module/usb_hid/Device.h"
-#include "shared-bindings/usb_hid/Device.h"
-#include "tusb.h"
-
-#ifdef USB_HID_REPORT_ID_KEYBOARD
-static uint8_t keyboard_report_buffer[USB_HID_REPORT_LENGTH_KEYBOARD];
-#endif
-
-#ifdef USB_HID_REPORT_ID_MOUSE
-static uint8_t mouse_report_buffer[USB_HID_REPORT_LENGTH_MOUSE];
-#endif
-
-#ifdef USB_HID_REPORT_ID_CONSUMER
-static uint8_t consumer_report_buffer[USB_HID_REPORT_LENGTH_CONSUMER];
-#endif
-
-#ifdef USB_HID_REPORT_ID_SYS_CONTROL
-static uint8_t sys_control_report_buffer[USB_HID_REPORT_LENGTH_SYS_CONTROL];
-#endif
-
-#ifdef USB_HID_REPORT_ID_GAMEPAD
-static uint8_t gamepad_report_buffer[USB_HID_REPORT_LENGTH_GAMEPAD];
-#endif
-
-#ifdef USB_HID_REPORT_ID_DIGITIZER
-static uint8_t digitizer_report_buffer[USB_HID_REPORT_LENGTH_DIGITIZER];
-#endif
-
-usb_hid_device_obj_t usb_hid_devices[] = {
-#ifdef USB_HID_REPORT_ID_KEYBOARD
-    {
-        .base          = { .type = &usb_hid_device_type } ,
-        .report_buffer = keyboard_report_buffer           ,
-        .report_id     = USB_HID_REPORT_ID_KEYBOARD       ,
-        .report_length = USB_HID_REPORT_LENGTH_KEYBOARD   ,
-        .usage_page    = HID_USAGE_PAGE_DESKTOP           ,
-        .usage         = HID_USAGE_DESKTOP_KEYBOARD       ,
-    },
-#endif
-
-#ifdef USB_HID_REPORT_ID_MOUSE
-    {
-        .base          = { .type = &usb_hid_device_type } ,
-        .report_buffer = mouse_report_buffer              ,
-        .report_id     = USB_HID_REPORT_ID_MOUSE          ,
-        .report_length = USB_HID_REPORT_LENGTH_MOUSE      ,
-        .usage_page    = HID_USAGE_PAGE_DESKTOP           ,
-        .usage         = HID_USAGE_DESKTOP_MOUSE          ,
-    },
-#endif
-
-#ifdef USB_HID_REPORT_ID_CONSUMER
-    {
-        .base          = { .type = &usb_hid_device_type } ,
-        .report_buffer = consumer_report_buffer           ,
-        .report_id     = USB_HID_REPORT_ID_CONSUMER       ,
-        .report_length = USB_HID_REPORT_LENGTH_CONSUMER   ,
-        .usage_page    = HID_USAGE_PAGE_CONSUMER          ,
-        .usage         = HID_USAGE_CONSUMER_CONTROL       ,
-    },
-#endif
-
-#ifdef USB_HID_REPORT_ID_SYS_CONTROL
-    {
-        .base          = { .type = &usb_hid_device_type }  ,
-        .report_buffer = sys_control_report_buffer         ,
-        .report_id     = USB_HID_REPORT_ID_SYS_CONTROL     ,
-        .report_length = USB_HID_REPORT_LENGTH_SYS_CONTROL ,
-        .usage_page    = HID_USAGE_PAGE_DESKTOP            ,
-        .usage         = HID_USAGE_DESKTOP_SYSTEM_CONTROL  ,
-    },
-#endif
-
-#ifdef USB_HID_REPORT_ID_GAMEPAD
-    {
-        .base          = { .type = &usb_hid_device_type } ,
-        .report_buffer = gamepad_report_buffer            ,
-        .report_id     = USB_HID_REPORT_ID_GAMEPAD        ,
-        .report_length = USB_HID_REPORT_LENGTH_GAMEPAD    ,
-        .usage_page    = HID_USAGE_PAGE_DESKTOP           ,
-        .usage         = HID_USAGE_DESKTOP_GAMEPAD        ,
-    },
-#endif
-
-#ifdef USB_HID_REPORT_ID_DIGITIZER
-    {
-        .base          = { .type = &usb_hid_device_type } ,
-        .report_buffer = digitizer_report_buffer          ,
-        .report_id     = USB_HID_REPORT_ID_DIGITIZER      ,
-        .report_length = USB_HID_REPORT_LENGTH_DIGITIZER  ,
-        .usage_page    = 0x0D                             ,
-        .usage         = 0x02                             ,
-    },
-#endif
-};
-
-
-mp_obj_tuple_t common_hal_usb_hid_devices = {
-    .base = {
-        .type = &mp_type_tuple,
-    },
-    .len = USB_HID_NUM_DEVICES,
-    .items = {
-#if USB_HID_NUM_DEVICES >= 1
-        (mp_obj_t) &usb_hid_devices[0],
-#endif
-#if USB_HID_NUM_DEVICES >= 2
-        (mp_obj_t) &usb_hid_devices[1],
-#endif
-#if USB_HID_NUM_DEVICES >= 3
-        (mp_obj_t) &usb_hid_devices[2],
-#endif
-#if USB_HID_NUM_DEVICES >= 4
-        (mp_obj_t) &usb_hid_devices[3],
-#endif
-#if USB_HID_NUM_DEVICES >= 5
-        (mp_obj_t) &usb_hid_devices[4],
-#endif
-#if USB_HID_NUM_DEVICES >= 6
-        (mp_obj_t) &usb_hid_devices[5],
-#endif
-    }
-};
+// Nothing needed here. Tables of HID devices are generated in autogen_usb_descriptor.c at compile-time.
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();
 }