Purge uGFX. (#14720)

* Purge uGFX. * Remove remnants of visualizer. * Remove remnants of uGFX.
2021-10-07 10:57:48 +11:00 · 2021-10-07 10:57:48 +11:00 · b2a186cf92
commit b2a186cf92
parent bc1f5ef381
66 changed files with 2 additions and 3898 deletions
--- a/.gitmodules
+++ b/.gitmodules
@ -6,10 +6,6 @@
 	path = lib/chibios-contrib
 	url = https://github.com/qmk/ChibiOS-Contrib
 	branch = master
-[submodule "lib/ugfx"]
-	path = lib/ugfx
-	url = https://github.com/qmk/uGFX
-	branch = master
 [submodule "lib/googletest"]
 	path = lib/googletest
 	url = https://github.com/qmk/googletest
--- a/1
+++ b/1
@ -490,7 +490,6 @@ endef
 ifndef SKIP_GIT
 	if [ ! -e lib/chibios ]; then git submodule sync lib/chibios && git submodule update --depth 50 --init lib/chibios; fi
 	if [ ! -e lib/chibios-contrib ]; then git submodule sync lib/chibios-contrib && git submodule update --depth 50 --init lib/chibios-contrib; fi
-	if [ ! -e lib/ugfx ]; then git submodule sync lib/ugfx && git submodule update --depth 50 --init lib/ugfx; fi
 	if [ ! -e lib/lufa ]; then git submodule sync lib/lufa && git submodule update --depth 50 --init lib/lufa; fi
 	if [ ! -e lib/vusb ]; then git submodule sync lib/vusb && git submodule update --depth 50 --init lib/vusb; fi
 	if [ ! -e lib/printf ]; then git submodule sync lib/printf && git submodule update --depth 50 --init lib/printf; fi
--- a/build_keyboard.mk
+++ b/build_keyboard.mk
@ -429,12 +429,6 @@ PROJECT_DEFS := $(OPT_DEFS)
 PROJECT_INC := $(VPATH) $(EXTRAINCDIRS) $(KEYBOARD_PATHS)
 PROJECT_CONFIG := $(CONFIG_H)

-ifeq ($(strip $(VISUALIZER_ENABLE)), yes)
-    VISUALIZER_DIR = $(QUANTUM_DIR)/visualizer
-    VISUALIZER_PATH = $(QUANTUM_PATH)/visualizer
-    include $(VISUALIZER_PATH)/visualizer.mk
-endif
-
 CONFIG_H += $(POST_CONFIG_H)
 ALL_CONFIGS := $(PROJECT_CONFIG) $(CONFIG_H)

--- a/common_features.mk
+++ b/common_features.mk
@ -450,10 +450,6 @@ ifeq ($(strip $(APA102_DRIVER_REQUIRED)), yes)
    SRC += apa102.c
 endif

-ifeq ($(strip $(VISUALIZER_ENABLE)), yes)
-    CIE1931_CURVE := yes
-endif
-
 ifeq ($(strip $(CIE1931_CURVE)), yes)
    OPT_DEFS += -DUSE_CIE1931_CURVE
    LED_TABLES := yes
--- a/disable_features.mk
+++ b/disable_features.mk
@ -22,7 +22,6 @@ FEATURE_NAMES += SLEEP_LED
 FEATURE_NAMES += SERIAL_LINK
 FEATURE_NAMES += STENO
 FEATURE_NAMES += SWAP_HANDS
-FEATURE_NAMES += VISUALIZER
 FEATURE_NAMES += WATCHDOG
 FEATURE_NAMES += XT

--- a/docs/es/hardware_drivers.md
+++ b/docs/es/hardware_drivers.md
@ -18,10 +18,6 @@ Soporte para direccionar pines en el ProMicro por su nombre Arduino en lugar de

 Soporte para pantallas OLED basadas en SSD1306. Para obtener más información consulta la página de [Característica de Controlador OLED](feature_oled_driver.md).

-## uGFX
-
-Puedes hacer uso de uGFX dentro de QMK para manejar LCDs de caracteres y gráficos, matrices de LED, OLED, TFT, y otras tecnologías de visualización. Esto necesita ser mejor documentado. Si estás tratando de hacer esto y leer el código no ayuda por favor [abre una issue](https://github.com/qmk/qmk_firmware/issues/new) y podemos ayudarte por el proceso.
-
 ## WS2812 (Solo AVR)

 Soporte para LEDs WS2811/WS2812{a,b,c}. Para obtener más información consulta la página de [Luz RGB](feature_rgblight.md).
--- a/docs/es/hardware_keyboard_guidelines.md
+++ b/docs/es/hardware_keyboard_guidelines.md
@ -142,8 +142,6 @@ El año debe ser el primer año en que se crea el archivo. Si el trabajo se hizo

 El núcleo de QMC está licenciado bajo la [GNU General Public License](https://www.gnu.org/licenses/licenses.en.html). Si estás enviando binarios para los procesadores AVR puedes elegir cualquiera [GPLv2](https://www.gnu.org/licenses/old-licenses/gpl-2.0.html) o [GPLv3](https://www.gnu.org/licenses/gpl.html). Si estás enviando binarios para ARM procesadores debes elegir [GPL Versión 3](https://www.gnu.org/licenses/gpl.html) para cumplir con los [ChibiOS](https://www.chibios.org) licencia GPLv3.

-Si tu teclado hace uso de la [uGFX](https://gfx.io) características dentro de QMK debes cumplir con la [Licencia de uGFX](https://ugfx.io/license.html), que requiere una licencia comercial separada antes de vender un dispositivo que contiene uGFX.
-
 ## Detalles técnicos

 Si estás buscando más información sobre cómo hacer que su teclado funcione con QMK, [echa un vistazo a la sección hardware](hardware.md)!
--- a/docs/fr-fr/getting_started_github.md
+++ b/docs/fr-fr/getting_started_github.md
@ -32,7 +32,6 @@ Submodule path 'lib/chibios': checked out '587968d6cbc2b0e1c7147540872f2a67e59ca
 Submodule path 'lib/chibios-contrib': checked out 'ede48346eee4b8d6847c19bc01420bee76a5e486'
 Submodule path 'lib/googletest': checked out 'ec44c6c1675c25b9827aacd08c02433cccde7780'
 Submodule path 'lib/lufa': checked out 'ce10f7642b0459e409839b23cc91498945119b4d'
-Submodule path 'lib/ugfx': checked out '3e97b74e03c93631cdd3ddb2ce43b963fdce19b2'
 ```

 Vous avez maintenant votre fork QMK sur votre machine locale, vous pouvez ajouter votre keymap, la compiler et la flasher sur votre board. Une fois heureux avec vos changements, vous pouvez les ajouter, commit, et pousser vers votre fork comme suit:
--- a/docs/getting_started_github.md
+++ b/docs/getting_started_github.md
@ -32,7 +32,6 @@ Submodule path 'lib/chibios': checked out '587968d6cbc2b0e1c7147540872f2a67e59ca
 Submodule path 'lib/chibios-contrib': checked out 'ede48346eee4b8d6847c19bc01420bee76a5e486'
 Submodule path 'lib/googletest': checked out 'ec44c6c1675c25b9827aacd08c02433cccde7780'
 Submodule path 'lib/lufa': checked out 'ce10f7642b0459e409839b23cc91498945119b4d'
-Submodule path 'lib/ugfx': checked out '3e97b74e03c93631cdd3ddb2ce43b963fdce19b2'
 ```

 You now have your QMK fork on your local machine, and you can add your keymap, compile it and flash it to your board. Once you're happy with your changes, you can add, commit, and push them to your fork like this:
--- a/docs/hardware_drivers.md
+++ b/docs/hardware_drivers.md
@ -18,10 +18,6 @@ Support for addressing pins on the ProMicro by their Arduino name rather than th

 Support for SSD1306 based OLED displays. For more information see the [OLED Driver Feature](feature_oled_driver.md) page.

-## uGFX
-
-You can make use of uGFX within QMK to drive character and graphic LCDs, LED arrays, OLED, TFT, and other display technologies. This needs to be better documented, if you are trying to do this and reading the code doesn't help please [open an issue](https://github.com/qmk/qmk_firmware/issues/new) and we can help you through the process.
-
 ## WS2812

 Support for WS2811/WS2812{a,b,c} LED's. For more information see the [RGB Light](feature_rgblight.md) page.
--- a/docs/hardware_keyboard_guidelines.md
+++ b/docs/hardware_keyboard_guidelines.md
@ -255,8 +255,6 @@ The year should be the first year the file is created. If work was done to that

 The core of QMK is licensed under the [GNU General Public License](https://www.gnu.org/licenses/licenses.en.html). If you are shipping binaries for AVR processors you may choose either [GPLv2](https://www.gnu.org/licenses/old-licenses/gpl-2.0.html) or [GPLv3](https://www.gnu.org/licenses/gpl.html). If you are shipping binaries for ARM processors you must choose [GPL Version 3](https://www.gnu.org/licenses/gpl.html) to comply with the [ChibiOS](https://www.chibios.org) GPLv3 license.

-If your keyboard makes use of the [uGFX](https://ugfx.io) features within QMK you must comply with the [uGFX License](https://ugfx.io/license.html), which requires a separate commercial license before selling a device containing uGFX.
-
 ## Technical Details

 If you're looking for more information on making your keyboard work with QMK, [check out the hardware section](hardware.md)!
--- a/docs/he-il/getting_started_github.md
+++ b/docs/he-il/getting_started_github.md
@ -35,7 +35,6 @@ Submodule path 'lib/chibios': checked out '587968d6cbc2b0e1c7147540872f2a67e59ca
 Submodule path 'lib/chibios-contrib': checked out 'ede48346eee4b8d6847c19bc01420bee76a5e486'
 Submodule path 'lib/googletest': checked out 'ec44c6c1675c25b9827aacd08c02433cccde7780'
 Submodule path 'lib/lufa': checked out 'ce10f7642b0459e409839b23cc91498945119b4d'
-Submodule path 'lib/ugfx': checked out '3e97b74e03c93631cdd3ddb2ce43b963fdce19b2'
 ```

 </div>
--- a/docs/ja/getting_started_github.md
+++ b/docs/ja/getting_started_github.md
@ -37,7 +37,6 @@ Submodule path 'lib/chibios': checked out '587968d6cbc2b0e1c7147540872f2a67e59ca
 Submodule path 'lib/chibios-contrib': checked out 'ede48346eee4b8d6847c19bc01420bee76a5e486'
 Submodule path 'lib/googletest': checked out 'ec44c6c1675c25b9827aacd08c02433cccde7780'
 Submodule path 'lib/lufa': checked out 'ce10f7642b0459e409839b23cc91498945119b4d'
-Submodule path 'lib/ugfx': checked out '3e97b74e03c93631cdd3ddb2ce43b963fdce19b2'
 ```

 ローカルマシンに QMK のフォークができるので、キーマップの追加、コンパイル、キーボードへの書き込みができます。変更に満足したら、以下のようにそれらをフォークへ追加、コミットおよびプッシュすることができます:
--- a/docs/ja/hardware_drivers.md
+++ b/docs/ja/hardware_drivers.md
@ -24,10 +24,6 @@ ProMicro のピンを AVR の名前ではなく、Arduino の名前で指定で

 SSD1306 ベースの OLED ディスプレイのサポート。詳しくは[OLED ドライバ](ja/feature_oled_driver.md)を参照して下さい。

-## uGFX
-
-QMK 内で uGFX を使用して、キャラクタ LCD やグラフィック LCD、LED アレイ、OLED ディスプレイ、TFT 液晶や他のディスプレイを制御できます。この部分はより詳しく文書化される必要があります。もしこれを使用したい場合にコードを読んでも分からない場合、[issue を開く](https://github.com/qmk/qmk_firmware/issues/new)を通して助けることができるかもしれません。
-
 ## WS2812

 WS2811/WS2812{a,b,c} LED のサポート。 詳しくは [RGB ライト](ja/feature_rgblight.md)を参照して下さい。
--- a/docs/ja/hardware_keyboard_guidelines.md
+++ b/docs/ja/hardware_keyboard_guidelines.md
@ -234,8 +234,6 @@ QMK が提供する機能の量を考えれば、新しいユーザーが混乱

 QMK のコア部分は [GNU General Public License](https://www.gnu.org/licenses/licenses.en.html) でライセンスされます。AVR マイコン用のバイナリを提供する場合は、[GPLv2](https://www.gnu.org/licenses/old-licenses/gpl-2.0.html) か、[GPLv3](https://www.gnu.org/licenses/gpl.html) のどちらかから選択出来ます。ARM マイコン用のバイナリを提供する場合は、 [ChibiOS](https://www.chibios.org) の GPLv3 ライセンスに準拠するため、[GPL Version 3](https://www.gnu.org/licenses/gpl.html) を選択しなければいけません。

-[uGFX](https://ugfx.io) を使用している場合は、[uGFX License](https://ugfx.io/license.html) に準拠する必要があります。uGFX を利用したデバイスを販売するには個別に商用ライセンスを取得しなければいけません。
-
 ## 技術的な詳細

 キーボードを QMK で動作させるための詳細は[ハードウェア](ja/hardware.md)を参照して下さい！
--- a/docs/ja/understanding_qmk.md
+++ b/docs/ja/understanding_qmk.md
@ -183,10 +183,6 @@ FIXME: This needs to be written

 FIXME: This needs to be written

-#### Visualizer
-
-FIXME: This needs to be written
-
 #### Keyboard state LEDs (Caps Lock, Num Lock, Scroll Lock)

 FIXME: This needs to be written
--- a/docs/ru-ru/getting_started_github.md
+++ b/docs/ru-ru/getting_started_github.md
@ -31,7 +31,6 @@ Submodule path 'lib/chibios': checked out '587968d6cbc2b0e1c7147540872f2a67e59ca
 Submodule path 'lib/chibios-contrib': checked out 'ede48346eee4b8d6847c19bc01420bee76a5e486'
 Submodule path 'lib/googletest': checked out 'ec44c6c1675c25b9827aacd08c02433cccde7780'
 Submodule path 'lib/lufa': checked out 'ce10f7642b0459e409839b23cc91498945119b4d'
-Submodule path 'lib/ugfx': checked out '3e97b74e03c93631cdd3ddb2ce43b963fdce19b2'
 ```

 Теперь у вас есть форк QMK на вашем локальном компьютере, и вы можете добавить свою раскладку, скомпилировать ее и прошить ей свою клавиатуру. Как только вы будете довольны своими изменениями, есть возможность добавить, зафиксировать их и сделать коммит в свой форк следующим образом:
--- a/docs/understanding_qmk.md
+++ b/docs/understanding_qmk.md
@ -29,7 +29,6 @@ Within `keyboard_task()` you'll find code to handle:
 * [Matrix Scanning](#matrix-scanning)
 * Mouse Handling
 * Serial Link(s)
-* Visualizer
 * Keyboard status LEDs (Caps Lock, Num Lock, Scroll Lock)

 #### Matrix Scanning
@ -180,10 +179,6 @@ FIXME: This needs to be written

 FIXME: This needs to be written

-#### Visualizer
-
-FIXME: This needs to be written
-
 #### Keyboard state LEDs (Caps Lock, Num Lock, Scroll Lock)

 FIXME: This needs to be written
--- a/docs/zh-cn/getting_started_github.md
+++ b/docs/zh-cn/getting_started_github.md
@ -32,7 +32,6 @@ Submodule path 'lib/chibios': checked out '587968d6cbc2b0e1c7147540872f2a67e59ca
 Submodule path 'lib/chibios-contrib': checked out 'ede48346eee4b8d6847c19bc01420bee76a5e486'
 Submodule path 'lib/googletest': checked out 'ec44c6c1675c25b9827aacd08c02433cccde7780'
 Submodule path 'lib/lufa': checked out 'ce10f7642b0459e409839b23cc91498945119b4d'
-Submodule path 'lib/ugfx': checked out '3e97b74e03c93631cdd3ddb2ce43b963fdce19b2'
 ```

 现在你本地计算机有QMK的分叉了,你可以添加你的布局了, 为你的键盘编译并刷新固件吧。如果你觉得你的修改很不错, 你可以添加,提交,然后想你的分叉推出（pull）你的改变，像这样:
--- a/6
+++ b/6
@ -18,10 +18,4 @@ quantum/serial_link/protocol
 quantum/serial_link/system
 quantum/serial_link/tests
 quantum/tools
-quantum/visualizer
-quantum/visualizer/resources
 drivers
-drivers/ugfx
-drivers/ugfx/gdisp
-drivers/ugfx/gdisp/is31fl3731c
-drivers/ugfx/gdisp/st7565
--- a/drivers/ugfx/gdisp/is31fl3731c/board_is31fl3731c_template.h
+++ b/drivers/ugfx/gdisp/is31fl3731c/board_is31fl3731c_template.h
@ -1,105 +0,0 @@
-/*
-Copyright 2016 Fred Sundvik <fsundvik@gmail.com>
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _GDISP_LLD_BOARD_H
-#define _GDISP_LLD_BOARD_H
-
-static const I2CConfig i2ccfg = {
-    400000  // clock speed (Hz); 400kHz max for IS31
-};
-
-static const uint8_t led_mask[] = {
-    0xFF, 0x00, /* C1-1 -> C1-16 */
-    0xFF, 0x00, /* C2-1 -> C2-16 */
-    0xFF, 0x00, /* C3-1 -> C3-16 */
-    0xFF, 0x00, /* C4-1 -> C4-16 */
-    0x3F, 0x00, /* C5-1 -> C5-16 */
-    0x00, 0x00, /* C6-1 -> C6-16 */
-    0x00, 0x00, /* C7-1 -> C7-16 */
-    0x00, 0x00, /* C8-1 -> C8-16 */
-    0x00, 0x00, /* C9-1 -> C9-16 */
-};
-
-// The address of the LED
-#define LA(c, r) (c + r * 16)
-// Need to be an address that is not mapped, but inside the range of the controller matrix
-#define NA LA(8, 8)
-
-// The numbers in the comments are the led numbers DXX on the PCB
-// The mapping is taken from the schematic of left hand side
-static const uint8_t led_mapping[GDISP_SCREEN_HEIGHT][GDISP_SCREEN_WIDTH] = {
-    //   45        44        43        42        41        40        39
-    {LA(1, 1), LA(1, 0), LA(0, 4), LA(0, 3), LA(0, 2), LA(0, 1), LA(0, 0)},
-    //   52        51        50        49        48        47        46
-    {LA(2, 3), LA(2, 2), LA(2, 1), LA(2, 0), LA(1, 4), LA(1, 3), LA(1, 2)},
-    //   58        57        56        55        54        53        N/A
-    {LA(3, 4), LA(3, 3), LA(3, 2), LA(3, 1), LA(3, 0), LA(2, 4), NA},
-    //   67        66        65        64        63        62        61
-    {LA(5, 3), LA(5, 2), LA(5, 1), LA(5, 0), LA(4, 4), LA(4, 3), LA(4, 2)},
-    //   76        75        74        73        72        60        59
-    {LA(7, 3), LA(7, 2), LA(7, 1), LA(7, 0), LA(6, 3), LA(4, 1), LA(4, 0)},
-    //   N/A       N/A       N/A       N/A       N/A       N/A       68
-    {NA, NA, NA, NA, NA, NA, LA(5, 4)},
-    //   N/A       N/A       N/A       N/A       71        70        69
-    {NA, NA, NA, NA, LA(6, 2), LA(6, 1), LA(6, 0)},
-};
-
-#define IS31_ADDR_DEFAULT 0x74  // AD connected to GND
-#define IS31_TIMEOUT 5000
-
-static GFXINLINE void init_board(GDisplay* g) {
-    (void)g;
-    /* I2C pins */
-    palSetPadMode(GPIOB, 0, PAL_MODE_ALTERNATIVE_2);  // PTB0/I2C0/SCL
-    palSetPadMode(GPIOB, 1, PAL_MODE_ALTERNATIVE_2);  // PTB1/I2C0/SDA
-    palSetPadMode(GPIOB, 16, PAL_MODE_OUTPUT_PUSHPULL);
-    palClearPad(GPIOB, 16);
-    /* start I2C */
-    i2cStart(&I2CD1, &i2ccfg);
-    // try high drive (from kiibohd)
-    I2CD1.i2c->C2 |= I2Cx_C2_HDRS;
-    // try glitch fixing (from kiibohd)
-    I2CD1.i2c->FLT = 4;
-}
-
-static GFXINLINE void post_init_board(GDisplay* g) { (void)g; }
-
-static GFXINLINE const uint8_t* get_led_mask(GDisplay* g) {
-    (void)g;
-    return led_mask;
-}
-
-static GFXINLINE uint8_t get_led_address(GDisplay* g, uint16_t x, uint16_t y) {
-    (void)g;
-    return led_mapping[y][x];
-}
-
-static GFXINLINE void set_hardware_shutdown(GDisplay* g, bool shutdown) {
-    (void)g;
-    if (!shutdown) {
-        palSetPad(GPIOB, 16);
-    } else {
-        palClearPad(GPIOB, 16);
-    }
-}
-
-static GFXINLINE void write_data(GDisplay* g, uint8_t* data, uint16_t length) {
-    (void)g;
-    i2cMasterTransmitTimeout(&I2CD1, IS31_ADDR_DEFAULT, data, length, 0, 0, US2ST(IS31_TIMEOUT));
-}
-
-#endif /* _GDISP_LLD_BOARD_H */
--- a/drivers/ugfx/gdisp/is31fl3731c/driver.mk
+++ b/drivers/ugfx/gdisp/is31fl3731c/driver.mk
@ -1,3 +0,0 @@
-GFXINC += drivers/ugfx/gdisp/is31fl3731c
-GFXSRC += drivers/ugfx/gdisp/is31fl3731c/gdisp_is31fl3731c.c
-GDISP_DRIVER_LIST += GDISPVMT_IS31FL3731C_QMK
--- a/drivers/ugfx/gdisp/is31fl3731c/gdisp_is31fl3731c.c
+++ b/drivers/ugfx/gdisp/is31fl3731c/gdisp_is31fl3731c.c
@ -1,302 +0,0 @@
-/*
-Copyright 2016 Fred Sundvik <fsundvik@gmail.com>
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "gfx.h"
-
-#if GFX_USE_GDISP
-
-#    define GDISP_DRIVER_VMT GDISPVMT_IS31FL3731C_QMK
-#    define GDISP_SCREEN_HEIGHT LED_HEIGHT
-#    define GDISP_SCREEN_WIDTH LED_WIDTH
-
-#    include "gdisp_lld_config.h"
-#    include "src/gdisp/gdisp_driver.h"
-
-#    include "board_is31fl3731c.h"
-
-// Can't include led_tables from here
-extern const uint8_t CIE1931_CURVE[];
-
-/*===========================================================================*/
-/* Driver local definitions.                                                 */
-/*===========================================================================*/
-
-#    ifndef GDISP_INITIAL_CONTRAST
-#        define GDISP_INITIAL_CONTRAST 0
-#    endif
-#    ifndef GDISP_INITIAL_BACKLIGHT
-#        define GDISP_INITIAL_BACKLIGHT 0
-#    endif
-
-#    define GDISP_FLG_NEEDFLUSH (GDISP_FLG_DRIVER << 0)
-
-#    define IS31_ADDR_DEFAULT 0x74
-
-#    define IS31_REG_CONFIG 0x00
-// bits in reg
-#    define IS31_REG_CONFIG_PICTUREMODE 0x00
-#    define IS31_REG_CONFIG_AUTOPLAYMODE 0x08
-#    define IS31_REG_CONFIG_AUDIOPLAYMODE 0x18
-// D2:D0 bits are starting frame for autoplay mode
-
-#    define IS31_REG_PICTDISP 0x01  // D2:D0 frame select for picture mode
-
-#    define IS31_REG_AUTOPLAYCTRL1 0x02
-// D6:D4 number of loops (000=infty)
-// D2:D0 number of frames to be used
-
-#    define IS31_REG_AUTOPLAYCTRL2 0x03  // D5:D0 delay time (*11ms)
-
-#    define IS31_REG_DISPLAYOPT 0x05
-#    define IS31_REG_DISPLAYOPT_INTENSITY_SAME 0x20  // same intensity for all frames
-#    define IS31_REG_DISPLAYOPT_BLINK_ENABLE 0x8
-// D2:D0 bits blink period time (*0.27s)
-
-#    define IS31_REG_AUDIOSYNC 0x06
-#    define IS31_REG_AUDIOSYNC_ENABLE 0x1
-
-#    define IS31_REG_FRAMESTATE 0x07
-
-#    define IS31_REG_BREATHCTRL1 0x08
-// D6:D4 fade out time (26ms*2^i)
-// D2:D0 fade in time (26ms*2^i)
-
-#    define IS31_REG_BREATHCTRL2 0x09
-#    define IS31_REG_BREATHCTRL2_ENABLE 0x10
-// D2:D0 extinguish time (3.5ms*2^i)
-
-#    define IS31_REG_SHUTDOWN 0x0A
-#    define IS31_REG_SHUTDOWN_OFF 0x0
-#    define IS31_REG_SHUTDOWN_ON 0x1
-
-#    define IS31_REG_AGCCTRL 0x0B
-#    define IS31_REG_ADCRATE 0x0C
-
-#    define IS31_COMMANDREGISTER 0xFD
-#    define IS31_FUNCTIONREG 0x0B  // helpfully called 'page nine'
-#    define IS31_FUNCTIONREG_SIZE 0xD
-
-#    define IS31_FRAME_SIZE 0xB4
-
-#    define IS31_PWM_REG 0x24
-#    define IS31_PWM_SIZE 0x90
-
-#    define IS31_LED_MASK_SIZE 0x12
-
-#    define IS31
-
-/*===========================================================================*/
-/* Driver local functions.                                                   */
-/*===========================================================================*/
-
-typedef struct {
-    uint8_t write_buffer_offset;
-    uint8_t write_buffer[IS31_FRAME_SIZE];
-    uint8_t frame_buffer[GDISP_SCREEN_HEIGHT * GDISP_SCREEN_WIDTH];
-    uint8_t page;
-} __attribute__((__packed__)) PrivData;
-
-// Some common routines and macros
-#    define PRIV(g) ((PrivData *)g->priv)
-
-/*===========================================================================*/
-/* Driver exported functions.                                                */
-/*===========================================================================*/
-
-static GFXINLINE void write_page(GDisplay *g, uint8_t page) {
-    uint8_t tx[2] __attribute__((aligned(2)));
-    tx[0] = IS31_COMMANDREGISTER;
-    tx[1] = page;
-    write_data(g, tx, 2);
-}
-
-static GFXINLINE void write_register(GDisplay *g, uint8_t page, uint8_t reg, uint8_t data) {
-    uint8_t tx[2] __attribute__((aligned(2)));
-    tx[0] = reg;
-    tx[1] = data;
-    write_page(g, page);
-    write_data(g, tx, 2);
-}
-
-static GFXINLINE void write_ram(GDisplay *g, uint8_t page, uint16_t offset, uint16_t length) {
-    PRIV(g)->write_buffer_offset = offset;
-    write_page(g, page);
-    write_data(g, (uint8_t *)PRIV(g), length + 1);
-}
-
-LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
-    // The private area is the display surface.
-    g->priv = gfxAlloc(sizeof(PrivData));
-    __builtin_memset(PRIV(g), 0, sizeof(PrivData));
-    PRIV(g)->page = 0;
-
-    // Initialise the board interface
-    init_board(g);
-    gfxSleepMilliseconds(10);
-
-    // zero function page, all registers (assuming full_page is all zeroes)
-    write_ram(g, IS31_FUNCTIONREG, 0, IS31_FUNCTIONREG_SIZE);
-    set_hardware_shutdown(g, false);
-    gfxSleepMilliseconds(10);
-    // software shutdown
-    write_register(g, IS31_FUNCTIONREG, IS31_REG_SHUTDOWN, IS31_REG_SHUTDOWN_OFF);
-    gfxSleepMilliseconds(10);
-    // zero function page, all registers
-    write_ram(g, IS31_FUNCTIONREG, 0, IS31_FUNCTIONREG_SIZE);
-    gfxSleepMilliseconds(10);
-
-    // zero all LED registers on all 8 pages, and enable the mask
-    __builtin_memcpy(PRIV(g)->write_buffer, get_led_mask(g), IS31_LED_MASK_SIZE);
-    for (uint8_t i = 0; i < 8; i++) {
-        write_ram(g, i, 0, IS31_FRAME_SIZE);
-        gfxSleepMilliseconds(1);
-    }
-
-    // software shutdown disable (i.e. turn stuff on)
-    write_register(g, IS31_FUNCTIONREG, IS31_REG_SHUTDOWN, IS31_REG_SHUTDOWN_OFF);
-    gfxSleepMilliseconds(10);
-
-    // Finish Init
-    post_init_board(g);
-
-    /* Initialise the GDISP structure */
-    g->g.Width       = GDISP_SCREEN_WIDTH;
-    g->g.Height      = GDISP_SCREEN_HEIGHT;
-    g->g.Orientation = GDISP_ROTATE_0;
-    g->g.Powermode   = powerOff;
-    g->g.Backlight   = GDISP_INITIAL_BACKLIGHT;
-    g->g.Contrast    = GDISP_INITIAL_CONTRAST;
-    return TRUE;
-}
-
-#    if GDISP_HARDWARE_FLUSH
-LLDSPEC void gdisp_lld_flush(GDisplay *g) {
-    // Don't flush if we don't need it.
-    if (!(g->flags & GDISP_FLG_NEEDFLUSH)) return;
-
-    PRIV(g)->page++;
-    PRIV(g)->page %= 2;
-    // TODO: some smarter algorithm for this
-    // We should run only one physical page at a time
-    // This way we don't need to send so much data, and
-    // we could use slightly less memory
-    uint8_t *src = PRIV(g)->frame_buffer;
-    for (int y = 0; y < GDISP_SCREEN_HEIGHT; y++) {
-        for (int x = 0; x < GDISP_SCREEN_WIDTH; x++) {
-            uint8_t val                                     = (uint16_t)*src * g->g.Backlight / 100;
-            PRIV(g)->write_buffer[get_led_address(g, x, y)] = CIE1931_CURVE[val];
-            ++src;
-        }
-    }
-    write_ram(g, PRIV(g)->page, IS31_PWM_REG, IS31_PWM_SIZE);
-    gfxSleepMilliseconds(1);
-    write_register(g, IS31_FUNCTIONREG, IS31_REG_PICTDISP, PRIV(g)->page);
-
-    g->flags &= ~GDISP_FLG_NEEDFLUSH;
-}
-#    endif
-
-#    if GDISP_HARDWARE_DRAWPIXEL
-LLDSPEC void gdisp_lld_draw_pixel(GDisplay *g) {
-    coord_t x, y;
-
-    switch (g->g.Orientation) {
-        default:
-        case GDISP_ROTATE_0:
-            x = g->p.x;
-            y = g->p.y;
-            break;
-        case GDISP_ROTATE_180:
-            x = GDISP_SCREEN_WIDTH - 1 - g->p.x;
-            y = g->p.y;
-            break;
-    }
-    PRIV(g)->frame_buffer[y * GDISP_SCREEN_WIDTH + x] = gdispColor2Native(g->p.color);
-    g->flags |= GDISP_FLG_NEEDFLUSH;
-}
-#    endif
-
-#    if GDISP_HARDWARE_PIXELREAD
-LLDSPEC color_t gdisp_lld_get_pixel_color(GDisplay *g) {
-    coord_t x, y;
-
-    switch (g->g.Orientation) {
-        default:
-        case GDISP_ROTATE_0:
-            x = g->p.x;
-            y = g->p.y;
-            break;
-        case GDISP_ROTATE_180:
-            x = GDISP_SCREEN_WIDTH - 1 - g->p.x;
-            y = g->p.y;
-            break;
-    }
-    return gdispNative2Color(PRIV(g)->frame_buffer[y * GDISP_SCREEN_WIDTH + x]);
-}
-#    endif
-
-#    if GDISP_NEED_CONTROL && GDISP_HARDWARE_CONTROL
-LLDSPEC void gdisp_lld_control(GDisplay *g) {
-    switch (g->p.x) {
-        case GDISP_CONTROL_POWER:
-            if (g->g.Powermode == (powermode_t)g->p.ptr) return;
-            switch ((powermode_t)g->p.ptr) {
-                case powerOff:
-                case powerSleep:
-                case powerDeepSleep:
-                    write_register(g, IS31_FUNCTIONREG, IS31_REG_SHUTDOWN, IS31_REG_SHUTDOWN_OFF);
-                    break;
-                case powerOn:
-                    write_register(g, IS31_FUNCTIONREG, IS31_REG_SHUTDOWN, IS31_REG_SHUTDOWN_ON);
-                    break;
-                default:
-                    return;
-            }
-            g->g.Powermode = (powermode_t)g->p.ptr;
-            return;
-
-        case GDISP_CONTROL_ORIENTATION:
-            if (g->g.Orientation == (orientation_t)g->p.ptr) return;
-            switch ((orientation_t)g->p.ptr) {
-                /* Rotation is handled by the drawing routines */
-                case GDISP_ROTATE_0:
-                case GDISP_ROTATE_180:
-                    g->g.Height = GDISP_SCREEN_HEIGHT;
-                    g->g.Width  = GDISP_SCREEN_WIDTH;
-                    break;
-                case GDISP_ROTATE_90:
-                case GDISP_ROTATE_270:
-                    g->g.Height = GDISP_SCREEN_WIDTH;
-                    g->g.Width  = GDISP_SCREEN_HEIGHT;
-                    break;
-                default:
-                    return;
-            }
-            g->g.Orientation = (orientation_t)g->p.ptr;
-            return;
-
-        case GDISP_CONTROL_BACKLIGHT:
-            if (g->g.Backlight == (unsigned)g->p.ptr) return;
-            unsigned val   = (unsigned)g->p.ptr;
-            g->g.Backlight = val > 100 ? 100 : val;
-            g->flags |= GDISP_FLG_NEEDFLUSH;
-            return;
-    }
-}
-#    endif  // GDISP_NEED_CONTROL
-
-#endif  // GFX_USE_GDISP
--- a/drivers/ugfx/gdisp/is31fl3731c/gdisp_lld_config.h
+++ b/drivers/ugfx/gdisp/is31fl3731c/gdisp_lld_config.h
@ -1,36 +0,0 @@
-/*
-Copyright 2016 Fred Sundvik <fsundvik@gmail.com>
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _GDISP_LLD_CONFIG_H
-#define _GDISP_LLD_CONFIG_H
-
-#if GFX_USE_GDISP
-
-/*===========================================================================*/
-/* Driver hardware support.                                                  */
-/*===========================================================================*/
-
-#    define GDISP_HARDWARE_FLUSH GFXON  // This controller requires flushing
-#    define GDISP_HARDWARE_DRAWPIXEL GFXON
-#    define GDISP_HARDWARE_PIXELREAD GFXON
-#    define GDISP_HARDWARE_CONTROL GFXON
-
-#    define GDISP_LLD_PIXELFORMAT GDISP_PIXELFORMAT_GRAY256
-
-#endif /* GFX_USE_GDISP */
-
-#endif /* _GDISP_LLD_CONFIG_H */
--- a/drivers/ugfx/gdisp/st7565/board_st7565_template.h
+++ b/drivers/ugfx/gdisp/st7565/board_st7565_template.h
@ -1,96 +0,0 @@
-/*
- * This file is subject to the terms of the GFX License. If a copy of
- * the license was not distributed with this file, you can obtain one at:
- *
- *              http://ugfx.org/license.html
- */
-
-#ifndef _GDISP_LLD_BOARD_H
-#define _GDISP_LLD_BOARD_H
-
-#include "quantum.h"
-
-#define ST7565_LCD_BIAS ST7565_LCD_BIAS_7
-#define ST7565_COM_SCAN ST7565_COM_SCAN_DEC
-#define ST7565_PAGE_ORDER 0, 1, 2, 3
-/*
- * Custom page order for several LCD boards, e.g. HEM12864-99
- * #define ST7565_PAGE_ORDER       4,5,6,7,0,1,2,3
- */
-
-#define ST7565_A0_PIN C7
-#define ST7565_RST_PIN C8
-#define ST7565_MOSI_PIN C6
-#define ST7565_SCLK_PIN C5
-#define ST7565_SS_PIN C4
-
-// DSPI Clock and Transfer Attributes
-// Frame Size: 8 bits
-// MSB First
-// CLK Low by default
-static const SPIConfig spi1config = {
-    // Operation complete callback or @p NULL.
-    .end_cb = NULL,
-    // The chip select line port - when not using pcs.
-    .ssport = PAL_PORT(ST7565_SS_PIN),
-    // brief The chip select line pad number - when not using pcs.
-    .sspad = PAL_PAD(ST7565_SS_PIN),
-    // SPI initialization data.
-    .tar0 = SPIx_CTARn_FMSZ(7)     // Frame size = 8 bytes
-            | SPIx_CTARn_ASC(1)    // After SCK Delay Scaler (min 50 ns) = 55.56ns
-            | SPIx_CTARn_DT(0)     // Delay After Transfer Scaler (no minimum)= 27.78ns
-            | SPIx_CTARn_CSSCK(0)  // PCS to SCK Delay Scaler (min 20 ns) = 27.78ns
-            | SPIx_CTARn_PBR(0)    // Baud Rate Prescaler = 2
-            | SPIx_CTARn_BR(0)     // Baud rate (min 50ns) = 55.56ns
-};
-
-static GFXINLINE void acquire_bus(GDisplay *g) {
-    (void)g;
-    // Only the LCD is using the SPI bus, so no need to acquire
-    // spiAcquireBus(&SPID1);
-    spiSelect(&SPID1);
-}
-
-static GFXINLINE void release_bus(GDisplay *g) {
-    (void)g;
-    // Only the LCD is using the SPI bus, so no need to release
-    // spiReleaseBus(&SPID1);
-    spiUnselect(&SPID1);
-}
-
-static GFXINLINE void init_board(GDisplay *g) {
-    (void)g;
-    setPinOutput(ST7565_A0_PIN);
-    writePinHigh(ST7565_A0_PIN);
-    setPinOutput(ST7565_RST_PIN);
-    writePinHigh(ST7565_RST_PIN);
-    setPinOutput(ST7565_SS_PIN);
-
-    palSetPadMode(PAL_PORT(ST7565_MOSI_PIN), PAL_PAD(ST7565_MOSI_PIN), PAL_MODE_ALTERNATIVE_2);
-    palSetPadMode(PAL_PORT(ST7565_SCLK_PIN), PAL_PAD(ST7565_SCLK_PIN), PAL_MODE_ALTERNATIVE_2);
-
-    spiInit();
-    spiStart(&SPID1, &spi1config);
-    release_bus(g);
-}
-
-static GFXINLINE void post_init_board(GDisplay *g) { (void)g; }
-
-static GFXINLINE void setpin_reset(GDisplay *g, bool_t state) {
-    (void)g;
-    writePin(ST7565_RST_PIN, !state);
-}
-
-static GFXINLINE void write_cmd(GDisplay *g, gU8 cmd) {
-    (void)g;
-    writePinLow(ST7565_A0_PIN);
-    spiSend(&SPID1, 1, &cmd);
-}
-
-static GFXINLINE void write_data(GDisplay *g, gU8 *data, gU16 length) {
-    (void)g;
-    writePinHigh(ST7565_A0_PIN);
-    spiSend(&SPID1, length, data);
-}
-
-#endif /* _GDISP_LLD_BOARD_H */
--- a/drivers/ugfx/gdisp/st7565/driver.mk
+++ b/drivers/ugfx/gdisp/st7565/driver.mk
@ -1,3 +0,0 @@
-GFXINC += drivers/ugfx/gdisp/st7565
-GFXSRC += drivers/ugfx/gdisp/st7565/gdisp_lld_ST7565.c
-GDISP_DRIVER_LIST += GDISPVMT_ST7565_QMK
--- a/drivers/ugfx/gdisp/st7565/gdisp_lld_ST7565.c
+++ b/drivers/ugfx/gdisp/st7565/gdisp_lld_ST7565.c
@ -1,314 +0,0 @@
-/*
- * This file is subject to the terms of the GFX License. If a copy of
- * the license was not distributed with this file, you can obtain one at:
- *
- *              http://ugfx.org/license.html
- */
-
-#include "gfx.h"
-
-#if GFX_USE_GDISP
-
-#    define GDISP_DRIVER_VMT GDISPVMT_ST7565_QMK
-#    include "gdisp_lld_config.h"
-#    include "src/gdisp/gdisp_driver.h"
-
-#    include "board_st7565.h"
-
-/*===========================================================================*/
-/* Driver local definitions.                                                 */
-/*===========================================================================*/
-
-#    ifndef GDISP_SCREEN_HEIGHT
-#        define GDISP_SCREEN_HEIGHT LCD_HEIGHT
-#    endif
-#    ifndef GDISP_SCREEN_WIDTH
-#        define GDISP_SCREEN_WIDTH LCD_WIDTH
-#    endif
-#    ifndef GDISP_INITIAL_CONTRAST
-#        define GDISP_INITIAL_CONTRAST 35
-#    endif
-#    ifndef GDISP_INITIAL_BACKLIGHT
-#        define GDISP_INITIAL_BACKLIGHT 100
-#    endif
-
-#    define GDISP_FLG_NEEDFLUSH (GDISP_FLG_DRIVER << 0)
-
-#    include "st7565.h"
-
-/*===========================================================================*/
-/* Driver config defaults for backward compatibility.                        */
-/*===========================================================================*/
-#    ifndef ST7565_LCD_BIAS
-#        define ST7565_LCD_BIAS ST7565_LCD_BIAS_7
-#    endif
-#    ifndef ST7565_ADC
-#        define ST7565_ADC ST7565_ADC_NORMAL
-#    endif
-#    ifndef ST7565_COM_SCAN
-#        define ST7565_COM_SCAN ST7565_COM_SCAN_INC
-#    endif
-#    ifndef ST7565_PAGE_ORDER
-#        define ST7565_PAGE_ORDER 0, 1, 2, 3, 4, 5, 6, 7
-#    endif
-
-/*===========================================================================*/
-/* Driver local functions.                                                   */
-/*===========================================================================*/
-
-// Some common routines and macros
-#    define RAM(g) ((gU8 *)g->priv)
-#    define write_cmd2(g, cmd1, cmd2) \
-        {                             \
-            write_cmd(g, cmd1);       \
-            write_cmd(g, cmd2);       \
-        }
-#    define write_cmd3(g, cmd1, cmd2, cmd3) \
-        {                                   \
-            write_cmd(g, cmd1);             \
-            write_cmd(g, cmd2);             \
-            write_cmd(g, cmd3);             \
-        }
-
-// Some common routines and macros
-#    define delay(us) gfxSleepMicroseconds(us)
-#    define delay_ms(ms) gfxSleepMilliseconds(ms)
-
-#    define xyaddr(x, y) ((x) + ((y) >> 3) * GDISP_SCREEN_WIDTH)
-#    define xybit(y) (1 << ((y)&7))
-
-/*===========================================================================*/
-/* Driver exported functions.                                                */
-/*===========================================================================*/
-
-/*
- * As this controller can't update on a pixel boundary we need to maintain the
- * the entire display surface in memory so that we can do the necessary bit
- * operations. Fortunately it is a small display in monochrome.
- * 64 * 128 / 8 = 1024 bytes.
- */
-
-LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
-    // The private area is the display surface.
-    g->priv = gfxAlloc(GDISP_SCREEN_HEIGHT * GDISP_SCREEN_WIDTH / 8);
-    if (!g->priv) {
-        return gFalse;
-    }
-
-    // Initialise the board interface
-    init_board(g);
-
-    // Hardware reset
-    setpin_reset(g, TRUE);
-    gfxSleepMilliseconds(20);
-    setpin_reset(g, FALSE);
-    gfxSleepMilliseconds(20);
-    acquire_bus(g);
-
-    write_cmd(g, ST7565_LCD_BIAS);
-    write_cmd(g, ST7565_ADC);
-    write_cmd(g, ST7565_COM_SCAN);
-
-    write_cmd(g, ST7565_START_LINE | 0);
-
-    write_cmd2(g, ST7565_CONTRAST, GDISP_INITIAL_CONTRAST * 64 / 101);
-    write_cmd(g, ST7565_RESISTOR_RATIO | 0x1);
-
-    // turn on voltage converter (VC=1, VR=0, VF=0)
-    write_cmd(g, ST7565_POWER_CONTROL | 0x04);
-    delay_ms(50);
-
-    // turn on voltage regulator (VC=1, VR=1, VF=0)
-    write_cmd(g, ST7565_POWER_CONTROL | 0x06);
-    delay_ms(50);
-
-    // turn on voltage follower (VC=1, VR=1, VF=1)
-    write_cmd(g, ST7565_POWER_CONTROL | 0x07);
-    delay_ms(50);
-
-    write_cmd(g, ST7565_DISPLAY_ON);
-    write_cmd(g, ST7565_ALLON_NORMAL);
-    write_cmd(g, ST7565_INVERT_DISPLAY);  // Disable Inversion of display.
-
-    write_cmd(g, ST7565_RMW);
-
-    // Finish Init
-    post_init_board(g);
-
-    // Release the bus
-    release_bus(g);
-
-    /* Initialise the GDISP structure */
-    g->g.Width       = GDISP_SCREEN_WIDTH;
-    g->g.Height      = GDISP_SCREEN_HEIGHT;
-    g->g.Orientation = GDISP_ROTATE_0;
-    g->g.Powermode   = powerOff;
-    g->g.Backlight   = GDISP_INITIAL_BACKLIGHT;
-    g->g.Contrast    = GDISP_INITIAL_CONTRAST;
-    return TRUE;
-}
-
-#    if GDISP_HARDWARE_FLUSH
-LLDSPEC void gdisp_lld_flush(GDisplay *g) {
-    unsigned p;
-
-    // Don't flush if we don't need it.
-    if (!(g->flags & GDISP_FLG_NEEDFLUSH)) return;
-
-    acquire_bus(g);
-    gU8 pagemap[] = {ST7565_PAGE_ORDER};
-    for (p = 0; p < sizeof(pagemap); p++) {
-        write_cmd(g, ST7565_PAGE | pagemap[p]);
-        write_cmd(g, ST7565_COLUMN_MSB | 0);
-        write_cmd(g, ST7565_COLUMN_LSB | 0);
-        write_cmd(g, ST7565_RMW);
-        write_data(g, RAM(g) + (p * GDISP_SCREEN_WIDTH), GDISP_SCREEN_WIDTH);
-    }
-    release_bus(g);
-
-    g->flags &= ~GDISP_FLG_NEEDFLUSH;
-}
-#    endif
-
-#    if GDISP_HARDWARE_DRAWPIXEL
-LLDSPEC void gdisp_lld_draw_pixel(GDisplay *g) {
-    coord_t x, y;
-
-    switch (g->g.Orientation) {
-        default:
-        case GDISP_ROTATE_0:
-            x = g->p.x;
-            y = g->p.y;
-            break;
-        case GDISP_ROTATE_90:
-            x = g->p.y;
-            y = GDISP_SCREEN_HEIGHT - 1 - g->p.x;
-            break;
-        case GDISP_ROTATE_180:
-            x = GDISP_SCREEN_WIDTH - 1 - g->p.x;
-            y = GDISP_SCREEN_HEIGHT - 1 - g->p.y;
-            break;
-        case GDISP_ROTATE_270:
-            x = GDISP_SCREEN_HEIGHT - 1 - g->p.y;
-            y = g->p.x;
-            break;
-    }
-    if (gdispColor2Native(g->p.color) != Black)
-        RAM(g)[xyaddr(x, y)] |= xybit(y);
-    else
-        RAM(g)[xyaddr(x, y)] &= ~xybit(y);
-    g->flags |= GDISP_FLG_NEEDFLUSH;
-}
-#    endif
-
-#    if GDISP_HARDWARE_PIXELREAD
-LLDSPEC color_t gdisp_lld_get_pixel_color(GDisplay *g) {
-    coord_t x, y;
-
-    switch (g->g.Orientation) {
-        default:
-        case GDISP_ROTATE_0:
-            x = g->p.x;
-            y = g->p.y;
-            break;
-        case GDISP_ROTATE_90:
-            x = g->p.y;
-            y = GDISP_SCREEN_HEIGHT - 1 - g->p.x;
-            break;
-        case GDISP_ROTATE_180:
-            x = GDISP_SCREEN_WIDTH - 1 - g->p.x;
-            y = GDISP_SCREEN_HEIGHT - 1 - g->p.y;
-            break;
-        case GDISP_ROTATE_270:
-            x = GDISP_SCREEN_HEIGHT - 1 - g->p.y;
-            y = g->p.x;
-            break;
-    }
-    return (RAM(g)[xyaddr(x, y)] & xybit(y)) ? White : Black;
-}
-#    endif
-
-#    if GDISP_HARDWARE_BITFILLS
-LLDSPEC void gdisp_lld_blit_area(GDisplay *g) {
-    uint8_t *buffer     = (uint8_t *)g->p.ptr;
-    int      linelength = g->p.cx;
-    for (int i = 0; i < g->p.cy; i++) {
-        unsigned dstx   = g->p.x;
-        unsigned dsty   = g->p.y + i;
-        unsigned srcx   = g->p.x1;
-        unsigned srcy   = g->p.y1 + i;
-        unsigned srcbit = srcy * g->p.x2 + srcx;
-        for (int j = 0; j < linelength; j++) {
-            uint8_t  src    = buffer[srcbit / 8];
-            uint8_t  bit    = 7 - (srcbit % 8);
-            uint8_t  bitset = (src >> bit) & 1;
-            uint8_t *dst    = &(RAM(g)[xyaddr(dstx, dsty)]);
-            if (bitset) {
-                *dst |= xybit(dsty);
-            } else {
-                *dst &= ~xybit(dsty);
-            }
-            dstx++;
-            srcbit++;
-        }
-    }
-    g->flags |= GDISP_FLG_NEEDFLUSH;
-}
-#    endif
-
-#    if GDISP_NEED_CONTROL && GDISP_HARDWARE_CONTROL
-LLDSPEC void gdisp_lld_control(GDisplay *g) {
-    switch (g->p.x) {
-        case GDISP_CONTROL_POWER:
-            if (g->g.Powermode == (powermode_t)g->p.ptr) return;
-            switch ((powermode_t)g->p.ptr) {
-                case powerOff:
-                case powerSleep:
-                case powerDeepSleep:
-                    acquire_bus(g);
-                    write_cmd(g, ST7565_DISPLAY_OFF);
-                    release_bus(g);
-                    break;
-                case powerOn:
-                    acquire_bus(g);
-                    write_cmd(g, ST7565_DISPLAY_ON);
-                    release_bus(g);
-                    break;
-                default:
-                    return;
-            }
-            g->g.Powermode = (powermode_t)g->p.ptr;
-            return;
-
-        case GDISP_CONTROL_ORIENTATION:
-            if (g->g.Orientation == (orientation_t)g->p.ptr) return;
-            switch ((orientation_t)g->p.ptr) {
-                /* Rotation is handled by the drawing routines */
-                case GDISP_ROTATE_0:
-                case GDISP_ROTATE_180:
-                    g->g.Height = GDISP_SCREEN_HEIGHT;
-                    g->g.Width  = GDISP_SCREEN_WIDTH;
-                    break;
-                case GDISP_ROTATE_90:
-                case GDISP_ROTATE_270:
-                    g->g.Height = GDISP_SCREEN_WIDTH;
-                    g->g.Width  = GDISP_SCREEN_HEIGHT;
-                    break;
-                default:
-                    return;
-            }
-            g->g.Orientation = (orientation_t)g->p.ptr;
-            return;
-
-        case GDISP_CONTROL_CONTRAST:
-            if ((unsigned)g->p.ptr > 100) g->p.ptr = (void *)100;
-            acquire_bus(g);
-            write_cmd2(g, ST7565_CONTRAST, ((((unsigned)g->p.ptr) << 6) / 101) & 0x3F);
-            release_bus(g);
-            g->g.Contrast = (unsigned)g->p.ptr;
-            return;
-    }
-}
-#    endif  // GDISP_NEED_CONTROL
-
-#endif  // GFX_USE_GDISP
--- a/drivers/ugfx/gdisp/st7565/gdisp_lld_config.h
+++ b/drivers/ugfx/gdisp/st7565/gdisp_lld_config.h
@ -1,27 +0,0 @@
-/*
- * This file is subject to the terms of the GFX License. If a copy of
- * the license was not distributed with this file, you can obtain one at:
- *
- *              http://ugfx.org/license.html
- */
-
-#ifndef _GDISP_LLD_CONFIG_H
-#define _GDISP_LLD_CONFIG_H
-
-#if GFX_USE_GDISP
-
-/*===========================================================================*/
-/* Driver hardware support.                                                  */
-/*===========================================================================*/
-
-#    define GDISP_HARDWARE_FLUSH GFXON  // This controller requires flushing
-#    define GDISP_HARDWARE_DRAWPIXEL GFXON
-#    define GDISP_HARDWARE_PIXELREAD GFXON
-#    define GDISP_HARDWARE_CONTROL GFXON
-#    define GDISP_HARDWARE_BITFILLS GFXON
-
-#    define GDISP_LLD_PIXELFORMAT GDISP_PIXELFORMAT_MONO
-
-#endif /* GFX_USE_GDISP */
-
-#endif /* _GDISP_LLD_CONFIG_H */
--- a/drivers/ugfx/gdisp/st7565/st7565.h
+++ b/drivers/ugfx/gdisp/st7565/st7565.h
@ -1,39 +0,0 @@
-/*
- * This file is subject to the terms of the GFX License. If a copy of
- * the license was not distributed with this file, you can obtain one at:
- *
- *              http://ugfx.org/license.html
- */
-
-#ifndef _ST7565_H
-#define _ST7565_H
-
-#define ST7565_CONTRAST 0x81
-#define ST7565_ALLON_NORMAL 0xA4
-#define ST7565_ALLON 0xA5
-#define ST7565_POSITIVE_DISPLAY 0xA6
-#define ST7565_INVERT_DISPLAY 0xA7
-#define ST7565_DISPLAY_OFF 0xAE
-#define ST7565_DISPLAY_ON 0xAF
-
-#define ST7565_LCD_BIAS_7 0xA3
-#define ST7565_LCD_BIAS_9 0xA2
-
-#define ST7565_ADC_NORMAL 0xA0
-#define ST7565_ADC_REVERSE 0xA1
-
-#define ST7565_COM_SCAN_INC 0xC0
-#define ST7565_COM_SCAN_DEC 0xC8
-
-#define ST7565_START_LINE 0x40
-#define ST7565_PAGE 0xB0
-#define ST7565_COLUMN_MSB 0x10
-#define ST7565_COLUMN_LSB 0x00
-#define ST7565_RMW 0xE0
-
-#define ST7565_RESISTOR_RATIO 0x20
-#define ST7565_POWER_CONTROL 0x28
-
-#define ST7565_RESET 0xE2
-
-#endif /* _ST7565_H */
--- a/keyboards/ergodox_infinity/board_is31fl3731c.h
+++ b/keyboards/ergodox_infinity/board_is31fl3731c.h
@ -1,110 +0,0 @@
-/*
-Copyright 2016 Fred Sundvik <fsundvik@gmail.com>
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _GDISP_LLD_BOARD_H
-#define _GDISP_LLD_BOARD_H
-
-static const I2CConfig i2ccfg = {
-  400000 // clock speed (Hz); 400kHz max for IS31
-};
-
-static const uint8_t led_mask[] = {
-	0xFF, 0x00, /* C1-1 -> C1-16 */
-	0xFF, 0x00, /* C2-1 -> C2-16 */
-	0xFF, 0x00, /* C3-1 -> C3-16 */
-	0xFF, 0x00, /* C4-1 -> C4-16 */
-	0x3F, 0x00, /* C5-1 -> C5-16 */
-	0x00, 0x00, /* C6-1 -> C6-16 */
-	0x00, 0x00, /* C7-1 -> C7-16 */
-	0x00, 0x00, /* C8-1 -> C8-16 */
-	0x00, 0x00, /* C9-1 -> C9-16 */
-};
-
-// The address of the LED
-#define LA(c, r) (c + r * 16 )
-// Need to be an address that is not mapped, but inside the range of the controller matrix
-#define NA LA(8, 8)
-
-// The numbers in the comments are the led numbers DXX on the PCB
-// The mapping is taken from the schematic of left hand side
-static const uint8_t led_mapping[GDISP_SCREEN_HEIGHT][GDISP_SCREEN_WIDTH] = {
-//   45        44        43        42        41        40        39
-   { LA(1, 1), LA(1, 0), LA(0, 4), LA(0, 3), LA(0, 2), LA(0, 1), LA(0, 0)},
-//   52        51        50        49        48        47        46
-   { LA(2, 3), LA(2, 2), LA(2, 1), LA(2, 0), LA(1, 4), LA(1, 3), LA(1, 2) },
-//   58        57        56        55        54        53        N/A
-   { LA(3, 4), LA(3, 3), LA(3, 2), LA(3, 1), LA(3, 0), LA(2, 4), NA },
-//   67        66        65        64        63        62        61
-   { LA(5, 3), LA(5, 2), LA(5, 1), LA(5, 0), LA(4, 4), LA(4, 3), LA(4, 2) },
-//   76        75        74        73        72        60        59
-   { LA(7, 3), LA(7, 2), LA(7, 1), LA(7, 0), LA(6, 3), LA(4, 1), LA(4, 0) },
-//   N/A       N/A       N/A       N/A       N/A       N/A       68
-   { NA,       NA,       NA,       NA,       NA,       NA,       LA(5, 4) },
-//   N/A       N/A       N/A       N/A       71        70        69
-   { NA,       NA,       NA,       NA,       LA(6, 2), LA(6, 1), LA(6, 0) },
-};
-
-
-#define IS31_ADDR_DEFAULT 0x74 // AD connected to GND
-#define IS31_TIMEOUT 5000
-
-static GFXINLINE void init_board(GDisplay *g) {
-    (void) g;
-    /* I2C pins */
-    palSetPadMode(GPIOB, 0, PAL_MODE_ALTERNATIVE_2); // PTB0/I2C0/SCL
-    palSetPadMode(GPIOB, 1, PAL_MODE_ALTERNATIVE_2); // PTB1/I2C0/SDA
-    palSetPadMode(GPIOB, 16, PAL_MODE_OUTPUT_PUSHPULL);
-    palClearPad(GPIOB, 16);
-    /* start I2C */
-    i2cStart(&I2CD1, &i2ccfg);
-    // try high drive (from kiibohd)
-    I2CD1.i2c->C2 |= I2Cx_C2_HDRS;
-    // try glitch fixing (from kiibohd)
-    I2CD1.i2c->FLT = 4;
-}
-
-static GFXINLINE void post_init_board(GDisplay *g) {
-	(void) g;
-}
-
-static GFXINLINE const uint8_t* get_led_mask(GDisplay* g) {
-    (void) g;
-    return led_mask;
-}
-
-static GFXINLINE uint8_t get_led_address(GDisplay* g, uint16_t x, uint16_t y)
-{
-    (void) g;
-    return led_mapping[y][x];
-}
-
-static GFXINLINE void set_hardware_shutdown(GDisplay* g, bool shutdown) {
-    (void) g;
-    if(!shutdown) {
-        palSetPad(GPIOB, 16);
-    }
-    else {
-        palClearPad(GPIOB, 16);
-    }
-}
-
-static GFXINLINE void write_data(GDisplay *g, uint8_t* data, uint16_t length) {
-	(void) g;
-	i2cMasterTransmitTimeout(&I2CD1, IS31_ADDR_DEFAULT, data, length, 0, 0, TIME_US2I(IS31_TIMEOUT));
-}
-
-#endif /* _GDISP_LLD_BOARD_H */
--- a/keyboards/ergodox_infinity/board_st7565.h
+++ b/keyboards/ergodox_infinity/board_st7565.h
@ -1,96 +0,0 @@
-/*
- * This file is subject to the terms of the GFX License. If a copy of
- * the license was not distributed with this file, you can obtain one at:
- *
- *              http://ugfx.org/license.html
- */
-
-#ifndef _GDISP_LLD_BOARD_H
-#define _GDISP_LLD_BOARD_H
-
-#include "quantum.h"
-
-#define ST7565_LCD_BIAS ST7565_LCD_BIAS_7
-#define ST7565_COM_SCAN ST7565_COM_SCAN_DEC
-#define ST7565_PAGE_ORDER 0, 1, 2, 3
-/*
- * Custom page order for several LCD boards, e.g. HEM12864-99
- * #define ST7565_PAGE_ORDER       4,5,6,7,0,1,2,3
- */
-
-#define ST7565_A0_PIN C7
-#define ST7565_RST_PIN C8
-#define ST7565_MOSI_PIN C6
-#define ST7565_SCLK_PIN C5
-#define ST7565_SS_PIN C4
-
-// DSPI Clock and Transfer Attributes
-// Frame Size: 8 bits
-// MSB First
-// CLK Low by default
-static const SPIConfig spi1config = {
-    // Operation complete callback or @p NULL.
-    .end_cb = NULL,
-    // The chip select line port - when not using pcs.
-    .ssport = PAL_PORT(ST7565_SS_PIN),
-    // brief The chip select line pad number - when not using pcs.
-    .sspad = PAL_PAD(ST7565_SS_PIN),
-    // SPI initialization data.
-    .tar0 = SPIx_CTARn_FMSZ(7)     // Frame size = 8 bytes
-            | SPIx_CTARn_ASC(1)    // After SCK Delay Scaler (min 50 ns) = 55.56ns
-            | SPIx_CTARn_DT(0)     // Delay After Transfer Scaler (no minimum)= 27.78ns
-            | SPIx_CTARn_CSSCK(0)  // PCS to SCK Delay Scaler (min 20 ns) = 27.78ns
-            | SPIx_CTARn_PBR(0)    // Baud Rate Prescaler = 2
-            | SPIx_CTARn_BR(0)     // Baud rate (min 50ns) = 55.56ns
-};
-
-static GFXINLINE void acquire_bus(GDisplay *g) {
-    (void)g;
-    // Only the LCD is using the SPI bus, so no need to acquire
-    // spiAcquireBus(&SPID1);
-    spiSelect(&SPID1);
-}
-
-static GFXINLINE void release_bus(GDisplay *g) {
-    (void)g;
-    // Only the LCD is using the SPI bus, so no need to release
-    // spiReleaseBus(&SPID1);
-    spiUnselect(&SPID1);
-}
-
-static GFXINLINE void init_board(GDisplay *g) {
-    (void)g;
-    setPinOutput(ST7565_A0_PIN);
-    writePinHigh(ST7565_A0_PIN);
-    setPinOutput(ST7565_RST_PIN);
-    writePinHigh(ST7565_RST_PIN);
-    setPinOutput(ST7565_SS_PIN);
-
-    palSetPadMode(PAL_PORT(ST7565_MOSI_PIN), PAL_PAD(ST7565_MOSI_PIN), PAL_MODE_ALTERNATIVE_2);
-    palSetPadMode(PAL_PORT(ST7565_SCLK_PIN), PAL_PAD(ST7565_SCLK_PIN), PAL_MODE_ALTERNATIVE_2);
-
-    spiInit();
-    spiStart(&SPID1, &spi1config);
-    release_bus(g);
-}
-
-static GFXINLINE void post_init_board(GDisplay *g) { (void)g; }
-
-static GFXINLINE void setpin_reset(GDisplay *g, bool_t state) {
-    (void)g;
-    writePin(ST7565_RST_PIN, !state);
-}
-
-static GFXINLINE void write_cmd(GDisplay *g, gU8 cmd) {
-    (void)g;
-    writePinLow(ST7565_A0_PIN);
-    spiSend(&SPID1, 1, &cmd);
-}
-
-static GFXINLINE void write_data(GDisplay *g, gU8 *data, gU16 length) {
-    (void)g;
-    writePinHigh(ST7565_A0_PIN);
-    spiSend(&SPID1, length, data);
-}
-
-#endif /* _GDISP_LLD_BOARD_H */
--- a/keyboards/ergodox_infinity/config.h
+++ b/keyboards/ergodox_infinity/config.h
@ -112,8 +112,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 /* Set 0 if debouncing isn't needed */
 #define DEBOUNCE    5

-#define VISUALIZER_USER_DATA_SIZE 16
-
 /*
 * Feature disable options
 *  These options are also useful to firmware size reduction.
--- a/keyboards/ergodox_infinity/ergodox_infinity.c
+++ b/keyboards/ergodox_infinity/ergodox_infinity.c
@ -4,9 +4,6 @@
 #include <string.h>
 #include "eeconfig.h"
 #include "serial_link/system/serial_link.h"
-#ifdef VISUALIZER_ENABLE
-#    include "lcd_backlight.h"
-#endif

 #define RED_PIN 1
 #define GREEN_PIN 2
@ -87,11 +84,7 @@ static uint16_t cie_lightness(uint16_t v) {
    return y * 65535.0f;
 }

-#ifdef VISUALIZER_ENABLE
-void lcd_backlight_hal_color(uint16_t r, uint16_t g, uint16_t b) {
-#else
 void ergodox_infinity_lcd_color(uint16_t r, uint16_t g, uint16_t b) {
-#endif
    CHANNEL_RED.CnV   = cie_lightness(r);
    CHANNEL_GREEN.CnV = cie_lightness(g);
    CHANNEL_BLUE.CnV  = cie_lightness(b);
@ -108,12 +101,10 @@ void keyboard_pre_init_kb() {
    setPinOutput(B16);
    writePinHigh(B16);
 #endif
-#ifndef VISUALIZER_ENABLE
    // The backlight always has to be initialized, otherwise it will stay lit
    lcd_backlight_hal_init();
-#    ifdef ST7565_ENABLE
+#ifdef ST7565_ENABLE
    ergodox_infinity_lcd_color(UINT16_MAX / 2, UINT16_MAX / 2, UINT16_MAX / 2);
-#    endif
 #endif
    keyboard_pre_init_user();
 }
--- a/keyboards/ergodox_infinity/ergodox_infinity.h
+++ b/keyboards/ergodox_infinity/ergodox_infinity.h
@ -79,9 +79,7 @@ inline void ergodox_led_all_set(uint8_t n) {
    ergodox_right_led_3_set(n);
 }

-#ifndef VISUALIZER_ENABLE
 void ergodox_infinity_lcd_color(uint16_t r, uint16_t g, uint16_t b);
-#endif

 #define XXX KC_NO

--- a/keyboards/ergodox_infinity/gfxconf.h
+++ b/keyboards/ergodox_infinity/gfxconf.h
@ -1,27 +0,0 @@
-/**
- * This file has a different license to the rest of the uGFX system.
- * You can copy, modify and distribute this file as you see fit.
- * You do not need to publish your source modifications to this file.
- * The only thing you are not permitted to do is to relicense it
- * under a different license.
- */
-
-/**
- * Copy this file into your project directory and rename it as gfxconf.h
- * Edit your copy to turn on the uGFX features you want to use.
- * The values below are the defaults.
- *
- * Only remove the comments from lines where you want to change the
- * default value. This allows definitions to be included from
- * driver makefiles when required and provides the best future
- * compatibility for your project.
- *
- * Please use spaces instead of tabs in this file.
- */
-
-#ifndef _GFXCONF_H
-#define _GFXCONF_H
-
-#include "common_gfxconf.h"
-
-#endif /* _GFXCONF_H */
--- a/keyboards/ergodox_infinity/rules.mk
+++ b/keyboards/ergodox_infinity/rules.mk
@ -34,11 +34,4 @@ ST7565_ENABLE = yes
 LED_MATRIX_ENABLE = yes
 LED_MATRIX_DRIVER = IS31FL3731

-# Config for Visualizer (set VISUALIZER_ENABLE = yes and ST7565_ENABLE = no to use)
-LCD_ENABLE = yes
-LCD_BACKLIGHT_ENABLE = yes
-LCD_DRIVER = st7565
-LCD_WIDTH = 128
-LCD_HEIGHT = 32
-
 LAYOUTS = ergodox
--- a/keyboards/ergodox_infinity/simple_visualizer.h
+++ b/keyboards/ergodox_infinity/simple_visualizer.h
@ -1,123 +0,0 @@
-/* Copyright 2017 Fred Sundvik
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef KEYBOARDS_ERGODOX_INFINITY_SIMPLE_VISUALIZER_H_
-#define KEYBOARDS_ERGODOX_INFINITY_SIMPLE_VISUALIZER_H_
-
-// Currently we are assuming that both the backlight and LCD are enabled
-// But it's entirely possible to write a custom visualizer that use only
-// one of them
-#ifndef LCD_BACKLIGHT_ENABLE
-#error This visualizer needs that LCD backlight is enabled
-#endif
-
-#ifndef LCD_ENABLE
-#error This visualizer needs that LCD is enabled
-#endif
-
-#include "visualizer.h"
-#include "visualizer_keyframes.h"
-#include "lcd_keyframes.h"
-#include "lcd_backlight_keyframes.h"
-#include "system/serial_link.h"
-#include "led.h"
-#include "default_animations.h"
-
-static const uint32_t logo_background_color = LCD_COLOR(0x00, 0x00, 0xFF);
-static const uint32_t initial_color = LCD_COLOR(0, 0, 0);
-
-static bool initial_update = true;
-
-// Feel free to modify the animations below, or even add new ones if needed
-
-static keyframe_animation_t lcd_layer_display = {
-    .num_frames = 1,
-    .loop = false,
-    .frame_lengths = {gfxMillisecondsToTicks(0)},
-    .frame_functions = {lcd_keyframe_display_layer_and_led_states}
-};
-
-// The color animation animates the LCD color when you change layers
-static keyframe_animation_t color_animation = {
-    .num_frames = 2,
-    .loop = false,
-    // Note that there's a 200 ms no-operation frame,
-    // this prevents the color from changing when activating the layer
-    // momentarily
-    .frame_lengths = {gfxMillisecondsToTicks(200), gfxMillisecondsToTicks(500)},
-    .frame_functions = {keyframe_no_operation, lcd_backlight_keyframe_animate_color},
-};
-
-void initialize_user_visualizer(visualizer_state_t* state) {
-    // The brightness will be dynamically adjustable in the future
-    // But for now, change it here.
-    lcd_backlight_brightness(130);
-    state->current_lcd_color = initial_color;
-    state->target_lcd_color = logo_background_color;
-    initial_update = true;
-    start_keyframe_animation(&default_startup_animation);
-}
-
-
-// This function should be implemented by the keymap visualizer
-// Don't change anything else than state->target_lcd_color and state->layer_text as that's the only thing
-// that the simple_visualizer assumes that you are updating
-// Also make sure that the buffer passed to state->layer_text remains valid until the previous animation is
-// stopped. This can be done by either double buffering it or by using constant strings
-static void get_visualizer_layer_and_color(visualizer_state_t* state);
-
-void update_user_visualizer_state(visualizer_state_t* state, visualizer_keyboard_status_t* prev_status) {
-    // Add more tests, change the colors and layer texts here
-    // Usually you want to check the high bits (higher layers first)
-    // because that's the order layers are processed for keypresses
-    // You can for check for example:
-    // state->status.layer
-    // state->status.default_layer
-    // state->status.leds (see led.h for available statuses)
-
-    uint32_t prev_color = state->target_lcd_color;
-    const char* prev_layer_text = state->layer_text;
-
-    get_visualizer_layer_and_color(state);
-
-    if (initial_update || prev_color != state->target_lcd_color) {
-        start_keyframe_animation(&color_animation);
-    }
-
-    if (initial_update || prev_layer_text != state->layer_text) {
-        start_keyframe_animation(&lcd_layer_display);
-    }
-    // You can also stop existing animations, and start your custom ones here
-    // remember that you should normally have only one animation for the LCD
-    // and one for the background. But you can also combine them if you want.
-}
-
-void user_visualizer_suspend(visualizer_state_t* state) {
-    state->layer_text = "Suspending...";
-    uint8_t hue = LCD_HUE(state->current_lcd_color);
-    uint8_t sat = LCD_SAT(state->current_lcd_color);
-    state->target_lcd_color = LCD_COLOR(hue, sat, 0);
-    start_keyframe_animation(&default_suspend_animation);
-}
-
-void user_visualizer_resume(visualizer_state_t* state) {
-    state->current_lcd_color = initial_color;
-    state->target_lcd_color = logo_background_color;
-    initial_update = true;
-    start_keyframe_animation(&default_startup_animation);
-}
-
-#endif /* KEYBOARDS_ERGODOX_INFINITY_SIMPLE_VISUALIZER_H_ */
--- a/keyboards/ergodox_infinity/visualizer.c
+++ b/keyboards/ergodox_infinity/visualizer.c
@ -1,328 +0,0 @@
-/*
-Copyright 2016 Fred Sundvik <fsundvik@gmail.com>
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-// Currently we are assuming that both the backlight and LCD are enabled
-// But it's entirely possible to write a custom visualizer that use only
-// one of them
-#ifndef LCD_BACKLIGHT_ENABLE
-#error This visualizer needs that LCD backlight is enabled
-#endif
-
-#ifndef LCD_ENABLE
-#error This visualizer needs that LCD is enabled
-#endif
-
-#include "visualizer.h"
-#include "visualizer_keyframes.h"
-#include "lcd_keyframes.h"
-#include "lcd_backlight_keyframes.h"
-#include "default_animations.h"
-
-static const uint32_t logo_background_color = LCD_COLOR(0x00, 0x00, 0xFF);
-static const uint32_t initial_color = LCD_COLOR(0, 0, 0);
-
-static const uint32_t led_emulation_colors[4] = {
-    LCD_COLOR(0, 0, 0),
-    LCD_COLOR(255, 255, 255),
-    LCD_COLOR(84, 255, 255),
-    LCD_COLOR(168, 255, 255),
-};
-
-static uint32_t next_led_target_color = 0;
-
-typedef enum {
-    LCD_STATE_INITIAL,
-    LCD_STATE_LAYER_BITMAP,
-    LCD_STATE_BITMAP_AND_LEDS,
-} lcd_state_t;
-
-static lcd_state_t lcd_state = LCD_STATE_INITIAL;
-
-typedef struct {
-    uint8_t led_on;
-    uint8_t led1;
-    uint8_t led2;
-    uint8_t led3;
-} visualizer_user_data_t;
-
-// Don't access from visualization function, use the visualizer state instead
-static visualizer_user_data_t user_data_keyboard = {
-    .led_on = 0,
-    .led1 = LED_BRIGHTNESS_HI,
-    .led2 = LED_BRIGHTNESS_HI,
-    .led3 = LED_BRIGHTNESS_HI,
-};
-
-_Static_assert(sizeof(visualizer_user_data_t) <= VISUALIZER_USER_DATA_SIZE,
-    "Please increase the VISUALIZER_USER_DATA_SIZE");
-
-// Feel free to modify the animations below, or even add new ones if needed
-
-
-// The color animation animates the LCD color when you change layers
-static keyframe_animation_t one_led_color = {
-    .num_frames = 1,
-    .loop = false,
-    .frame_lengths = {gfxMillisecondsToTicks(0)},
-    .frame_functions = {lcd_backlight_keyframe_set_color},
-};
-
-bool swap_led_target_color(keyframe_animation_t* animation, visualizer_state_t* state) {
-    uint32_t temp = next_led_target_color;
-    next_led_target_color = state->target_lcd_color;
-    state->target_lcd_color = temp;
-    return false;
-}
-
-// The color animation animates the LCD color when you change layers
-static keyframe_animation_t two_led_colors = {
-    .num_frames = 2,
-    .loop = true,
-    .frame_lengths = {gfxMillisecondsToTicks(1000), gfxMillisecondsToTicks(0)},
-    .frame_functions = {lcd_backlight_keyframe_set_color, swap_led_target_color},
-};
-
-// The LCD animation alternates between the layer name display and a
-// bitmap that displays all active layers
-static keyframe_animation_t lcd_bitmap_animation = {
-    .num_frames = 1,
-    .loop = false,
-    .frame_lengths = {gfxMillisecondsToTicks(0)},
-    .frame_functions = {lcd_keyframe_display_layer_bitmap},
-};
-
-static keyframe_animation_t lcd_bitmap_leds_animation = {
-    .num_frames = 2,
-    .loop = true,
-    .frame_lengths = {gfxMillisecondsToTicks(2000), gfxMillisecondsToTicks(2000)},
-    .frame_functions = {lcd_keyframe_display_layer_bitmap, lcd_keyframe_display_led_states},
-};
-
-void initialize_user_visualizer(visualizer_state_t* state) {
-    // The brightness will be dynamically adjustable in the future
-    // But for now, change it here.
-    lcd_backlight_brightness(130);
-    state->current_lcd_color = initial_color;
-    state->target_lcd_color = logo_background_color;
-    lcd_state = LCD_STATE_INITIAL;
-    start_keyframe_animation(&default_startup_animation);
-}
-
-static inline bool is_led_on(visualizer_user_data_t* user_data, uint8_t num) {
-    return user_data->led_on & (1u << num);
-}
-
-static uint8_t get_led_index_master(visualizer_user_data_t* user_data) {
-    for (int i=0; i < 3; i++) {
-        if (is_led_on(user_data, i)) {
-            return i + 1;
-        }
-    }
-    return 0;
-}
-
-static uint8_t get_led_index_slave(visualizer_user_data_t* user_data) {
-    uint8_t master_index = get_led_index_master(user_data);
-    if (master_index!=0) {
-        for (int i=master_index; i < 3; i++) {
-            if (is_led_on(user_data, i)) {
-                return i + 1;
-            }
-        }
-    }
-
-    return 0;
-}
-
-static uint8_t get_secondary_led_index(visualizer_user_data_t* user_data) {
-    if (is_led_on(user_data, 0) &&
-            is_led_on(user_data, 1) &&
-            is_led_on(user_data, 2)) {
-        return 3;
-    }
-    return 0;
-}
-
-static uint8_t get_brightness(visualizer_user_data_t* user_data, uint8_t index) {
-    switch (index) {
-    case 1:
-        return user_data->led1;
-    case 2:
-        return user_data->led2;
-    case 3:
-        return user_data->led3;
-    }
-    return 0;
-}
-
-static void update_emulated_leds(visualizer_state_t* state, visualizer_keyboard_status_t* prev_status) {
-    visualizer_user_data_t* user_data_new = (visualizer_user_data_t*)state->status.user_data;
-    visualizer_user_data_t* user_data_old = (visualizer_user_data_t*)prev_status->user_data;
-
-    uint8_t new_index;
-    uint8_t old_index;
-
-    if (is_keyboard_master()) {
-        new_index = get_led_index_master(user_data_new);
-        old_index = get_led_index_master(user_data_old);
-    }
-    else {
-        new_index = get_led_index_slave(user_data_new);
-        old_index = get_led_index_slave(user_data_old);
-    }
-    uint8_t new_secondary_index = get_secondary_led_index(user_data_new);
-    uint8_t old_secondary_index = get_secondary_led_index(user_data_old);
-
-    uint8_t old_brightness = get_brightness(user_data_old, old_index);
-    uint8_t new_brightness = get_brightness(user_data_new, new_index);
-
-    uint8_t old_secondary_brightness = get_brightness(user_data_old, old_secondary_index);
-    uint8_t new_secondary_brightness = get_brightness(user_data_new, new_secondary_index);
-
-    if (lcd_state == LCD_STATE_INITIAL ||
-            new_index != old_index ||
-            new_secondary_index != old_secondary_index ||
-            new_brightness != old_brightness ||
-            new_secondary_brightness != old_secondary_brightness) {
-
-        if (new_secondary_index != 0) {
-            state->target_lcd_color = change_lcd_color_intensity(
-                led_emulation_colors[new_index], new_brightness);
-            next_led_target_color = change_lcd_color_intensity(
-                led_emulation_colors[new_secondary_index], new_secondary_brightness);
-
-            stop_keyframe_animation(&one_led_color);
-            start_keyframe_animation(&two_led_colors);
-        } else {
-            state->target_lcd_color = change_lcd_color_intensity(
-                led_emulation_colors[new_index], new_brightness);
-            stop_keyframe_animation(&two_led_colors);
-            start_keyframe_animation(&one_led_color);
-        }
-    }
-}
-
-static void update_lcd_text(visualizer_state_t* state, visualizer_keyboard_status_t* prev_status) {
-    if (state->status.leds) {
-        if (lcd_state != LCD_STATE_BITMAP_AND_LEDS ||
-                state->status.leds != prev_status->leds ||
-                state->status.layer != prev_status->layer ||
-                state->status.default_layer != prev_status->default_layer) {
-
-            // NOTE: that it doesn't matter if the animation isn't playing, stop will do nothing in that case
-            stop_keyframe_animation(&lcd_bitmap_animation);
-
-            lcd_state = LCD_STATE_BITMAP_AND_LEDS;
-            // For information:
-            // The logic in this function makes sure that this doesn't happen, but if you call start on an
-            // animation that is already playing it will be restarted.
-            start_keyframe_animation(&lcd_bitmap_leds_animation);
-        }
-    } else {
-        if (lcd_state != LCD_STATE_LAYER_BITMAP ||
-                state->status.layer != prev_status->layer ||
-                state->status.default_layer != prev_status->default_layer) {
-
-            stop_keyframe_animation(&lcd_bitmap_leds_animation);
-
-            lcd_state = LCD_STATE_LAYER_BITMAP;
-            start_keyframe_animation(&lcd_bitmap_animation);
-        }
-    }
-}
-
-void update_user_visualizer_state(visualizer_state_t* state, visualizer_keyboard_status_t* prev_status) {
-    // Check the status here to start and stop animations
-    // You might have to save some state, like the current animation here so that you can start the right
-    // This function is called every time the status changes
-
-    // NOTE that this is called from the visualizer thread, so don't access anything else outside the status
-    // This is also important because the slave won't have access to the active layer for example outside the
-    // status.
-
-    update_emulated_leds(state, prev_status);
-    update_lcd_text(state, prev_status);
-
-}
-
-void user_visualizer_suspend(visualizer_state_t* state) {
-    state->layer_text = "Suspending...";
-    uint8_t hue = LCD_HUE(state->current_lcd_color);
-    uint8_t sat = LCD_SAT(state->current_lcd_color);
-    state->target_lcd_color = LCD_COLOR(hue, sat, 0);
-    start_keyframe_animation(&default_suspend_animation);
-}
-
-void user_visualizer_resume(visualizer_state_t* state) {
-    state->current_lcd_color = initial_color;
-    state->target_lcd_color = logo_background_color;
-    lcd_state = LCD_STATE_INITIAL;
-    start_keyframe_animation(&default_startup_animation);
-}
-
-void ergodox_board_led_on(void){
-    // No board led support
-}
-
-void ergodox_right_led_1_on(void){
-    user_data_keyboard.led_on |= (1u << 0);
-    visualizer_set_user_data(&user_data_keyboard);
-}
-
-void ergodox_right_led_2_on(void){
-    user_data_keyboard.led_on |= (1u << 1);
-    visualizer_set_user_data(&user_data_keyboard);
-}
-
-void ergodox_right_led_3_on(void){
-    user_data_keyboard.led_on |= (1u << 2);
-    visualizer_set_user_data(&user_data_keyboard);
-}
-
-void ergodox_board_led_off(void){
-    // No board led support
-}
-
-void ergodox_right_led_1_off(void){
-    user_data_keyboard.led_on &= ~(1u << 0);
-    visualizer_set_user_data(&user_data_keyboard);
-}
-
-void ergodox_right_led_2_off(void){
-    user_data_keyboard.led_on &= ~(1u << 1);
-    visualizer_set_user_data(&user_data_keyboard);
-}
-
-void ergodox_right_led_3_off(void){
-    user_data_keyboard.led_on &= ~(1u << 2);
-    visualizer_set_user_data(&user_data_keyboard);
-}
-
-void ergodox_right_led_1_set(uint8_t n) {
-    user_data_keyboard.led1 = n;
-    visualizer_set_user_data(&user_data_keyboard);
-}
-
-void ergodox_right_led_2_set(uint8_t n) {
-    user_data_keyboard.led2 = n;
-    visualizer_set_user_data(&user_data_keyboard);
-}
-
-void ergodox_right_led_3_set(uint8_t n) {
-    user_data_keyboard.led3 = n;
-    visualizer_set_user_data(&user_data_keyboard);
-}
--- a/keyboards/whitefox/gfxconf.h
+++ b/keyboards/whitefox/gfxconf.h
@ -1,27 +0,0 @@
-/**
- * This file has a different license to the rest of the uGFX system.
- * You can copy, modify and distribute this file as you see fit.
- * You do not need to publish your source modifications to this file.
- * The only thing you are not permitted to do is to relicense it
- * under a different license.
- */
-
-/**
- * Copy this file into your project directory and rename it as gfxconf.h
- * Edit your copy to turn on the uGFX features you want to use.
- * The values below are the defaults.
- *
- * Only remove the comments from lines where you want to change the
- * default value. This allows definitions to be included from
- * driver makefiles when required and provides the best future
- * compatibility for your project.
- *
- * Please use spaces instead of tabs in this file.
- */
-
-#ifndef _GFXCONF_H
-#define _GFXCONF_H
-
-#include "common_gfxconf.h"
-
-#endif /* _GFXCONF_H */
--- a/keyboards/whitefox/visualizer.c
+++ b/keyboards/whitefox/visualizer.c
@ -1,54 +0,0 @@
-/* Copyright 2017 Fred Sundvik
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "visualizer.h"
-#include "visualizer_keyframes.h"
-#include "default_animations.h"
-
-static bool initial_update = true;
-
-// Feel free to modify the animations below, or even add new ones if needed
-
-void initialize_user_visualizer(visualizer_state_t *state) {
-    // The brightness will be dynamically adjustable in the future
-    // But for now, change it here.
-    initial_update = true;
-    start_keyframe_animation(&default_startup_animation);
-}
-
-void update_user_visualizer_state(visualizer_state_t *state, visualizer_keyboard_status_t *prev_status) {
-    // Add more tests, change the colors and layer texts here
-    // Usually you want to check the high bits (higher layers first)
-    // because that's the order layers are processed for keypresses
-    // You can for check for example:
-    // state->status.layer
-    // state->status.default_layer
-    // state->status.leds (see led.h for available statuses)
-
-    if (initial_update) {
-        initial_update = false;
-        start_keyframe_animation(&led_test_animation);
-    }
-}
-
-void user_visualizer_suspend(visualizer_state_t *state) {
-    start_keyframe_animation(&default_suspend_animation);
-}
-
-void user_visualizer_resume(visualizer_state_t *state) {
-    initial_update = true;
-    start_keyframe_animation(&default_startup_animation);
-}
--- a/lib/ugfx
+++ b/lib/ugfx
@ -1 +0,0 @@
-Subproject commit 40b48f470addad6a4fb1177de1a69a181158739b
--- a/quantum/keyboard.c
+++ b/quantum/keyboard.c
@ -64,9 +64,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #ifdef SERIAL_LINK_ENABLE
 #    include "serial_link/system/serial_link.h"
 #endif
-#ifdef VISUALIZER_ENABLE
-#    include "visualizer/visualizer.h"
-#endif
 #ifdef POINTING_DEVICE_ENABLE
 #    include "pointing_device.h"
 #endif
@ -381,7 +378,6 @@ void switch_events(uint8_t row, uint8_t col, bool pressed) {
 *
 * * scan matrix
 * * handle mouse movements
- * * run visualizer code
 * * handle midi commands
 * * light LEDs
 *
@ -519,10 +515,6 @@ MATRIX_LOOP_END:
    serial_link_update();
 #endif

-#ifdef VISUALIZER_ENABLE
-    visualizer_update(default_layer_state, layer_state, visualizer_get_mods(), host_keyboard_leds());
-#endif
-
 #ifdef POINTING_DEVICE_ENABLE
    pointing_device_task();
 #endif
--- a/quantum/visualizer/LICENSE.md
+++ b/quantum/visualizer/LICENSE.md
@ -1,29 +0,0 @@
-The files in this project are licensed under the MIT license
-It uses the following libraries
-uGFX - with it's own license, see the license.html file in the uGFX subfolder for more information
-tmk_core - is indirectly used and not included in the repository. It's licensed under the GPLv2 license
-Chibios - which is used by tmk_core is licensed under GPLv3.
-
-Therefore the effective license for any project using the library is GPLv3
-
-The MIT License (MIT)
-
-Copyright (c) 2016 Fred Sundvik
-
-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.
--- a/quantum/visualizer/common_gfxconf.h
+++ b/quantum/visualizer/common_gfxconf.h
@ -1,354 +0,0 @@
-/**
- * This file has a different license to the rest of the uGFX system.
- * You can copy, modify and distribute this file as you see fit.
- * You do not need to publish your source modifications to this file.
- * The only thing you are not permitted to do is to relicense it
- * under a different license.
- */
-
-/**
- * Copy this file into your project directory and rename it as gfxconf.h
- * Edit your copy to turn on the uGFX features you want to use.
- * The values below are the defaults.
- *
- * Only remove the comments from lines where you want to change the
- * default value. This allows definitions to be included from
- * driver makefiles when required and provides the best future
- * compatibility for your project.
- *
- * Please use spaces instead of tabs in this file.
- */
-
-#pragma once
-
-///////////////////////////////////////////////////////////////////////////
-// GFX - Compatibility options                                           //
-///////////////////////////////////////////////////////////////////////////
-//#define GFX_COMPAT_V2                                GFXON
-//#define GFX_COMPAT_OLDCOLORS                         GFXON
-
-///////////////////////////////////////////////////////////////////////////
-// GOS - One of these must be defined, preferably in your Makefile       //
-///////////////////////////////////////////////////////////////////////////
-//#define GFX_USE_OS_CHIBIOS                           GFXOFF
-//#define GFX_USE_OS_FREERTOS                          GFXOFF
-//    #define GFX_FREERTOS_USE_TRACE                   GFXOFF
-//#define GFX_USE_OS_WIN32                             GFXOFF
-//#define GFX_USE_OS_LINUX                             GFXOFF
-//#define GFX_USE_OS_OSX                               GFXOFF
-//#define GFX_USE_OS_ECOS                              GFXOFF
-//#define GFX_USE_OS_RAWRTOS                           GFXOFF
-//#define GFX_USE_OS_ARDUINO                           GFXOFF
-//#define GFX_USE_OS_KEIL                              GFXOFF
-//#define GFX_USE_OS_RTX5                              GFXOFF
-//#define GFX_USE_OS_CMSIS                             GFXOFF
-//#define GFX_USE_OS_CMSIS2                            GFXOFF
-//#define GFX_USE_OS_RAW32                             GFXOFF
-//#define GFX_USE_OS_ZEPHYR                            GFXOFF
-//#define GFX_USE_OS_NIOS                              GFXOFF
-//#define GFX_USE_OS_QT                                GFXOFF
-//    #define INTERRUPTS_OFF()                         optional_code
-//    #define INTERRUPTS_ON()                          optional_code
-
-// Options that (should where relevant) apply to all operating systems
-#define GFX_NO_INLINE GFXON
-//    #define GFX_COMPILER                             GFX_COMPILER_UNKNOWN
-//    #define GFX_SHOW_COMPILER                        GFXOFF
-//    #define GFX_CPU                                  GFX_CPU_UNKNOWN
-//    #define GFX_CPU_NO_ALIGNMENT_FAULTS              GFXOFF
-//    #define GFX_CPU_ENDIAN                           GFX_CPU_ENDIAN_UNKNOWN
-//    #define GFX_OS_HEAP_SIZE                         0
-//    #define GFX_OS_NO_INIT                           GFXOFF
-//    #define GFX_OS_INIT_NO_WARNING                   GFXOFF
-//    #define GFX_OS_PRE_INIT_FUNCTION                 myHardwareInitRoutine
-//    #define GFX_OS_EXTRA_INIT_FUNCTION               myOSInitRoutine
-//    #define GFX_OS_EXTRA_DEINIT_FUNCTION             myOSDeInitRoutine
-//    #define GFX_OS_CALL_UGFXMAIN                     GFXOFF
-//    #define GFX_OS_UGFXMAIN_STACKSIZE                0
-//    #define GFX_EMULATE_MALLOC                       GFXOFF
-//    #define GFX_MEM_LT64K                            GFXOFF
-
-///////////////////////////////////////////////////////////////////////////
-// GDISP                                                                 //
-///////////////////////////////////////////////////////////////////////////
-#define GFX_USE_GDISP GFXON
-
-//#define GDISP_NEED_AUTOFLUSH                         GFXOFF
-//#define GDISP_NEED_TIMERFLUSH                        GFXOFF
-//#define GDISP_NEED_VALIDATION                        GFXON
-//#define GDISP_NEED_CLIP                              GFXON
-#define GDISP_NEED_CIRCLE GFXON
-//#define GDISP_NEED_DUALCIRCLE                        GFXOFF
-#define GDISP_NEED_ELLIPSE GFXON
-#define GDISP_NEED_ARC GFXON
-#define GDISP_NEED_ARCSECTORS GFXON
-#define GDISP_NEED_CONVEX_POLYGON GFXON
-//#define GDISP_NEED_SCROLL                            GFXOFF
-#define GDISP_NEED_PIXELREAD GFXON
-#define GDISP_NEED_CONTROL GFXON
-//#define GDISP_NEED_QUERY                             GFXOFF
-//#define GDISP_NEED_MULTITHREAD                       GFXOFF
-//#define GDISP_NEED_STREAMING                         GFXOFF
-#define GDISP_NEED_TEXT GFXON
-//    #define GDISP_NEED_TEXT_WORDWRAP                 GFXOFF
-//    #define GDISP_NEED_TEXT_BOXPADLR                 1
-//    #define GDISP_NEED_TEXT_BOXPADTB                 1
-//    #define GDISP_NEED_ANTIALIAS                     GFXOFF
-//    #define GDISP_NEED_UTF8                          GFXOFF
-#define GDISP_NEED_TEXT_KERNING GFXON
-//    #define GDISP_INCLUDE_FONT_UI1                   GFXOFF
-//    #define GDISP_INCLUDE_FONT_UI2                   GFXOFF		// The smallest preferred font.
-//    #define GDISP_INCLUDE_FONT_LARGENUMBERS          GFXOFF
-//    #define GDISP_INCLUDE_FONT_DEJAVUSANS10          GFXOFF
-//    #define GDISP_INCLUDE_FONT_DEJAVUSANS12          GFXOFF
-//    #define GDISP_INCLUDE_FONT_DEJAVUSANS16          GFXOFF
-//    #define GDISP_INCLUDE_FONT_DEJAVUSANS20          GFXOFF
-//    #define GDISP_INCLUDE_FONT_DEJAVUSANS24          GFXOFF
-//    #define GDISP_INCLUDE_FONT_DEJAVUSANS32          GFXOFF
-#define GDISP_INCLUDE_FONT_DEJAVUSANSBOLD12 GFXON
-//    #define GDISP_INCLUDE_FONT_FIXED_10X20           GFXOFF
-//    #define GDISP_INCLUDE_FONT_FIXED_7X14            GFXOFF
-#define GDISP_INCLUDE_FONT_FIXED_5X8 GFXON
-//    #define GDISP_INCLUDE_FONT_DEJAVUSANS12_AA       GFXOFF
-//    #define GDISP_INCLUDE_FONT_DEJAVUSANS16_AA       GFXOFF
-//    #define GDISP_INCLUDE_FONT_DEJAVUSANS20_AA       GFXOFF
-//    #define GDISP_INCLUDE_FONT_DEJAVUSANS24_AA       GFXOFF
-//    #define GDISP_INCLUDE_FONT_DEJAVUSANS32_AA       GFXOFF
-//    #define GDISP_INCLUDE_FONT_DEJAVUSANSBOLD12_AA   GFXOFF
-//    #define GDISP_INCLUDE_USER_FONTS                 GFXOFF
-
-//#define GDISP_NEED_IMAGE                             GFXOFF
-//    #define GDISP_NEED_IMAGE_NATIVE                  GFXOFF
-//    #define GDISP_NEED_IMAGE_GIF                     GFXOFF
-//        #define GDISP_IMAGE_GIF_BLIT_BUFFER_SIZE     32
-//    #define GDISP_NEED_IMAGE_BMP                     GFXOFF
-//        #define GDISP_NEED_IMAGE_BMP_1               GFXON
-//        #define GDISP_NEED_IMAGE_BMP_4               GFXON
-//        #define GDISP_NEED_IMAGE_BMP_4_RLE           GFXON
-//        #define GDISP_NEED_IMAGE_BMP_8               GFXON
-//        #define GDISP_NEED_IMAGE_BMP_8_RLE           GFXON
-//        #define GDISP_NEED_IMAGE_BMP_16              GFXON
-//        #define GDISP_NEED_IMAGE_BMP_24              GFXON
-//        #define GDISP_NEED_IMAGE_BMP_32              GFXON
-//        #define GDISP_IMAGE_BMP_BLIT_BUFFER_SIZE     32
-//    #define GDISP_NEED_IMAGE_JPG                     GFXOFF
-//    #define GDISP_NEED_IMAGE_PNG                     GFXOFF
-//        #define GDISP_NEED_IMAGE_PNG_INTERLACED      GFXOFF
-//        #define GDISP_NEED_IMAGE_PNG_TRANSPARENCY    GFXON
-//        #define GDISP_NEED_IMAGE_PNG_BACKGROUND      GFXON
-//        #define GDISP_NEED_IMAGE_PNG_ALPHACLIFF      32
-//        #define GDISP_NEED_IMAGE_PNG_PALETTE_124     GFXON
-//        #define GDISP_NEED_IMAGE_PNG_PALETTE_8       GFXON
-//        #define GDISP_NEED_IMAGE_PNG_GRAYSCALE_124   GFXON
-//        #define GDISP_NEED_IMAGE_PNG_GRAYSCALE_8     GFXON
-//        #define GDISP_NEED_IMAGE_PNG_GRAYSCALE_16    GFXON
-//        #define GDISP_NEED_IMAGE_PNG_GRAYALPHA_8     GFXON
-//        #define GDISP_NEED_IMAGE_PNG_GRAYALPHA_16    GFXON
-//        #define GDISP_NEED_IMAGE_PNG_RGB_8           GFXON
-//        #define GDISP_NEED_IMAGE_PNG_RGB_16          GFXON
-//        #define GDISP_NEED_IMAGE_PNG_RGBALPHA_8      GFXON
-//        #define GDISP_NEED_IMAGE_PNG_RGBALPHA_16     GFXON
-//        #define GDISP_IMAGE_PNG_BLIT_BUFFER_SIZE     32
-//        #define GDISP_IMAGE_PNG_FILE_BUFFER_SIZE     8
-//        #define GDISP_IMAGE_PNG_Z_BUFFER_SIZE        32768
-//    #define GDISP_NEED_IMAGE_ACCOUNTING              GFXOFF
-
-//#define GDISP_NEED_PIXMAP                            GFXOFF
-//    #define GDISP_NEED_PIXMAP_IMAGE                  GFXOFF
-
-//#define GDISP_DEFAULT_ORIENTATION                    gOrientationLandscape    // If not defined the native hardware orientation is used.
-//#define GDISP_LINEBUF_SIZE                           128
-//#define GDISP_STARTUP_COLOR                          GFX_BLACK
-#define GDISP_NEED_STARTUP_LOGO GFXOFF
-
-//#define GDISP_TOTAL_DISPLAYS                         1
-
-//#define GDISP_DRIVER_LIST                            GDISPVMT_Win32, GDISPVMT_Win32
-#ifdef GDISP_DRIVER_LIST
-//        // For code and speed optimization define as GFXON or GFXOFF if all controllers have the same capability
-#    define GDISP_HARDWARE_STREAM_WRITE GFXOFF
-#    define GDISP_HARDWARE_STREAM_READ GFXOFF
-#    define GDISP_HARDWARE_STREAM_POS GFXOFF
-#    define GDISP_HARDWARE_DRAWPIXEL GFXON
-#    define GDISP_HARDWARE_CLEARS GFXOFF
-#    define GDISP_HARDWARE_FILLS GFXOFF
-//#define GDISP_HARDWARE_BITFILLS              GFXOFF
-#    define GDISP_HARDWARE_SCROLL GFXOFF
-#    define GDISP_HARDWARE_PIXELREAD GFXON
-#    define GDISP_HARDWARE_CONTROL GFXON
-#    define GDISP_HARDWARE_QUERY GFXOFF
-#    define GDISP_HARDWARE_CLIP GFXOFF
-
-#    define GDISP_PIXELFORMAT GDISP_PIXELFORMAT_RGB888
-#endif
-
-#define GDISP_USE_GFXNET GFXOFF
-//    #define GDISP_GFXNET_PORT                        13001
-//    #define GDISP_GFXNET_CUSTOM_LWIP_STARTUP         GFXOFF
-//    #define GDISP_DONT_WAIT_FOR_NET_DISPLAY          GFXOFF
-//    #define GDISP_GFXNET_UNSAFE_SOCKETS              GFXOFF
-
-///////////////////////////////////////////////////////////////////////////
-// GWIN                                                                  //
-///////////////////////////////////////////////////////////////////////////
-#define GFX_USE_GWIN GFXOFF
-
-//#define GWIN_NEED_WINDOWMANAGER                      GFXOFF
-//    #define GWIN_REDRAW_IMMEDIATE                    GFXOFF
-//    #define GWIN_REDRAW_SINGLEOP                     GFXOFF
-//    #define GWIN_NEED_FLASHING                       GFXOFF
-//        #define GWIN_FLASHING_PERIOD                 250
-
-//#define GWIN_NEED_CONSOLE                            GFXOFF
-//    #define GWIN_CONSOLE_USE_HISTORY                 GFXOFF
-//        #define GWIN_CONSOLE_HISTORY_AVERAGING       GFXOFF
-//        #define GWIN_CONSOLE_HISTORY_ATCREATE        GFXOFF
-//    #define GWIN_CONSOLE_ESCSEQ                      GFXOFF
-//    #define GWIN_CONSOLE_USE_BASESTREAM              GFXOFF
-//    #define GWIN_CONSOLE_USE_FLOAT                   GFXOFF
-//#define GWIN_NEED_GRAPH                              GFXOFF
-//#define GWIN_NEED_GL3D                               GFXOFF
-
-//#define GWIN_NEED_WIDGET                             GFXOFF
-//#define GWIN_FOCUS_HIGHLIGHT_WIDTH                   1
-//    #define GWIN_NEED_LABEL                          GFXOFF
-//        #define GWIN_LABEL_ATTRIBUTE                 GFXOFF
-//    #define GWIN_NEED_BUTTON                         GFXOFF
-//        #define GWIN_BUTTON_LAZY_RELEASE             GFXOFF
-//    #define GWIN_NEED_SLIDER                         GFXOFF
-//        #define GWIN_SLIDER_NOSNAP                   GFXOFF
-//        #define GWIN_SLIDER_DEAD_BAND                5
-//        #define GWIN_SLIDER_TOGGLE_INC               20
-//    #define GWIN_NEED_CHECKBOX                       GFXOFF
-//    #define GWIN_NEED_IMAGE                          GFXOFF
-//        #define GWIN_NEED_IMAGE_ANIMATION            GFXOFF
-//    #define GWIN_NEED_RADIO                          GFXOFF
-//    #define GWIN_NEED_LIST                           GFXOFF
-//        #define GWIN_NEED_LIST_IMAGES                GFXOFF
-//    #define GWIN_NEED_PROGRESSBAR                    GFXOFF
-//        #define GWIN_PROGRESSBAR_AUTO                GFXOFF
-//    #define GWIN_NEED_KEYBOARD                       GFXOFF
-//        #define GWIN_KEYBOARD_DEFAULT_LAYOUT         VirtualKeyboard_English1
-//        #define GWIN_NEED_KEYBOARD_ENGLISH1          GFXON
-//    #define GWIN_NEED_TEXTEDIT                       GFXOFF
-//    #define GWIN_FLAT_STYLING                        GFXOFF
-//    #define GWIN_WIDGET_TAGS                         GFXOFF
-
-//#define GWIN_NEED_CONTAINERS                         GFXOFF
-//    #define GWIN_NEED_CONTAINER                      GFXOFF
-//    #define GWIN_NEED_FRAME                          GFXOFF
-//    #define GWIN_NEED_TABSET                         GFXOFF
-//        #define GWIN_TABSET_TABHEIGHT                18
-
-///////////////////////////////////////////////////////////////////////////
-// GTRANS                                                                //
-///////////////////////////////////////////////////////////////////////////
-//#define GFX_USE_GTRANS                               GFXOFF
-
-///////////////////////////////////////////////////////////////////////////
-// GEVENT                                                                //
-///////////////////////////////////////////////////////////////////////////
-#define GFX_USE_GEVENT GFXON
-
-//#define GEVENT_ASSERT_NO_RESOURCE                    GFXOFF
-//#define GEVENT_MAXIMUM_SIZE                          32
-//#define GEVENT_MAX_SOURCE_LISTENERS                  32
-
-///////////////////////////////////////////////////////////////////////////
-// GTIMER                                                                //
-///////////////////////////////////////////////////////////////////////////
-#define GFX_USE_GTIMER GFXOFF
-
-//#define GTIMER_THREAD_PRIORITY                       gThreadpriorityHigh
-//#define GTIMER_THREAD_WORKAREA_SIZE                  2048
-
-///////////////////////////////////////////////////////////////////////////
-// GQUEUE                                                                //
-///////////////////////////////////////////////////////////////////////////
-#define GFX_USE_GQUEUE GFXOFF
-
-//#define GQUEUE_NEED_ASYNC                            GFXOFF
-//#define GQUEUE_NEED_GSYNC                            GFXOFF
-//#define GQUEUE_NEED_FSYNC                            GFXOFF
-//#define GQUEUE_NEED_BUFFERS                          GFXOFF
-
-///////////////////////////////////////////////////////////////////////////
-// GINPUT                                                                //
-///////////////////////////////////////////////////////////////////////////
-#define GFX_USE_GINPUT GFXOFF
-
-//#define GINPUT_NEED_MOUSE                            GFXOFF
-//    #define GINPUT_TOUCH_STARTRAW                    GFXOFF
-//    #define GINPUT_TOUCH_NOTOUCH                     GFXOFF
-//    #define GINPUT_TOUCH_NOCALIBRATE                 GFXOFF
-//    #define GINPUT_TOUCH_NOCALIBRATE_GUI             GFXOFF
-//    #define GINPUT_MOUSE_POLL_PERIOD                 25
-//    #define GINPUT_MOUSE_CLICK_TIME                  300
-//    #define GINPUT_TOUCH_CXTCLICK_TIME               700
-//    #define GINPUT_TOUCH_USER_CALIBRATION_LOAD       GFXOFF
-//    #define GINPUT_TOUCH_USER_CALIBRATION_SAVE       GFXOFF
-//    #define GMOUSE_DRIVER_LIST                       GMOUSEVMT_Win32, GMOUSEVMT_Win32
-//    #define GINPUT_TOUCH_CALIBRATION_FONT1           "* Double"
-//    #define GINPUT_TOUCH_CALIBRATION_FONT2           "* Narrow"
-//    #define GINPUT_TOUCH_CALIBRATION_TITLE           "Calibration"
-//    #define GINPUT_TOUCH_CALIBRATION_ERROR           "Calibration Failed!"
-//#define GINPUT_NEED_KEYBOARD                         GFXOFF
-//    #define GINPUT_KEYBOARD_POLL_PERIOD              200
-//    #define GKEYBOARD_DRIVER_LIST                    GKEYBOARDVMT_Win32, GKEYBOARDVMT_Win32
-//    #define GKEYBOARD_LAYOUT_OFF                     GFXOFF
-//        #define GKEYBOARD_LAYOUT_SCANCODE2_US        GFXOFF
-//#define GINPUT_NEED_TOGGLE                           GFXOFF
-//#define GINPUT_NEED_DIAL                             GFXOFF
-
-///////////////////////////////////////////////////////////////////////////
-// GFILE                                                                 //
-///////////////////////////////////////////////////////////////////////////
-#define GFX_USE_GFILE GFXOFF
-
-//#define GFILE_NEED_PRINTG                            GFXOFF
-//#define GFILE_NEED_SCANG                             GFXOFF
-//#define GFILE_NEED_STRINGS                           GFXOFF
-//#define GFILE_NEED_FILELISTS                         GFXOFF
-//#define GFILE_NEED_STDIO                             GFXOFF
-//#define GFILE_NEED_NOAUTOMOUNT                       GFXOFF
-//#define GFILE_NEED_NOAUTOSYNC                        GFXOFF
-
-//#define GFILE_NEED_MEMFS                             GFXOFF
-//#define GFILE_NEED_ROMFS                             GFXOFF
-//#define GFILE_NEED_RAMFS                             GFXOFF
-//#define GFILE_NEED_FATFS                             GFXOFF
-//#define GFILE_NEED_NATIVEFS                          GFXOFF
-//#define GFILE_NEED_CHBIOSFS                          GFXOFF
-//#define GFILE_NEED_USERFS                            GFXOFF
-
-//#define GFILE_ALLOW_FLOATS                           GFXOFF
-//#define GFILE_ALLOW_DEVICESPECIFIC                   GFXOFF
-//#define GFILE_MAX_GFILES                             3
-
-///////////////////////////////////////////////////////////////////////////
-// GADC                                                                  //
-///////////////////////////////////////////////////////////////////////////
-#define GFX_USE_GADC GFXOFF
-//    #define GADC_MAX_LOWSPEED_DEVICES                4
-
-///////////////////////////////////////////////////////////////////////////
-// GAUDIO                                                                //
-///////////////////////////////////////////////////////////////////////////
-#define GFX_USE_GAUDIO GFXOFF
-//    #define GAUDIO_NEED_PLAY                         GFXOFF
-//    #define GAUDIO_NEED_RECORD                       GFXOFF
-
-///////////////////////////////////////////////////////////////////////////
-// GMISC                                                                 //
-///////////////////////////////////////////////////////////////////////////
-#define GFX_USE_GMISC GFXON
-
-//#define GMISC_NEED_ARRAYOPS                          GFXOFF
-//#define GMISC_NEED_FASTTRIG                          GFXOFF
-//#define GMISC_NEED_FIXEDTRIG                         GFXOFF
-//#define GMISC_NEED_INVSQRT                           GFXOFF
-//    #define GMISC_INVSQRT_MIXED_ENDIAN               GFXOFF
-//    #define GMISC_INVSQRT_REAL_SLOW                  GFXOFF
-#define GMISC_NEED_MATRIXFLOAT2D GFXON
-#define GMISC_NEED_MATRIXFIXED2D GFXOFF
-//#define GMISC_NEED_HITTEST_POLY                      GFXOFF
--- a/quantum/visualizer/default_animations.c
+++ b/quantum/visualizer/default_animations.c
@ -1,177 +0,0 @@
-/* Copyright 2017 Fred Sundvik
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#if defined(VISUALIZER_ENABLE)
-
-#    include "default_animations.h"
-#    include "visualizer.h"
-#    ifdef LCD_ENABLE
-#        include "lcd_keyframes.h"
-#    endif
-#    ifdef LCD_BACKLIGHT_ENABLE
-#        include "lcd_backlight_keyframes.h"
-#    endif
-
-#    ifdef BACKLIGHT_ENABLE
-#        include "led_backlight_keyframes.h"
-#    endif
-
-#    include "visualizer_keyframes.h"
-
-#    if defined(LCD_ENABLE) || defined(LCD_BACKLIGHT_ENABLE) || defined(BACKLIGHT_ENABLE)
-
-static bool keyframe_enable(keyframe_animation_t* animation, visualizer_state_t* state) {
-#        ifdef LCD_ENABLE
-    lcd_keyframe_enable(animation, state);
-#        endif
-#        ifdef LCD_BACKLIGHT_ENABLE
-    lcd_backlight_keyframe_enable(animation, state);
-#        endif
-#        ifdef BACKLIGHT_ENABLE
-    led_backlight_keyframe_enable(animation, state);
-#        endif
-    return false;
-}
-
-static bool keyframe_disable(keyframe_animation_t* animation, visualizer_state_t* state) {
-#        ifdef LCD_ENABLE
-    lcd_keyframe_disable(animation, state);
-#        endif
-#        ifdef LCD_BACKLIGHT_ENABLE
-    lcd_backlight_keyframe_disable(animation, state);
-#        endif
-#        ifdef BACKLIGHT_ENABLE
-    led_backlight_keyframe_disable(animation, state);
-#        endif
-    return false;
-}
-
-static bool keyframe_fade_in(keyframe_animation_t* animation, visualizer_state_t* state) {
-    bool ret = false;
-#        ifdef LCD_BACKLIGHT_ENABLE
-    ret |= lcd_backlight_keyframe_animate_color(animation, state);
-#        endif
-#        ifdef BACKLIGHT_ENABLE
-    ret |= led_backlight_keyframe_fade_in_all(animation, state);
-#        endif
-    return ret;
-}
-
-static bool keyframe_fade_out(keyframe_animation_t* animation, visualizer_state_t* state) {
-    bool ret = false;
-#        ifdef LCD_BACKLIGHT_ENABLE
-    ret |= lcd_backlight_keyframe_animate_color(animation, state);
-#        endif
-#        ifdef BACKLIGHT_ENABLE
-    ret |= led_backlight_keyframe_fade_out_all(animation, state);
-#        endif
-    return ret;
-}
-
-// Don't worry, if the startup animation is long, you can use the keyboard like normal
-// during that time
-keyframe_animation_t default_startup_animation = {
-#        if LCD_ENABLE
-    .num_frames = 3,
-#        else
-    .num_frames = 2,
-#        endif
-    .loop          = false,
-    .frame_lengths = {0,
-#        if LCD_ENABLE
-                      0,
-#        endif
-                      gfxMillisecondsToTicks(5000)},
-    .frame_functions =
-        {
-            keyframe_enable,
-#        if LCD_ENABLE
-            lcd_keyframe_draw_logo,
-#        endif
-            keyframe_fade_in,
-        },
-};
-
-keyframe_animation_t default_suspend_animation = {
-#        if LCD_ENABLE
-    .num_frames = 3,
-#        else
-    .num_frames = 2,
-#        endif
-    .loop = false,
-    .frame_lengths =
-        {
-#        if LCD_ENABLE
-            0,
-#        endif
-            gfxMillisecondsToTicks(1000), 0},
-    .frame_functions =
-        {
-#        if LCD_ENABLE
-            lcd_keyframe_display_layer_text,
-#        endif
-            keyframe_fade_out,
-            keyframe_disable,
-        },
-};
-#    endif
-
-#    if defined(BACKLIGHT_ENABLE)
-#        define CROSSFADE_TIME 1000
-#        define GRADIENT_TIME 3000
-
-keyframe_animation_t led_test_animation = {
-    .num_frames = 14,
-    .loop       = true,
-    .frame_lengths =
-        {
-            gfxMillisecondsToTicks(1000),            // fade in
-            gfxMillisecondsToTicks(1000),            // no op (leds on)
-            gfxMillisecondsToTicks(1000),            // fade out
-            gfxMillisecondsToTicks(CROSSFADE_TIME),  // crossfade
-            gfxMillisecondsToTicks(GRADIENT_TIME),   // left to rigt (outside in)
-            gfxMillisecondsToTicks(CROSSFADE_TIME),  // crossfade
-            gfxMillisecondsToTicks(GRADIENT_TIME),   // top_to_bottom
-            0,                                       // mirror leds
-            gfxMillisecondsToTicks(CROSSFADE_TIME),  // crossfade
-            gfxMillisecondsToTicks(GRADIENT_TIME),   // left_to_right (mirrored, so inside out)
-            gfxMillisecondsToTicks(CROSSFADE_TIME),  // crossfade
-            gfxMillisecondsToTicks(GRADIENT_TIME),   // top_to_bottom
-            0,                                       // normal leds
-            gfxMillisecondsToTicks(CROSSFADE_TIME),  // crossfade
-
-        },
-    .frame_functions =
-        {
-            led_backlight_keyframe_fade_in_all,
-            keyframe_no_operation,
-            led_backlight_keyframe_fade_out_all,
-            led_backlight_keyframe_crossfade,
-            led_backlight_keyframe_left_to_right_gradient,
-            led_backlight_keyframe_crossfade,
-            led_backlight_keyframe_top_to_bottom_gradient,
-            led_backlight_keyframe_mirror_orientation,
-            led_backlight_keyframe_crossfade,
-            led_backlight_keyframe_left_to_right_gradient,
-            led_backlight_keyframe_crossfade,
-            led_backlight_keyframe_top_to_bottom_gradient,
-            led_backlight_keyframe_normal_orientation,
-            led_backlight_keyframe_crossfade,
-        },
-};
-#    endif
-
-#endif
--- a/quantum/visualizer/default_animations.h
+++ b/quantum/visualizer/default_animations.h
@ -1,27 +0,0 @@
-/* Copyright 2017 Fred Sundvik
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#pragma once
-
-#include "visualizer.h"
-
-// You can use these default animations, but of course you can also write your own custom ones instead
-extern keyframe_animation_t default_startup_animation;
-extern keyframe_animation_t default_suspend_animation;
-
-// An animation for testing and demonstrating the led support, should probably not be used for real world
-// cases
-extern keyframe_animation_t led_test_animation;
--- a/quantum/visualizer/lcd_backlight.c
+++ b/quantum/visualizer/lcd_backlight.c
@ -1,87 +0,0 @@
-/*
-The MIT License (MIT)
-
-Copyright (c) 2016 Fred Sundvik
-
-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 "lcd_backlight.h"
-#include <math.h>
-
-static uint8_t current_hue        = 0;
-static uint8_t current_saturation = 0;
-static uint8_t current_intensity  = 0;
-static uint8_t current_brightness = 0;
-
-void lcd_backlight_init(void) {
-    lcd_backlight_hal_init();
-    lcd_backlight_color(current_hue, current_saturation, current_intensity);
-}
-
-// This code is based on Brian Neltner's blogpost and example code
-// "Why every LED light should be using HSI colorspace".
-// http://blog.saikoled.com/post/43693602826/why-every-led-light-should-be-using-hsi
-static void hsi_to_rgb(float h, float s, float i, uint16_t* r_out, uint16_t* g_out, uint16_t* b_out) {
-    unsigned int r, g, b;
-    h = fmodf(h, 360.0f);                         // cycle h around to 0-360 degrees
-    h = 3.14159f * h / 180.0f;                    // Convert to radians.
-    s = s > 0.0f ? (s < 1.0f ? s : 1.0f) : 0.0f;  // clamp s and i to interval [0,1]
-    i = i > 0.0f ? (i < 1.0f ? i : 1.0f) : 0.0f;
-
-    // Math! Thanks in part to Kyle Miller.
-    if (h < 2.09439f) {
-        r = 65535.0f * i / 3.0f * (1.0f + s * cos(h) / cosf(1.047196667f - h));
-        g = 65535.0f * i / 3.0f * (1.0f + s * (1.0f - cosf(h) / cos(1.047196667f - h)));
-        b = 65535.0f * i / 3.0f * (1.0f - s);
-    } else if (h < 4.188787) {
-        h = h - 2.09439;
-        g = 65535.0f * i / 3.0f * (1.0f + s * cosf(h) / cosf(1.047196667f - h));
-        b = 65535.0f * i / 3.0f * (1.0f + s * (1.0f - cosf(h) / cosf(1.047196667f - h)));
-        r = 65535.0f * i / 3.0f * (1.0f - s);
-    } else {
-        h = h - 4.188787;
-        b = 65535.0f * i / 3.0f * (1.0f + s * cosf(h) / cosf(1.047196667f - h));
-        r = 65535.0f * i / 3.0f * (1.0f + s * (1.0f - cosf(h) / cosf(1.047196667f - h)));
-        g = 65535.0f * i / 3.0f * (1.0f - s);
-    }
-    *r_out = r > 65535 ? 65535 : r;
-    *g_out = g > 65535 ? 65535 : g;
-    *b_out = b > 65535 ? 65535 : b;
-}
-
-void lcd_backlight_color(uint8_t hue, uint8_t saturation, uint8_t intensity) {
-    uint16_t r, g, b;
-    float    hue_f        = 360.0f * (float)hue / 255.0f;
-    float    saturation_f = (float)saturation / 255.0f;
-    float    intensity_f  = (float)intensity / 255.0f;
-    intensity_f *= (float)current_brightness / 255.0f;
-    hsi_to_rgb(hue_f, saturation_f, intensity_f, &r, &g, &b);
-    current_hue        = hue;
-    current_saturation = saturation;
-    current_intensity  = intensity;
-    lcd_backlight_hal_color(r, g, b);
-}
-
-void lcd_backlight_brightness(uint8_t b) {
-    current_brightness = b;
-    lcd_backlight_color(current_hue, current_saturation, current_intensity);
-}
-
-uint8_t lcd_get_backlight_brightness(void) { return current_brightness; }
--- a/quantum/visualizer/lcd_backlight.h
+++ b/quantum/visualizer/lcd_backlight.h
@ -1,43 +0,0 @@
-/*
-The MIT License (MIT)
-
-Copyright (c) 2016 Fred Sundvik
-
-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.
-*/
-
-#pragma once
-
-#include <stdint.h>
-
-// Helper macros for storing hue, staturation and intensity as unsigned integers
-#define LCD_COLOR(hue, saturation, intensity) (hue << 16 | saturation << 8 | intensity)
-#define LCD_HUE(color) ((color >> 16) & 0xFF)
-#define LCD_SAT(color) ((color >> 8) & 0xFF)
-#define LCD_INT(color) (color & 0xFF)
-
-static inline uint32_t change_lcd_color_intensity(uint32_t color, uint8_t new_intensity) { return (color & 0xFFFFFF00) | new_intensity; }
-
-void    lcd_backlight_init(void);
-void    lcd_backlight_color(uint8_t hue, uint8_t saturation, uint8_t intensity);
-void    lcd_backlight_brightness(uint8_t b);
-uint8_t lcd_get_backlight_brightness(void);
-
-void lcd_backlight_hal_init(void);
-void lcd_backlight_hal_color(uint16_t r, uint16_t g, uint16_t b);
--- a/quantum/visualizer/lcd_backlight_keyframes.c
+++ b/quantum/visualizer/lcd_backlight_keyframes.c
@ -1,69 +0,0 @@
-/* Copyright 2017 Fred Sundvik
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "lcd_backlight_keyframes.h"
-
-bool lcd_backlight_keyframe_animate_color(keyframe_animation_t* animation, visualizer_state_t* state) {
-    int     frame_length = animation->frame_lengths[animation->current_frame];
-    int     current_pos  = frame_length - animation->time_left_in_frame;
-    uint8_t t_h          = LCD_HUE(state->target_lcd_color);
-    uint8_t t_s          = LCD_SAT(state->target_lcd_color);
-    uint8_t t_i          = LCD_INT(state->target_lcd_color);
-    uint8_t p_h          = LCD_HUE(state->prev_lcd_color);
-    uint8_t p_s          = LCD_SAT(state->prev_lcd_color);
-    uint8_t p_i          = LCD_INT(state->prev_lcd_color);
-
-    uint8_t d_h1 = t_h - p_h;  // Modulo arithmetic since we want to wrap around
-    int     d_h2 = t_h - p_h;
-    // Chose the shortest way around
-    int d_h = abs(d_h2) < d_h1 ? d_h2 : d_h1;
-    int d_s = t_s - p_s;
-    int d_i = t_i - p_i;
-
-    int hue       = (d_h * current_pos) / frame_length;
-    int sat       = (d_s * current_pos) / frame_length;
-    int intensity = (d_i * current_pos) / frame_length;
-    // dprintf("%X -> %X = %X\n", p_h, t_h, hue);
-    hue += p_h;
-    sat += p_s;
-    intensity += p_i;
-    state->current_lcd_color = LCD_COLOR(hue, sat, intensity);
-    lcd_backlight_color(LCD_HUE(state->current_lcd_color), LCD_SAT(state->current_lcd_color), LCD_INT(state->current_lcd_color));
-
-    return true;
-}
-
-bool lcd_backlight_keyframe_set_color(keyframe_animation_t* animation, visualizer_state_t* state) {
-    (void)animation;
-    state->prev_lcd_color    = state->target_lcd_color;
-    state->current_lcd_color = state->target_lcd_color;
-    lcd_backlight_color(LCD_HUE(state->current_lcd_color), LCD_SAT(state->current_lcd_color), LCD_INT(state->current_lcd_color));
-    return false;
-}
-
-bool lcd_backlight_keyframe_disable(keyframe_animation_t* animation, visualizer_state_t* state) {
-    (void)animation;
-    (void)state;
-    lcd_backlight_hal_color(0, 0, 0);
-    return false;
-}
-
-bool lcd_backlight_keyframe_enable(keyframe_animation_t* animation, visualizer_state_t* state) {
-    (void)animation;
-    (void)state;
-    lcd_backlight_color(LCD_HUE(state->current_lcd_color), LCD_SAT(state->current_lcd_color), LCD_INT(state->current_lcd_color));
-    return false;
-}
--- a/quantum/visualizer/lcd_backlight_keyframes.h
+++ b/quantum/visualizer/lcd_backlight_keyframes.h
@ -1,27 +0,0 @@
-/* Copyright 2017 Fred Sundvik
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#pragma once
-
-#include "visualizer.h"
-
-// Animates the LCD backlight color between the current color and the target color (of the state)
-bool lcd_backlight_keyframe_animate_color(keyframe_animation_t* animation, visualizer_state_t* state);
-// Sets the backlight color to the target color
-bool lcd_backlight_keyframe_set_color(keyframe_animation_t* animation, visualizer_state_t* state);
-
-bool lcd_backlight_keyframe_disable(keyframe_animation_t* animation, visualizer_state_t* state);
-bool lcd_backlight_keyframe_enable(keyframe_animation_t* animation, visualizer_state_t* state);
--- a/quantum/visualizer/lcd_keyframes.c
+++ b/quantum/visualizer/lcd_keyframes.c
@ -1,184 +0,0 @@
-/* Copyright 2017 Fred Sundvik
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "lcd_keyframes.h"
-#include <string.h>
-#include "action_util.h"
-#include "led.h"
-#include "resources/resources.h"
-
-bool lcd_keyframe_display_layer_text(keyframe_animation_t* animation, visualizer_state_t* state) {
-    (void)animation;
-    gdispClear(White);
-    gdispDrawString(0, 10, state->layer_text, state->font_dejavusansbold12, Black);
-    return false;
-}
-
-static void format_layer_bitmap_string(uint16_t default_layer, uint16_t layer, char* buffer) {
-    for (int i = 0; i < 16; i++) {
-        uint32_t mask = (1u << i);
-        if (default_layer & mask) {
-            if (layer & mask) {
-                *buffer = 'B';
-            } else {
-                *buffer = 'D';
-            }
-        } else if (layer & mask) {
-            *buffer = '1';
-        } else {
-            *buffer = '0';
-        }
-        ++buffer;
-
-        if (i == 3 || i == 7 || i == 11) {
-            *buffer = ' ';
-            ++buffer;
-        }
-    }
-    *buffer = 0;
-}
-
-bool lcd_keyframe_display_layer_bitmap(keyframe_animation_t* animation, visualizer_state_t* state) {
-    (void)animation;
-    const char* layer_help = "1=On D=Default B=Both";
-    char        layer_buffer[16 + 4];  // 3 spaces and one null terminator
-    gdispClear(White);
-    gdispDrawString(0, 0, layer_help, state->font_fixed5x8, Black);
-    format_layer_bitmap_string(state->status.default_layer, state->status.layer, layer_buffer);
-    gdispDrawString(0, 10, layer_buffer, state->font_fixed5x8, Black);
-    format_layer_bitmap_string(state->status.default_layer >> 16, state->status.layer >> 16, layer_buffer);
-    gdispDrawString(0, 20, layer_buffer, state->font_fixed5x8, Black);
-    return false;
-}
-
-static void format_mods_bitmap_string(uint8_t mods, char* buffer) {
-    *buffer = ' ';
-    ++buffer;
-
-    for (int i = 0; i < 8; i++) {
-        uint32_t mask = (1u << i);
-        if (mods & mask) {
-            *buffer = '1';
-        } else {
-            *buffer = '0';
-        }
-        ++buffer;
-
-        if (i == 3) {
-            *buffer = ' ';
-            ++buffer;
-        }
-    }
-    *buffer = 0;
-}
-
-bool lcd_keyframe_display_mods_bitmap(keyframe_animation_t* animation, visualizer_state_t* state) {
-    (void)animation;
-
-    const char* title       = "Modifier states";
-    const char* mods_header = " CSAG CSAG ";
-    char        status_buffer[12];
-
-    gdispClear(White);
-    gdispDrawString(0, 0, title, state->font_fixed5x8, Black);
-    gdispDrawString(0, 10, mods_header, state->font_fixed5x8, Black);
-    format_mods_bitmap_string(state->status.mods, status_buffer);
-    gdispDrawString(0, 20, status_buffer, state->font_fixed5x8, Black);
-
-    return false;
-}
-
-#define LED_STATE_STRING_SIZE sizeof("NUM CAPS SCRL COMP KANA")
-
-static void get_led_state_string(char* output, visualizer_state_t* state) {
-    uint8_t pos = 0;
-
-    if (state->status.leds & (1u << USB_LED_NUM_LOCK)) {
-        memcpy(output + pos, "NUM ", 4);
-        pos += 4;
-    }
-    if (state->status.leds & (1u << USB_LED_CAPS_LOCK)) {
-        memcpy(output + pos, "CAPS ", 5);
-        pos += 5;
-    }
-    if (state->status.leds & (1u << USB_LED_SCROLL_LOCK)) {
-        memcpy(output + pos, "SCRL ", 5);
-        pos += 5;
-    }
-    if (state->status.leds & (1u << USB_LED_COMPOSE)) {
-        memcpy(output + pos, "COMP ", 5);
-        pos += 5;
-    }
-    if (state->status.leds & (1u << USB_LED_KANA)) {
-        memcpy(output + pos, "KANA", 4);
-        pos += 4;
-    }
-    output[pos] = 0;
-}
-
-bool lcd_keyframe_display_led_states(keyframe_animation_t* animation, visualizer_state_t* state) {
-    (void)animation;
-    char output[LED_STATE_STRING_SIZE];
-    get_led_state_string(output, state);
-    gdispClear(White);
-    gdispDrawString(0, 10, output, state->font_dejavusansbold12, Black);
-    return false;
-}
-
-bool lcd_keyframe_display_layer_and_led_states(keyframe_animation_t* animation, visualizer_state_t* state) {
-    (void)animation;
-    gdispClear(White);
-    uint8_t y = 10;
-    if (state->status.leds) {
-        char output[LED_STATE_STRING_SIZE];
-        get_led_state_string(output, state);
-        gdispDrawString(0, 1, output, state->font_dejavusansbold12, Black);
-        y = 17;
-    }
-    gdispDrawString(0, y, state->layer_text, state->font_dejavusansbold12, Black);
-    return false;
-}
-
-bool lcd_keyframe_draw_logo(keyframe_animation_t* animation, visualizer_state_t* state) {
-    (void)state;
-    (void)animation;
-    // Read the uGFX documentation for information how to use the displays
-    // http://wiki.ugfx.org/index.php/Main_Page
-    gdispClear(Black);
-
-    // You can use static variables for things that can't be found in the animation
-    // or state structs, here we use the image
-
-    // gdispGBlitArea is a tricky function to use since it supports blitting part of the image
-    // if you have full screen image, then just use LCD_WIDTH and LCD_HEIGHT for both source and target dimensions
-    gdispGBlitArea(GDISP, 0, 0, 128, 32, 0, 0, LCD_WIDTH, (pixel_t*)resource_lcd_logo);
-
-    return false;
-}
-
-bool lcd_keyframe_disable(keyframe_animation_t* animation, visualizer_state_t* state) {
-    (void)animation;
-    (void)state;
-    gdispSetPowerMode(powerOff);
-    return false;
-}
-
-bool lcd_keyframe_enable(keyframe_animation_t* animation, visualizer_state_t* state) {
-    (void)animation;
-    (void)state;
-    gdispSetPowerMode(powerOn);
-    return false;
-}
--- a/quantum/visualizer/lcd_keyframes.h
+++ b/quantum/visualizer/lcd_keyframes.h
@ -1,35 +0,0 @@
-/* Copyright 2017 Fred Sundvik
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#pragma once
-
-#include "visualizer.h"
-
-// Displays the layer text centered vertically on the screen
-bool lcd_keyframe_display_layer_text(keyframe_animation_t* animation, visualizer_state_t* state);
-// Displays a bitmap (0/1) of all the currently active layers
-bool lcd_keyframe_display_layer_bitmap(keyframe_animation_t* animation, visualizer_state_t* state);
-// Displays a bitmap (0/1) of all the currently active mods
-bool lcd_keyframe_display_mods_bitmap(keyframe_animation_t* animation, visualizer_state_t* state);
-// Displays the keyboard led states (CAPS (Caps lock), NUM (Num lock), SCRL (Scroll lock), COMP (Compose), KANA)
-bool lcd_keyframe_display_led_states(keyframe_animation_t* animation, visualizer_state_t* state);
-// Displays both the layer text and the led states
-bool lcd_keyframe_display_layer_and_led_states(keyframe_animation_t* animation, visualizer_state_t* state);
-// Displays the QMK logo on the LCD screen
-bool lcd_keyframe_draw_logo(keyframe_animation_t* animation, visualizer_state_t* state);
-
-bool lcd_keyframe_disable(keyframe_animation_t* animation, visualizer_state_t* state);
-bool lcd_keyframe_enable(keyframe_animation_t* animation, visualizer_state_t* state);
--- a/quantum/visualizer/led_backlight_keyframes.c
+++ b/quantum/visualizer/led_backlight_keyframes.c
@ -1,143 +0,0 @@
-/*
-The MIT License (MIT)
-
-Copyright (c) 2016 Fred Sundvik
-
-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 "gfx.h"
-#include <math.h>
-#include "led_backlight_keyframes.h"
-
-static uint8_t fade_led_color(keyframe_animation_t* animation, int from, int to) {
-    int frame_length = animation->frame_lengths[animation->current_frame];
-    int current_pos  = frame_length - animation->time_left_in_frame;
-    int delta        = to - from;
-    int luma         = (delta * current_pos) / frame_length;
-    luma += from;
-    return luma;
-}
-
-static void keyframe_fade_all_leds_from_to(keyframe_animation_t* animation, uint8_t from, uint8_t to) {
-    uint8_t luma  = fade_led_color(animation, from, to);
-    color_t color = LUMA2COLOR(luma);
-    gdispGClear(LED_DISPLAY, color);
-}
-
-// TODO: Should be customizable per keyboard
-#define NUM_ROWS LED_HEIGHT
-#define NUM_COLS LED_WIDTH
-
-static uint8_t crossfade_start_frame[NUM_ROWS][NUM_COLS];
-static uint8_t crossfade_end_frame[NUM_ROWS][NUM_COLS];
-
-static uint8_t compute_gradient_color(float t, float index, float num) {
-    const float two_pi           = M_PI * 2.0f;
-    float       normalized_index = (1.0f - index / (num - 1.0f)) * two_pi;
-    float       x                = t * two_pi + normalized_index;
-    float       v                = 0.5 * (cosf(x) + 1.0f);
-    return (uint8_t)(255.0f * v);
-}
-
-bool led_backlight_keyframe_fade_in_all(keyframe_animation_t* animation, visualizer_state_t* state) {
-    (void)state;
-    keyframe_fade_all_leds_from_to(animation, 0, 255);
-    return true;
-}
-
-bool led_backlight_keyframe_fade_out_all(keyframe_animation_t* animation, visualizer_state_t* state) {
-    (void)state;
-    keyframe_fade_all_leds_from_to(animation, 255, 0);
-    return true;
-}
-
-bool led_backlight_keyframe_left_to_right_gradient(keyframe_animation_t* animation, visualizer_state_t* state) {
-    (void)state;
-    float frame_length = animation->frame_lengths[animation->current_frame];
-    float current_pos  = frame_length - animation->time_left_in_frame;
-    float t            = current_pos / frame_length;
-    for (int i = 0; i < NUM_COLS; i++) {
-        uint8_t color = compute_gradient_color(t, i, NUM_COLS);
-        gdispGDrawLine(LED_DISPLAY, i, 0, i, NUM_ROWS - 1, LUMA2COLOR(color));
-    }
-    return true;
-}
-
-bool led_backlight_keyframe_top_to_bottom_gradient(keyframe_animation_t* animation, visualizer_state_t* state) {
-    (void)state;
-    float frame_length = animation->frame_lengths[animation->current_frame];
-    float current_pos  = frame_length - animation->time_left_in_frame;
-    float t            = current_pos / frame_length;
-    for (int i = 0; i < NUM_ROWS; i++) {
-        uint8_t color = compute_gradient_color(t, i, NUM_ROWS);
-        gdispGDrawLine(LED_DISPLAY, 0, i, NUM_COLS - 1, i, LUMA2COLOR(color));
-    }
-    return true;
-}
-
-static void copy_current_led_state(uint8_t* dest) {
-    for (int i = 0; i < NUM_ROWS; i++) {
-        for (int j = 0; j < NUM_COLS; j++) {
-            dest[i * NUM_COLS + j] = gdispGGetPixelColor(LED_DISPLAY, j, i);
-        }
-    }
-}
-bool led_backlight_keyframe_crossfade(keyframe_animation_t* animation, visualizer_state_t* state) {
-    (void)state;
-    if (animation->first_update_of_frame) {
-        copy_current_led_state(&crossfade_start_frame[0][0]);
-        run_next_keyframe(animation, state);
-        copy_current_led_state(&crossfade_end_frame[0][0]);
-    }
-    for (int i = 0; i < NUM_ROWS; i++) {
-        for (int j = 0; j < NUM_COLS; j++) {
-            color_t color = LUMA2COLOR(fade_led_color(animation, crossfade_start_frame[i][j], crossfade_end_frame[i][j]));
-            gdispGDrawPixel(LED_DISPLAY, j, i, color);
-        }
-    }
-    return true;
-}
-
-bool led_backlight_keyframe_mirror_orientation(keyframe_animation_t* animation, visualizer_state_t* state) {
-    (void)state;
-    (void)animation;
-    gdispGSetOrientation(LED_DISPLAY, GDISP_ROTATE_180);
-    return false;
-}
-
-bool led_backlight_keyframe_normal_orientation(keyframe_animation_t* animation, visualizer_state_t* state) {
-    (void)state;
-    (void)animation;
-    gdispGSetOrientation(LED_DISPLAY, GDISP_ROTATE_0);
-    return false;
-}
-
-bool led_backlight_keyframe_disable(keyframe_animation_t* animation, visualizer_state_t* state) {
-    (void)state;
-    (void)animation;
-    gdispGSetPowerMode(LED_DISPLAY, powerOff);
-    return false;
-}
-
-bool led_backlight_keyframe_enable(keyframe_animation_t* animation, visualizer_state_t* state) {
-    (void)state;
-    (void)animation;
-    gdispGSetPowerMode(LED_DISPLAY, powerOn);
-    return false;
-}
--- a/quantum/visualizer/led_backlight_keyframes.h
+++ b/quantum/visualizer/led_backlight_keyframes.h
@ -1,40 +0,0 @@
-/*
-The MIT License (MIT)
-
-Copyright (c) 2016 Fred Sundvik
-
-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.
-*/
-
-#pragma once
-
-#include "visualizer.h"
-
-bool led_backlight_keyframe_fade_in_all(keyframe_animation_t* animation, visualizer_state_t* state);
-bool led_backlight_keyframe_fade_out_all(keyframe_animation_t* animation, visualizer_state_t* state);
-bool led_backlight_keyframe_left_to_right_gradient(keyframe_animation_t* animation, visualizer_state_t* state);
-bool led_backlight_keyframe_top_to_bottom_gradient(keyframe_animation_t* animation, visualizer_state_t* state);
-bool led_backlight_keyframe_crossfade(keyframe_animation_t* animation, visualizer_state_t* state);
-bool led_backlight_keyframe_mirror_orientation(keyframe_animation_t* animation, visualizer_state_t* state);
-bool led_backlight_keyframe_normal_orientation(keyframe_animation_t* animation, visualizer_state_t* state);
-
-bool led_backlight_keyframe_disable(keyframe_animation_t* animation, visualizer_state_t* state);
-bool led_backlight_keyframe_enable(keyframe_animation_t* animation, visualizer_state_t* state);
-
-extern keyframe_animation_t led_test_animation;
--- a/quantum/visualizer/readme.md
+++ b/quantum/visualizer/readme.md
@ -1,18 +0,0 @@
-# A visualization library for the TMK keyboard firmware
-
-This library is designed to work together with the [TMK keyboard firmware](https://github.com/tmk/tmk_keyboard). Currently it only works for [Chibios](http://www.chibios.org/)
- flavors, but it would be possible to add support for other configurations as well. The LCD display functionality is provided by the [uGFX library](https://ugfx.io/). 
-
-## To use this library as a user
-You can and should modify the visualizer\_user.c file. Check the comments in the file for more information.
-
-## To add this library to custom keyboard projects
-
-1. Add tmk_visualizer as a submodule to your project
-1. Set VISUALIZER_DIR in the main keyboard project makefile to point to the submodule
-1. Define LCD\_ENABLE and/or LCD\_BACKLIGHT\_ENABLE, to enable support
-1. Include the visualizer.mk make file
-1. Copy the files in the example\_integration folder to your keyboard project
-1. All other files than the callback.c file are included automatically, so you will need to add callback.c to your makefile manually. If you already have a similar file in your project, you can just copy the functions instead of the whole file.
-1. Edit the files to match your hardware. You might might want to read the Chibios and UGfx documentation, for more information.
-1. If you enable LCD support you might also have to write a custom uGFX display driver, check the uGFX documentation for that. You probably also want to enable SPI support in your Chibios configuration.
--- a/quantum/visualizer/resources/lcd_logo.c
+++ b/quantum/visualizer/resources/lcd_logo.c
@ -1,45 +0,0 @@
-/* Copyright 2017 Fred Sundvik
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "resources.h"
-
-// clang-format off
-
-// To generate an image array like this
-// Ensure the image is 128 x 32 or smaller
-// Convert the bitmap to a C array using a program like http://www.riuson.com/lcd-image-converter/
-// Ensure the the conversion process produces a monochrome format array - 1 bit/pixel, left to right, top to bottom
-// Update array in the source code with the C array produced by the conversion program
-
-// The image below is generated from lcd_logo.png
-__attribute__((weak)) const uint8_t resource_lcd_logo[512] = {
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x02, 0x92, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x92, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x02, 0x92, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x1F, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0xFE, 0xEE, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1E, 0xEE, 0xF0, 0x01, 0xC6, 0x0D, 0x8C, 0x1F, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0xFE, 0xEE, 0xFE, 0x03, 0xE7, 0x1D, 0x9C, 0x1F, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1E, 0xEE, 0xF0, 0x06, 0x37, 0x1D, 0xB8, 0x18, 0x0B, 0x59, 0xC8, 0x09, 0xE5, 0x9E, 0x00,
-    0x00, 0x1E, 0xEE, 0xF0, 0x06, 0x37, 0xBD, 0xF0, 0x18, 0x6F, 0x7F, 0xEC, 0x9B, 0x37, 0xB3, 0x00, 0x00, 0xFE, 0xEE, 0xFE, 0x06, 0x37, 0xBD, 0xE0, 0x1F, 0x6C, 0x66, 0x6D, 0xD8, 0x36, 0x33, 0x00,
-    0x00, 0x1E, 0xEE, 0xF0, 0x06, 0x36, 0xED, 0xF0, 0x1F, 0x6C, 0x66, 0x6D, 0x59, 0xF6, 0x3E, 0x00, 0x00, 0x1F, 0x6D, 0xF0, 0x06, 0x36, 0xED, 0xB8, 0x18, 0x6C, 0x66, 0x67, 0x73, 0x36, 0x30, 0x00,
-    0x00, 0xFF, 0x83, 0xFE, 0x03, 0xE6, 0x4D, 0x9C, 0x18, 0x6C, 0x66, 0x67, 0x73, 0x36, 0x1F, 0x00, 0x00, 0x1F, 0xEF, 0xF0, 0x01, 0xC6, 0x0D, 0x8C, 0x18, 0x6C, 0x66, 0x62, 0x21, 0xD6, 0x0E, 0x00,
-    0x00, 0xFF, 0xEF, 0xFE, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xF0, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x1F, 0xFF, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x02, 0x92, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x92, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x02, 0x92, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-};
--- a/quantum/visualizer/resources/lcd_logo.png
+++ b/quantum/visualizer/resources/lcd_logo.png
--- a/quantum/visualizer/resources/resources.h
+++ b/quantum/visualizer/resources/resources.h
@ -1,23 +0,0 @@
-/* Copyright 2017 Fred Sundvik
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#pragma once
-
-#include <stdint.h>
-
-#ifdef LCD_ENABLE
-extern const uint8_t resource_lcd_logo[];
-#endif
--- a/quantum/visualizer/visualizer.c
+++ b/quantum/visualizer/visualizer.c
@ -1,483 +0,0 @@
-/*
-The MIT License (MIT)
-
-Copyright (c) 2016 Fred Sundvik
-
-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 "config.h"
-#include "visualizer.h"
-#include <string.h>
-#ifdef PROTOCOL_CHIBIOS
-#    include <ch.h>
-#endif
-
-#include "gfx.h"
-
-#ifdef LCD_BACKLIGHT_ENABLE
-#    include "lcd_backlight.h"
-#endif
-
-//#define DEBUG_VISUALIZER
-
-#ifdef DEBUG_VISUALIZER
-#    include "debug.h"
-#else
-#    include "nodebug.h"
-#endif
-
-#ifdef SERIAL_LINK_ENABLE
-#    include "serial_link/protocol/transport.h"
-#    include "serial_link/system/serial_link.h"
-#endif
-
-#include "action_util.h"
-
-// Define this in config.h
-#ifndef VISUALIZER_THREAD_PRIORITY
-// The visualizer needs gfx thread priorities
-#    define VISUALIZER_THREAD_PRIORITY (NORMAL_PRIORITY - 2)
-#endif
-
-static visualizer_keyboard_status_t current_status = {.layer         = 0xFFFFFFFF,
-                                                      .default_layer = 0xFFFFFFFF,
-                                                      .leds          = 0xFFFFFFFF,
-#ifdef BACKLIGHT_ENABLE
-                                                      .backlight_level = 0,
-#endif
-                                                      .mods      = 0xFF,
-                                                      .suspended = false,
-#ifdef VISUALIZER_USER_DATA_SIZE
-                                                      .user_data = {0}
-#endif
-};
-
-static bool same_status(visualizer_keyboard_status_t* status1, visualizer_keyboard_status_t* status2) {
-    return status1->layer == status2->layer && status1->default_layer == status2->default_layer && status1->mods == status2->mods && status1->leds == status2->leds && status1->suspended == status2->suspended
-#ifdef BACKLIGHT_ENABLE
-           && status1->backlight_level == status2->backlight_level
-#endif
-#ifdef VISUALIZER_USER_DATA_SIZE
-           && memcmp(status1->user_data, status2->user_data, VISUALIZER_USER_DATA_SIZE) == 0
-#endif
-        ;
-}
-
-static bool visualizer_enabled = false;
-
-#ifdef VISUALIZER_USER_DATA_SIZE
-static uint8_t user_data[VISUALIZER_USER_DATA_SIZE];
-#endif
-
-#define MAX_SIMULTANEOUS_ANIMATIONS 4
-static keyframe_animation_t* animations[MAX_SIMULTANEOUS_ANIMATIONS] = {};
-
-#ifdef SERIAL_LINK_ENABLE
-MASTER_TO_ALL_SLAVES_OBJECT(current_status, visualizer_keyboard_status_t);
-
-static remote_object_t* remote_objects[] = {
-    REMOTE_OBJECT(current_status),
-};
-
-#endif
-
-GDisplay* LCD_DISPLAY = 0;
-GDisplay* LED_DISPLAY = 0;
-
-#ifdef LCD_DISPLAY_NUMBER
-__attribute__((weak)) GDisplay* get_lcd_display(void) { return gdispGetDisplay(LCD_DISPLAY_NUMBER); }
-#endif
-
-#ifdef LED_DISPLAY_NUMBER
-__attribute__((weak)) GDisplay* get_led_display(void) { return gdispGetDisplay(LED_DISPLAY_NUMBER); }
-#endif
-
-void start_keyframe_animation(keyframe_animation_t* animation) {
-    animation->current_frame      = -1;
-    animation->time_left_in_frame = 0;
-    animation->need_update        = true;
-    int free_index                = -1;
-    for (int i = 0; i < MAX_SIMULTANEOUS_ANIMATIONS; i++) {
-        if (animations[i] == animation) {
-            return;
-        }
-        if (free_index == -1 && animations[i] == NULL) {
-            free_index = i;
-        }
-    }
-    if (free_index != -1) {
-        animations[free_index] = animation;
-    }
-}
-
-void stop_keyframe_animation(keyframe_animation_t* animation) {
-    animation->current_frame         = animation->num_frames;
-    animation->time_left_in_frame    = 0;
-    animation->need_update           = true;
-    animation->first_update_of_frame = false;
-    animation->last_update_of_frame  = false;
-    for (int i = 0; i < MAX_SIMULTANEOUS_ANIMATIONS; i++) {
-        if (animations[i] == animation) {
-            animations[i] = NULL;
-            return;
-        }
-    }
-}
-
-void stop_all_keyframe_animations(void) {
-    for (int i = 0; i < MAX_SIMULTANEOUS_ANIMATIONS; i++) {
-        if (animations[i]) {
-            animations[i]->current_frame         = animations[i]->num_frames;
-            animations[i]->time_left_in_frame    = 0;
-            animations[i]->need_update           = true;
-            animations[i]->first_update_of_frame = false;
-            animations[i]->last_update_of_frame  = false;
-            animations[i]                        = NULL;
-        }
-    }
-}
-
-static uint8_t get_num_running_animations(void) {
-    uint8_t count = 0;
-    for (int i = 0; i < MAX_SIMULTANEOUS_ANIMATIONS; i++) {
-        count += animations[i] ? 1 : 0;
-    }
-    return count;
-}
-
-static bool update_keyframe_animation(keyframe_animation_t* animation, visualizer_state_t* state, systemticks_t delta, systemticks_t* sleep_time) {
-    // TODO: Clean up this messy code
-    dprintf("Animation frame%d, left %d, delta %d\n", animation->current_frame, animation->time_left_in_frame, delta);
-    if (animation->current_frame == animation->num_frames) {
-        animation->need_update = false;
-        return false;
-    }
-    if (animation->current_frame == -1) {
-        animation->current_frame         = 0;
-        animation->time_left_in_frame    = animation->frame_lengths[0];
-        animation->need_update           = true;
-        animation->first_update_of_frame = true;
-    } else {
-        animation->time_left_in_frame -= delta;
-        while (animation->time_left_in_frame <= 0) {
-            int left = animation->time_left_in_frame;
-            if (animation->need_update) {
-                animation->time_left_in_frame   = 0;
-                animation->last_update_of_frame = true;
-                (*animation->frame_functions[animation->current_frame])(animation, state);
-                animation->last_update_of_frame = false;
-            }
-            animation->current_frame++;
-            animation->need_update           = true;
-            animation->first_update_of_frame = true;
-            if (animation->current_frame == animation->num_frames) {
-                if (animation->loop) {
-                    animation->current_frame = 0;
-                } else {
-                    stop_keyframe_animation(animation);
-                    return false;
-                }
-            }
-            delta                         = -left;
-            animation->time_left_in_frame = animation->frame_lengths[animation->current_frame];
-            animation->time_left_in_frame -= delta;
-        }
-    }
-    if (animation->need_update) {
-        animation->need_update           = (*animation->frame_functions[animation->current_frame])(animation, state);
-        animation->first_update_of_frame = false;
-    }
-
-    systemticks_t wanted_sleep = animation->need_update ? gfxMillisecondsToTicks(10) : (unsigned)animation->time_left_in_frame;
-    if (wanted_sleep < *sleep_time) {
-        *sleep_time = wanted_sleep;
-    }
-
-    return true;
-}
-
-void run_next_keyframe(keyframe_animation_t* animation, visualizer_state_t* state) {
-    int next_frame = animation->current_frame + 1;
-    if (next_frame == animation->num_frames) {
-        next_frame = 0;
-    }
-    keyframe_animation_t temp_animation  = *animation;
-    temp_animation.current_frame         = next_frame;
-    temp_animation.time_left_in_frame    = animation->frame_lengths[next_frame];
-    temp_animation.first_update_of_frame = true;
-    temp_animation.last_update_of_frame  = false;
-    temp_animation.need_update           = false;
-    visualizer_state_t temp_state        = *state;
-    (*temp_animation.frame_functions[next_frame])(&temp_animation, &temp_state);
-}
-
-// TODO: Optimize the stack size, this is probably way too big
-static DECLARE_THREAD_STACK(visualizerThreadStack, 1024);
-static DECLARE_THREAD_FUNCTION(visualizerThread, arg) {
-    (void)arg;
-
-    GListener event_listener;
-    geventListenerInit(&event_listener);
-    geventAttachSource(&event_listener, (GSourceHandle)&current_status, 0);
-
-    visualizer_keyboard_status_t initial_status = {
-        .default_layer = 0xFFFFFFFF,
-        .layer         = 0xFFFFFFFF,
-        .mods          = 0xFF,
-        .leds          = 0xFFFFFFFF,
-        .suspended     = false,
-#ifdef BACKLIGHT_ENABLE
-        .backlight_level = 0,
-#endif
-#ifdef VISUALIZER_USER_DATA_SIZE
-        .user_data = {0},
-#endif
-    };
-
-    visualizer_state_t state = {.status            = initial_status,
-                                .current_lcd_color = 0,
-#ifdef LCD_ENABLE
-                                .font_fixed5x8         = gdispOpenFont("fixed_5x8"),
-                                .font_dejavusansbold12 = gdispOpenFont("DejaVuSansBold12")
-#endif
-    };
-    initialize_user_visualizer(&state);
-    state.prev_lcd_color = state.current_lcd_color;
-
-#ifdef LCD_BACKLIGHT_ENABLE
-    lcd_backlight_color(LCD_HUE(state.current_lcd_color), LCD_SAT(state.current_lcd_color), LCD_INT(state.current_lcd_color));
-#endif
-
-    systemticks_t sleep_time   = TIME_INFINITE;
-    systemticks_t current_time = gfxSystemTicks();
-    bool          force_update = true;
-
-    while (true) {
-        systemticks_t new_time = gfxSystemTicks();
-        systemticks_t delta    = new_time - current_time;
-        current_time           = new_time;
-        bool enabled           = visualizer_enabled;
-        if (force_update || !same_status(&state.status, &current_status)) {
-            force_update = false;
-#if BACKLIGHT_ENABLE
-            if (current_status.backlight_level != state.status.backlight_level) {
-                if (current_status.backlight_level != 0) {
-                    gdispGSetPowerMode(LED_DISPLAY, powerOn);
-                    uint16_t percent = (uint16_t)current_status.backlight_level * 100 / BACKLIGHT_LEVELS;
-                    gdispGSetBacklight(LED_DISPLAY, percent);
-                } else {
-                    gdispGSetPowerMode(LED_DISPLAY, powerOff);
-                }
-                state.status.backlight_level = current_status.backlight_level;
-            }
-#endif
-            if (visualizer_enabled) {
-                if (current_status.suspended) {
-                    stop_all_keyframe_animations();
-                    visualizer_enabled = false;
-                    state.status       = current_status;
-                    user_visualizer_suspend(&state);
-                } else {
-                    visualizer_keyboard_status_t prev_status = state.status;
-                    state.status                             = current_status;
-                    update_user_visualizer_state(&state, &prev_status);
-                }
-                state.prev_lcd_color = state.current_lcd_color;
-            }
-        }
-        if (!enabled && state.status.suspended && current_status.suspended == false) {
-            // Setting the status to the initial status will force an update
-            // when the visualizer is enabled again
-            state.status           = initial_status;
-            state.status.suspended = false;
-            stop_all_keyframe_animations();
-            user_visualizer_resume(&state);
-            state.prev_lcd_color = state.current_lcd_color;
-        }
-        sleep_time = TIME_INFINITE;
-        for (int i = 0; i < MAX_SIMULTANEOUS_ANIMATIONS; i++) {
-            if (animations[i]) {
-                update_keyframe_animation(animations[i], &state, delta, &sleep_time);
-            }
-        }
-#ifdef BACKLIGHT_ENABLE
-        gdispGFlush(LED_DISPLAY);
-#endif
-
-#ifdef LCD_ENABLE
-        gdispGFlush(LCD_DISPLAY);
-#endif
-
-#ifdef EMULATOR
-        draw_emulator();
-#endif
-        // Enable the visualizer when the startup or the suspend animation has finished
-        if (!visualizer_enabled && state.status.suspended == false && get_num_running_animations() == 0) {
-            visualizer_enabled = true;
-            force_update       = true;
-            sleep_time         = 0;
-        }
-
-        systemticks_t after_update = gfxSystemTicks();
-        unsigned      update_delta = after_update - current_time;
-        if (sleep_time != TIME_INFINITE) {
-            if (sleep_time > update_delta) {
-                sleep_time -= update_delta;
-            } else {
-                sleep_time = 0;
-            }
-        }
-        dprintf("Update took %d, last delta %d, sleep_time %d\n", update_delta, delta, sleep_time);
-#ifdef PROTOCOL_CHIBIOS
-        // The gEventWait function really takes milliseconds, even if the documentation says ticks.
-        // Unfortunately there's no generic ugfx conversion from system time to milliseconds,
-        // so let's do it in a platform dependent way.
-
-        // On windows the system ticks is the same as milliseconds anyway
-        if (sleep_time != TIME_INFINITE) {
-            sleep_time = TIME_I2MS(sleep_time);
-        }
-#endif
-        geventEventWait(&event_listener, sleep_time);
-    }
-#ifdef LCD_ENABLE
-    gdispCloseFont(state.font_fixed5x8);
-    gdispCloseFont(state.font_dejavusansbold12);
-#endif
-
-    return 0;
-}
-
-void visualizer_init(void) {
-    gfxInit();
-
-#ifdef LCD_BACKLIGHT_ENABLE
-    lcd_backlight_init();
-#endif
-
-#ifdef SERIAL_LINK_ENABLE
-    add_remote_objects(remote_objects, sizeof(remote_objects) / sizeof(remote_object_t*));
-#endif
-
-#ifdef LCD_ENABLE
-    LCD_DISPLAY = get_lcd_display();
-#endif
-
-#ifdef BACKLIGHT_ENABLE
-    LED_DISPLAY = get_led_display();
-#endif
-
-    // We are using a low priority thread, the idea is to have it run only
-    // when the main thread is sleeping during the matrix scanning
-    gfxThreadCreate(visualizerThreadStack, sizeof(visualizerThreadStack), VISUALIZER_THREAD_PRIORITY, visualizerThread, NULL);
-}
-
-void update_status(bool changed) {
-    if (changed) {
-        GSourceListener* listener = geventGetSourceListener((GSourceHandle)&current_status, NULL);
-        if (listener) {
-            geventSendEvent(listener);
-        }
-    }
-#ifdef SERIAL_LINK_ENABLE
-    static systime_t last_update    = 0;
-    systime_t        current_update = chVTGetSystemTimeX();
-    systime_t        delta          = current_update - last_update;
-    if (changed || delta > TIME_MS2I(10)) {
-        last_update                     = current_update;
-        visualizer_keyboard_status_t* r = begin_write_current_status();
-        *r                              = current_status;
-        end_write_current_status();
-    }
-#endif
-}
-
-uint8_t visualizer_get_mods() {
-    uint8_t mods = get_mods();
-
-#ifndef NO_ACTION_ONESHOT
-    if (!has_oneshot_mods_timed_out()) {
-        mods |= get_oneshot_mods();
-    }
-#endif
-    return mods;
-}
-
-#ifdef VISUALIZER_USER_DATA_SIZE
-void visualizer_set_user_data(void* u) { memcpy(user_data, u, VISUALIZER_USER_DATA_SIZE); }
-#endif
-
-void visualizer_update(layer_state_t default_state, layer_state_t state, uint8_t mods, uint32_t leds) {
-    // Note that there's a small race condition here, the thread could read
-    // a state where one of these are set but not the other. But this should
-    // not really matter as it will be fixed during the next loop step.
-    // Alternatively a mutex could be used instead of the volatile variables
-
-    bool changed = false;
-#ifdef SERIAL_LINK_ENABLE
-    if (is_serial_link_connected()) {
-        visualizer_keyboard_status_t* new_status = read_current_status();
-        if (new_status) {
-            if (!same_status(&current_status, new_status)) {
-                changed        = true;
-                current_status = *new_status;
-            }
-        }
-    } else {
-#else
-    {
-#endif
-        visualizer_keyboard_status_t new_status = {
-            .layer         = state,
-            .default_layer = default_state,
-            .mods          = mods,
-            .leds          = leds,
-#ifdef BACKLIGHT_ENABLE
-            .backlight_level = current_status.backlight_level,
-#endif
-            .suspended = current_status.suspended,
-        };
-#ifdef VISUALIZER_USER_DATA_SIZE
-        memcpy(new_status.user_data, user_data, VISUALIZER_USER_DATA_SIZE);
-#endif
-        if (!same_status(&current_status, &new_status)) {
-            changed        = true;
-            current_status = new_status;
-        }
-    }
-    update_status(changed);
-}
-
-void visualizer_suspend(void) {
-    current_status.suspended = true;
-    update_status(true);
-}
-
-void visualizer_resume(void) {
-    current_status.suspended = false;
-    update_status(true);
-}
-
-#ifdef BACKLIGHT_ENABLE
-void backlight_set(uint8_t level) {
-    current_status.backlight_level = level;
-    update_status(true);
-}
-#endif
--- a/quantum/visualizer/visualizer.h
+++ b/quantum/visualizer/visualizer.h
@ -1,154 +0,0 @@
-/*
-The MIT License (MIT)
-
-Copyright (c) 2016 Fred Sundvik
-
-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.
-*/
-
-#pragma once
-
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdbool.h>
-
-#include "config.h"
-#include "gfx.h"
-#include "action_layer.h"
-
-#ifdef LCD_BACKLIGHT_ENABLE
-#    include "lcd_backlight.h"
-#endif
-
-#ifdef BACKLIGHT_ENABLE
-#    include "backlight.h"
-#endif
-
-// use this function to merge both real_mods and oneshot_mods in a uint16_t
-uint8_t visualizer_get_mods(void);
-
-// This need to be called once at the start
-void visualizer_init(void);
-// This should be called at every matrix scan
-void visualizer_update(layer_state_t default_state, layer_state_t state, uint8_t mods, uint32_t leds);
-
-// This should be called when the keyboard goes to suspend state
-void visualizer_suspend(void);
-// This should be called when the keyboard wakes up from suspend state
-void visualizer_resume(void);
-
-// These functions are week, so they can be overridden by the keyboard
-// if needed
-GDisplay* get_lcd_display(void);
-GDisplay* get_led_display(void);
-
-// For emulator builds, this function need to be implemented
-#ifdef EMULATOR
-void draw_emulator(void);
-#endif
-
-// If you need support for more than 16 keyframes per animation, you can change this
-#define MAX_VISUALIZER_KEY_FRAMES 16
-
-struct keyframe_animation_t;
-
-typedef struct {
-    layer_state_t layer;
-    layer_state_t default_layer;
-    uint32_t      leds;  // See led.h for available statuses
-    uint8_t       mods;
-    bool          suspended;
-#ifdef BACKLIGHT_ENABLE
-    uint8_t backlight_level;
-#endif
-#ifdef VISUALIZER_USER_DATA_SIZE
-    uint8_t user_data[VISUALIZER_USER_DATA_SIZE];
-#endif
-} visualizer_keyboard_status_t;
-
-// The state struct is used by the various keyframe functions
-// It's also used for setting the LCD color and layer text
-// from the user customized code
-typedef struct visualizer_state_t {
-    // The user code should primarily be modifying these
-    uint32_t    target_lcd_color;
-    const char* layer_text;
-
-    // The user visualizer(and animation functions) can read these
-    visualizer_keyboard_status_t status;
-
-    // These are used by the animation functions
-    uint32_t current_lcd_color;
-    uint32_t prev_lcd_color;
-#ifdef LCD_ENABLE
-    gFont font_fixed5x8;
-    gFont font_dejavusansbold12;
-#endif
-} visualizer_state_t;
-
-// Any custom keyframe function should have this signature
-// return true to get continuous updates, otherwise you will only get one
-// update per frame
-typedef bool (*frame_func)(struct keyframe_animation_t*, visualizer_state_t*);
-
-// Represents a keyframe animation, so fields are internal to the system
-// while others are meant to be initialized by the user code
-typedef struct keyframe_animation_t {
-    // These should be initialized
-    int        num_frames;
-    bool       loop;
-    int        frame_lengths[MAX_VISUALIZER_KEY_FRAMES];
-    frame_func frame_functions[MAX_VISUALIZER_KEY_FRAMES];
-
-    // Used internally by the system, and can also be read by
-    // keyframe update functions
-    int  current_frame;
-    int  time_left_in_frame;
-    bool first_update_of_frame;
-    bool last_update_of_frame;
-    bool need_update;
-
-} keyframe_animation_t;
-
-extern GDisplay* LCD_DISPLAY;
-extern GDisplay* LED_DISPLAY;
-
-void start_keyframe_animation(keyframe_animation_t* animation);
-void stop_keyframe_animation(keyframe_animation_t* animation);
-// This runs the next keyframe, but does not update the animation state
-// Useful for crossfades for example
-void run_next_keyframe(keyframe_animation_t* animation, visualizer_state_t* state);
-
-// The master can set userdata which will be transferred to the slave
-#ifdef VISUALIZER_USER_DATA_SIZE
-void visualizer_set_user_data(void* user_data);
-#endif
-
-// These functions have to be implemented by the user
-// Called regularly each time the state has changed (but not every scan loop)
-void update_user_visualizer_state(visualizer_state_t* state, visualizer_keyboard_status_t* prev_status);
-// Called when the computer goes to suspend, will also stop calling update_user_visualizer_state
-void user_visualizer_suspend(visualizer_state_t* state);
-// You have to start at least one animation as a response to the following two functions
-// When the animation has finished the visualizer will resume normal operation and start calling the
-// update_user_visualizer_state again
-// Called when the keyboard boots up
-void initialize_user_visualizer(visualizer_state_t* state);
-// Called when the computer resumes from a suspend
-void user_visualizer_resume(visualizer_state_t* state);
--- a/quantum/visualizer/visualizer.mk
+++ b/quantum/visualizer/visualizer.mk
@ -1,123 +0,0 @@
-# The MIT License (MIT)
-# 
-# Copyright (c) 2016 Fred Sundvik
-# 
-# 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.
-
-define ADD_DRIVER
-    $(1)_DRIVER:=$(strip $($(1)_DRIVER))
-    $(1)_WIDTH:=$(strip $($(1)_WIDTH))
-    $(1)_HEIGHT:=$(strip $($(1)_HEIGHT))
-    ifeq ($($(1)_DRIVER),)
-        $$(error $(1)_DRIVER is not defined)
-    endif
-    ifeq ($($(1)_WIDTH),)
-        $$(error $(1)_WIDTH is not defined)
-    endif
-    ifeq ($($(1)_HEIGHT),)
-        $$(error $(1)_HEIGHT is not defined)
-    endif
-    OPT_DEFS+=-D$(1)_WIDTH=$($(1)_WIDTH)
-    OPT_DEFS+=-D$(1)_HEIGHT=$($(1)_HEIGHT)
-    GFXDEFS+=-D$(1)_WIDTH=$($(1)_WIDTH)
-    GFXDEFS+=-D$(1)_HEIGHT=$($(1)_HEIGHT)
-    $(1)_DISPLAY_NUMBER:=$$(words $$(GDISP_DRIVER_LIST))
-    OPT_DEFS+=-D$(1)_DISPLAY_NUMBER=$$($(1)_DISPLAY_NUMBER)
-    include $(TOP_DIR)/drivers/ugfx/gdisp/$($(1)_DRIVER)/driver.mk
-endef
-
-GDISP_DRIVER_LIST:=
-
-SRC += $(VISUALIZER_DIR)/visualizer.c \
-	$(VISUALIZER_DIR)/visualizer_keyframes.c
-EXTRAINCDIRS += $(GFXINC) $(VISUALIZER_DIR)
-GFXLIB = $(LIB_PATH)/ugfx
-VPATH += $(VISUALIZER_PATH)
-
-OPT_DEFS += -DVISUALIZER_ENABLE
-
-ifdef LCD_ENABLE
-OPT_DEFS += -DLCD_ENABLE
-ULIBS += -lm
-endif
-
-ifeq ($(strip $(LCD_ENABLE)), yes)
-    SRC += $(VISUALIZER_DIR)/lcd_keyframes.c
-    ifeq ($(strip $(LCD_BACKLIGHT_ENABLE)), yes)
-        OPT_DEFS += -DLCD_BACKLIGHT_ENABLE
-        SRC += $(VISUALIZER_DIR)/lcd_backlight.c
-        SRC += $(VISUALIZER_DIR)/lcd_backlight_keyframes.c
-    endif
-# Note, that the linker will strip out any resources that are not actually in use
-SRC += $(VISUALIZER_DIR)/resources/lcd_logo.c
-$(eval $(call ADD_DRIVER,LCD))
-endif
-
-ifeq ($(strip $(BACKLIGHT_ENABLE)), yes)
-SRC += $(VISUALIZER_DIR)/led_backlight_keyframes.c
-$(eval $(call ADD_DRIVER,LED))
-endif
-
-SRC += $(VISUALIZER_DIR)/default_animations.c
-
-include $(GFXLIB)/gfx.mk
-# For the common_gfxconf.h
-GFXINC += quantum/visualizer
-
-GFXSRC := $(patsubst $(TOP_DIR)/%,%,$(GFXSRC))
-GFXDEFS := $(patsubst %,-D%,$(patsubst -D%,%,$(GFXDEFS)))
-
-GDISP_LIST_COMMA=,
-GDISP_LIST_EMPTY=
-GDISP_LIST_SPACE=$(GDISP_LIST_EMPTY) $(GDISP_LIST_EMPTY)
-
-GDISP_DRIVER_LIST := $(strip $(GDISP_DRIVER_LIST))
-GDISP_DRIVER_LIST := $(subst $(GDISP_LIST_SPACE),$(GDISP_LIST_COMMA),$(GDISP_DRIVER_LIST))
-
-GFXDEFS +=-DGDISP_DRIVER_LIST="$(GDISP_DRIVER_LIST)"
-
-ifneq ("$(wildcard $(KEYMAP_PATH)/visualizer.c)","")
-    SRC += $(KEYMAP_PATH)/visualizer.c
-else 
-    VISUALIZER_1 := $(KEYBOARD_PATH_1)/visualizer.c
-    VISUALIZER_2 := $(KEYBOARD_PATH_2)/visualizer.c
-    VISUALIZER_3 := $(KEYBOARD_PATH_3)/visualizer.c
-    VISUALIZER_4 := $(KEYBOARD_PATH_4)/visualizer.c
-    VISUALIZER_5 := $(KEYBOARD_PATH_5)/visualizer.c
-
-    ifneq ("$(wildcard $(VISUALIZER_5))","")
-        SRC += $(VISUALIZER_5)
-    endif
-    ifneq ("$(wildcard $(VISUALIZER_4))","")
-        SRC += $(VISUALIZER_4)
-    endif
-    ifneq ("$(wildcard $(VISUALIZER_3))","")
-        SRC += $(VISUALIZER_3)
-    endif
-    ifneq ("$(wildcard $(VISUALIZER_2))","")
-        SRC += $(VISUALIZER_2)
-    endif
-    ifneq ("$(wildcard $(VISUALIZER_1))","")
-        SRC += $(VISUALIZER_1)
-    endif
-endif
-
-ifdef EMULATOR
-UINCDIR += $(TMK_DIR)/common
-endif
--- a/quantum/visualizer/visualizer_keyframes.c
+++ b/quantum/visualizer/visualizer_keyframes.c
@ -1,23 +0,0 @@
-/* Copyright 2017 Fred Sundvik
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "visualizer_keyframes.h"
-
-bool keyframe_no_operation(keyframe_animation_t* animation, visualizer_state_t* state) {
-    (void)animation;
-    (void)state;
-    return false;
-}
--- a/quantum/visualizer/visualizer_keyframes.h
+++ b/quantum/visualizer/visualizer_keyframes.h
@ -1,23 +0,0 @@
-/* Copyright 2017 Fred Sundvik
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#pragma once
-
-#include "visualizer.h"
-
-// Some predefined keyframe functions that can be used by the user code
-// Does nothing, useful for adding delays
-bool keyframe_no_operation(keyframe_animation_t* animation, visualizer_state_t* state);
--- a/show_options.mk
+++ b/show_options.mk
@ -32,7 +32,6 @@ HARDWARE_OPTION_NAMES = \
  LCD_ENABLE \
  LED_TABLES \
  POINTING_DEVICE_ENABLE \
-  VISUALIZER_ENABLE \
  DIP_SWITCH_ENABLE

 OTHER_OPTION_NAMES = \
--- a/tmk_core/protocol/chibios/chibios.c
+++ b/tmk_core/protocol/chibios/chibios.c
@ -46,9 +46,6 @@
 #ifdef SERIAL_LINK_ENABLE
 #    include "serial_link/system/serial_link.h"
 #endif
-#ifdef VISUALIZER_ENABLE
-#    include "visualizer/visualizer.h"
-#endif
 #ifdef MIDI_ENABLE
 #    include "qmk_midi.h"
 #endif
@ -161,10 +158,6 @@ void protocol_init(void) {
    init_serial_link();
 #endif

-#ifdef VISUALIZER_ENABLE
-    visualizer_init();
-#endif
-
    host_driver_t *driver = NULL;

    /* Wait until the USB or serial link is active */
@ -214,9 +207,6 @@ void protocol_task(void) {
 #if !defined(NO_USB_STARTUP_CHECK)
    if (USB_DRIVER.state == USB_SUSPENDED) {
        print("[s]");
-#    ifdef VISUALIZER_ENABLE
-        visualizer_suspend();
-#    endif
        while (USB_DRIVER.state == USB_SUSPENDED) {
            /* Do this in the suspended state */
 #    ifdef SERIAL_LINK_ENABLE
@ -235,10 +225,6 @@ void protocol_task(void) {
 #    ifdef MOUSEKEY_ENABLE
        mousekey_send();
 #    endif /* MOUSEKEY_ENABLE */
-
-#    ifdef VISUALIZER_ENABLE
-        visualizer_resume();
-#    endif
    }
 #endif

--- a/util/chibios_conf_updater.sh
+++ b/util/chibios_conf_updater.sh
@ -38,7 +38,7 @@ find_chibi_files() {
    local search_path="$1"
    shift
    local conditions=( "$@" )
-    for file in $(find -L "$search_path" -not -path '*/lib/chibios*' -and -not -path '*/lib/ugfx*' -and -not -path '*/util/*' -and \( "${conditions[@]}" \) | sort) ; do
+    for file in $(find -L "$search_path" -not -path '*/lib/chibios*' -and -not -path '*/util/*' -and \( "${conditions[@]}" \) | sort) ; do
        if [ -z "$(grep 'include_next' "$file")" ] ; then
            echo $file
        fi
				`@ -1 +0,0 @@`
				`Subproject commit 40b48f470addad6a4fb1177de1a69a181158739b`