clang-format changes

13 files changed, 364 insertions, 448 deletions

diff --git a/quantum/visualizer/common_gfxconf.h b/quantum/visualizer/common_gfxconf.h
index eb705b1881..865e588693 100644
--- a/quantum/visualizer/common_gfxconf.h
+++ b/quantum/visualizer/common_gfxconf.h
@@ -22,7 +22,6 @@
 #ifndef COMMON_GFXCONF_H
 #define COMMON_GFXCONF_H
 
-
 ///////////////////////////////////////////////////////////////////////////
 // GOS - One of these must be defined, preferably in your Makefile       //
 ///////////////////////////////////////////////////////////////////////////
@@ -41,11 +40,11 @@
 //    #define INTERRUPTS_OFF()                         optional_code
 //    #define INTERRUPTS_ON()                          optional_code
 // These are not defined by default for some reason
-#define GOS_NEED_X_THREADS	FALSE
-#define GOS_NEED_X_HEAP		FALSE
+#define GOS_NEED_X_THREADS FALSE
+#define GOS_NEED_X_HEAP FALSE
 
 // Options that (should where relevant) apply to all operating systems
-    #define GFX_NO_INLINE                            FALSE
+#define GFX_NO_INLINE FALSE
 //    #define GFX_COMPILER                             GFX_COMPILER_UNKNOWN
 //    #define GFX_CPU                                  GFX_CPU_UNKNOWN
 //    #define GFX_OS_HEAP_SIZE                         0
@@ -55,32 +54,31 @@
 //    #define GFX_OS_EXTRA_INIT_FUNCTION               myOSInitRoutine
 //    #define GFX_OS_EXTRA_DEINIT_FUNCTION             myOSDeInitRoutine
 
-
 ///////////////////////////////////////////////////////////////////////////
 // GDISP                                                                 //
 ///////////////////////////////////////////////////////////////////////////
-#define GFX_USE_GDISP                                TRUE
+#define GFX_USE_GDISP TRUE
 
 //#define GDISP_NEED_AUTOFLUSH                         FALSE
 //#define GDISP_NEED_TIMERFLUSH                        FALSE
 //#define GDISP_NEED_VALIDATION                        TRUE
 //#define GDISP_NEED_CLIP                              TRUE
-#define GDISP_NEED_CIRCLE                            TRUE
-#define GDISP_NEED_ELLIPSE                           TRUE
-#define GDISP_NEED_ARC                               TRUE
-#define GDISP_NEED_ARCSECTORS                        TRUE
-#define GDISP_NEED_CONVEX_POLYGON                    TRUE
+#define GDISP_NEED_CIRCLE TRUE
+#define GDISP_NEED_ELLIPSE TRUE
+#define GDISP_NEED_ARC TRUE
+#define GDISP_NEED_ARCSECTORS TRUE
+#define GDISP_NEED_CONVEX_POLYGON TRUE
 //#define GDISP_NEED_SCROLL                            FALSE
-#define GDISP_NEED_PIXELREAD                         TRUE
-#define GDISP_NEED_CONTROL                           TRUE
+#define GDISP_NEED_PIXELREAD TRUE
+#define GDISP_NEED_CONTROL TRUE
 //#define GDISP_NEED_QUERY                             FALSE
 //#define GDISP_NEED_MULTITHREAD                       FALSE
 //#define GDISP_NEED_STREAMING                         FALSE
-#define GDISP_NEED_TEXT                              TRUE
+#define GDISP_NEED_TEXT TRUE
 //    #define GDISP_NEED_TEXT_WORDWRAP                 FALSE
 //    #define GDISP_NEED_ANTIALIAS                     FALSE
 //    #define GDISP_NEED_UTF8                          FALSE
-    #define GDISP_NEED_TEXT_KERNING                  TRUE
+#define GDISP_NEED_TEXT_KERNING TRUE
 //    #define GDISP_INCLUDE_FONT_UI1                   FALSE
 //    #define GDISP_INCLUDE_FONT_UI2                   FALSE		// The smallest preferred font.
 //    #define GDISP_INCLUDE_FONT_LARGENUMBERS          FALSE
@@ -90,10 +88,10 @@
 //    #define GDISP_INCLUDE_FONT_DEJAVUSANS20          FALSE
 //    #define GDISP_INCLUDE_FONT_DEJAVUSANS24          FALSE
 //    #define GDISP_INCLUDE_FONT_DEJAVUSANS32          FALSE
-    #define GDISP_INCLUDE_FONT_DEJAVUSANSBOLD12      TRUE
+#define GDISP_INCLUDE_FONT_DEJAVUSANSBOLD12 TRUE
 //    #define GDISP_INCLUDE_FONT_FIXED_10X20           FALSE
 //    #define GDISP_INCLUDE_FONT_FIXED_7X14            FALSE
-    #define GDISP_INCLUDE_FONT_FIXED_5X8             TRUE
+#define GDISP_INCLUDE_FONT_FIXED_5X8 TRUE
 //    #define GDISP_INCLUDE_FONT_DEJAVUSANS12_AA       FALSE
 //    #define GDISP_INCLUDE_FONT_DEJAVUSANS16_AA       FALSE
 //    #define GDISP_INCLUDE_FONT_DEJAVUSANS20_AA       FALSE
@@ -118,50 +116,49 @@
 //    #define GDISP_NEED_IMAGE_PNG                     FALSE
 //    #define GDISP_NEED_IMAGE_ACCOUNTING              FALSE
 #ifdef EMULATOR
-#define GDISP_NEED_PIXMAP                            TRUE
+#    define GDISP_NEED_PIXMAP TRUE
 #endif
 //    #define GDISP_NEED_PIXMAP_IMAGE                  FALSE
 
 //#define GDISP_DEFAULT_ORIENTATION                    GDISP_ROTATE_LANDSCAPE    // If not defined the native hardware orientation is used.
 //#define GDISP_LINEBUF_SIZE                           128
 //#define GDISP_STARTUP_COLOR                          Black
-#define GDISP_NEED_STARTUP_LOGO                      FALSE
+#define GDISP_NEED_STARTUP_LOGO FALSE
 
 //#define GDISP_TOTAL_DISPLAYS		                 2
 
-    #ifdef GDISP_DRIVER_LIST
-        // For code and speed optimization define as TRUE or FALSE if all controllers have the same capability
-        #define GDISP_HARDWARE_STREAM_WRITE          FALSE
-        #define GDISP_HARDWARE_STREAM_READ           FALSE
-        #define GDISP_HARDWARE_STREAM_POS            FALSE
-        #define GDISP_HARDWARE_DRAWPIXEL             TRUE
-        #define GDISP_HARDWARE_CLEARS                FALSE
-        #define GDISP_HARDWARE_FILLS                 FALSE
-        //#define GDISP_HARDWARE_BITFILLS              FALSE
-        #define GDISP_HARDWARE_SCROLL                FALSE
-        #define GDISP_HARDWARE_PIXELREAD             TRUE
-        #define GDISP_HARDWARE_CONTROL               TRUE
-        #define GDISP_HARDWARE_QUERY                 FALSE
-        #define GDISP_HARDWARE_CLIP                  FALSE
-
-        #define GDISP_PIXELFORMAT                    GDISP_PIXELFORMAT_RGB888
-    #endif
+#ifdef GDISP_DRIVER_LIST
+// For code and speed optimization define as TRUE or FALSE if all controllers have the same capability
+#    define GDISP_HARDWARE_STREAM_WRITE FALSE
+#    define GDISP_HARDWARE_STREAM_READ FALSE
+#    define GDISP_HARDWARE_STREAM_POS FALSE
+#    define GDISP_HARDWARE_DRAWPIXEL TRUE
+#    define GDISP_HARDWARE_CLEARS FALSE
+#    define GDISP_HARDWARE_FILLS FALSE
+//#define GDISP_HARDWARE_BITFILLS              FALSE
+#    define GDISP_HARDWARE_SCROLL FALSE
+#    define GDISP_HARDWARE_PIXELREAD TRUE
+#    define GDISP_HARDWARE_CONTROL TRUE
+#    define GDISP_HARDWARE_QUERY FALSE
+#    define GDISP_HARDWARE_CLIP FALSE
+
+#    define GDISP_PIXELFORMAT GDISP_PIXELFORMAT_RGB888
+#endif
 
 // The custom format is not defined for some reason, so define it as error
 // so we don't get compiler warnings
 #define GDISP_PIXELFORMAT_CUSTOM GDISP_PIXELFORMAT_ERROR
 
-#define GDISP_USE_GFXNET                             FALSE
+#define GDISP_USE_GFXNET FALSE
 //    #define GDISP_GFXNET_PORT                        13001
 //    #define GDISP_GFXNET_CUSTOM_LWIP_STARTUP         FALSE
 //    #define GDISP_DONT_WAIT_FOR_NET_DISPLAY          FALSE
 //    #define GDISP_GFXNET_UNSAFE_SOCKETS              FALSE
 
-
 ///////////////////////////////////////////////////////////////////////////
 // GWIN                                                                  //
 ///////////////////////////////////////////////////////////////////////////
-#define GFX_USE_GWIN                                 FALSE
+#define GFX_USE_GWIN FALSE
 
 //#define GWIN_NEED_WINDOWMANAGER                      FALSE
 //    #define GWIN_REDRAW_IMMEDIATE                    FALSE
@@ -210,30 +207,27 @@
 //    #define GWIN_NEED_TABSET                         FALSE
 //        #define GWIN_TABSET_TABHEIGHT                18
 
-
 ///////////////////////////////////////////////////////////////////////////
 // GEVENT                                                                //
 ///////////////////////////////////////////////////////////////////////////
-#define GFX_USE_GEVENT                               TRUE
+#define GFX_USE_GEVENT TRUE
 
 //#define GEVENT_ASSERT_NO_RESOURCE                    FALSE
 //#define GEVENT_MAXIMUM_SIZE                          32
 //#define GEVENT_MAX_SOURCE_LISTENERS                  32
 
-
 ///////////////////////////////////////////////////////////////////////////
 // GTIMER                                                                //
 ///////////////////////////////////////////////////////////////////////////
-#define GFX_USE_GTIMER                               FALSE
+#define GFX_USE_GTIMER FALSE
 
 //#define GTIMER_THREAD_PRIORITY                       HIGH_PRIORITY
 //#define GTIMER_THREAD_WORKAREA_SIZE                  2048
 
-
 ///////////////////////////////////////////////////////////////////////////
 // GQUEUE                                                                //
 ///////////////////////////////////////////////////////////////////////////
-#define GFX_USE_GQUEUE                               FALSE
+#define GFX_USE_GQUEUE FALSE
 
 //#define GQUEUE_NEED_ASYNC                            FALSE
 //#define GQUEUE_NEED_GSYNC                            FALSE
@@ -243,7 +237,7 @@
 ///////////////////////////////////////////////////////////////////////////
 // GINPUT                                                                //
 ///////////////////////////////////////////////////////////////////////////
-#define GFX_USE_GINPUT                               FALSE
+#define GFX_USE_GINPUT FALSE
 
 //#define GINPUT_NEED_MOUSE                            FALSE
 //    #define GINPUT_TOUCH_STARTRAW                    FALSE
@@ -264,11 +258,10 @@
 //#define GINPUT_NEED_TOGGLE                           FALSE
 //#define GINPUT_NEED_DIAL                             FALSE
 
-
 ///////////////////////////////////////////////////////////////////////////
 // GFILE                                                                 //
 ///////////////////////////////////////////////////////////////////////////
-#define GFX_USE_GFILE                                FALSE
+#define GFX_USE_GFILE FALSE
 
 //#define GFILE_NEED_PRINTG                            FALSE
 //#define GFILE_NEED_SCANG                             FALSE
@@ -292,26 +285,24 @@
 ///////////////////////////////////////////////////////////////////////////
 // GADC                                                                  //
 ///////////////////////////////////////////////////////////////////////////
-#define GFX_USE_GADC                                 FALSE
+#define GFX_USE_GADC FALSE
 
 //#define GADC_MAX_LOWSPEED_DEVICES                    4
 
-
 ///////////////////////////////////////////////////////////////////////////
 // GAUDIO                                                                //
 ///////////////////////////////////////////////////////////////////////////
-#define GFX_USE_GAUDIO                               FALSE
+#define GFX_USE_GAUDIO FALSE
 // There seems to be a bug in the ugfx code, the wrong define is used
 // So define it in order to avoid warnings
-#define GFX_USE_GAUDIN                               GFX_USE_GAUDIO
+#define GFX_USE_GAUDIN GFX_USE_GAUDIO
 //    #define GAUDIO_NEED_PLAY                         FALSE
 //    #define GAUDIO_NEED_RECORD                       FALSE
 
-
 ///////////////////////////////////////////////////////////////////////////
 // GMISC                                                                 //
 ///////////////////////////////////////////////////////////////////////////
-#define GFX_USE_GMISC                                TRUE
+#define GFX_USE_GMISC TRUE
 
 //#define GMISC_NEED_ARRAYOPS                          FALSE
 //#define GMISC_NEED_FASTTRIG                          FALSE
@@ -319,7 +310,7 @@
 //#define GMISC_NEED_INVSQRT                           FALSE
 //    #define GMISC_INVSQRT_MIXED_ENDIAN               FALSE
 //    #define GMISC_INVSQRT_REAL_SLOW                  FALSE
-#define GMISC_NEED_MATRIXFLOAT2D                     TRUE
-#define GMISC_NEED_MATRIXFIXED2D                     FALSE
+#define GMISC_NEED_MATRIXFLOAT2D TRUE
+#define GMISC_NEED_MATRIXFIXED2D FALSE
 
 #endif /* COMMON_GFXCONF_H */
diff --git a/quantum/visualizer/default_animations.c b/quantum/visualizer/default_animations.c
index 2d03273720..2f43c67cc8 100644
--- a/quantum/visualizer/default_animations.c
+++ b/quantum/visualizer/default_animations.c
@@ -16,161 +16,162 @@
 
 #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 "default_animations.h"
+#    include "visualizer.h"
+#    ifdef LCD_ENABLE
+#        include "lcd_keyframes.h"
+#    endif
+#    ifdef LCD_BACKLIGHT_ENABLE
+#        include "lcd_backlight_keyframes.h"
+#    endif
 
-#include "visualizer_keyframes.h"
+#    ifdef BACKLIGHT_ENABLE
+#        include "led_backlight_keyframes.h"
+#    endif
 
+#    include "visualizer_keyframes.h"
 
-#if defined(LCD_ENABLE) || defined(LCD_BACKLIGHT_ENABLE) || defined(BACKLIGHT_ENABLE)
+#    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
+#        ifdef LCD_ENABLE
     lcd_keyframe_enable(animation, state);
-#endif
-#ifdef LCD_BACKLIGHT_ENABLE
+#        endif
+#        ifdef LCD_BACKLIGHT_ENABLE
     lcd_backlight_keyframe_enable(animation, state);
-#endif
-#ifdef BACKLIGHT_ENABLE
+#        endif
+#        ifdef BACKLIGHT_ENABLE
     led_backlight_keyframe_enable(animation, state);
-#endif
+#        endif
     return false;
 }
 
 static bool keyframe_disable(keyframe_animation_t* animation, visualizer_state_t* state) {
-#ifdef LCD_ENABLE
+#        ifdef LCD_ENABLE
     lcd_keyframe_disable(animation, state);
-#endif
-#ifdef LCD_BACKLIGHT_ENABLE
+#        endif
+#        ifdef LCD_BACKLIGHT_ENABLE
     lcd_backlight_keyframe_disable(animation, state);
-#endif
-#ifdef BACKLIGHT_ENABLE
+#        endif
+#        ifdef BACKLIGHT_ENABLE
     led_backlight_keyframe_disable(animation, state);
-#endif
+#        endif
     return false;
 }
 
 static bool keyframe_fade_in(keyframe_animation_t* animation, visualizer_state_t* state) {
     bool ret = false;
-#ifdef LCD_BACKLIGHT_ENABLE
+#        ifdef LCD_BACKLIGHT_ENABLE
     ret |= lcd_backlight_keyframe_animate_color(animation, state);
-#endif
-#ifdef BACKLIGHT_ENABLE
+#        endif
+#        ifdef BACKLIGHT_ENABLE
     ret |= led_backlight_keyframe_fade_in_all(animation, state);
-#endif
+#        endif
     return ret;
 }
 
 static bool keyframe_fade_out(keyframe_animation_t* animation, visualizer_state_t* state) {
     bool ret = false;
-#ifdef LCD_BACKLIGHT_ENABLE
+#        ifdef LCD_BACKLIGHT_ENABLE
     ret |= lcd_backlight_keyframe_animate_color(animation, state);
-#endif
-#ifdef BACKLIGHT_ENABLE
+#        endif
+#        ifdef BACKLIGHT_ENABLE
     ret |= led_backlight_keyframe_fade_out_all(animation, state);
-#endif
+#        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
+#        if LCD_ENABLE
     .num_frames = 3,
-#else
+#        else
     .num_frames = 2,
-#endif
-    .loop = false,
-    .frame_lengths = {
-        0, 
-#if LCD_ENABLE
-        0, 
-#endif
-        gfxMillisecondsToTicks(5000)},
-    .frame_functions = {
+#        endif
+    .loop          = false,
+    .frame_lengths = {0,
+#        if LCD_ENABLE
+                      0,
+#        endif
+                      gfxMillisecondsToTicks(5000)},
+    .frame_functions =
+        {
             keyframe_enable,
-#if LCD_ENABLE
+#        if LCD_ENABLE
             lcd_keyframe_draw_logo,
-#endif
+#        endif
             keyframe_fade_in,
-    },
+        },
 };
 
 keyframe_animation_t default_suspend_animation = {
-#if LCD_ENABLE
+#        if LCD_ENABLE
     .num_frames = 3,
-#else
+#        else
     .num_frames = 2,
-#endif
+#        endif
     .loop = false,
-    .frame_lengths = {
-#if LCD_ENABLE
-        0, 
-#endif
-        gfxMillisecondsToTicks(1000), 
-        0},
-    .frame_functions = {
-#if LCD_ENABLE
+    .frame_lengths =
+        {
+#        if LCD_ENABLE
+            0,
+#        endif
+            gfxMillisecondsToTicks(1000), 0},
+    .frame_functions =
+        {
+#        if LCD_ENABLE
             lcd_keyframe_display_layer_text,
-#endif
+#        endif
             keyframe_fade_out,
             keyframe_disable,
-    },
+        },
 };
-#endif
+#    endif
 
-#if defined(BACKLIGHT_ENABLE)
-#define CROSSFADE_TIME 1000
-#define GRADIENT_TIME 3000
+#    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,
-    },
+    .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
 
 #endif
diff --git a/quantum/visualizer/lcd_backlight.c b/quantum/visualizer/lcd_backlight.c
index 6cd996f75e..23978974e3 100644
--- a/quantum/visualizer/lcd_backlight.c
+++ b/quantum/visualizer/lcd_backlight.c
@@ -25,9 +25,9 @@ SOFTWARE.
 #include "lcd_backlight.h"
 #include <math.h>
 
-static uint8_t current_hue = 0;
+static uint8_t current_hue        = 0;
 static uint8_t current_saturation = 0;
-static uint8_t current_intensity = 0;
+static uint8_t current_intensity  = 0;
 static uint8_t current_brightness = 0;
 
 void lcd_backlight_init(void) {
@@ -40,26 +40,26 @@ void lcd_backlight_init(void) {
 // 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]
+    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) {
+    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);
+        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);
+        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;
@@ -68,15 +68,15 @@ static void hsi_to_rgb(float h, float s, float i, uint16_t* r_out, uint16_t* g_o
 
 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;
+    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);
+    current_hue        = hue;
+    current_saturation = saturation;
+    current_intensity  = intensity;
+    lcd_backlight_hal_color(r, g, b);
 }
 
 void lcd_backlight_brightness(uint8_t b) {
@@ -84,6 +84,4 @@ void lcd_backlight_brightness(uint8_t b) {
     lcd_backlight_color(current_hue, current_saturation, current_intensity);
 }
 
-uint8_t lcd_get_backlight_brightness(void) {
-	return current_brightness;
-}
+uint8_t lcd_get_backlight_brightness(void) { return current_brightness; }
diff --git a/quantum/visualizer/lcd_backlight.h b/quantum/visualizer/lcd_backlight.h
index 95d7a07b46..7b0b6a9fd5 100644
--- a/quantum/visualizer/lcd_backlight.h
+++ b/quantum/visualizer/lcd_backlight.h
@@ -32,13 +32,11 @@ SOFTWARE.
 #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;
-}
+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);
+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);
diff --git a/quantum/visualizer/lcd_backlight_keyframes.c b/quantum/visualizer/lcd_backlight_keyframes.c
index 8c402baf6c..c13cce311d 100644
--- a/quantum/visualizer/lcd_backlight_keyframes.c
+++ b/quantum/visualizer/lcd_backlight_keyframes.c
@@ -17,46 +17,40 @@
 #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);
+    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;
+    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 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);
+    // 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));
+    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->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));
+    lcd_backlight_color(LCD_HUE(state->current_lcd_color), LCD_SAT(state->current_lcd_color), LCD_INT(state->current_lcd_color));
     return false;
 }
 
@@ -70,8 +64,6 @@ bool lcd_backlight_keyframe_disable(keyframe_animation_t* animation, visualizer_
 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));
+    lcd_backlight_color(LCD_HUE(state->current_lcd_color), LCD_SAT(state->current_lcd_color), LCD_INT(state->current_lcd_color));
     return false;
 }
diff --git a/quantum/visualizer/lcd_keyframes.c b/quantum/visualizer/lcd_keyframes.c
index 75eb457001..c7d9841df3 100644
--- a/quantum/visualizer/lcd_keyframes.c
+++ b/quantum/visualizer/lcd_keyframes.c
@@ -28,8 +28,7 @@ bool lcd_keyframe_display_layer_text(keyframe_animation_t* animation, visualizer
 }
 
 static void format_layer_bitmap_string(uint16_t default_layer, uint16_t layer, char* buffer) {
-    for (int i=0; i<16;i++)
-    {
+    for (int i = 0; i < 16; i++) {
         uint32_t mask = (1u << i);
         if (default_layer & mask) {
             if (layer & mask) {
@@ -44,7 +43,7 @@ static void format_layer_bitmap_string(uint16_t default_layer, uint16_t layer, c
         }
         ++buffer;
 
-        if (i==3 || i==7 || i==11) {
+        if (i == 3 || i == 7 || i == 11) {
             *buffer = ' ';
             ++buffer;
         }
@@ -55,7 +54,7 @@ static void format_layer_bitmap_string(uint16_t default_layer, uint16_t layer, c
 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
+    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);
@@ -69,8 +68,7 @@ static void format_mods_bitmap_string(uint8_t mods, char* buffer) {
     *buffer = ' ';
     ++buffer;
 
-    for (int i = 0; i<8; i++)
-    {
+    for (int i = 0; i < 8; i++) {
         uint32_t mask = (1u << i);
         if (mods & mask) {
             *buffer = '1';
@@ -79,7 +77,7 @@ static void format_mods_bitmap_string(uint8_t mods, char* buffer) {
         }
         ++buffer;
 
-        if (i==3) {
+        if (i == 3) {
             *buffer = ' ';
             ++buffer;
         }
@@ -90,9 +88,9 @@ static void format_mods_bitmap_string(uint8_t mods, char* buffer) {
 bool lcd_keyframe_display_mods_bitmap(keyframe_animation_t* animation, visualizer_state_t* state) {
     (void)animation;
 
-    const char* title = "Modifier states";
+    const char* title       = "Modifier states";
     const char* mods_header = " CSAG CSAG ";
-    char status_buffer[12];
+    char        status_buffer[12];
 
     gdispClear(White);
     gdispDrawString(0, 0, title, state->font_fixed5x8, Black);
@@ -109,30 +107,29 @@ 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;
+        memcpy(output + pos, "NUM ", 4);
+        pos += 4;
     }
     if (state->status.leds & (1u << USB_LED_CAPS_LOCK)) {
-       memcpy(output + pos, "CAPS ", 5);
-       pos += 5;
+        memcpy(output + pos, "CAPS ", 5);
+        pos += 5;
     }
     if (state->status.leds & (1u << USB_LED_SCROLL_LOCK)) {
-       memcpy(output + pos, "SCRL ", 5);
-       pos += 5;
+        memcpy(output + pos, "SCRL ", 5);
+        pos += 5;
     }
     if (state->status.leds & (1u << USB_LED_COMPOSE)) {
-       memcpy(output + pos, "COMP ", 5);
-       pos += 5;
+        memcpy(output + pos, "COMP ", 5);
+        pos += 5;
     }
     if (state->status.leds & (1u << USB_LED_KANA)) {
-       memcpy(output + pos, "KANA", 4);
-       pos += 4;
+        memcpy(output + pos, "KANA", 4);
+        pos += 4;
     }
     output[pos] = 0;
 }
 
-bool lcd_keyframe_display_led_states(keyframe_animation_t* animation, visualizer_state_t* state)
-{
+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);
@@ -165,14 +162,13 @@ bool lcd_keyframe_draw_logo(keyframe_animation_t* animation, visualizer_state_t*
     // 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
+    // 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, LCD_WIDTH, LCD_HEIGHT, 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;
diff --git a/quantum/visualizer/lcd_keyframes.h b/quantum/visualizer/lcd_keyframes.h
index 2e912b4c73..6346c8643b 100644
--- a/quantum/visualizer/lcd_keyframes.h
+++ b/quantum/visualizer/lcd_keyframes.h
@@ -35,5 +35,4 @@ bool lcd_keyframe_draw_logo(keyframe_animation_t* animation, visualizer_state_t*
 bool lcd_keyframe_disable(keyframe_animation_t* animation, visualizer_state_t* state);
 bool lcd_keyframe_enable(keyframe_animation_t* animation, visualizer_state_t* state);
 
-
 #endif /* QUANTUM_VISUALIZER_LCD_KEYFRAMES_H_ */
diff --git a/quantum/visualizer/led_backlight_keyframes.c b/quantum/visualizer/led_backlight_keyframes.c
index eb3f5561d8..d81117d2be 100644
--- a/quantum/visualizer/led_backlight_keyframes.c
+++ b/quantum/visualizer/led_backlight_keyframes.c
@@ -27,15 +27,15 @@ SOFTWARE.
 
 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;
+    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);
+    uint8_t luma  = fade_led_color(animation, from, to);
     color_t color = LUMA2COLOR(luma);
     gdispGClear(LED_DISPLAY, color);
 }
@@ -48,10 +48,10 @@ 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);
+    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);
 }
 
@@ -70,9 +70,9 @@ bool led_backlight_keyframe_fade_out_all(keyframe_animation_t* animation, visual
 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++) {
+    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));
     }
@@ -82,9 +82,9 @@ bool led_backlight_keyframe_left_to_right_gradient(keyframe_animation_t* animati
 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++) {
+    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));
     }
@@ -92,9 +92,9 @@ bool led_backlight_keyframe_top_to_bottom_gradient(keyframe_animation_t* animati
 }
 
 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);
+    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);
         }
     }
 }
@@ -105,9 +105,9 @@ bool led_backlight_keyframe_crossfade(keyframe_animation_t* animation, visualize
         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]));
+    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);
         }
     }
diff --git a/quantum/visualizer/led_backlight_keyframes.h b/quantum/visualizer/led_backlight_keyframes.h
index 487151013a..648f92b915 100644
--- a/quantum/visualizer/led_backlight_keyframes.h
+++ b/quantum/visualizer/led_backlight_keyframes.h
@@ -40,5 +40,4 @@ bool led_backlight_keyframe_enable(keyframe_animation_t* animation, visualizer_s
 
 extern keyframe_animation_t led_test_animation;
 
-
 #endif /* LED_KEYFRAMES_H */
diff --git a/quantum/visualizer/resources/lcd_logo.c b/quantum/visualizer/resources/lcd_logo.c
index 314776c0b2..165e6d1f53 100644
--- a/quantum/visualizer/resources/lcd_logo.c
+++ b/quantum/visualizer/resources/lcd_logo.c
@@ -16,7 +16,6 @@
 
 #include "resources.h"
 
-
 // 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/
@@ -24,39 +23,7 @@
 // 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, 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, 0xf8, 0xfe, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x38, 0x38, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x38, 0x38, 0x38, 0x06, 0x29, 0x41, 0x24, 0x52, 0x24, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x38, 0x38, 0x38, 0x09, 0x55, 0x42, 0xaa, 0xaa, 0xaa, 0xa8, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x38, 0x38, 0x38, 0x09, 0x55, 0x82, 0x28, 0xaa, 0xae, 0x8c, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x38, 0x38, 0x38, 0x09, 0x55, 0x43, 0x28, 0xaa, 0xaa, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x38, 0x38, 0x38, 0x0a, 0x55, 0x42, 0x28, 0xaa, 0xaa, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x38, 0x38, 0x38, 0x05, 0x45, 0x42, 0x28, 0x89, 0x4a, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x18, 0x38, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x1c, 0x38, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x0e, 0x38, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x03, 0xff, 0x80, 0x04, 0x45, 0x14, 0xa4, 0x92, 0x83, 0x52, 0x22, 0x22, 0x36, 0x00, 0x00,
-    0x00, 0x00, 0x38, 0x00, 0x0a, 0xaa, 0xaa, 0xaa, 0xba, 0x84, 0x55, 0x55, 0x57, 0x45, 0x00, 0x00,
-    0x00, 0x00, 0x38, 0x00, 0x08, 0xaa, 0xaa, 0xaa, 0x92, 0xb2, 0x55, 0x55, 0x42, 0x65, 0x00, 0x00,
-    0x00, 0x00, 0x38, 0x00, 0x08, 0xaa, 0xaa, 0xaa, 0x92, 0x81, 0x56, 0x65, 0x42, 0x45, 0x00, 0x00,
-    0x00, 0x00, 0x38, 0x00, 0x0a, 0xaa, 0xaa, 0xaa, 0x92, 0x81, 0x54, 0x45, 0x42, 0x45, 0x00, 0x00,
-    0x00, 0x00, 0x38, 0x00, 0x04, 0x48, 0xa2, 0x4a, 0x89, 0x06, 0x24, 0x42, 0x41, 0x36, 0x00, 0x00,
-    0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 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, 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
-};
-
+__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, 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, 0xf8, 0xfe, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x38, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                                              0x00, 0x38, 0x38, 0x38, 0x06, 0x29, 0x41, 0x24, 0x52, 0x24, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x38, 0x38, 0x09, 0x55, 0x42, 0xaa, 0xaa, 0xaa, 0xa8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x38, 0x38, 0x09, 0x55, 0x82, 0x28, 0xaa, 0xae, 0x8c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x38, 0x38, 0x09, 0x55, 0x43, 0x28, 0xaa, 0xaa, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x38, 0x38, 0x0a, 0x55, 0x42, 0x28, 0xaa, 0xaa, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x38, 0x38, 0x05, 0x45, 0x42, 0x28, 0x89, 0x4a, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x38, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x38, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                                              0x00, 0x0e, 0x38, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xff, 0x80, 0x04, 0x45, 0x14, 0xa4, 0x92, 0x83, 0x52, 0x22, 0x22, 0x36, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x0a, 0xaa, 0xaa, 0xaa, 0xba, 0x84, 0x55, 0x55, 0x57, 0x45, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x08, 0xaa, 0xaa, 0xaa, 0x92, 0xb2, 0x55, 0x55, 0x42, 0x65, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x08, 0xaa, 0xaa, 0xaa, 0x92, 0x81, 0x56, 0x65, 0x42, 0x45, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x0a, 0xaa, 0xaa, 0xaa, 0x92, 0x81, 0x54, 0x45, 0x42, 0x45, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x04, 0x48, 0xa2, 0x4a, 0x89, 0x06, 0x24, 0x42, 0x41, 0x36, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                                                              0x00, 0x00, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 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, 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};
diff --git a/quantum/visualizer/resources/resources.h b/quantum/visualizer/resources/resources.h
index 1ea27a5364..74fd8d2f65 100644
--- a/quantum/visualizer/resources/resources.h
+++ b/quantum/visualizer/resources/resources.h
@@ -23,5 +23,4 @@
 extern const uint8_t resource_lcd_logo[];
 #endif
 
-
 #endif /* QUANTUM_VISUALIZER_RESOURCES_RESOURCES_H_ */
diff --git a/quantum/visualizer/visualizer.c b/quantum/visualizer/visualizer.c
index 516cf2a847..3f182e74d8 100644
--- a/quantum/visualizer/visualizer.c
+++ b/quantum/visualizer/visualizer.c
@@ -26,26 +26,26 @@ SOFTWARE.
 #include "visualizer.h"
 #include <string.h>
 #ifdef PROTOCOL_CHIBIOS
-#include "ch.h"
+#    include "ch.h"
 #endif
 
 #include "gfx.h"
 
 #ifdef LCD_BACKLIGHT_ENABLE
-#include "lcd_backlight.h"
+#    include "lcd_backlight.h"
 #endif
 
 //#define DEBUG_VISUALIZER
 
 #ifdef DEBUG_VISUALIZER
-#include "debug.h"
+#    include "debug.h"
 #else
-#include "nodebug.h"
+#    include "nodebug.h"
 #endif
 
 #ifdef SERIAL_LINK_ENABLE
-#include "serial_link/protocol/transport.h"
-#include "serial_link/system/serial_link.h"
+#    include "serial_link/protocol/transport.h"
+#    include "serial_link/system/serial_link.h"
 #endif
 
 #include "action_util.h"
@@ -53,36 +53,31 @@ SOFTWARE.
 // Define this in config.h
 #ifndef VISUALIZER_THREAD_PRIORITY
 // The visualizer needs gfx thread priorities
-#define VISUALIZER_THREAD_PRIORITY (NORMAL_PRIORITY - 2)
+#    define VISUALIZER_THREAD_PRIORITY (NORMAL_PRIORITY - 2)
 #endif
 
-static visualizer_keyboard_status_t current_status = {
-    .layer = 0xFFFFFFFF,
-    .default_layer = 0xFFFFFFFF,
-    .leds = 0xFFFFFFFF,
+static visualizer_keyboard_status_t current_status = {.layer         = 0xFFFFFFFF,
+                                                      .default_layer = 0xFFFFFFFF,
+                                                      .leds          = 0xFFFFFFFF,
 #ifdef BACKLIGHT_ENABLE
-    .backlight_level = 0,
+                                                      .backlight_level = 0,
 #endif
-    .mods = 0xFF,
-    .suspended = false,
+                                                      .mods      = 0xFF,
+                                                      .suspended = false,
 #ifdef VISUALIZER_USER_DATA_SIZE
-    .user_data = {0}
+                                                      .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
+    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
+           && status1->backlight_level == status2->backlight_level
 #endif
 #ifdef VISUALIZER_USER_DATA_SIZE
-        && memcmp(status1->user_data, status2->user_data, VISUALIZER_USER_DATA_SIZE) == 0
+           && memcmp(status1->user_data, status2->user_data, VISUALIZER_USER_DATA_SIZE) == 0
 #endif
-    ;
+        ;
 }
 
 static bool visualizer_enabled = false;
@@ -107,44 +102,38 @@ GDisplay* LCD_DISPLAY = 0;
 GDisplay* LED_DISPLAY = 0;
 
 #ifdef LCD_DISPLAY_NUMBER
-__attribute__((weak))
-GDisplay* get_lcd_display(void) {
-    return gdispGetDisplay(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);
-}
+__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->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++) {
+    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;
+            free_index = i;
         }
     }
-    if (free_index!=-1) {
+    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->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++) {
+    animation->last_update_of_frame  = false;
+    for (int i = 0; i < MAX_SIMULTANEOUS_ANIMATIONS; i++) {
         if (animations[i] == animation) {
             animations[i] = NULL;
             return;
@@ -153,21 +142,21 @@ void stop_keyframe_animation(keyframe_animation_t* animation) {
 }
 
 void stop_all_keyframe_animations(void) {
-    for (int i=0;i<MAX_SIMULTANEOUS_ANIMATIONS;i++) {
+    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]->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;
+            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++) {
+    for (int i = 0; i < MAX_SIMULTANEOUS_ANIMATIONS; i++) {
         count += animations[i] ? 1 : 0;
     }
     return count;
@@ -175,46 +164,44 @@ static uint8_t get_num_running_animations(void) {
 
 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);
+    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;
+        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->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->need_update           = true;
             animation->first_update_of_frame = true;
             if (animation->current_frame == animation->num_frames) {
                 if (animation->loop) {
                     animation->current_frame = 0;
-                }
-                else {
+                } else {
                     stop_keyframe_animation(animation);
                     return false;
                 }
             }
-            delta = -left;
+            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->need_update           = (*animation->frame_functions[animation->current_frame])(animation, state);
         animation->first_update_of_frame = false;
     }
 
@@ -231,13 +218,13 @@ void run_next_keyframe(keyframe_animation_t* animation, visualizer_state_t* stat
     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];
+    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.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);
 }
 
@@ -252,70 +239,64 @@ static DECLARE_THREAD_FUNCTION(visualizerThread, arg) {
 
     visualizer_keyboard_status_t initial_status = {
         .default_layer = 0xFFFFFFFF,
-        .layer = 0xFFFFFFFF,
-        .mods = 0xFF,
-        .leds = 0xFFFFFFFF,
-        .suspended = false,
-    #ifdef BACKLIGHT_ENABLE
+        .layer         = 0xFFFFFFFF,
+        .mods          = 0xFF,
+        .leds          = 0xFFFFFFFF,
+        .suspended     = false,
+#ifdef BACKLIGHT_ENABLE
         .backlight_level = 0,
-    #endif
-    #ifdef VISUALIZER_USER_DATA_SIZE
+#endif
+#ifdef VISUALIZER_USER_DATA_SIZE
         .user_data = {0},
-    #endif
+#endif
     };
 
-    visualizer_state_t state = {
-        .status = initial_status,
-        .current_lcd_color = 0,
+    visualizer_state_t state = {.status            = initial_status,
+                                .current_lcd_color = 0,
 #ifdef LCD_ENABLE
-        .font_fixed5x8 = gdispOpenFont("fixed_5x8"),
-        .font_dejavusansbold12 = gdispOpenFont("DejaVuSansBold12")
+                                .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));
+    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 sleep_time   = TIME_INFINITE;
     systemticks_t current_time = gfxSystemTicks();
-    bool force_update = true;
+    bool          force_update = true;
 
-    while(true) {
+    while (true) {
         systemticks_t new_time = gfxSystemTicks();
-        systemticks_t delta = new_time - current_time;
-        current_time = new_time;
-        bool enabled = visualizer_enabled;
+        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 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 {
+                } else {
                     gdispGSetPowerMode(LED_DISPLAY, powerOff);
                 }
                 state.status.backlight_level = current_status.backlight_level;
             }
-    #endif
+#endif
             if (visualizer_enabled) {
                 if (current_status.suspended) {
                     stop_all_keyframe_animations();
                     visualizer_enabled = false;
-                    state.status = current_status;
+                    state.status       = current_status;
                     user_visualizer_suspend(&state);
-                }
-                else {
+                } else {
                     visualizer_keyboard_status_t prev_status = state.status;
-                    state.status = current_status;
+                    state.status                             = current_status;
                     update_user_visualizer_state(&state, &prev_status);
                 }
                 state.prev_lcd_color = state.current_lcd_color;
@@ -324,14 +305,14 @@ static DECLARE_THREAD_FUNCTION(visualizerThread, arg) {
         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           = 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++) {
+        for (int i = 0; i < MAX_SIMULTANEOUS_ANIMATIONS; i++) {
             if (animations[i]) {
                 update_keyframe_animation(animations[i], &state, delta, &sleep_time);
             }
@@ -350,17 +331,16 @@ static DECLARE_THREAD_FUNCTION(visualizerThread, arg) {
         // 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;
+            force_update       = true;
+            sleep_time         = 0;
         }
 
         systemticks_t after_update = gfxSystemTicks();
-        unsigned update_delta = after_update - current_time;
+        unsigned      update_delta = after_update - current_time;
         if (sleep_time != TIME_INFINITE) {
             if (sleep_time > update_delta) {
                 sleep_time -= update_delta;
-            }
-            else {
+            } else {
                 sleep_time = 0;
             }
         }
@@ -388,26 +368,25 @@ static DECLARE_THREAD_FUNCTION(visualizerThread, arg) {
 void visualizer_init(void) {
     gfxInit();
 
-  #ifdef LCD_BACKLIGHT_ENABLE
+#ifdef LCD_BACKLIGHT_ENABLE
     lcd_backlight_init();
-  #endif
+#endif
 
-  #ifdef SERIAL_LINK_ENABLE
-    add_remote_objects(remote_objects, sizeof(remote_objects) / sizeof(remote_object_t*) );
-  #endif
+#ifdef SERIAL_LINK_ENABLE
+    add_remote_objects(remote_objects, sizeof(remote_objects) / sizeof(remote_object_t*));
+#endif
 
-  #ifdef LCD_ENABLE
+#ifdef LCD_ENABLE
     LCD_DISPLAY = get_lcd_display();
-  #endif
+#endif
 
-  #ifdef BACKLIGHT_ENABLE
+#ifdef BACKLIGHT_ENABLE
     LED_DISPLAY = get_led_display();
-  #endif
+#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);
+    gfxThreadCreate(visualizerThreadStack, sizeof(visualizerThreadStack), VISUALIZER_THREAD_PRIORITY, visualizerThread, NULL);
 }
 
 void update_status(bool changed) {
@@ -418,33 +397,31 @@ void update_status(bool changed) {
         }
     }
 #ifdef SERIAL_LINK_ENABLE
-    static systime_t last_update = 0;
-    systime_t current_update = chVTGetSystemTimeX();
-    systime_t delta = current_update - last_update;
+    static systime_t last_update    = 0;
+    systime_t        current_update = chVTGetSystemTimeX();
+    systime_t        delta          = current_update - last_update;
     if (changed || delta > MS2ST(10)) {
-        last_update = current_update;
+        last_update                     = current_update;
         visualizer_keyboard_status_t* r = begin_write_current_status();
-        *r = current_status;
+        *r                              = current_status;
         end_write_current_status();
     }
 #endif
 }
 
 uint8_t visualizer_get_mods() {
-  uint8_t mods = get_mods();
+    uint8_t mods = get_mods();
 
 #ifndef NO_ACTION_ONESHOT
-  if (!has_oneshot_mods_timed_out()) {
-    mods |= get_oneshot_mods();
-  }
+    if (!has_oneshot_mods_timed_out()) {
+        mods |= get_oneshot_mods();
+    }
 #endif
-  return mods;
+    return mods;
 }
 
 #ifdef VISUALIZER_USER_DATA_SIZE
-void visualizer_set_user_data(void* u) {
-    memcpy(user_data, u, 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) {
@@ -455,34 +432,33 @@ void visualizer_update(layer_state_t default_state, layer_state_t state, uint8_t
 
     bool changed = false;
 #ifdef SERIAL_LINK_ENABLE
-    if (is_serial_link_connected ()) {
+    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;
+                changed        = true;
                 current_status = *new_status;
             }
         }
-    }
-    else {
+    } else {
 #else
-   {
+    {
 #endif
         visualizer_keyboard_status_t new_status = {
-            .layer = state,
+            .layer         = state,
             .default_layer = default_state,
-            .mods = mods,
-            .leds = leds,
+            .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);
+        memcpy(new_status.user_data, user_data, VISUALIZER_USER_DATA_SIZE);
 #endif
         if (!same_status(&current_status, &new_status)) {
-            changed = true;
+            changed        = true;
             current_status = new_status;
         }
     }
diff --git a/quantum/visualizer/visualizer.h b/quantum/visualizer/visualizer.h
index 56ea1fd98c..7ca6837ce6 100644
--- a/quantum/visualizer/visualizer.h
+++ b/quantum/visualizer/visualizer.h
@@ -33,11 +33,11 @@ SOFTWARE.
 #include "action_layer.h"
 
 #ifdef LCD_BACKLIGHT_ENABLE
-#include "lcd_backlight.h"
+#    include "lcd_backlight.h"
 #endif
 
 #ifdef BACKLIGHT_ENABLE
-#include "backlight.h"
+#    include "backlight.h"
 #endif
 
 // use this function to merge both real_mods and oneshot_mods in a uint16_t
@@ -71,9 +71,9 @@ 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;
+    uint32_t      leds;  // See led.h for available statuses
+    uint8_t       mods;
+    bool          suspended;
 #ifdef BACKLIGHT_ENABLE
     uint8_t backlight_level;
 #endif
@@ -87,7 +87,7 @@ typedef struct {
 // from the user customized code
 typedef struct visualizer_state_t {
     // The user code should primarily be modifying these
-    uint32_t target_lcd_color;
+    uint32_t    target_lcd_color;
     const char* layer_text;
 
     // The user visualizer(and animation functions) can read these
@@ -111,15 +111,15 @@ typedef bool (*frame_func)(struct keyframe_animation_t*, visualizer_state_t*);
 // 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];
+    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;
+    int  current_frame;
+    int  time_left_in_frame;
     bool first_update_of_frame;
     bool last_update_of_frame;
     bool need_update;