diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index e169d1aebd..a0a067896d 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -56,6 +56,7 @@ exclude: |
         Marlin/src(/gcode)?/feature/input_shaper/|
         Marlin/src(/gcode)?/feature/pressure_advance/|
         Marlin/src(/gcode)?/feature/precise_stepping/|
+        Marlin/src(/gcode)?/feature/phase_stepping/|
         Marlin/src/module/prusa/|
         Marlin/src/gcode/calibrate/M958.cpp
       )|
diff --git a/CMakePresets.json b/CMakePresets.json
index 0165e10b92..46b38420bb 100644
--- a/CMakePresets.json
+++ b/CMakePresets.json
@@ -3018,6 +3018,322 @@
                 }
             }
         },
+        {
+            "name": "xl-burst_debug_boot",
+            "generator": "Ninja",
+            "binaryDir": "build-vscode-buddy",
+            "cacheVariables": {
+                "CMAKE_MAKE_PROGRAM": {
+                    "type": "FILEPATH",
+                    "value": "${sourceDir}/.dependencies/ninja-1.10.2/ninja"
+                },
+                "CMAKE_EXPORT_COMPILE_COMMANDS": {
+                    "type": "STRING",
+                    "value": "ON"
+                },
+                "PRINTER": {
+                    "type": "STRING",
+                    "value": "XL"
+                },
+                "BOARD": {
+                    "type": "STRING",
+                    "value": "<default>"
+                },
+                "BOARD_VERSION": {
+                    "type": "STRING",
+                    "value": "0.9.0"
+                },
+                "DWARF_BINARY_DIR": {
+                    "type": "FILEPATH",
+                    "value": "${sourceDir}/build-vscode-dwarf"
+                },
+                "MODULARBED_BINARY_DIR": {
+                    "type": "FILEPATH",
+                    "value": "${sourceDir}/build-vscode-modularbed"
+                },
+                "PRESET_COMPILE_OPTIONS": {
+                    "type": "STRING",
+                    "value": ""
+                },
+                "ENABLE_BURST": {
+                    "type": "BOOL",
+                    "value": "YES"
+                },
+                "IS_KNOBLET": {
+                    "type": "STRING",
+                    "value": "FALSE"
+                },
+                "BOOTLOADER": {
+                    "type": "STRING",
+                    "value": "YES"
+                },
+                "GENERATE_BBF": {
+                    "type": "BOOL",
+                    "value": "TRUE"
+                },
+                "GENERATE_DFU": {
+                    "type": "BOOL",
+                    "value": "OFF"
+                },
+                "SIGNING_KEY": {
+                    "type": "FILEPATH",
+                    "value": ""
+                },
+                "CMAKE_TOOLCHAIN_FILE": {
+                    "type": "FILEPATH",
+                    "value": "${sourceDir}/cmake/GccArmNoneEabi.cmake"
+                },
+                "CMAKE_BUILD_TYPE": {
+                    "type": "STRING",
+                    "value": "Debug"
+                },
+                "PROJECT_VERSION_SUFFIX": {
+                    "type": "STRING",
+                    "value": "<auto>"
+                },
+                "PROJECT_VERSION_SUFFIX_SHORT": {
+                    "type": "STRING",
+                    "value": "<auto>"
+                }
+            }
+        },
+        {
+            "name": "xl-burst_debug_noboot",
+            "generator": "Ninja",
+            "binaryDir": "build-vscode-buddy",
+            "cacheVariables": {
+                "CMAKE_MAKE_PROGRAM": {
+                    "type": "FILEPATH",
+                    "value": "${sourceDir}/.dependencies/ninja-1.10.2/ninja"
+                },
+                "CMAKE_EXPORT_COMPILE_COMMANDS": {
+                    "type": "STRING",
+                    "value": "ON"
+                },
+                "PRINTER": {
+                    "type": "STRING",
+                    "value": "XL"
+                },
+                "BOARD": {
+                    "type": "STRING",
+                    "value": "<default>"
+                },
+                "BOARD_VERSION": {
+                    "type": "STRING",
+                    "value": "0.9.0"
+                },
+                "DWARF_BINARY_DIR": {
+                    "type": "FILEPATH",
+                    "value": "${sourceDir}/build-vscode-dwarf"
+                },
+                "MODULARBED_BINARY_DIR": {
+                    "type": "FILEPATH",
+                    "value": "${sourceDir}/build-vscode-modularbed"
+                },
+                "PRESET_COMPILE_OPTIONS": {
+                    "type": "STRING",
+                    "value": ""
+                },
+                "ENABLE_BURST": {
+                    "type": "BOOL",
+                    "value": "YES"
+                },
+                "IS_KNOBLET": {
+                    "type": "STRING",
+                    "value": "FALSE"
+                },
+                "BOOTLOADER": {
+                    "type": "STRING",
+                    "value": "NO"
+                },
+                "GENERATE_BBF": {
+                    "type": "BOOL",
+                    "value": "FALSE"
+                },
+                "GENERATE_DFU": {
+                    "type": "BOOL",
+                    "value": "OFF"
+                },
+                "SIGNING_KEY": {
+                    "type": "FILEPATH",
+                    "value": ""
+                },
+                "CMAKE_TOOLCHAIN_FILE": {
+                    "type": "FILEPATH",
+                    "value": "${sourceDir}/cmake/GccArmNoneEabi.cmake"
+                },
+                "CMAKE_BUILD_TYPE": {
+                    "type": "STRING",
+                    "value": "Debug"
+                },
+                "PROJECT_VERSION_SUFFIX": {
+                    "type": "STRING",
+                    "value": "<auto>"
+                },
+                "PROJECT_VERSION_SUFFIX_SHORT": {
+                    "type": "STRING",
+                    "value": "<auto>"
+                }
+            }
+        },
+        {
+            "name": "xl-burst_release_boot",
+            "generator": "Ninja",
+            "binaryDir": "build-vscode-buddy",
+            "cacheVariables": {
+                "CMAKE_MAKE_PROGRAM": {
+                    "type": "FILEPATH",
+                    "value": "${sourceDir}/.dependencies/ninja-1.10.2/ninja"
+                },
+                "CMAKE_EXPORT_COMPILE_COMMANDS": {
+                    "type": "STRING",
+                    "value": "ON"
+                },
+                "PRINTER": {
+                    "type": "STRING",
+                    "value": "XL"
+                },
+                "BOARD": {
+                    "type": "STRING",
+                    "value": "<default>"
+                },
+                "BOARD_VERSION": {
+                    "type": "STRING",
+                    "value": "0.9.0"
+                },
+                "DWARF_BINARY_DIR": {
+                    "type": "FILEPATH",
+                    "value": "${sourceDir}/build-vscode-dwarf"
+                },
+                "MODULARBED_BINARY_DIR": {
+                    "type": "FILEPATH",
+                    "value": "${sourceDir}/build-vscode-modularbed"
+                },
+                "PRESET_COMPILE_OPTIONS": {
+                    "type": "STRING",
+                    "value": ""
+                },
+                "ENABLE_BURST": {
+                    "type": "BOOL",
+                    "value": "YES"
+                },
+                "IS_KNOBLET": {
+                    "type": "STRING",
+                    "value": "FALSE"
+                },
+                "BOOTLOADER": {
+                    "type": "STRING",
+                    "value": "YES"
+                },
+                "GENERATE_BBF": {
+                    "type": "BOOL",
+                    "value": "TRUE"
+                },
+                "GENERATE_DFU": {
+                    "type": "BOOL",
+                    "value": "OFF"
+                },
+                "SIGNING_KEY": {
+                    "type": "FILEPATH",
+                    "value": ""
+                },
+                "CMAKE_TOOLCHAIN_FILE": {
+                    "type": "FILEPATH",
+                    "value": "${sourceDir}/cmake/GccArmNoneEabi.cmake"
+                },
+                "CMAKE_BUILD_TYPE": {
+                    "type": "STRING",
+                    "value": "Release"
+                },
+                "PROJECT_VERSION_SUFFIX": {
+                    "type": "STRING",
+                    "value": "<auto>"
+                },
+                "PROJECT_VERSION_SUFFIX_SHORT": {
+                    "type": "STRING",
+                    "value": "<auto>"
+                }
+            }
+        },
+        {
+            "name": "xl-burst_release_noboot",
+            "generator": "Ninja",
+            "binaryDir": "build-vscode-buddy",
+            "cacheVariables": {
+                "CMAKE_MAKE_PROGRAM": {
+                    "type": "FILEPATH",
+                    "value": "${sourceDir}/.dependencies/ninja-1.10.2/ninja"
+                },
+                "CMAKE_EXPORT_COMPILE_COMMANDS": {
+                    "type": "STRING",
+                    "value": "ON"
+                },
+                "PRINTER": {
+                    "type": "STRING",
+                    "value": "XL"
+                },
+                "BOARD": {
+                    "type": "STRING",
+                    "value": "<default>"
+                },
+                "BOARD_VERSION": {
+                    "type": "STRING",
+                    "value": "0.9.0"
+                },
+                "DWARF_BINARY_DIR": {
+                    "type": "FILEPATH",
+                    "value": "${sourceDir}/build-vscode-dwarf"
+                },
+                "MODULARBED_BINARY_DIR": {
+                    "type": "FILEPATH",
+                    "value": "${sourceDir}/build-vscode-modularbed"
+                },
+                "PRESET_COMPILE_OPTIONS": {
+                    "type": "STRING",
+                    "value": ""
+                },
+                "ENABLE_BURST": {
+                    "type": "BOOL",
+                    "value": "YES"
+                },
+                "IS_KNOBLET": {
+                    "type": "STRING",
+                    "value": "FALSE"
+                },
+                "BOOTLOADER": {
+                    "type": "STRING",
+                    "value": "NO"
+                },
+                "GENERATE_BBF": {
+                    "type": "BOOL",
+                    "value": "FALSE"
+                },
+                "GENERATE_DFU": {
+                    "type": "BOOL",
+                    "value": "OFF"
+                },
+                "SIGNING_KEY": {
+                    "type": "FILEPATH",
+                    "value": ""
+                },
+                "CMAKE_TOOLCHAIN_FILE": {
+                    "type": "FILEPATH",
+                    "value": "${sourceDir}/cmake/GccArmNoneEabi.cmake"
+                },
+                "CMAKE_BUILD_TYPE": {
+                    "type": "STRING",
+                    "value": "Release"
+                },
+                "PROJECT_VERSION_SUFFIX": {
+                    "type": "STRING",
+                    "value": "<auto>"
+                },
+                "PROJECT_VERSION_SUFFIX_SHORT": {
+                    "type": "STRING",
+                    "value": "<auto>"
+                }
+            }
+        },
         {
             "name": "xl-knoblet_debug_boot",
             "generator": "Ninja",
diff --git a/ProjectOptions.cmake b/ProjectOptions.cmake
index cc773982c2..e9794c5178 100644
--- a/ProjectOptions.cmake
+++ b/ProjectOptions.cmake
@@ -127,6 +127,11 @@ set(IS_KNOBLET
     )
 define_boolean_option(IS_KNOBLET ${IS_KNOBLET})
 
+set(ENABLE_BURST
+    "NO"
+    CACHE BOOL "Enable BURST stepping on supported printers."
+    )
+
 # Validate options
 foreach(OPTION "PRINTER" "BOARD" "MCU" "BOOTLOADER" "TRANSLATIONS_ENABLED" "TOUCH_ENABLED")
   if(NOT ${OPTION} IN_LIST ${OPTION}_VALID_OPTS)
@@ -285,6 +290,8 @@ set(PRINTERS_WITH_POWER_PANIC "MK4" "MK3.5" "XL") # this does require selftest a
                                                   # to work
 set(PRINTERS_WITH_PRECISE_HOMING "MK4" "MK3.5")
 set(PRINTERS_WITH_PRECISE_HOMING_COREXY "XL" "XL_DEV_KIT")
+set(PRINTERS_WITH_PHASE_STEPPING "XL")
+set(PRINTERS_WITH_BURST_STEPPING "XL")
 # private MINI would not fit to 1MB so it has disabled selftest set(PRINTERS_WITH_SELFTEST "MINI"
 # "MK4")
 set(PRINTERS_WITH_SELFTEST "MK4" "MK3.5" "XL" "iX" "MINI")
@@ -459,6 +466,23 @@ else()
   define_boolean_option(HAS_HUMAN_INTERACTIONS NO)
 endif()
 
+if(${PRINTER} IN_LIST PRINTERS_WITH_PHASE_STEPPING AND BOARD_IS_MASTER_BOARD)
+  set(HAS_PHASE_STEPPING YES)
+else()
+  set(HAS_PHASE_STEPPING NO)
+endif()
+define_boolean_option(HAS_PHASE_STEPPING ${HAS_PHASE_STEPPING})
+
+if(ENABLE_BURST
+   AND ${PRINTER} IN_LIST PRINTERS_WITH_BURST_STEPPING
+   AND BOARD_IS_MASTER_BOARD
+   )
+  set(HAS_BURST_STEPPING YES)
+else()
+  set(HAS_BURST_STEPPING NO)
+endif()
+define_boolean_option(HAS_BURST_STEPPING ${HAS_BURST_STEPPING})
+
 if(${PRINTER} IN_LIST PRINTERS_WITH_LOADCELL AND BOARD_IS_MASTER_BOARD)
   set(HAS_LOADCELL YES)
 else()
diff --git a/doc/logging_components.md b/doc/logging_components.md
index 7e48238e3b..b7f044577c 100644
--- a/doc/logging_components.md
+++ b/doc/logging_components.md
@@ -1,7 +1,6 @@
 # Logging - Defined Components
 This file is generated automatically so don't edit it directly
 
-- Accel: LOG_SEVERITY_INFO, src/puppy/dwarf/accelerometer.cpp
 - Bootloader: LOG_SEVERITY_INFO, src/bootloader/bootloader.cpp
 - Buddy: LOG_SEVERITY_DEBUG, src/common/appmain.cpp
 - BufferedSerial: LOG_SEVERITY_DEBUG, src/hw/buffered_serial.cpp
@@ -38,7 +37,9 @@ This file is generated automatically so don't edit it directly
 - ModularBed: LOG_SEVERITY_INFO, src/puppies/modular_bed.cpp
 - Network: LOG_SEVERITY_INFO, lib/WUI/wui.cpp
 - PRUSA_GCODE: LOG_SEVERITY_INFO, src/marlin_stubs/gcode.cpp
+- PhaseStepping: LOG_SEVERITY_DEBUG, lib/Marlin/Marlin/src/feature/phase_stepping/phase_stepping.cpp
 - PowerPanic: LOG_SEVERITY_INFO, src/common/power_panic.cpp
+- PreciseStepping: LOG_SEVERITY_DEBUG, lib/Marlin/Marlin/src/feature/precise_stepping/precise_stepping.cpp
 - PrusaToolChanger: LOG_SEVERITY_DEBUG, lib/Marlin/Marlin/src/module/prusa/toolchanger_utils.cpp
 - Puppies: LOG_SEVERITY_DEBUG, src/puppies/puppy_task.cpp
 - Resources: LOG_SEVERITY_DEBUG, src/resources/bootstrap.cpp
diff --git a/doc/timers.md b/doc/timers.md
index fc85dec342..be8e792e50 100644
--- a/doc/timers.md
+++ b/doc/timers.md
@@ -1,15 +1,54 @@
-ARM-CORE SysTick timer - used by FreeRTOS
-TIM1 - hwio - FAN0 and FAN1 PWM                             - src\main.cpp
-TIM2 - hwio - BUZZER                                        - src\main.cpp
-TIM3 - hwio - HEAT0 and BED_HEAT PWM                        - src\main.cpp
-TIM4 - reserved for encoder
-TIM5 - SystemTimer (~12ns tick, 32bit, 84MHz, 1s period)    - src\common\timing_sys.c
-TIM6 - Marlin/Temperature                                   - lib\Marlin\Marlin\src\HAL\HAL_STM32_F4_F7\STM32F4\timers.cpp
-TIM7 - Marlin/Temperature                                   - lib\Marlin\Marlin\src\HAL\HAL_STM32_F4_F7\STM32F4\timers.cpp
-TIM8 - Marlin/Stepper                                       - lib\Marlin\Marlin\src\HAL\HAL_STM32_F4_F7\STM32F4\timers.cpp
-TIM9 -
-TIM10 -  
-TIM11 -  
-TIM12 -
-TIM13 -
-TIM14 - GUI - jogwheel, hwio, touch                         - src\main.cpp
+SysTick
+: used by FreeRTOS
+
+TIM1
+: hwio - FAN0 and FAN1 PWM
+: `src/main.cpp`
+
+TIM2
+: hwio - BUZZER
+: `src/main.cpp`
+
+TIM3
+: hwio - HEAT0 and BED_HEAT PWM
+: `src/main.cpp`
+
+TIM4
+: reserved for encoder
+
+TIM5
+: SystemTimer (~12ns tick, 32bit, 84MHz, 1s period)
+: `src/common/timing_sys.c`
+
+TIM6
+: Marlin/Temperature
+: `lib/Marlin/Marlin/src/HAL/HAL_STM32_F4_F7/STM32F4/timers.cpp`
+
+TIM7
+: Marlin/Temperature
+: `lib/Marlin/Marlin/src/HAL/HAL_STM32_F4_F7/STM32F4/timers.cpp`
+
+TIM8
+: Burst stepping
+: `lib/Marlin/Marlin/src/feature/phase_stepping/burst_stepper.cpp`
+
+TIM9
+:
+
+TIM10
+:
+
+TIM11
+:
+
+TIM12
+: Marlin/Stepper
+: `lib/Marlin/Marlin/src/HAL/HAL_STM32_F4_F7/STM32F4/timers.cpp`
+
+TIM13
+: Phase stepping
+: `lib/Marlin/Marlin/src/feature/phase_stepping/phase_stepping.cpp`
+
+TIM14
+: GUI - jogwheel, hwio, touch
+: `src/main.cpp`
diff --git a/include/buddy/phase_stepping_opts.h b/include/buddy/phase_stepping_opts.h
new file mode 100644
index 0000000000..dafd6cc517
--- /dev/null
+++ b/include/buddy/phase_stepping_opts.h
@@ -0,0 +1,32 @@
+#pragma once
+#include <option/has_burst_stepping.h>
+
+namespace phase_stepping::opts {
+
+static constexpr int MOTOR_PERIOD = 1024; // The number of ticks per electrical period of the Trinamic driver
+static constexpr int SIN_FRACTION = 4;
+static constexpr int SIN_PERIOD = SIN_FRACTION * MOTOR_PERIOD;
+static constexpr int CURRENT_AMPLITUDE = 248;
+static constexpr int CORRECTION_HARMONICS = 16;
+static constexpr int SUPPORTED_AXIS_COUNT = 2;
+static constexpr int SERIAL_DECIMALS = 5; // Float decimals written in the serial output
+static constexpr int ALLOWED_MISSED_TX = 5000;
+static constexpr int REFRESH_FREQ = option::has_burst_stepping
+    ? 10000
+    : 40000;
+static constexpr int GPIO_BUFFER_SIZE = 200;
+
+} // namespace phase_stepping::opts
+
+#define PHSTEP_TIMER_ISR_HANDLER TIM8_UP_TIM13_IRQHandler
+
+// You might be wondering why we use hard-coded constants and we don't read
+// them from handles: it is wasted 500 ns - that is 2 % of CPU load
+#define PHSTEP_TMC_SPI             SPI3
+#define PHSTEP_TMC_DMA             DMA1_Stream5
+#define PHSTEP_TMC_DMA_REGS        reinterpret_cast<DMA_Base_Registers *>((((uint32_t)PHSTEP_TMC_DMA & (uint32_t)(~0x3FFU)) + 4U))
+#define PHSTEP_TMC_DMA_REGS_OFFSET 6U
+
+#define BURST_DMA             DMA2_Stream1
+#define BURST_DMA_REGS        reinterpret_cast<DMA_Base_Registers *>((((uint32_t)BURST_DMA & (uint32_t)(~0x3FFU))))
+#define BURST_DMA_REGS_OFFSET 6U
diff --git a/include/buddy/priorities_config.h b/include/buddy/priorities_config.h
index ed0d8b82b4..bbdaffe3ad 100644
--- a/include/buddy/priorities_config.h
+++ b/include/buddy/priorities_config.h
@@ -22,12 +22,13 @@ static_assert(configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY == 5);
     #if !BOARD_IS_XBUDDY
         #define ISR_PRIORITY_ENDSTOP 0 // High priority to preempt the STEP_TIMER when possible
     #endif
-    #define ISR_PRIORITY_STEP_TIMER 1
-    #define ISR_PRIORITY_HX717_HARD 2
+    #define ISR_PRIORITY_PHASE_TIMER 1
+    #define ISR_PRIORITY_STEP_TIMER  2
+    #define ISR_PRIORITY_HX717_HARD  3
     #if BOARD_IS_XBUDDY
         #define ISR_PRIORITY_ENDSTOP ISR_PRIORITY_HX717_HARD // Shared EXTI line: avoid STEP jitter
     #endif
-    #define ISR_PRIORITY_TEMP_TIMER    3
+    #define ISR_PRIORITY_TEMP_TIMER    4
     #define ISR_PRIORITY_POWER_PANIC   5
     #define ISR_PRIORITY_PUPPIES_USART 5
     #define ISR_PRIORITY_HX717_SOFT    5
diff --git a/include/device/stm32f4/device/peripherals.h b/include/device/stm32f4/device/peripherals.h
index 54e244dd52..243b38ca60 100644
--- a/include/device/stm32f4/device/peripherals.h
+++ b/include/device/stm32f4/device/peripherals.h
@@ -74,6 +74,9 @@ extern DMA_HandleTypeDef hdma_adc3;
 extern TIM_HandleTypeDef htim1;
 extern TIM_HandleTypeDef htim2;
 extern TIM_HandleTypeDef htim3;
+extern TIM_HandleTypeDef htim8;
+extern DMA_HandleTypeDef hdma_tim8;
+extern TIM_HandleTypeDef htim13;
 extern TIM_HandleTypeDef htim14;
 
 //
@@ -255,19 +258,21 @@ extern TIM_HandleTypeDef htim14;
         #define uart_mmu 6
     #endif
 #elif BOARD_IS_XLBUDDY
-    #define i2c_eeprom        2
-    #define i2c_usbc          1
-    #define i2c_touch         3
-    #define i2c_io_extender   2
-    #define spi_flash         5
-    #define spi_lcd           6
-    #define spi_tmc           3
-    #define uart_esp          8
-    #define spi_accelerometer 2
+    #define i2c_eeprom         2
+    #define i2c_usbc           1
+    #define i2c_touch          3
+    #define i2c_io_extender    2
+    #define spi_flash          5
+    #define spi_lcd            6
+    #define spi_tmc            3
+    #define uart_esp           8
+    #define spi_accelerometer  2
     // Side LEDs use either SPI4 or share SPI with LCD, depending on HW revision
     // #define spi_led           4 or spi_lcd
-    #define uart_puppies      3
-    #define uart_reserved     6
+    #define uart_puppies       3
+    #define uart_reserved      6
+    #define tim_burst_stepping 8
+    #define tim_phase_stepping 13
 #else
     #error Unknown board
 #endif
@@ -332,6 +337,8 @@ void hw_spi6_init();
 void hw_tim1_init();
 void hw_tim2_init();
 void hw_tim3_init();
+void hw_tim8_init();
+void hw_tim13_init();
 void hw_tim14_init();
 
 //
@@ -347,6 +354,9 @@ void hw_tim14_init();
 /// Get handle for given peripheral: SPI_HANDLE_FOR(lcd) -> hspi3
 #define SPI_HANDLE_FOR(peripheral) _JOIN(hspi, spi_##peripheral, )
 
+/// Get handle for given peripheral: TIM_HANDLE_FOR(phase_stepping) -> htim12
+#define TIM_HANDLE_FOR(peripheral) _JOIN(htim, tim_##peripheral, )
+
 /// Get handle for given peripheral: UART_HANDLE_FOR(esp) -> huart3
 #define UART_HANDLE_FOR(peripheral) _JOIN(huart, uart_##peripheral, )
 
diff --git a/include/marlin/Configuration_XL_adv.h b/include/marlin/Configuration_XL_adv.h
index bb434d8766..62e470a216 100644
--- a/include/marlin/Configuration_XL_adv.h
+++ b/include/marlin/Configuration_XL_adv.h
@@ -24,6 +24,7 @@
 // clang-format off
 
 #include "filename_defs.h"
+#include <option/has_burst_stepping.h>
 
 /**
  * Configuration_adv.h
@@ -1246,7 +1247,7 @@
 // @section serial
 
 // The ASCII buffer for serial input
-#define MAX_CMD_SIZE 96
+#define MAX_CMD_SIZE 256
 #define BUFSIZE 8
 
 // Transmission to Host Buffer Size
@@ -1799,7 +1800,12 @@
         #if (BOARD_VER_EQUAL_TO(0, 4, 0))
             #define STALL_THRESHOLD_TMC2130 247 // (steps per tick) - reciprocal value of minimal speed
         #else
-            #define STALL_THRESHOLD_TMC2130 300 // (steps per tick) - reciprocal value of minimal speed
+            #if !HAS_BURST_STEPPING()
+                #define STALL_THRESHOLD_TMC2130 300 // (steps per tick) - reciprocal value of minimal speed
+            #else
+                // TODO: this is just a ballpark value
+                #define STALL_THRESHOLD_TMC2130 400 // (steps per tick) - reciprocal value of minimal speed
+            #endif
         #endif
     #endif
 
diff --git a/include/puppies/Dwarf.hpp b/include/puppies/Dwarf.hpp
index 53a8e7e82d..7dc0abd188 100644
--- a/include/puppies/Dwarf.hpp
+++ b/include/puppies/Dwarf.hpp
@@ -33,7 +33,6 @@ class Dwarf : public ModbusDevice {
     static constexpr uint16_t IS_SELECTED { ftrstd::to_underlying(SystemCoil::is_selected) };
     static constexpr uint16_t LOADCELL_ENABLE { ftrstd::to_underlying(SystemCoil::loadcell_enable) };
     static constexpr uint16_t ACCELEROMETER_ENABLE { ftrstd::to_underlying(SystemCoil::accelerometer_enable) };
-    static constexpr uint16_t ACCELEROMETER_HIGH { ftrstd::to_underlying(SystemCoil::accelerometer_high) };
 
     static constexpr uint16_t HW_BOM_ID_ADDR { ftrstd::to_underlying(SystemInputRegister::hw_bom_id) };
     static constexpr uint16_t TMC_READ_RESPONSE_ADDRESS { ftrstd::to_underlying(SystemInputRegister::tmc_read_response_1) };
@@ -376,7 +375,6 @@ void ToolsMappingBody::windowEvent(EventLock, [[maybe_unused]] window_t *sender,
     ModbusCoil<IS_SELECTED> IsSelectedCoil {};
     ModbusCoil<LOADCELL_ENABLE> LoadcellEnableCoil {};
     ModbusCoil<ACCELEROMETER_ENABLE> AccelerometerEnableCoil {};
-    ModbusCoil<ACCELEROMETER_HIGH> AccelerometerHighCoil {};
 
     MODBUS_REGISTER MarlinErrorString_t {
         uint16_t title[10] {}; // 20 chars, title of error
diff --git a/include/puppies/fifo_coder.hpp b/include/puppies/fifo_coder.hpp
index 51063fcbdf..dcfadd6f48 100644
--- a/include/puppies/fifo_coder.hpp
+++ b/include/puppies/fifo_coder.hpp
@@ -28,8 +28,8 @@ enum class MessageType : uint8_t {
     no_data = 0, // Padding
     log = 1,
     loadcell = 2,
-    accelerometer = 3, ///< Single sample with timestamp
     accelerometer_fast = 4, ///< Multiple samples without timestamp
+    accelerometer_sampling_rate = 5, /// Single floating point number with frequency in Hz
     // ...
 };
 
@@ -49,12 +49,12 @@ typedef struct __attribute__((packed)) {
 } LoadcellRecord;
 
 typedef std::array<char, 8> LogData;
-typedef struct __attribute__((packed)) {
-    TimeStamp_us timestamp_us;
-    AccelerometerXyzSample sample;
-} AccelerometerData;
 typedef std::array<AccelerometerXyzSample, 2> AccelerometerFastData;
 
+typedef struct {
+    float frequency;
+} AccelerometerSamplingRate;
+
 // Payload to message type mapping using template specialization
 template <typename T>
 inline constexpr MessageType message_type() {
@@ -72,19 +72,18 @@ inline constexpr MessageType message_type<LoadcellRecord>() {
 }
 
 template <>
-inline constexpr MessageType message_type<AccelerometerData>() {
-    return MessageType::accelerometer;
+inline constexpr MessageType message_type<AccelerometerFastData>() {
+    return MessageType::accelerometer_fast;
 }
 
 template <>
-inline constexpr MessageType message_type<AccelerometerFastData>() {
-    return MessageType::accelerometer_fast;
+inline constexpr MessageType message_type<AccelerometerSamplingRate>() {
+    return MessageType::accelerometer_sampling_rate;
 }
 } // namespace common::puppies::fifo
 
 namespace dwarf::accelerometer {
 struct AccelerometerRecord {
-    common::puppies::fifo::TimeStamp_us timestamp;
     union {
         struct {
             int16_t x, y, z;
diff --git a/include/puppies/fifo_decoder.hpp b/include/puppies/fifo_decoder.hpp
index b363da0858..2b7fd87164 100644
--- a/include/puppies/fifo_decoder.hpp
+++ b/include/puppies/fifo_decoder.hpp
@@ -23,8 +23,8 @@ class Decoder {
     typedef struct {
         std::function<void(LogData)> log_handler;
         std::function<void(LoadcellRecord)> loadcell_handler;
-        std::function<void(AccelerometerData)> accelerometer_handler;
         std::function<void(AccelerometerFastData)> accelerometer_fast_handler;
+        std::function<void(AccelerometerSamplingRate)> accelerometer_freq_handler;
     } Callbacks_t;
 
     Decoder(std::array<uint16_t, MODBUS_FIFO_LEN> &fifo, size_t len);
diff --git a/lib/AddMarlin.cmake b/lib/AddMarlin.cmake
index 6aeba3efc4..3379e2a575 100644
--- a/lib/AddMarlin.cmake
+++ b/lib/AddMarlin.cmake
@@ -258,6 +258,15 @@ if(BOARD_IS_MASTER_BOARD)
               Marlin/Marlin/src/module/tool_change.cpp
       )
   endif()
+
+  if(PRINTER IN_LIST PRINTERS_WITH_PHASE_STEPPING)
+    target_sources(
+      Marlin
+      PRIVATE Marlin/Marlin/src/feature/phase_stepping/calibration.cpp
+              Marlin/Marlin/src/feature/phase_stepping/phase_stepping.cpp
+              Marlin/Marlin/src/gcode/feature/phase_stepping/M970-M977.cpp
+      )
+  endif()
 endif()
 
 target_compile_features(Marlin PUBLIC cxx_std_17)
diff --git a/lib/Marlin/Marlin/src/HAL/HAL_STM32_F4_F7/STM32F4/timers.cpp b/lib/Marlin/Marlin/src/HAL/HAL_STM32_F4_F7/STM32F4/timers.cpp
index 12b99261ef..1f508f34ff 100644
--- a/lib/Marlin/Marlin/src/HAL/HAL_STM32_F4_F7/STM32F4/timers.cpp
+++ b/lib/Marlin/Marlin/src/HAL/HAL_STM32_F4_F7/STM32F4/timers.cpp
@@ -32,7 +32,7 @@
 // ------------------------
 
 #define NUM_HARDWARE_TIMERS 3
-#define STEP_TIMER_IRQ_ID TIM8_CC_IRQn
+#define STEP_TIMER_IRQ_ID TIM8_BRK_TIM12_IRQn
 #define MOVE_TIMER_IRQ_ID TIM6_DAC_IRQn
 #define TEMP_TIMER_IRQ_ID TIM7_IRQn
 
@@ -56,8 +56,8 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
                        temp_prescaler = TEMP_TIMER_PRESCALE - 1;
     switch (timer_num) {
       case STEP_TIMER_NUM:
-        __HAL_RCC_TIM8_CLK_ENABLE();
-        TimerHandle[timer_num].handle.Instance               = TIM8;
+        __HAL_RCC_TIM12_CLK_ENABLE();
+        TimerHandle[timer_num].handle.Instance               = TIM12;
         TimerHandle[timer_num].handle.Init.Period            = 65535;
         TimerHandle[timer_num].handle.Init.Prescaler         = step_prescaler; // Frequency of timer ticks should be 1MHz, based on 168000000 / (167 + 1).
         TimerHandle[timer_num].handle.Init.ClockDivision     = TIM_CLOCKDIVISION_DIV1;
@@ -119,7 +119,7 @@ void HAL_timer_start(const uint8_t timer_num, const uint32_t frequency) {
   }
 }
 
-extern "C" void TIM8_CC_IRQHandler() {
+extern "C" void TIM8_BRK_TIM12_IRQHandler() {
   ((void(*)())TimerHandle[STEP_TIMER_NUM].callback)();
 }
 extern "C" void TIM7_IRQHandler() {
diff --git a/lib/Marlin/Marlin/src/HAL/HAL_STM32_F4_F7/STM32F4/timers.h b/lib/Marlin/Marlin/src/HAL/HAL_STM32_F4_F7/STM32F4/timers.h
index 037c18416b..f38243af04 100644
--- a/lib/Marlin/Marlin/src/HAL/HAL_STM32_F4_F7/STM32F4/timers.h
+++ b/lib/Marlin/Marlin/src/HAL/HAL_STM32_F4_F7/STM32F4/timers.h
@@ -45,7 +45,7 @@
 #define MOVE_TIMER_PRESCALE     1000 // prescaler for setting Move timer, 72Khz
 #define MOVE_TIMER_FREQUENCY    400 // move interrupt frequency
 
-#define STEPPER_TIMER_PRESCALE (SYSTEM_CORE_CLOCK / 1000000)
+#define STEPPER_TIMER_PRESCALE (SYSTEM_CORE_CLOCK / 2 / 1000000)
 #define STEPPER_TIMER_RATE     1000000   // frequency of stepper timer
 #define STEPPER_TIMER_TICKS_PER_US ((STEPPER_TIMER_RATE) / 1000000) // stepper timer ticks per µs
 
diff --git a/lib/Marlin/Marlin/src/Marlin.cpp b/lib/Marlin/Marlin/src/Marlin.cpp
index e77cb5f3a1..09c0833129 100644
--- a/lib/Marlin/Marlin/src/Marlin.cpp
+++ b/lib/Marlin/Marlin/src/Marlin.cpp
@@ -33,6 +33,16 @@
 #include "feature/input_shaper/input_shaper_config.hpp"
 #include "feature/pressure_advance/pressure_advance_config.hpp"
 
+#include <option/has_phase_stepping.h>
+#if HAS_PHASE_STEPPING()
+  #include "feature/phase_stepping/phase_stepping.hpp"
+#endif
+
+#include <option/has_burst_stepping.h>
+#if HAS_BURST_STEPPING()
+  #include "feature/phase_stepping/burst_stepper.hpp"
+#endif
+
 #include "core/utility.h"
 #include "lcd/ultralcd.h"
 #include "module/motion.h"
@@ -1015,6 +1025,12 @@ void setup() {
   // NOTE: this enables (timer) interrupts!
   planner.init();
   stepper.init();
+#if HAS_PHASE_STEPPING()
+  phase_stepping::init();
+#endif
+#if HAS_BURST_STEPPING()
+  burst_stepping::init();
+#endif
   PreciseStepping::init();
 #ifdef ADVANCED_STEP_GENERATORS
   input_shaper::init();
diff --git a/lib/Marlin/Marlin/src/Marlin.h b/lib/Marlin/Marlin/src/Marlin.h
index 2b39899a8d..8c17f29acb 100644
--- a/lib/Marlin/Marlin/src/Marlin.h
+++ b/lib/Marlin/Marlin/src/Marlin.h
@@ -355,6 +355,9 @@ extern bool wait_for_heatup;
 
 #if HAS_AUTO_REPORTING || ENABLED(HOST_KEEPALIVE_FEATURE)
   extern bool suspend_auto_report;
+  #define TEMPORARY_AUTO_REPORT_OFF(name) REMEMBER(name, suspend_auto_report, true)
+#else
+  #define TEMPORARY_AUTO_REPORT_OFF(name)
 #endif
 
 extern uint16_t job_id;
diff --git a/lib/Marlin/Marlin/src/core/utility.cpp b/lib/Marlin/Marlin/src/core/utility.cpp
index ac61af6f0e..ce7d241b83 100644
--- a/lib/Marlin/Marlin/src/core/utility.cpp
+++ b/lib/Marlin/Marlin/src/core/utility.cpp
@@ -46,9 +46,8 @@ void safe_delay(millis_t ms) {
   #include "../gcode/gcode.h" // for set_autoreport_paused
 
   void serial_delay(const millis_t ms) {
-    const bool was = suspend_auto_report;
+    TEMPORARY_AUTO_REPORT_OFF(suspend_auto_report);
     safe_delay(ms);
-    suspend_auto_report = was;
   }
 #endif
 
diff --git a/lib/Marlin/Marlin/src/feature/input_shaper/input_shaper.cpp b/lib/Marlin/Marlin/src/feature/input_shaper/input_shaper.cpp
index a09a823435..d80f95511a 100644
--- a/lib/Marlin/Marlin/src/feature/input_shaper/input_shaper.cpp
+++ b/lib/Marlin/Marlin/src/feature/input_shaper/input_shaper.cpp
@@ -274,7 +274,19 @@ void input_shaper_state_init(input_shaper_state_t &is_state, const move_t &move,
 
     is_state.half_accel = get_move_half_accel(move, axis);
     is_state.start_v = get_move_start_v(move, axis);
+
+#ifdef COREXY
+    if (axis == A_AXIS) {
+        is_state.start_pos = move.start_pos.x + move.start_pos.y;
+    } else if (axis == B_AXIS) {
+        is_state.start_pos = move.start_pos.x - move.start_pos.y;
+    } else {
+        fatal_error("Invalid axis", "input_shaper_state_init");
+    }
+#else
     is_state.start_pos = get_move_start_pos(move, axis);
+#endif
+
     is_state.step_dir = get_move_step_dir(move, axis);
 
     is_state.is_crossing_zero_velocity = false;
@@ -365,7 +377,7 @@ bool logical_axis_input_shaper_t::update(const input_shaper_state_t &axis_is) {
 // that processing multiple time events at once could cause that very close time event could be skipped. That
 // could lead to incorrect step timing.
 // Returns true if input_shaper_state was updated and false otherwise.
-static bool input_shaper_state_update(input_shaper_state_t &is_state, const int axis) {
+bool input_shaper_state_update(input_shaper_state_t &is_state, const int axis) {
 #ifdef COREXY
     bool x_updated = false;
     bool y_updated = false;
@@ -485,43 +497,43 @@ FORCE_INLINE void input_shaper_step_generator_update(input_shaper_step_generator
 step_event_info_t input_shaper_step_generator_next_step_event(input_shaper_step_generator_t &step_generator, step_generator_state_t &step_generator_state) {
     assert(step_generator.is_state != nullptr);
     step_event_info_t next_step_event = { std::numeric_limits<double>::max(), 0, STEP_EVENT_INFO_STATUS_GENERATED_INVALID };
-    bool is_updated = false;
-    do {
-        const bool step_dir = step_generator.is_state->step_dir;
-        const float half_step_dist = Planner::mm_per_half_step[step_generator.axis];
-        const float next_target = float(step_generator_state.current_distance[step_generator.axis] + (step_generator.step_dir ? 0 : -1)) * Planner::mm_per_step[step_generator.axis] + half_step_dist;
-        const float next_distance = next_target - step_generator.start_pos;
-        const float step_time = calc_time_for_distance(step_generator, next_distance);
-
-        // When step_time is infinity, it means that next_distance will never be reached.
-        // This happens when next_target exceeds end_position, and deceleration decelerates velocity to zero or negative value.
-        // Also, we need to stop when step_time exceeds local_end.
-        if (const double elapsed_time = double(step_time) + step_generator.is_state->print_time; elapsed_time > (step_generator.is_state->nearest_next_change + EPSILON)) {
-            next_step_event.time = step_generator.is_state->nearest_next_change;
-
-            is_updated = input_shaper_state_update(*step_generator.is_state, step_generator.axis);
-
-            // Update step direction flag, which is cached until this move segment is processed.
-            const uint16_t current_axis_dir_flag = (STEP_EVENT_FLAG_X_DIR << step_generator.axis);
-            step_generator_state.flags &= ~current_axis_dir_flag;
-            step_generator_state.flags |= (!step_generator.is_state->step_dir) * current_axis_dir_flag;
-
-            // Update active axis flag, which is cached until this move segment is processed.
-            const uint16_t current_axis_active_flag = (STEP_EVENT_FLAG_X_ACTIVE << step_generator.axis);
-            step_generator_state.flags &= ~current_axis_active_flag;
-            step_generator_state.flags |= (step_generator.is_state->start_v != 0. || step_generator.is_state->half_accel != 0.) * current_axis_active_flag;
-
-            input_shaper_step_generator_update(step_generator);
-            PreciseStepping::move_segment_processed_handler();
-        } else {
-            next_step_event.time = elapsed_time;
-            next_step_event.flags = STEP_EVENT_FLAG_STEP_X << step_generator.axis;
-            next_step_event.flags |= step_generator_state.flags;
-            next_step_event.status = STEP_EVENT_INFO_STATUS_GENERATED_VALID;
-            step_generator_state.current_distance[step_generator.axis] += (step_dir ? 1 : -1);
-            break;
+
+    const bool step_dir = step_generator.is_state->step_dir;
+    const float half_step_dist = Planner::mm_per_half_step[step_generator.axis];
+    const float next_target = float(step_generator_state.current_distance[step_generator.axis] + (step_generator.step_dir ? 0 : -1)) * Planner::mm_per_step[step_generator.axis] + half_step_dist;
+    const float next_distance = next_target - step_generator.start_pos;
+    const float step_time = calc_time_for_distance(step_generator, next_distance);
+
+    // When step_time is infinity, it means that next_distance will never be reached.
+    // This happens when next_target exceeds end_position, and deceleration decelerates velocity to zero or negative value.
+    // Also, we need to stop when step_time exceeds local_end.
+    if (const double elapsed_time = double(step_time) + step_generator.is_state->print_time; elapsed_time > (step_generator.is_state->nearest_next_change + EPSILON)) {
+        next_step_event.time = step_generator.is_state->nearest_next_change;
+
+        if (input_shaper_state_update(*step_generator.is_state, step_generator.axis) && step_generator.is_state->nearest_next_change < MAX_PRINT_TIME) {
+            next_step_event.flags |= STEP_EVENT_FLAG_KEEP_ALIVE;
+            next_step_event.status = STEP_EVENT_INFO_STATUS_GENERATED_KEEP_ALIVE;
         }
-    } while (is_updated);
+
+        // Update step direction flag, which is cached until this move segment is processed.
+        const uint16_t current_axis_dir_flag = (STEP_EVENT_FLAG_X_DIR << step_generator.axis);
+        step_generator_state.flags &= ~current_axis_dir_flag;
+        step_generator_state.flags |= (!step_generator.is_state->step_dir) * current_axis_dir_flag;
+
+        // Update active axis flag, which is cached until this move segment is processed.
+        const uint16_t current_axis_active_flag = (STEP_EVENT_FLAG_X_ACTIVE << step_generator.axis);
+        step_generator_state.flags &= ~current_axis_active_flag;
+        step_generator_state.flags |= (step_generator.is_state->start_v != 0. || step_generator.is_state->half_accel != 0.) * current_axis_active_flag;
+
+        input_shaper_step_generator_update(step_generator);
+        PreciseStepping::move_segment_processed_handler();
+    } else {
+        next_step_event.time = elapsed_time;
+        next_step_event.flags = STEP_EVENT_FLAG_STEP_X << step_generator.axis;
+        next_step_event.flags |= step_generator_state.flags;
+        next_step_event.status = STEP_EVENT_INFO_STATUS_GENERATED_VALID;
+        step_generator_state.current_distance[step_generator.axis] += (step_dir ? 1 : -1);
+    }
 
     return next_step_event;
 }
diff --git a/lib/Marlin/Marlin/src/feature/input_shaper/input_shaper.hpp b/lib/Marlin/Marlin/src/feature/input_shaper/input_shaper.hpp
index 410771ca35..3478aadd32 100644
--- a/lib/Marlin/Marlin/src/feature/input_shaper/input_shaper.hpp
+++ b/lib/Marlin/Marlin/src/feature/input_shaper/input_shaper.hpp
@@ -13,14 +13,9 @@
 #pragma once
 #include <array>
 #include "input_shaper_config.hpp"
+#include "../precise_stepping/fwdecl.hpp"
 #include "../../core/types.h"
 
-struct move_t;
-struct step_event_info_t;
-struct step_generator_state_t;
-struct input_shaper_state_t;
-struct input_shaper_step_generator_t;
-
 constexpr const uint8_t MAX_INPUT_SHAPER_PULSES = 5;
 
 constexpr const double INPUT_SHAPER_VELOCITY_EPSILON = 0.0001;
@@ -142,3 +137,5 @@ void input_shaper_step_generator_init(const move_t &move, input_shaper_step_gene
 FORCE_INLINE void input_shaper_step_generator_update(input_shaper_step_generator_t &step_generator);
 
 void input_shaper_state_init(input_shaper_state_t &is_state, const move_t &move, uint8_t axis);
+
+bool input_shaper_state_update(input_shaper_state_t &is_state, const int axis);
diff --git a/lib/Marlin/Marlin/src/feature/phase_stepping/burst_stepper.cpp b/lib/Marlin/Marlin/src/feature/phase_stepping/burst_stepper.cpp
new file mode 100644
index 0000000000..43d02e91f5
--- /dev/null
+++ b/lib/Marlin/Marlin/src/feature/phase_stepping/burst_stepper.cpp
@@ -0,0 +1,186 @@
+#include "burst_stepper.hpp"
+#include "common.hpp"
+#include <hwio.h>
+#include <array>
+#include <device/peripherals.h>
+#include "otp.hpp"
+
+using namespace phase_stepping;
+using namespace phase_stepping::opts;
+using namespace burst_stepping;
+using namespace buddy::hw;
+
+struct DMA_Base_Registers {
+    __IO uint32_t ISR; /*!< DMA interrupt status register */
+    __IO uint32_t Reserved0;
+    __IO uint32_t IFCR; /*!< DMA interrupt flag clear register */
+};
+
+// GPIO event buffer that can be played via DMA. Supports fast clearing. If you
+// ever come to this code and think "Hey, we should use sparse cleaning", stop.
+// For buffers over 25 events it is faster to save the hassle of storing extra
+// indices and instead, just erase the whole buffer.
+template <int SIZE>
+class GpioEventBuffer {
+public:
+    GpioEventBuffer() {
+        _buffer.fill(0);
+    }
+
+    void clear() {
+        if (!_dirty) {
+            return;
+        }
+        _buffer.fill(0);
+        _dirty = false;
+    };
+
+    void start_fill() {
+        _dirty = true;
+    }
+
+    void add_event(int idx, uint32_t event_mask) {
+        // assert(idx < SIZE);
+        _buffer[idx] |= event_mask;
+    }
+
+    static int size() {
+        return SIZE;
+    }
+
+    bool dirty() {
+        return _dirty;
+    }
+
+    const uint32_t *dma_buffer() const {
+        return _buffer.data();
+    }
+
+private:
+    std::array<uint32_t, SIZE> _buffer {};
+    bool _dirty = false;
+};
+
+template <typename T>
+using PerAxisArray = std::array<T, SUPPORTED_AXIS_COUNT>;
+
+// Buddy pin abstraction for dir signals
+static constexpr PerAxisArray<OutputPin> dir_signals = { { xDir, yDir } };
+
+// Bitmasks for step pins on the port
+static GPIO_TypeDef *step_gpio_port = nullptr;
+static PerAxisArray<uint32_t> step_masks;
+
+// Module items
+static PerAxisArray<bool> axis_direction;
+static PerAxisArray<bool> axis_step_state;
+static PerAxisArray<bool> axis_was_set;
+static std::array<GpioEventBuffer<GPIO_BUFFER_SIZE>, 2> porta_event_buffers;
+static GpioEventBuffer<GPIO_BUFFER_SIZE>
+    *setup_buffer = &porta_event_buffers[0],
+    *fire_buffer = &porta_event_buffers[1];
+
+static void setup_pinout_1() {
+    step_gpio_port = GPIOA;
+    step_masks = { { 1 << 0, 1 << 3 } };
+}
+
+static void setup_pinout_2() {
+    step_gpio_port = GPIOD;
+    step_masks = { { 1 << 7, 1 << 5 } };
+}
+
+void burst_stepping::init() {
+    auto otp_bom_id = otp_get_bom_id();
+    if (!otp_bom_id.has_value()) {
+        bsod("Unable to determine board BOM ID");
+    }
+    auto board_bom_id = *otp_bom_id;
+
+    if (board_bom_id >= 9 || board_bom_id == 4) {
+        setup_pinout_2();
+    } else {
+        setup_pinout_1();
+    }
+
+    HAL_TIM_Base_Start(&TIM_HANDLE_FOR(burst_stepping));
+    __HAL_TIM_ENABLE_DMA(&TIM_HANDLE_FOR(burst_stepping), TIM_DMA_UPDATE);
+}
+
+FORCE_OFAST void burst_stepping::set_phase_diff(AxisEnum axis, int diff) {
+    if (axis >= SUPPORTED_AXIS_COUNT) {
+        bsod("Unsupported axis");
+    }
+
+    if (diff < 0) {
+        diff = -diff;
+        axis_direction[axis] = false;
+    } else {
+        axis_direction[axis] = true;
+    }
+
+    if (diff > GPIO_BUFFER_SIZE) {
+        bsod("Axis speed over limit");
+    }
+
+    if (diff == 0) {
+        return;
+    }
+
+    // We use fixed 16.16 number to find the transition points
+    const std::size_t udiff = diff;
+    const std::size_t spacing = (GPIO_BUFFER_SIZE << 16) / diff;
+    const uint32_t pos_mask = step_masks[axis];
+    const uint32_t neg_mask = step_masks[axis] << 16;
+    auto *lsetup_buffer = setup_buffer;
+
+    bool current_state = axis_step_state[axis];
+    lsetup_buffer->start_fill();
+    for (std::size_t i = 0; i != udiff; i++) {
+        current_state = !current_state;
+        std::size_t idx = (spacing * i) >> 16;
+        if (current_state) {
+            lsetup_buffer->add_event(idx, pos_mask);
+        } else {
+            lsetup_buffer->add_event(idx, neg_mask);
+        }
+    }
+    axis_step_state[axis] = current_state;
+    axis_was_set[axis] = true;
+}
+
+FORCE_OFAST static void setup_and_fire_dma() {
+    assert(!busy());
+    BURST_DMA->CR = BURST_DMA->CR & (~DMA_SxCR_EN_Msk);
+    BURST_DMA->NDTR = fire_buffer->size();
+    BURST_DMA->PAR = reinterpret_cast<uint32_t>(&step_gpio_port->BSRR);
+    BURST_DMA->M0AR = reinterpret_cast<uint32_t>(fire_buffer->dma_buffer());
+    BURST_DMA_REGS->IFCR = 0b111111 << BURST_DMA_REGS_OFFSET;
+    __HAL_TIM_SET_COUNTER(&TIM_HANDLE_FOR(burst_stepping), 0);
+    BURST_DMA->CR = (BURST_DMA->CR
+                        & ~(DMA_SxCR_DBM_Msk | DMA_SxCR_DMEIE_Msk | DMA_SxCR_TEIE_Msk | DMA_SxCR_HTIE_Msk | DMA_SxCR_TCIE_Msk))
+        | DMA_SxCR_EN_Msk;
+}
+
+FORCE_OFAST bool burst_stepping::busy() {
+    return (BURST_DMA->NDTR > 0) && (BURST_DMA->CR & DMA_SxCR_EN_Msk);
+}
+
+FORCE_OFAST void burst_stepping::fire() {
+    for (std::size_t i = 0; i != axis_direction.size(); i++) {
+        if (!axis_was_set[i]) {
+            continue;
+        }
+        axis_was_set[i] = false;
+        if (axis_direction[i]) {
+            dir_signals[i].write(Pin::State::low);
+        } else {
+            dir_signals[i].write(Pin::State::high);
+        }
+    }
+    if (setup_buffer->dirty()) {
+        std::swap(setup_buffer, fire_buffer);
+        setup_and_fire_dma();
+        setup_buffer->clear();
+    }
+}
diff --git a/lib/Marlin/Marlin/src/feature/phase_stepping/burst_stepper.hpp b/lib/Marlin/Marlin/src/feature/phase_stepping/burst_stepper.hpp
new file mode 100644
index 0000000000..31b1e9a4fa
--- /dev/null
+++ b/lib/Marlin/Marlin/src/feature/phase_stepping/burst_stepper.hpp
@@ -0,0 +1,35 @@
+#pragma once
+
+#include "../../inc/MarlinConfig.h"
+#include <option/has_burst_stepping.h>
+
+// This module provides interface for generating given number of steps with as
+// least CPU intervention as possible.
+
+namespace burst_stepping {
+
+/**
+ * Initializes burst-step generator. This function has to be called before any
+ * other function of burst stepping is invoked.
+ **/
+void init();
+
+/**
+ * Sets number of step pulses to generate for given axis. The steps are not
+ * generated until fire is invoked.
+ **/
+void set_phase_diff(AxisEnum axis, int diff);
+
+/**
+ * Starts asynchronously generating steps previously set via set_phase_diff;
+ **/
+void fire();
+
+/**
+ * Return true if burst activity is undergoing
+ * NOTE: this is only sufficient when called _after_ checking phase_stepping to ensure that a new
+ *       burst can't be scheduled!
+ **/
+bool busy();
+
+}; // namespace burst_stepping
diff --git a/lib/Marlin/Marlin/src/feature/phase_stepping/calibration.cpp b/lib/Marlin/Marlin/src/feature/phase_stepping/calibration.cpp
new file mode 100644
index 0000000000..ef819f1917
--- /dev/null
+++ b/lib/Marlin/Marlin/src/feature/phase_stepping/calibration.cpp
@@ -0,0 +1,677 @@
+#include "calibration.hpp"
+#include "phase_stepping.hpp"
+#include "calibration_config.hpp"
+
+#include <log.h>
+#include <module/planner.h>
+#include <module/motion.h>
+#include <gcode/gcode.h>
+
+#include <vector>
+#include <cmath>
+#include <numbers>
+
+using namespace phase_stepping;
+using namespace phase_stepping::opts;
+
+LOG_COMPONENT_REF(PhaseStepping);
+
+// Currently re/set by M977
+CalibrationResult phase_stepping::last_calibration_result = CalibrationResult::make_unknown();
+
+// Temporary debugging to Marlin serial for convenience
+#define SERIAL_DEBUG
+
+// Poor man's "coroutine-like" golden search algorithm. It is instantiated with
+// initial range. The method run() runs the algorithm until it needs to evaluate
+// the cost function. You can get the requested point of evaluation via x(), and
+// you submit the result via submit(x, f(x)). Then you have to again, run it via
+// run() and so on until you reach desired precision.
+class InterruptableGoldenSearch {
+    static constexpr float PHI = std::numbers::phi_v<float>;
+
+    enum class Phase {
+        NotStarted = 0,
+        InitialFcRequested = 1,
+        InitialFdRequested = 2,
+        FcRequested = 3,
+        FdRequested = 4,
+    };
+
+    Phase _phase = Phase::NotStarted;
+    int _iterations = 0, _evals = 0;
+    float _a, _b, _c, _d;
+    float _fc = 0, _fd = 0;
+    float _requested_x = 0, _result = 0;
+
+    const char *_debug_name;
+
+    void _do_iteration() {
+        log_info(PhaseStepping, "%s: it %d, bracket (%f, %f) = (%f, %f)",
+            _debug_name, _iterations, _c, _d, _fc, _fd);
+
+#ifdef SERIAL_DEBUG
+        SERIAL_ECHO(_debug_name);
+        SERIAL_ECHO(": it ");
+        SERIAL_ECHO(_iterations);
+        SERIAL_ECHO(", bracket (");
+        SERIAL_PRINT(_c, SERIAL_DECIMALS);
+        SERIAL_ECHO(", ");
+        SERIAL_PRINT(_d, SERIAL_DECIMALS);
+        SERIAL_ECHO(") = (");
+        SERIAL_PRINT(_fc, SERIAL_DECIMALS);
+        SERIAL_ECHO(", ");
+        SERIAL_PRINT(_fd, SERIAL_DECIMALS);
+        SERIAL_ECHOLN(")");
+#endif
+
+        if (_fc < _fd) {
+            _b = _d;
+            _d = _c;
+            _fd = _fc;
+            _c = _b - (_b - _a) / PHI;
+            _requested_x = _c;
+            _phase = Phase::FcRequested;
+        } else {
+            _a = _c;
+            _c = _d;
+            _fc = _fd;
+            _d = _a + (_b - _a) / PHI;
+            _requested_x = _d;
+            _phase = Phase::FdRequested;
+        }
+        _iterations++;
+    }
+
+public:
+    InterruptableGoldenSearch(float a, float b, const char *name = "unnamed")
+        : _a(a)
+        , _b(b)
+        , _debug_name(name) {}
+
+    float x() const {
+        return _requested_x;
+    }
+
+    void submit(float fx) {
+        _result = fx;
+    }
+
+    void run() {
+        switch (_phase) {
+        case Phase::NotStarted:
+            _c = _b - (_b - _a) / PHI;
+            _d = _a + (_b - _a) / PHI;
+            _requested_x = _c;
+            _phase = Phase::InitialFcRequested;
+            break;
+        case Phase::InitialFcRequested:
+            _fc = _result;
+            _requested_x = _d;
+            _phase = Phase::InitialFdRequested;
+            break;
+        case Phase::InitialFdRequested:
+            _fd = _result;
+
+#ifdef SERIAL_DEBUG
+            SERIAL_ECHO(_debug_name);
+            SERIAL_ECHO(": ");
+            SERIAL_ECHO("Initial bracket (");
+            SERIAL_PRINT(_c, SERIAL_DECIMALS);
+            SERIAL_ECHO(", ");
+            SERIAL_PRINT(_d, SERIAL_DECIMALS);
+            SERIAL_ECHO(") = (");
+            SERIAL_PRINT(_fc, SERIAL_DECIMALS);
+            SERIAL_ECHO(", ");
+            SERIAL_PRINT(_fd, SERIAL_DECIMALS);
+            SERIAL_ECHOLN(")");
+#endif
+
+            _do_iteration();
+            break;
+        case Phase::FcRequested:
+            _fc = _result;
+            _do_iteration();
+            break;
+        case Phase::FdRequested:
+            _fd = _result;
+            _do_iteration();
+        }
+        _evals++;
+    }
+
+    float step_size() const {
+        return std::abs(_b - _a);
+    }
+
+    int iterations() const {
+        return _iterations;
+    }
+
+    int evals() const {
+        return _evals;
+    }
+
+    float arg_min() const {
+        return _fc < _fd ? _c : _d;
+    }
+
+    float min() const {
+        return std::min(_fc, _fd);
+    }
+};
+
+// Given change in physical space, return change in logical axis.
+// - for cartesian this is identity,
+// - for CORE XY it converts (A, B) to (X, Y)
+static std::tuple<float, float> physical_to_logical(float x, float y) {
+#ifdef COREXY
+    return {
+        (x + y) / 2,
+        (x - y) / 2
+    };
+#else
+    return { x, y };
+#endif
+}
+
+static float rev_to_mm(AxisEnum axis, float revs) {
+    static constinit std::array<float, SUPPORTED_AXIS_COUNT> FACTORS = []() consteval {
+        static_assert(SUPPORTED_AXIS_COUNT <= 3);
+
+        int STEPS_PER_UNIT[] = DEFAULT_AXIS_STEPS_PER_UNIT;
+        int MICROSTEPS[] = { X_MICROSTEPS, Y_MICROSTEPS, Z_MICROSTEPS };
+
+        std::array<float, SUPPORTED_AXIS_COUNT> ret;
+        for (int i = 0; i != SUPPORTED_AXIS_COUNT; i++) {
+            ret[i] = float(MICROSTEPS[i]) / float(STEPS_PER_UNIT[i]);
+        }
+        return ret;
+    }();
+    return revs * get_motor_steps(axis) * FACTORS[axis];
+}
+
+// @brief Wait for a state of a given axis specified by a predicate.
+// @return true on success, false on timeout
+template <typename Pred>
+static bool wait_for_movement_state(phase_stepping::AxisState &axis_state,
+    int timeout_ms, Pred pred) {
+    auto start_time = ticks_ms();
+
+    while (!(pred(axis_state))) {
+        auto cur_time = ticks_ms();
+        if (ticks_diff(cur_time, start_time) > timeout_ms) {
+            return false;
+        } else {
+            idle(true, true);
+        }
+    }
+    return true;
+}
+
+// Wait for end of acceleration phase of a given axis. Returns true on success,
+// false on timeout
+static bool wait_for_accel_end(phase_stepping::AxisState &axis_state,
+    int timeout_ms = 1000) {
+    return wait_for_movement_state(axis_state, timeout_ms, [](phase_stepping::AxisState &s) {
+        return s.is_cruising.load();
+    });
+}
+
+// Computes a pseudo-projection of one vector to another. The length of
+// direction vector is not normalized.
+static float pseudo_project(std::tuple<float, float> what, std::tuple<float, float> dir) {
+    return std::get<0>(what) * std::get<0>(dir) + std::get<1>(what) * std::get<1>(dir);
+}
+
+static float project_to_axis(AxisEnum axis, const PrusaAccelerometer::Acceleration &sample) {
+#ifdef COREXY
+    std::pair<float, float> proj_dir;
+    if (axis == AxisEnum::X_AXIS) {
+        proj_dir = { M_SQRT1_2, M_SQRT1_2 };
+    } else if (axis == AxisEnum::Y_AXIS) {
+        proj_dir = { -M_SQRT1_2, M_SQRT1_2 };
+    } else {
+        bsod("Unsupported axis");
+    }
+
+    return pseudo_project({ sample.val[0], sample.val[1] }, proj_dir);
+#else
+    if (axis == AxisEnum::X_AXIS) {
+        return sample.val[0];
+    } else if (axis == AxisEnum::Y_AXIS) {
+        return sample.val[1];
+    } else {
+        bsod("Unsupported axis");
+    }
+#endif
+}
+
+// Naively compute n-th bin of DFT and return its amplitude
+static float dft_n_mag(const std::vector<float> &signal, int n) {
+    assert(n >= 0);
+
+    float sum_sin = 0, sum_cos = 0;
+    for (std::size_t i = 0; i != signal.size(); i++) {
+        float x = 2 * std::numbers::pi_v<float> * i * n / signal.size();
+        float y = signal[i];
+        sum_sin += y * sin(x);
+        sum_cos += y * cos(x);
+    }
+
+    return std::sqrt(sum_sin * sum_sin + sum_cos * sum_cos);
+}
+
+// Given desired revolutions and speed, return expected revolutions for
+// measurements and required delay before measurement in seconds
+static std::tuple<float, float> sample_capture_revs(float revs, float speed) {
+    static const float MOVE_MARGIN = 0.2; // To account for acceleration and deceleration we use simple hard-coded constant, revs.
+    static const float ACC_RESONANCE_PERIOD = 0.2; // To account for print head resonances after acceleration, seconds.
+
+    return {
+        fabs(revs) + MOVE_MARGIN + ACC_RESONANCE_PERIOD * speed,
+        ACC_RESONANCE_PERIOD
+    };
+}
+
+static void move_to_calibration_start(AxisEnum axis, const PrinterCalibrationConfig &config) {
+    auto [measurement_revs, _] = sample_capture_revs(config.calib_revs, config.phases[0].speed);
+
+    float a_revs = axis == AxisEnum::A_AXIS ? measurement_revs : 0;
+    float b_revs = axis == AxisEnum::B_AXIS ? measurement_revs : 0;
+    const auto [d_rot_x, d_rot_y] = physical_to_logical(a_revs, b_revs);
+    const float dx = rev_to_mm(AxisEnum::X_AXIS, d_rot_x);
+    const float dy = rev_to_mm(AxisEnum::Y_AXIS, d_rot_y);
+
+    const float target_x = X_BED_SIZE / 2.f - dx / 2.f;
+    const float target_y = Y_BED_SIZE / 2.f - dy / 2.f;
+
+    do_blocking_move_to_xy(target_x, target_y);
+}
+
+static void reset_compensation(AxisEnum axis) {
+    phase_stepping::axis_states[axis]->forward_current.clear();
+    phase_stepping::axis_states[axis]->backward_current.clear();
+}
+
+// Return a tuple <motor_period_count, relevant_samples_count> that gives a
+// number of full motor periods in the signal and corresponding signal count
+std::optional<std::tuple<int, int>> matching_samples_count(int sample_count, float sampling_freq,
+    AxisEnum axis, float speed) {
+    float motor_period_duration = 1 / (speed * get_motor_steps(axis) / 4);
+    float sampling_duration = sample_count / sampling_freq;
+    int motor_period_count = int(sampling_duration / motor_period_duration);
+    int relevant_samples_count = int(motor_period_count * motor_period_duration / sampling_duration * sample_count);
+
+    if (relevant_samples_count >= sample_count) {
+        log_error(PhaseStepping, "Not enough samples for calibration: %d/%d",
+            relevant_samples_count, sample_count);
+        return std::nullopt;
+    }
+
+    return std::tuple { motor_period_count, relevant_samples_count };
+}
+
+float phase_stepping::capture_samples(AxisEnum axis, float speed, float revs,
+    const std::function<void(const PrusaAccelerometer::Acceleration &)> &yield_sample) {
+    assert(speed > 0);
+
+    Planner::synchronize();
+
+    phase_stepping::AxisState &axis_state = *phase_stepping::axis_states[axis];
+
+    // Find move target that corresponds to given number of revs
+    auto [measurement_revs, vibration_delay] = sample_capture_revs(revs, speed);
+    int direction = revs > 0 ? 1 : -1;
+    float axis_revs = direction * measurement_revs;
+    float a_revs = axis == AxisEnum::X_AXIS ? axis_revs : 0;
+    float b_revs = axis == AxisEnum::Y_AXIS ? axis_revs : 0;
+
+    auto [x_revs, y_revs] = physical_to_logical(a_revs, b_revs);
+    auto [x_speed, y_speed] = physical_to_logical(
+        axis == AxisEnum::X_AXIS ? rev_to_mm(AxisEnum::X_AXIS, speed) : 0,
+        axis == AxisEnum::Y_AXIS ? rev_to_mm(AxisEnum::Y_AXIS, speed) : 0);
+    float d_x = rev_to_mm(AxisEnum::X_AXIS, x_revs);
+    float d_y = rev_to_mm(AxisEnum::Y_AXIS, y_revs);
+
+    float feedrate_mms = sqrt(x_speed * x_speed + y_speed * y_speed);
+
+    plan_move_by(feedrate_mms, d_x, d_y);
+
+    if (!wait_for_accel_end(axis_state)) {
+        log_error(PhaseStepping, "Acceleration phase didn't ended within timeout");
+        return 0;
+    }
+
+    gcode.dwell(vibration_delay * 1000, true);
+
+    int counter = 0;
+    PrusaAccelerometer accelerometer;
+    if (accelerometer.get_error() != PrusaAccelerometer::Error::none) {
+        log_error(PhaseStepping, "Cannot initialize accelerometer %u", static_cast<unsigned>(accelerometer.get_error()));
+        return 0;
+    }
+    accelerometer.clear();
+    while (axis_state.is_cruising.load()) {
+        counter++;
+        PrusaAccelerometer::Acceleration sample;
+        int has_new_sample = accelerometer.get_sample(sample);
+        if (has_new_sample && counter > 20) { // Be pessimistic about old samples in FIFOs
+            yield_sample(sample);
+        }
+    }
+    if (accelerometer.get_error() != PrusaAccelerometer::Error::none) {
+        log_error(PhaseStepping, "Accelerometer reading failed %u", static_cast<unsigned>(accelerometer.get_error()));
+        return 0;
+    }
+    return accelerometer.get_sampling_rate();
+}
+
+std::vector<float> phase_stepping::analyze_resonance(AxisEnum axis,
+    float speed, float revs, const std::vector<int> &requested_harmonics) {
+    const int expected_max_sample_count = 1500 * speed * std::abs(revs);
+
+    std::vector<float> signal;
+    signal.reserve(expected_max_sample_count);
+    float sampling_freq = capture_samples(axis, speed, revs, [&](const auto &sample) {
+        if (signal.size() < signal.capacity()) {
+            signal.push_back(project_to_axis(axis, sample));
+        }
+    });
+
+    log_info(PhaseStepping, "Accelerometer sampling freq: %f", sampling_freq);
+    if (sampling_freq < 1100 || sampling_freq > 1500) {
+        log_error(PhaseStepping, "Sampling freq out of range: %f", sampling_freq);
+        return {};
+    }
+
+    auto msc_r = matching_samples_count(
+        signal.size(), sampling_freq, axis, speed);
+
+    if (!msc_r.has_value()) {
+        log_error(PhaseStepping, "Cannot analyze resonance, no matching sample count");
+        return {};
+    }
+    auto [motor_period_count, samples_count] = *msc_r;
+
+    if (samples_count < 3) {
+        log_error(PhaseStepping, "Cannot analyze resonance, too short signal: %d", samples_count);
+        return {};
+    }
+
+    signal.resize(samples_count);
+
+    std::vector<float> res;
+    res.reserve(requested_harmonics.size());
+
+    for (auto n : requested_harmonics) {
+        std::size_t harm = n * motor_period_count;
+        assert(harm < signal.size());
+        if (harm <= 0 || harm >= signal.size() - 1) {
+            res.push_back(dft_n_mag(signal, n * motor_period_count));
+        } else {
+            float a1 = dft_n_mag(signal, n * motor_period_count - 1);
+            float a2 = dft_n_mag(signal, n * motor_period_count);
+            float a3 = dft_n_mag(signal, n * motor_period_count + 1);
+            res.push_back((a1 + a2 + a3) / 3.f);
+        }
+
+        idle(true, true);
+    }
+
+    return { res };
+}
+
+// Execution of calibration phase can be nicely divided into separate functions,
+// however, these functions share a common context. This class provides the
+// context for the (otherwise free-standing) functions.
+class CalibrationPhaseExecutor {
+    static constexpr int RETRY_COUNT = 4;
+
+    AxisEnum _axis;
+    const PrinterCalibrationConfig &_printer_config;
+    const CalibrationPhase &_phase_config;
+    CalibrationReporterBase &_reporter;
+    int _progress = 0;
+
+    int _progress_tick_count() const {
+        return 2 * _phase_config.iteration_count;
+    }
+
+    // Iterate search for forward and backward dimension; leaves the optimal
+    // result in the correction table. Returns forward and backward score
+    template <typename F>
+        requires requires(F f, MotorPhaseCorrection &mpc, int i, float x) { f(mpc, i, x); }
+    std::optional<std::tuple<float, float>> _run_simultaneous_search(
+        InterruptableGoldenSearch forward_search,
+        InterruptableGoldenSearch backward_search,
+        int iterations,
+        F apply_x) {
+        auto &axis_state = *phase_stepping::axis_states[_axis];
+
+        // Calibration is quite CPU-heavy, we gotta release the processor to do other stuff from time to time
+        // Also GUI thread is waiting for marlin server acks, so we gotta do marlin idling
+        // That's why the idles are here
+
+        for (int i = 0; i != iterations; i++) {
+            forward_search.run();
+            backward_search.run();
+
+            axis_state.forward_current.modify_correction([&](auto &table) {
+                apply_x(table, 0, forward_search.x());
+            });
+
+            idle(true, true);
+
+            axis_state.backward_current.modify_correction([&](auto &table) {
+                apply_x(table, 1, backward_search.x());
+            });
+
+            idle(true, true);
+
+            for (int retries = 0; retries <= RETRY_COUNT; retries++) {
+                if (retries == RETRY_COUNT) {
+                    log_error(PhaseStepping, "Out of retries in argument search");
+                    return std::nullopt;
+                }
+                if (retries != 0) {
+                    move_to_calibration_start(_axis, _printer_config);
+                }
+
+                auto b_res = phase_stepping::analyze_resonance(_axis,
+                    _phase_config.speed, _printer_config.calib_revs, { _phase_config.harmonic });
+
+                idle(true, true);
+
+                auto f_res = phase_stepping::analyze_resonance(_axis,
+                    _phase_config.speed, -_printer_config.calib_revs, { _phase_config.harmonic });
+
+                idle(true, true);
+
+                if (!f_res.empty() && !b_res.empty()) {
+                    forward_search.submit(f_res[0]);
+                    backward_search.submit(b_res[0]);
+                    break;
+                }
+                log_error(PhaseStepping, "Resonance analysis failed in argument search");
+            }
+            _reporter.on_calibration_phase_progress(100 * (_progress++) / _progress_tick_count());
+
+            idle(true, true);
+        }
+
+        // Apply the result
+        axis_state.forward_current.modify_correction([&](auto &table) {
+            apply_x(table, 0, forward_search.arg_min());
+        });
+        idle(true, true);
+
+        axis_state.backward_current.modify_correction([&](auto &table) {
+            apply_x(table, 1, backward_search.arg_min());
+        });
+        idle(true, true);
+
+        return { { forward_search.min(), backward_search.min() } };
+    }
+
+    const SpectralItem &_get_fwd_item() const {
+        return axis_states[_axis]->forward_current.get_correction()[_phase_config.harmonic];
+    }
+
+    const SpectralItem &_get_bwd_item() const {
+        return axis_states[_axis]->backward_current.get_correction()[_phase_config.harmonic];
+    }
+
+public:
+    CalibrationPhaseExecutor(
+        AxisEnum axis, const PrinterCalibrationConfig &printer_config,
+        const CalibrationPhase &phase_config, CalibrationReporterBase &reporter)
+        : _axis(axis)
+        , _printer_config(printer_config)
+        , _phase_config(phase_config)
+        , _reporter(reporter) {}
+
+    std::optional<std::tuple<float, float>> baseline() {
+        for (int retries = 0; retries != RETRY_COUNT; retries++) {
+            auto b_res = phase_stepping::analyze_resonance(_axis,
+                _phase_config.speed, _printer_config.calib_revs, { { _phase_config.harmonic } });
+            auto f_res = phase_stepping::analyze_resonance(_axis,
+                _phase_config.speed, -_printer_config.calib_revs, { { _phase_config.harmonic } });
+
+            if (!f_res.empty() && !b_res.empty()) {
+                return { { f_res[0], b_res[0] } };
+            }
+        }
+
+        log_error(PhaseStepping, "Cannot obtain baseline measurement");
+        return std::nullopt;
+    }
+
+    // Return success flags, leave axis corrections tables in the final
+    // destination
+    std::optional<std::tuple<float, float>> run() {
+        // Find phase
+        const float initial_f_pha = _phase_config.pha.value_or(_get_fwd_item().pha);
+        const float initial_f_mag = _phase_config.mag.value_or(_get_fwd_item().mag);
+        const float initial_b_pha = _phase_config.pha.value_or(_get_bwd_item().pha);
+        const float initial_b_mag = _phase_config.mag.value_or(_get_bwd_item().mag);
+        const float pha_range = _phase_config.pha_window / 2.f;
+        auto phase_res = _run_simultaneous_search(
+            { initial_f_pha - pha_range, initial_f_pha + pha_range, "forward-pha" },
+            { initial_b_pha - pha_range, initial_b_pha + pha_range, "backward-pha" },
+            _phase_config.iteration_count,
+            [&](MotorPhaseCorrection &mph, int i, float pha) {
+                mph[_phase_config.harmonic] = {
+                    .mag = (i == 0) ? initial_f_mag : initial_b_mag,
+                    .pha = pha
+                };
+            });
+        if (!phase_res.has_value()) {
+            return std::nullopt;
+        }
+
+        // Find magnitude
+        const float mag_range = _phase_config.mag_window / 2.f;
+        auto mag_res = _run_simultaneous_search(
+            { initial_f_mag - mag_range, initial_f_mag + mag_range, "forward-mag" },
+            { initial_b_mag - mag_range, initial_b_mag + mag_range, "backward-mag" },
+            _phase_config.iteration_count,
+            [&](MotorPhaseCorrection &mph, int i, float mag) {
+                mph[_phase_config.harmonic].mag = mag;
+            });
+        if (!mag_res.has_value()) {
+            return std::nullopt;
+        }
+
+        return { mag_res };
+    }
+};
+
+std::optional<std::tuple<MotorPhaseCorrection, MotorPhaseCorrection>>
+phase_stepping::calibrate_axis(AxisEnum axis, CalibrationReporterBase &reporter) {
+    std::optional<std::tuple<MotorPhaseCorrection, MotorPhaseCorrection>> r;
+
+    const auto config = get_printer_calibration_config();
+
+    reset_compensation(axis);
+
+    phase_stepping::EnsureEnabled _;
+
+    reporter.on_initial_movement();
+    move_to_calibration_start(axis, config);
+    Planner::synchronize();
+
+    reporter.set_calibration_phases_count(config.phases.size());
+    for (std::size_t phase_i = 0; phase_i != config.phases.size(); phase_i++) {
+        const CalibrationPhase &calib_phase = config.phases[phase_i];
+
+        reporter.on_enter_calibration_phase(phase_i);
+
+        auto executor = CalibrationPhaseExecutor(axis, config, calib_phase, reporter);
+        auto baseline_res = executor.baseline();
+        if (!baseline_res.has_value()) {
+            return r;
+        }
+        auto [baseline_f, baseline_b] = *baseline_res;
+
+        auto calib_res = executor.run();
+        if (!calib_res.has_value()) {
+            return r;
+        }
+        auto [min_f, min_b] = *calib_res;
+
+        reporter.on_calibration_phase_result(min_f / baseline_f, min_b / baseline_b);
+    }
+    reporter.on_termination();
+
+    r.emplace();
+    std::get<0>(*r) = phase_stepping::axis_states[axis]->forward_current.get_correction();
+    std::get<1>(*r) = phase_stepping::axis_states[axis]->backward_current.get_correction();
+    return r;
+}
+
+PrinterCalibrationConfig phase_stepping::get_printer_calibration_config() {
+#if PRINTER_IS_PRUSA_XL
+    static constexpr std::array phases = {
+        CalibrationPhase {
+            .harmonic = 2,
+            .speed = 3.f,
+            .pha = 3.14f,
+            .pha_window = 4.f,
+            .mag = 0.02f,
+            .mag_window = 0.05f,
+            .iteration_count = 10,
+        },
+        CalibrationPhase {
+            .harmonic = 4,
+            .speed = 1.5f,
+            .pha = 0.f,
+            .pha_window = 4.f,
+            .mag = 0.015f,
+            .mag_window = 0.04f,
+            .iteration_count = 10,
+        },
+        CalibrationPhase {
+            .harmonic = 2,
+            .speed = 3.f,
+            .pha_window = 1.f,
+            .mag_window = 0.02f,
+            .iteration_count = 16,
+        },
+        CalibrationPhase {
+            .harmonic = 4,
+            .speed = 1.5f,
+            .pha_window = 1.5f,
+            .mag_window = 0.02f,
+            .iteration_count = 16,
+        },
+    };
+
+    return PrinterCalibrationConfig {
+        .calib_revs = 0.5f,
+        .phases = std::vector(phases.begin(), phases.end()),
+    };
+#else
+    #error "Unsupported printer"
+#endif
+}
diff --git a/lib/Marlin/Marlin/src/feature/phase_stepping/calibration.hpp b/lib/Marlin/Marlin/src/feature/phase_stepping/calibration.hpp
new file mode 100644
index 0000000000..ce003889d4
--- /dev/null
+++ b/lib/Marlin/Marlin/src/feature/phase_stepping/calibration.hpp
@@ -0,0 +1,145 @@
+#pragma once
+
+#include "common.hpp"
+
+#include <cassert>
+#include <functional>
+#include <tuple>
+#include <optional>
+#include <vector>
+#include <atomic>
+
+#include <module/prusa/accelerometer.h>
+#include <core/types.h>
+
+namespace phase_stepping {
+
+/**
+ * Assuming phase stepping is enabled, measure resonance data for given axis.
+ * Returns measured accelerometer samples via a callback, the function returns
+ * measured frequency.
+ *
+ * Speed is assumed to be always positive in rotations per seconds, revolutions
+ * to made can be negative.
+ *
+ * On accelerometer error returns 0 as frequency. The error reason is silently
+ * ignored.
+ */
+float capture_samples(AxisEnum axis, float speed, float revs,
+    const std::function<void(const PrusaAccelerometer::Acceleration &)> &yield_sample);
+
+/**
+ * Assuming phase stepping is enabled, measure resonance and return requested
+ * harmonics.
+ *
+ * Returns the measurement measurement.
+ */
+std::vector<float> analyze_resonance(AxisEnum axis,
+    float speed, float revs, const std::vector<int> &requested_harmonics);
+
+/**
+ * Calibration routine notifies about the progress made via this class. Subclass
+ * it and pass it to the calibration routine.
+ */
+class CalibrationReporterBase {
+protected:
+    int _calibration_phases_count = -1;
+    int _current_calibration_phase = 0;
+
+public:
+    virtual ~CalibrationReporterBase() = default;
+
+    /**
+     * Report initial movement is in progress
+     */
+    virtual void on_initial_movement() = 0;
+
+    /**
+     * Set number of calibration phases
+     */
+    virtual void set_calibration_phases_count(int phases) {
+        _calibration_phases_count = phases;
+    }
+
+    /**
+     * Report beginning of the new phase
+     */
+    virtual void on_enter_calibration_phase(int phase) {
+        _current_calibration_phase = phase;
+    }
+
+    /**
+     * Report progress in percent for given phase
+     */
+    virtual void on_calibration_phase_progress(int progress) = 0;
+
+    /**
+     * Report result in percents for given calibration phase. Lower = better.
+     */
+    virtual void on_calibration_phase_result(float forward_score, float backward_score) = 0;
+
+    /**
+     * Report calibration termination
+     */
+    virtual void on_termination() = 0;
+};
+
+/**
+ * Assuming the printer is homed, calibrate given axis. The progress is reported
+ * via reporter. The routine is blocking.
+ *
+ * Returns a tuple with forward and backward calibration
+ */
+std::optional<std::tuple<MotorPhaseCorrection, MotorPhaseCorrection>>
+calibrate_axis(AxisEnum axis, CalibrationReporterBase &reporter);
+
+class CalibrationResult {
+public:
+    struct Scores {
+        float p1f;
+        float p1b;
+        float p2f;
+        float p2b;
+    };
+
+    enum class State {
+        unknown, // calibration not run
+        known, // calibration ran to completion
+        error, // calibration failed
+    };
+
+private:
+    Scores scores;
+    State state;
+
+    constexpr CalibrationResult(const Scores &scores, const State &state)
+        : scores { scores }
+        , state { state } {}
+
+public:
+    constexpr State get_state() const { return state; }
+
+    constexpr static CalibrationResult make_unknown() {
+        return { Scores {}, State::unknown };
+    }
+
+    constexpr static CalibrationResult make_error() {
+        return { Scores {}, State::error };
+    }
+
+    constexpr static CalibrationResult make_known(const Scores &scores) {
+        return { scores, State::known };
+    }
+
+    constexpr const Scores &get_scores() const {
+        assert(get_state() == State::known);
+        return scores;
+    }
+};
+
+/**
+ * Global state of the last axis calibration. Re/set by M977.
+ */
+extern CalibrationResult last_calibration_result;
+
+} // namespace phase_stepping
diff --git a/lib/Marlin/Marlin/src/feature/phase_stepping/calibration_config.hpp b/lib/Marlin/Marlin/src/feature/phase_stepping/calibration_config.hpp
new file mode 100644
index 0000000000..e7cfeb98f6
--- /dev/null
+++ b/lib/Marlin/Marlin/src/feature/phase_stepping/calibration_config.hpp
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <printers.h>
+
+#include <optional>
+#include <vector>
+#include <array>
+
+namespace phase_stepping {
+
+struct CalibrationPhase {
+    int harmonic;
+    float speed;
+
+    std::optional<float> pha = {}; // Optionally force starting point
+    float pha_window = 0.1f;
+
+    std::optional<float> mag = {}; // Optionally force starting point
+    float mag_window = 0.01f;
+
+    int iteration_count = 18;
+};
+
+struct PrinterCalibrationConfig {
+    float calib_revs;
+    std::vector<CalibrationPhase> phases;
+};
+
+PrinterCalibrationConfig get_printer_calibration_config();
+
+}; // namespace phase_stepping
diff --git a/lib/Marlin/Marlin/src/feature/phase_stepping/common.hpp b/lib/Marlin/Marlin/src/feature/phase_stepping/common.hpp
new file mode 100644
index 0000000000..60ab4e3a9d
--- /dev/null
+++ b/lib/Marlin/Marlin/src/feature/phase_stepping/common.hpp
@@ -0,0 +1,14 @@
+#pragma once
+
+#include <array>
+#include <buddy/phase_stepping_opts.h>
+
+namespace phase_stepping {
+
+struct SpectralItem {
+    float mag = 0, pha = 0;
+};
+
+// WARNING: changing this type has consequences in regards to data persistency!
+using MotorPhaseCorrection = std::array<SpectralItem, opts::CORRECTION_HARMONICS + 1>;
+} // namespace phase_stepping
diff --git a/lib/Marlin/Marlin/src/feature/phase_stepping/lut.cpp b/lib/Marlin/Marlin/src/feature/phase_stepping/lut.cpp
new file mode 100644
index 0000000000..0eb7e55e95
--- /dev/null
+++ b/lib/Marlin/Marlin/src/feature/phase_stepping/lut.cpp
@@ -0,0 +1,106 @@
+#include "lut.hpp"
+#include "common.hpp"
+
+#include <hwio_pindef.h>
+#include <buddy/phase_stepping_opts.h>
+
+#include <array>
+#include <numbers>
+#include <cstdint>
+
+using namespace phase_stepping;
+using namespace phase_stepping::opts;
+
+// Module definitions
+
+static const auto sin_lut_values = []() {
+    // Build 1/4 of sin period
+    static constexpr int QUARTER = SIN_PERIOD / 4;
+    std::array<uint8_t, QUARTER + 1> values;
+    for (size_t i = 0; i != values.size(); i++) {
+        values[i] = CURRENT_AMPLITUDE * sin(std::numbers::pi_v<float> / 2.f * i / QUARTER) + 0.5;
+    }
+
+    return values;
+}();
+
+// Function definitions
+
+int phase_stepping::sin_lut(int x) {
+    x = normalize_sin_phase(x);
+    if (x <= SIN_PERIOD / 4) {
+        return sin_lut_values[x];
+    }
+    if (x <= SIN_PERIOD / 2) {
+        return sin_lut_values[SIN_PERIOD / 2 - x];
+    }
+    if (x <= 3 * SIN_PERIOD / 4) {
+        return -sin_lut_values[x - SIN_PERIOD / 2];
+    }
+    return -sin_lut_values[SIN_PERIOD - x];
+};
+
+int phase_stepping::cos_lut(int x) {
+    return sin_lut(x + SIN_PERIOD / 4);
+}
+
+int phase_stepping::normalize_sin_phase(int phase) {
+    phase = phase % SIN_PERIOD;
+    if (phase < 0) {
+        phase += SIN_PERIOD;
+    }
+    return phase;
+}
+
+int phase_stepping::normalize_motor_phase(int phase) {
+    phase = phase % MOTOR_PERIOD;
+    if (phase < 0) {
+        phase += MOTOR_PERIOD;
+    }
+    return phase;
+}
+
+void CorrectedCurrentLut::clear() {
+    _spectrum.fill({});
+    _phase_shift.fill({});
+}
+
+void CorrectedCurrentLut::_update_phase_shift() {
+    for (size_t i = 0; i != _phase_shift.size(); i++) {
+        float item_phase = i * 2 * std::numbers::pi_v<float> / MOTOR_PERIOD;
+        float phase_shift = 0;
+        for (size_t n = 0; n != _spectrum.size(); n++) {
+            const SpectralItem &s = _spectrum[n];
+            phase_shift += s.mag * std::sin(n * item_phase + s.pha);
+        }
+        _phase_shift[i] = std::round(SIN_PERIOD / (2 * std::numbers::pi_v<float>)*phase_shift);
+    }
+}
+
+CoilCurrents CorrectedCurrentLut::get_current(int idx) const {
+    int pha = SIN_FRACTION * idx + _phase_shift[normalize_motor_phase(idx)];
+    return {
+        sin_lut(pha), cos_lut(pha)
+    };
+}
+
+int CorrectedCurrentLut::get_phase_shift(int idx) const {
+    return _phase_shift[normalize_motor_phase(idx)] / SIN_FRACTION;
+}
+
+void CorrectedCurrentLutSimple::_update_phase_shift() {
+    for (size_t i = 0; i != MOTOR_PERIOD; i++) {
+        float item_phase = i * 2 * std::numbers::pi_v<float> / MOTOR_PERIOD;
+        float phase_shift = 0;
+        for (size_t n = 0; n != _spectrum.size(); n++) {
+            const SpectralItem &s = _spectrum[n];
+            phase_shift += s.mag * std::sin(n * item_phase + s.pha);
+        }
+        _sin.set(i, std::round(CURRENT_AMPLITUDE * std::sin(item_phase + phase_shift)));
+        _cos.set(i, std::round(CURRENT_AMPLITUDE * std::cos(item_phase + phase_shift)));
+    }
+}
+
+CoilCurrents CorrectedCurrentLutSimple::get_current(int idx) const {
+    return { _sin.get(idx), _cos.get(idx) };
+}
diff --git a/lib/Marlin/Marlin/src/feature/phase_stepping/lut.hpp b/lib/Marlin/Marlin/src/feature/phase_stepping/lut.hpp
new file mode 100644
index 0000000000..6dd702e852
--- /dev/null
+++ b/lib/Marlin/Marlin/src/feature/phase_stepping/lut.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include "common.hpp"
+
+#include <bitset>
+#include <cstdint>
+
+// This module is responsible for implementing any lookup tables used in phase
+// stepping.
+
+namespace phase_stepping {
+
+/**
+ * Lookup table-based implementation of sin/cos that uses MOTOR_PERIOD as its
+ * period. Returns integral value that is scaled to 248 - TMC max value.
+ */
+int sin_lut(int x);
+int cos_lut(int x);
+
+/**
+ * Given a phase, normalize it into range <0, MOTOR_PERIOD)
+ **/
+int normalize_motor_phase(int phase);
+
+/**
+ * Given a phase, normalize it into range <0, SIN_PERIOD)
+ **/
+int normalize_sin_phase(int phase);
+
+struct CoilCurrents {
+    int a;
+    int b;
+
+    bool operator==(const CoilCurrents &) const = default;
+};
+
+class CorrectedCurrentLut {
+
+public:
+    void clear();
+
+public:
+    MotorPhaseCorrection _spectrum = {};
+    std::array<int8_t, opts::MOTOR_PERIOD> _phase_shift = {};
+
+    void _update_phase_shift();
+
+public:
+    CorrectedCurrentLut() = default;
+
+    const auto &get_correction() const {
+        return _spectrum;
+    };
+
+    template <typename F>
+        requires requires(F f) { f(_spectrum); }
+    void modify_correction(F f) {
+        f(_spectrum);
+        _update_phase_shift();
+    }
+
+    CoilCurrents get_current(int idx) const;
+    int get_phase_shift(int idx) const;
+};
+
+/**
+ * Alternative LUT with simplified implementation for reference/testing purposes
+ **/
+class CorrectedCurrentLutSimple {
+public:
+    struct CurrentTrace {
+        std::array<uint8_t, opts::MOTOR_PERIOD> _val;
+        std::bitset<opts::MOTOR_PERIOD> _sign;
+
+        int get(int idx) const {
+            idx = normalize_motor_phase(idx);
+            return _val[idx] * (_sign[idx] ? 1 : -1);
+        }
+
+        void set(int idx, int val) {
+            idx = normalize_motor_phase(idx);
+            _sign[idx] = val > 0;
+            _val[idx] = abs(val);
+        }
+    };
+
+    MotorPhaseCorrection _spectrum = {};
+    CurrentTrace _sin, _cos;
+
+    void _update_phase_shift();
+
+public:
+    CorrectedCurrentLutSimple() {
+        _update_phase_shift();
+    }
+
+    const auto &get_correction() const {
+        return _spectrum;
+    };
+
+    template <typename F>
+        requires requires(F f) { f(_spectrum); }
+    void modify_correction(F f) {
+        f(_spectrum);
+        _update_phase_shift();
+    }
+
+    CoilCurrents get_current(int idx) const;
+};
+
+} // namespace phase_stepping
diff --git a/lib/Marlin/Marlin/src/feature/phase_stepping/phase_stepping.cpp b/lib/Marlin/Marlin/src/feature/phase_stepping/phase_stepping.cpp
new file mode 100644
index 0000000000..da5078ebb8
--- /dev/null
+++ b/lib/Marlin/Marlin/src/feature/phase_stepping/phase_stepping.cpp
@@ -0,0 +1,862 @@
+#include "phase_stepping.hpp"
+#include "debug_util.hpp"
+
+#if HAS_BURST_STEPPING()
+    #include "burst_stepper.hpp"
+#else
+    #include "quick_tmc_spi.hpp"
+#endif
+
+#include "../precise_stepping/precise_stepping.hpp"
+#include "../precise_stepping/internal.hpp"
+#include "../input_shaper/input_shaper.hpp"
+#include <config_store/store_instance.hpp>
+
+#include <device/peripherals.h>
+#include <module/motion.h>
+#include <module/stepper.h>
+#include <module/stepper/trinamic.h>
+#include <trinamic.h>
+#include <TMCStepper.h>
+
+#include <Pin.hpp>
+#include <log.h>
+
+#include <cassert>
+#include <cmath>
+
+LOG_COMPONENT_DEF(PhaseStepping, LOG_SEVERITY_DEBUG);
+
+using namespace phase_stepping;
+using namespace phase_stepping::opts;
+using namespace buddy::hw;
+
+// Global definitions
+std::array<
+    std::unique_ptr<AxisState>,
+    SUPPORTED_AXIS_COUNT>
+    phase_stepping::axis_states = { { nullptr, nullptr } };
+
+// Module definitions
+#if !HAS_BURST_STEPPING()
+static uint_fast8_t axis_num_to_refresh = 0;
+#endif
+static uint32_t last_timer_tick = 0;
+
+MoveTarget::MoveTarget(float position)
+    : initial_pos(position)
+    , half_accel(0)
+    , start_v(0)
+    , duration(0)
+    , target(position) {}
+
+MoveTarget::MoveTarget(const move_t &move, int axis, const uint64_t move_duration_ticks) {
+    assert(move_duration_ticks <= std::numeric_limits<uint32_t>::max());
+    float r = get_move_axis_r(move, axis);
+    initial_pos = extract_physical_position(AxisEnum(axis), move.start_pos);
+    half_accel = r * float(move.half_accel);
+    start_v = r * float(move.start_v);
+    duration = uint32_t(move_duration_ticks);
+    target = target_position();
+}
+
+MoveTarget::MoveTarget(const input_shaper_state_t &is_state, const uint64_t move_duration_ticks)
+    : initial_pos(is_state.start_pos)
+    , half_accel(is_state.half_accel)
+    , start_v(is_state.start_v)
+    , duration(uint32_t(move_duration_ticks)) {
+    target = target_position();
+    assert(move_duration_ticks <= std::numeric_limits<uint32_t>::max());
+}
+
+float MoveTarget::target_position() const {
+    float epoch = duration / 1000000.f;
+    return initial_pos + start_v * epoch + half_accel * epoch * epoch;
+}
+
+void phase_stepping::init() {
+    phase_stepping::axis_states[0].reset(new AxisState(AxisEnum::X_AXIS));
+    phase_stepping::axis_states[1].reset(new AxisState(AxisEnum::Y_AXIS));
+}
+
+void phase_stepping::load() {
+    load_from_persistent_storage(AxisEnum::X_AXIS);
+    load_from_persistent_storage(AxisEnum::Y_AXIS);
+}
+
+FORCE_INLINE uint64_t convert_absolute_time_to_ticks(const double time) {
+    return uint64_t(time * 1'000'000.);
+}
+
+FORCE_INLINE uint64_t calc_move_segment_end_time_in_ticks(const move_t &move) {
+    return convert_absolute_time_to_ticks(move.print_time + move.move_t);
+}
+
+FORCE_INLINE uint64_t calc_move_segment_end_time_in_ticks(const input_shaper_state_t &is_state) {
+    return convert_absolute_time_to_ticks(is_state.nearest_next_change);
+}
+
+template <typename T>
+FORCE_INLINE T resolve_axis_inversion(bool is_inverted_flag, T val) {
+    // Since the TMC driver in XDirect mode swaps meaning of phases, the
+    // non-inverted axis has to be inverted and vice-versa
+    return is_inverted_flag
+        ? val
+        : -val;
+}
+
+FORCE_INLINE CorrectedCurrentLut &resolve_current_lut(AxisState &axis_state) {
+    return axis_state.direction
+        ? axis_state.forward_current
+        : axis_state.backward_current;
+}
+
+static void init_step_generator_internal(
+    const move_t &move,
+    move_segment_step_generator_t &step_generator,
+    step_generator_state_t & /*step_generator_state*/) {
+    auto &axis_state = *step_generator.phase_step_state;
+    const uint8_t axis = step_generator.axis;
+
+    assert(axis_state.pending_targets.isEmpty());
+
+    axis_state.initial_time = ticks_us();
+
+    axis_state.last_position = axis_state.target->initial_pos;
+    axis_state.last_processed_move = &move;
+
+    int32_t initial_steps_made = pos_to_steps(AxisEnum(axis), axis_state.target->initial_pos);
+    axis_state.initial_count_position = Stepper::get_axis_steps(AxisEnum(axis)) - initial_steps_made;
+    axis_state.initial_count_position_from_startup = Stepper::get_axis_steps_from_startup(AxisEnum(axis)) - initial_steps_made;
+
+    axis_state.active = true;
+}
+
+void phase_stepping::init_step_generator_classic(
+    const move_t &move,
+    move_segment_step_generator_t &step_generator,
+    step_generator_state_t &step_generator_state) {
+    assert(is_beginning_empty_move(move));
+
+    auto &axis_state = *step_generator.phase_step_state;
+    axis_state.active = false;
+
+    const uint8_t axis = step_generator.axis;
+    axis_state.current_print_time_ticks = convert_absolute_time_to_ticks(move.print_time);
+
+    const uint64_t next_print_time_ticks = calc_move_segment_end_time_in_ticks(move);
+    const uint64_t move_duration_ticks = next_print_time_ticks - axis_state.current_print_time_ticks;
+    axis_state.target = MoveTarget(move, axis, move_duration_ticks);
+    axis_state.current_print_time_ticks = next_print_time_ticks;
+
+    step_generator_state.step_generator[axis] = &step_generator;
+    step_generator_state.next_step_func[axis] = (generator_next_step_f)next_step_event_classic;
+
+    // We are keeping a reference to a move segment in last_processed_move.
+    // Otherwise, a move segment can be discarded while we are using it.
+    move.reference_cnt += 1;
+
+    init_step_generator_internal(move, step_generator, step_generator_state);
+}
+
+void phase_stepping::init_step_generator_input_shaping(
+    const move_t &move,
+    input_shaper_step_generator_t &step_generator,
+    step_generator_state_t &step_generator_state) {
+    assert(is_beginning_empty_move(move));
+
+    auto &axis_state = *step_generator.phase_step_state;
+    axis_state.active = false;
+
+    // Inherit input shaper initialization...
+    input_shaper_step_generator_init(move, step_generator, step_generator_state);
+
+    axis_state.current_print_time_ticks = convert_absolute_time_to_ticks(step_generator.is_state->print_time);
+
+    const uint64_t next_print_time_ticks = calc_move_segment_end_time_in_ticks(*step_generator.is_state);
+    const uint64_t move_duration_ticks = next_print_time_ticks - axis_state.current_print_time_ticks;
+    axis_state.target = MoveTarget(*step_generator.is_state, move_duration_ticks);
+    axis_state.current_print_time_ticks = next_print_time_ticks;
+
+    // ...and then override next_step_func with phase stepping one
+    const uint8_t axis = step_generator.axis;
+    step_generator_state.step_generator[axis] = &step_generator;
+    step_generator_state.next_step_func[axis] = (generator_next_step_f)next_step_event_input_shaping;
+
+    init_step_generator_internal(move, step_generator, step_generator_state);
+}
+
+step_event_info_t phase_stepping::next_step_event_classic(
+    move_segment_step_generator_t &step_generator,
+    step_generator_state_t & /*step_generator_state*/) {
+    AxisState &axis_state = *step_generator.phase_step_state;
+
+    assert(axis_state.last_processed_move != nullptr);
+    assert(axis_state.last_processed_move->reference_cnt != 0);
+
+    step_event_info_t next_step_event = { std::numeric_limits<double>::max(), 0, STEP_EVENT_INFO_STATUS_GENERATED_INVALID };
+    if (axis_state.pending_targets.isFull()) {
+        next_step_event.time = axis_state.last_processed_move->print_time + axis_state.last_processed_move->move_t;
+        next_step_event.status = StepEventInfoStatus::STEP_EVENT_INFO_STATUS_GENERATED_PENDING;
+    } else if (const move_t *next_move = PreciseStepping::move_segment_queue_next_move(*axis_state.last_processed_move); next_move != nullptr) {
+        next_step_event.time = next_move->print_time;
+
+        if (!is_ending_empty_move(*next_move)) {
+            uint8_t axis = axis_state.axis_index;
+
+            const uint64_t next_print_time_ticks = calc_move_segment_end_time_in_ticks(*next_move);
+            const uint64_t move_duration_ticks = next_print_time_ticks - axis_state.current_print_time_ticks;
+            auto new_target = MoveTarget(*next_move, axis, move_duration_ticks);
+            axis_state.current_print_time_ticks = next_print_time_ticks;
+
+            float target_pos = new_target.target;
+            int32_t target_steps = pos_to_steps(AxisEnum(axis), target_pos);
+            PreciseStepping::step_generator_state.current_distance[axis] = target_steps;
+
+            axis_state.active = false;
+            axis_state.pending_targets.enqueue(new_target);
+            axis_state.active = true;
+
+            next_step_event.flags |= STEP_EVENT_FLAG_KEEP_ALIVE;
+            next_step_event.status = STEP_EVENT_INFO_STATUS_GENERATED_KEEP_ALIVE;
+        }
+
+        // The move segment is fully processed, and in the queue is another unprocessed move segment.
+        // So we decrement reference count of the current move segment and increment reference count of next move segment.
+        --axis_state.last_processed_move->reference_cnt;
+        axis_state.last_processed_move = next_move;
+        ++axis_state.last_processed_move->reference_cnt;
+
+        PreciseStepping::move_segment_processed_handler();
+    } else {
+        next_step_event.time = axis_state.last_processed_move->print_time + axis_state.last_processed_move->move_t;
+    }
+
+    return next_step_event;
+}
+
+step_event_info_t phase_stepping::next_step_event_input_shaping(
+    input_shaper_step_generator_t &step_generator,
+    step_generator_state_t & /*step_generator_state*/) {
+    AxisState &axis_state = *step_generator.phase_step_state;
+
+    assert(step_generator.is_state != nullptr);
+
+    step_event_info_t next_step_event = { std::numeric_limits<double>::max(), 0, STEP_EVENT_INFO_STATUS_GENERATED_INVALID };
+    if (axis_state.pending_targets.isFull()) {
+        next_step_event.time = step_generator.is_state->nearest_next_change;
+        next_step_event.status = StepEventInfoStatus::STEP_EVENT_INFO_STATUS_GENERATED_PENDING;
+    } else {
+        next_step_event.time = step_generator.is_state->nearest_next_change;
+
+        if (const bool is_updated = input_shaper_state_update(*step_generator.is_state, step_generator.axis);
+            is_updated && step_generator.is_state->nearest_next_change < MAX_PRINT_TIME) {
+
+            uint8_t axis = axis_state.axis_index;
+
+            const uint64_t next_print_time_ticks = calc_move_segment_end_time_in_ticks(*step_generator.is_state);
+            const uint64_t move_duration_ticks = next_print_time_ticks - axis_state.current_print_time_ticks;
+            auto new_target = MoveTarget(*step_generator.is_state, move_duration_ticks);
+            axis_state.current_print_time_ticks = next_print_time_ticks;
+
+            float target_pos = new_target.target;
+            int32_t target_steps = pos_to_steps(AxisEnum(axis), target_pos);
+            PreciseStepping::step_generator_state.current_distance[axis] = target_steps;
+
+            axis_state.active = false;
+            axis_state.pending_targets.enqueue(new_target);
+            axis_state.active = true;
+
+            next_step_event.flags |= STEP_EVENT_FLAG_KEEP_ALIVE;
+            next_step_event.status = STEP_EVENT_INFO_STATUS_GENERATED_KEEP_ALIVE;
+        }
+
+        PreciseStepping::move_segment_processed_handler();
+    }
+
+    return next_step_event;
+}
+
+#ifdef _DEBUG
+void phase_stepping::assert_initialized() {
+    // This is explicitly kept non-inline to serve as a single trap point
+    assert(initialized());
+}
+#endif
+
+void phase_stepping::synchronize() {
+    planner.synchronize();
+}
+
+bool phase_stepping::processing() {
+    // check for pending targets
+    for (auto &state : axis_states) {
+        if (state && (!state->pending_targets.isEmpty() || state->target.has_value())) {
+            return true;
+        }
+    }
+
+    // ensure the last target has also been flushed
+#if HAS_BURST_STEPPING()
+    if (burst_stepping::busy()) {
+        return true;
+    }
+#else
+    if (phase_stepping::spi::busy()) {
+        return true;
+    }
+#endif
+
+    return false;
+}
+
+void phase_stepping::set_phase_origin(AxisEnum axis, float pos) {
+    assert(axis < SUPPORTED_AXIS_COUNT);
+    assert_initialized();
+
+    auto &axis_state = *axis_states[axis];
+    bool was_active = axis_state.active;
+    axis_state.active = false;
+
+    float inverted_position = resolve_axis_inversion(axis_state.inverted, pos);
+    axis_state.zero_rotor_phase = normalize_motor_phase(-pos_to_phase(axis, inverted_position) + axis_state.last_phase);
+    axis_state.last_position = pos;
+
+    axis_state.active = was_active;
+}
+
+void phase_stepping::enable_phase_stepping(AxisEnum axis_num) {
+    assert(axis_num < SUPPORTED_AXIS_COUNT);
+    assert(!planner.has_blocks_queued() && !PreciseStepping::processing());
+
+    // We know that PHASE_STEPPING is enabled only on TMC2130 boards
+    auto &stepper = static_cast<TMC2130Stepper &>(stepper_axis(axis_num));
+    auto &axis_state = *axis_states[axis_num];
+    assert(!axis_state.active && !axis_state.target.has_value() && axis_state.pending_targets.isEmpty());
+
+    axis_state.last_position = 0;
+    axis_state.direction = true; // TODO: should use last_direction_bits
+
+#if HAS_BURST_STEPPING()
+    axis_state.original_microsteps = stepper.microsteps();
+    axis_state.last_phase = axis_state.zero_rotor_phase = axis_state.driver_phase = stepper.MSCNT();
+    axis_state.phase_correction = 0;
+    axis_state.had_interpolation = stepper.intpol();
+    stepper.intpol(false);
+    stepper.microsteps(256);
+#else
+    // In order to start phase stepping, we have to set phase currents that are
+    // in sync with current position, and then switch the driver to current
+    // mode.
+    int current_phase = stepper.MSCNT();
+
+    axis_state.last_currents = resolve_current_lut(axis_state).get_current(current_phase);
+
+    // Set IHOLD to be the same as IRUN (as IHOLD is always used in XDIRECT)
+    axis_state.initial_hold_multiplier = stepper.hold_multiplier();
+    stepper.rms_current(stepper.rms_current(), 1.);
+
+    // Swapping coils isn't a mistake - TMC in Xdirect mode swaps coils
+    stepper.coil_A(axis_state.last_currents.b);
+    stepper.coil_B(axis_state.last_currents.a);
+    stepper.direct_mode(true);
+
+    // We initialize the zero rotor phase to current phase. The real initialization is done by
+    // set_phase_origin() when the local coordinate system is effectively initialized.
+    axis_state.zero_rotor_phase = current_phase;
+    axis_state.last_phase = current_phase;
+#endif
+    // Read axis configuration and cache it so we can access it fast
+    if (axis_num == AxisEnum::X_AXIS) {
+        axis_state.inverted = INVERT_X_DIR;
+    } else if (axis_num == AxisEnum::Y_AXIS) {
+        axis_state.inverted = INVERT_Y_DIR;
+    } else if (axis_num == AxisEnum::Z_AXIS) {
+        axis_state.inverted = INVERT_Z_DIR;
+    }
+
+    // Sync the counters just before enabling the axis
+    int32_t initial_steps_made = pos_to_steps(axis_num, axis_state.last_position);
+    axis_state.initial_count_position = Stepper::get_axis_steps(axis_num) - initial_steps_made;
+    axis_state.initial_count_position_from_startup = Stepper::get_axis_steps_from_startup(axis_num) - initial_steps_made;
+
+    axis_state.missed_tx_cnt = 0;
+    axis_state.active = true;
+
+    auto enable_mask = PHASE_STEPPING_GENERATOR_X << axis_num;
+    PreciseStepping::physical_axis_step_generator_types |= enable_mask;
+
+    HAL_TIM_Base_Start_IT(&TIM_HANDLE_FOR(phase_stepping));
+}
+
+void phase_stepping::disable_phase_stepping(AxisEnum axis_num) {
+    assert(axis_num < SUPPORTED_AXIS_COUNT);
+    assert(!planner.processing());
+
+    // We know that PHASE_STEPPING is enabled only on TMC2130 boards
+    auto &stepper = static_cast<TMC2130Stepper &>(stepper_axis(axis_num));
+    auto &axis_state = *axis_states[axis_num];
+
+    axis_state.active = false;
+    auto enable_mask = PHASE_STEPPING_GENERATOR_X << axis_num;
+    PreciseStepping::physical_axis_step_generator_types &= ~enable_mask;
+
+#if HAS_BURST_STEPPING()
+    stepper.microsteps(axis_state.original_microsteps);
+    stepper.intpol(axis_state.had_interpolation);
+#else
+    // In order to avoid glitch in motor motion, we have to first, make steps to
+    // get MSCNT into sync and then we disable XDirect mode
+    int original_microsteps = stepper.microsteps();
+    stepper.microsteps(256);
+    int current_phase = normalize_motor_phase(axis_state.last_phase);
+    while (current_phase != stepper.MSCNT()) {
+        switch (axis_num) {
+        case 0:
+            XStep->toggle();
+            break;
+        case 1:
+            YStep->toggle();
+            break;
+        case 2:
+            zStep.toggle();
+            break;
+        default:
+            break;
+        }
+        delayMicroseconds(20);
+    }
+    stepper.direct_mode(false);
+    stepper.microsteps(original_microsteps);
+#endif
+
+    // Reset IHOLD to the original state
+    stepper.rms_current(stepper.rms_current(), axis_state.initial_hold_multiplier);
+
+    if (!any_axis_active()) {
+        HAL_TIM_Base_Stop_IT(&TIM_HANDLE_FOR(phase_stepping));
+    }
+}
+
+void phase_stepping::enable(AxisEnum axis_num, bool enable) {
+    assert(axis_num < SUPPORTED_AXIS_COUNT);
+    assert_initialized();
+
+    auto &axis_state = axis_states[axis_num];
+    if (axis_state->active == enable) {
+        return;
+    }
+    if (enable) {
+        // Enable phase stepping and reset PS to update the phase origin
+        phase_stepping::enable_phase_stepping(axis_num);
+        PreciseStepping::reset_from_halt(true);
+    } else {
+        phase_stepping::disable_phase_stepping(axis_num);
+    }
+}
+
+void phase_stepping::stop_immediately() {
+    for (auto &axis_state : axis_states) {
+        bool was_active = axis_state->active;
+        axis_state->active = false;
+
+        axis_state->target.reset();
+        while (!axis_state->pending_targets.isEmpty()) {
+            axis_state->pending_targets.dequeue();
+        }
+
+        axis_state->active = was_active;
+    }
+}
+
+// Given axis and speed, return current adjustment expressed as range <0, 255>
+[[maybe_unused]] static int current_adjustment(int /*axis*/, float speed) {
+    speed = std::abs(speed);
+#if PRINTER_IS_PRUSA_XL
+    float BREAKPOINT = 6.f;
+    float ENDPOINT = 10.f;
+    int REDUCTION_TO = 150;
+
+    if (speed < BREAKPOINT) {
+        return 255;
+    }
+    if (speed > ENDPOINT) {
+        return REDUCTION_TO;
+    }
+    return 255 - (speed - BREAKPOINT) * (255 - REDUCTION_TO) / (ENDPOINT - BREAKPOINT);
+#else
+    #error "Unsupported printer"
+#endif
+}
+
+int phase_stepping::phase_difference(int a, int b) {
+    int diff = a - b;
+    if (diff > MOTOR_PERIOD / 2) {
+        diff -= MOTOR_PERIOD;
+    } else if (diff < -MOTOR_PERIOD / 2) {
+        diff += MOTOR_PERIOD;
+    }
+    return diff;
+}
+
+static void mark_missed_transaction(AxisState &axis_state) {
+    ++axis_state.missed_tx_cnt;
+    if (axis_state.missed_tx_cnt > ALLOWED_MISSED_TX) {
+        bsod("Phase stepping: Too many missed transactions");
+    }
+}
+
+static bool is_refresh_period_sane(uint32_t now, uint32_t last_timer_tick) {
+    // The refresh period of the timer should be constant. We mainly care about
+    // the case when there was too long delay between refreshes as it marks that
+    // the interrupt was delayed and the next update might be sooner than we
+    // anticipate.
+
+    static constexpr uint REFRESH_PERIOD_US = 1'000'000 / REFRESH_FREQ;
+    static constexpr uint UPDATE_DURATION_US = 20; // Rather pesimistic update
+
+    uint32_t refresh_period = ticks_diff(now, last_timer_tick);
+    return refresh_period < 2 * REFRESH_PERIOD_US - UPDATE_DURATION_US;
+}
+
+static FORCE_INLINE FORCE_OFAST void refresh_axis(
+    AxisState &axis_state, uint32_t now, uint32_t previous_tick) {
+    if (!axis_state.active) {
+        return;
+    }
+
+    [[maybe_unused]] const auto axis_index = axis_state.axis_index;
+    [[maybe_unused]] const auto axis_enum = AxisEnum(axis_state.axis_index);
+
+    if (!is_refresh_period_sane(now, previous_tick)) {
+        // If the ISR handler was delayed, we don't have enough time to process
+        // the update. Abort the update so we can catch up.
+        mark_missed_transaction(axis_state);
+        return;
+    }
+
+#if !HAS_BURST_STEPPING()
+    if (!phase_stepping::spi::initialize_transaction()) {
+        mark_missed_transaction(axis_state);
+        return;
+    }
+#endif
+
+    uint32_t move_epoch = ticks_diff(now, axis_state.initial_time);
+    float move_position = axis_state.last_position;
+
+    while (!axis_state.target.has_value() || move_epoch > axis_state.target->duration) {
+        uint32_t time_overshoot = 0;
+        if (axis_state.target.has_value()) {
+            time_overshoot = ticks_diff(move_epoch, axis_state.target->duration);
+            move_position = axis_state.target->target;
+            axis_state.target.reset();
+        }
+
+        if (!axis_state.pending_targets.isEmpty()) {
+            // Pull new movement
+            axis_state.target = axis_state.pending_targets.dequeue();
+
+            axis_state.is_cruising = axis_state.target->half_accel == 0 && axis_state.target->duration > 10'000;
+            axis_state.is_moving = true;
+
+            // Time overshoots accounts for the lost time in the previous state
+            axis_state.initial_time = now - time_overshoot;
+            move_position = axis_state.target->initial_pos;
+            move_epoch = time_overshoot;
+        } else {
+            // No new movement
+            axis_state.is_cruising = false;
+            axis_state.is_moving = false;
+            break;
+        }
+    }
+
+    auto [speed, position] = axis_state.target.has_value()
+        ? axis_position(axis_state, move_epoch)
+        : std::make_tuple(0.f, move_position);
+
+    float physical_position = resolve_axis_inversion(axis_state.inverted, position);
+    float physical_speed = resolve_axis_inversion(axis_state.inverted, speed);
+
+    if (physical_speed != 0.f) {
+        // update the direction in order to fetch the correct lut
+        axis_state.direction = physical_speed > 0;
+    }
+    const auto &current_lut = resolve_current_lut(axis_state);
+
+    int new_phase = normalize_motor_phase(pos_to_phase(axis_index, physical_position) + axis_state.zero_rotor_phase);
+    assert(phase_difference(axis_state.last_phase, new_phase) < 256);
+
+#if HAS_BURST_STEPPING()
+    axis_state.phase_correction = current_lut.get_phase_shift(new_phase);
+    int shifted_phase = normalize_motor_phase(new_phase + axis_state.phase_correction);
+    int steps_diff = phase_difference(shifted_phase, axis_state.driver_phase);
+    burst_stepping::set_phase_diff(axis_enum, steps_diff);
+    axis_state.driver_phase = shifted_phase;
+#else
+    auto new_currents = current_lut.get_current(new_phase);
+    int c_adj = current_adjustment(axis_index, mm_to_rev(axis_enum, physical_speed));
+    new_currents.a = new_currents.a * c_adj / 255;
+    new_currents.b = new_currents.b * c_adj / 255;
+    if (new_currents != axis_state.last_currents) {
+        spi::set_xdirect(axis_index, new_currents);
+        axis_state.last_currents = new_currents;
+    }
+#endif
+
+    // Only update counters if position didn't change, so that when idling the stepper counters can
+    // be manipulated directly. When motion is restarted init_step_generator is guaranteed to be
+    // called and will refresh the new starting values.
+    if (position != axis_state.last_position) {
+        // update counters to the new position
+        int32_t steps_made = pos_to_steps(axis_index, position);
+        Stepper::set_axis_steps(axis_enum, axis_state.initial_count_position + steps_made);
+        Stepper::set_axis_steps_from_startup(axis_enum, axis_state.initial_count_position_from_startup + steps_made);
+
+        // flag axis movement (if any)
+        if (speed != 0.f) {
+            Stepper::report_axis_movement(axis_enum, speed);
+        }
+
+        axis_state.last_position = position;
+        axis_state.last_phase = new_phase;
+    }
+
+    axis_state.missed_tx_cnt = 0;
+    axis_state.last_timer_tick = last_timer_tick;
+}
+
+FORCE_OFAST void phase_stepping::handle_periodic_refresh() {
+    // This routine is extremely time sensitive and it should be as fast as
+    // possible.
+    //
+    // The latest measurement show the following timing (from ISR to end 7 µs
+    // total):
+    //
+    // - time + move advancement handling: 970ns (happy path)
+    // - position computation: 1.9µs
+    // - post to phase: 1.3 µs
+    // - current lookup: 800 ns
+    // - Quick transmission: 900ns (time from call to first bit) + 1µs transaction termination
+
+    static constexpr uint REFRESH_PERIOD_US = 1'000'000 / REFRESH_FREQ;
+    uint32_t now = ticks_us() + REFRESH_PERIOD_US;
+
+    // always refresh the last_timer_tick
+    uint32_t old_tick = last_timer_tick;
+    last_timer_tick = now;
+
+#if HAS_BURST_STEPPING()
+    // Fire the previously setup steps...
+    burst_stepping::fire();
+
+    // ...and refresh all axes
+    for (std::size_t i = 0; i != SUPPORTED_AXIS_COUNT; i++) {
+        refresh_axis(*axis_states[i], now, old_tick);
+    }
+#else
+    phase_stepping::spi::finish_transmission();
+
+    ++axis_num_to_refresh;
+    if (axis_num_to_refresh == axis_states.size()) {
+        axis_num_to_refresh = 0;
+    }
+    refresh_axis(*axis_states[axis_num_to_refresh], now, old_tick);
+#endif
+}
+
+bool phase_stepping::any_axis_active() {
+    return std::ranges::any_of(axis_states, [](const auto &state) -> bool {
+        return (state && state->active);
+    });
+}
+
+int32_t phase_stepping::pos_to_phase(int axis, float position) {
+    static constinit std::array<float, SUPPORTED_AXIS_COUNT> FACTORS = []() consteval {
+        static_assert(SUPPORTED_AXIS_COUNT <= 3);
+
+        int STEPS_PER_UNIT[] = DEFAULT_AXIS_STEPS_PER_UNIT;
+        int MICROSTEPS[] = { X_MICROSTEPS, Y_MICROSTEPS, Z_MICROSTEPS };
+
+        std::array<float, SUPPORTED_AXIS_COUNT> ret;
+        for (int i = 0; i != SUPPORTED_AXIS_COUNT; i++) {
+            ret[i] = 256.f * STEPS_PER_UNIT[i] / MICROSTEPS[i];
+        }
+        return ret;
+    }();
+    return normalize_motor_phase(position * FACTORS[axis]);
+}
+
+int32_t phase_stepping::pos_to_steps(int axis, float position) {
+    static constinit std::array<float, SUPPORTED_AXIS_COUNT> FACTORS = []() consteval {
+        static_assert(SUPPORTED_AXIS_COUNT <= 3);
+
+        int STEPS_PER_UNIT[] = DEFAULT_AXIS_STEPS_PER_UNIT;
+
+        std::array<float, SUPPORTED_AXIS_COUNT> ret;
+        for (int i = 0; i != SUPPORTED_AXIS_COUNT; i++) {
+            ret[i] = float(STEPS_PER_UNIT[i]);
+        }
+        return ret;
+    }();
+    return position * FACTORS[axis];
+}
+
+int32_t pos_to_msteps(int axis, float position) {
+    static constinit std::array<float, SUPPORTED_AXIS_COUNT> FACTORS = []() consteval {
+        static_assert(SUPPORTED_AXIS_COUNT <= 3);
+
+        int STEPS_PER_UNIT[] = DEFAULT_AXIS_STEPS_PER_UNIT;
+
+        std::array<float, SUPPORTED_AXIS_COUNT> ret;
+        for (int i = 0; i != SUPPORTED_AXIS_COUNT; i++) {
+            ret[i] = float(STEPS_PER_UNIT[i]) / PLANNER_STEPS_MULTIPLIER;
+        }
+        return ret;
+    }();
+    return position * FACTORS[axis];
+}
+
+float phase_stepping::mm_to_rev(int motor, float mm) {
+    static constinit std::array<float, SUPPORTED_AXIS_COUNT> FACTORS = []() consteval {
+        static_assert(SUPPORTED_AXIS_COUNT <= 3);
+
+        int STEPS_PER_UNIT[] = DEFAULT_AXIS_STEPS_PER_UNIT;
+        int MICROSTEPS[] = { X_MICROSTEPS, Y_MICROSTEPS, Z_MICROSTEPS };
+
+        std::array<float, SUPPORTED_AXIS_COUNT> ret;
+        for (int i = 0; i != SUPPORTED_AXIS_COUNT; i++) {
+            ret[i] = 1.f / (get_motor_steps(AxisEnum(i)) * float(MICROSTEPS[i]) / float(STEPS_PER_UNIT[i]));
+        }
+        return ret;
+    }();
+    return mm * FACTORS[motor];
+}
+
+int phase_stepping::phase_per_ustep(int axis) {
+    static constinit std::array<int, SUPPORTED_AXIS_COUNT> FACTORS = []() consteval {
+        static_assert(SUPPORTED_AXIS_COUNT <= 3);
+
+        int MICROSTEPS[] = { X_MICROSTEPS, Y_MICROSTEPS, Z_MICROSTEPS };
+
+        std::array<int, SUPPORTED_AXIS_COUNT> ret;
+        for (int i = 0; i != SUPPORTED_AXIS_COUNT; i++) {
+            ret[i] = 256 / MICROSTEPS[i];
+        }
+        return ret;
+    }();
+    return FACTORS[axis];
+}
+
+#if HAS_BURST_STEPPING()
+int phase_stepping::logical_ustep(AxisEnum axis) {
+    int mscnt = stepper_axis(axis).MSCNT();
+    if (axis >= opts::SUPPORTED_AXIS_COUNT) {
+        return mscnt;
+    }
+    const AxisState &axis_state = *axis_states[axis];
+    if (!axis_state.active) {
+        return mscnt;
+    }
+
+    // ensure we're not being called while still moving
+    assert(!axis_state.target.has_value());
+    assert(!burst_stepping::busy());
+
+    return normalize_motor_phase(mscnt - axis_state.phase_correction);
+}
+#endif
+
+FORCE_OFAST std::tuple<float, float> phase_stepping::axis_position(const AxisState &axis_state, uint32_t move_epoch) {
+    float epoch = move_epoch / 1000000.f;
+    const MoveTarget &trg = *axis_state.target;
+    return {
+        trg.start_v + 2.f * trg.half_accel * epoch,
+        trg.initial_pos + trg.start_v * epoch + trg.half_accel * epoch * epoch
+    };
+}
+
+namespace phase_stepping {
+namespace {
+    /**
+     * @brief Used for saving correction to/from a file
+     *
+     */
+    struct CorrectionSaveFormat {
+        uint8_t reserve[32] {}; // 32 zeroed out bytes to have some room in the future for potential versioning etc (head)
+        MotorPhaseCorrection correction;
+    };
+} // namespace
+
+void save_correction_to_file(const CorrectedCurrentLut &lut, const char *file_path) {
+    FILE *save_file = fopen(file_path, "wb");
+    if (!save_file) {
+        assert(false); // should never happen
+        return;
+    }
+
+    CorrectionSaveFormat save_format { .correction = lut.get_correction() };
+    [[maybe_unused]] auto written = fwrite(&save_format, 1, sizeof(CorrectionSaveFormat), save_file);
+    assert(written == sizeof(CorrectionSaveFormat));
+
+    fclose(save_file);
+}
+
+void load_correction_from_file(CorrectedCurrentLut &lut, const char *file_path) {
+    FILE *read_file = fopen(file_path, "rb");
+    if (!read_file) {
+        return; // not an error
+    }
+
+    CorrectionSaveFormat save_format {};
+    auto read = fread(&save_format, 1, sizeof(CorrectionSaveFormat), read_file);
+    if (read == sizeof(CorrectionSaveFormat)) {
+        lut.modify_correction([&](MotorPhaseCorrection &table) {
+            table = save_format.correction;
+        });
+    }
+    fclose(read_file);
+}
+
+void save_to_persistent_storage(AxisEnum axis) {
+    assert(axis < SUPPORTED_AXIS_COUNT);
+    config_store().set_phase_stepping_enabled(axis, axis_states[axis]->active);
+
+    save_correction_to_file(axis_states[axis]->forward_current, get_correction_file_path(axis, CorrectionType::forward));
+    save_correction_to_file(axis_states[axis]->backward_current, get_correction_file_path(axis, CorrectionType::backward));
+}
+
+void load_from_persistent_storage(AxisEnum axis) {
+    assert(axis < SUPPORTED_AXIS_COUNT);
+    phase_stepping::enable(axis, config_store().get_phase_stepping_enabled(axis));
+
+    load_correction_from_file(axis_states[axis]->forward_current, get_correction_file_path(axis, CorrectionType::forward));
+    load_correction_from_file(axis_states[axis]->backward_current, get_correction_file_path(axis, CorrectionType::backward));
+}
+
+} // namespace phase_stepping
+
+// This function is intentionally placed inside the phase stepping source codes
+// to allow for inlining and cross-function optimizations without LTO being
+// enabled.
+extern "C" void PHSTEP_TIMER_ISR_HANDLER(void) {
+    // We avoid slow HAL handling on purpose as phase stepping is invoked
+    // frequently and every microsecond saves about 4 % of CPU load. That is:
+    // - we don't use traceISR_ENTER()/EXIT() as it takes 1.2 µs
+    // - we don't use HAL handler: HAL_TIM_IRQHandler(&htim13) as it takes 3 µs
+    // - we avoid indirect access to peripheral registers via handle as it takes
+    //   0.4 µs
+    TIM13->SR &= ~TIM_FLAG_UPDATE;
+    phase_stepping::handle_periodic_refresh();
+}
+
+// For the same reason as the ISR handler above, we include the
+// quick_tmc_spi.cpp, burst_stepper.cpp and lut.cpp instead of compiling them
+// separately:
+#if HAS_BURST_STEPPING()
+    #include "burst_stepper.cpp"
+#else
+    #include "quick_tmc_spi.cpp"
+#endif
+#include "lut.cpp"
diff --git a/lib/Marlin/Marlin/src/feature/phase_stepping/phase_stepping.hpp b/lib/Marlin/Marlin/src/feature/phase_stepping/phase_stepping.hpp
new file mode 100644
index 0000000000..cc7b29816f
--- /dev/null
+++ b/lib/Marlin/Marlin/src/feature/phase_stepping/phase_stepping.hpp
@@ -0,0 +1,436 @@
+#pragma once
+
+#include <option/has_phase_stepping.h>
+#include <option/has_burst_stepping.h>
+
+#include "../precise_stepping/fwdecl.hpp"
+
+#if not(HAS_PHASE_STEPPING())
+    #include "phase_stepping_dummies.hpp"
+#else
+
+    #include "common.hpp"
+    #include "lut.hpp"
+
+    #include <libs/circularqueue.h>
+    #include <core/types.h>
+    #include <bsod.h>
+
+    #include <algorithm>
+    #include <memory>
+    #include <atomic>
+    #include <cassert>
+
+namespace phase_stepping {
+
+struct MoveTarget {
+    MoveTarget() = default;
+    MoveTarget(float position);
+    MoveTarget(const move_t &move, int axis, uint64_t move_duration_ticks);
+    MoveTarget(const input_shaper_state_t &is_state, uint64_t move_duration_ticks);
+
+    float initial_pos = 0;
+    float half_accel = 0;
+    float start_v = 0;
+    uint32_t duration = 0; // Movement duration in us
+    float target;
+
+private:
+    float target_position() const;
+};
+
+struct AxisState {
+    AxisState(AxisEnum axis)
+        : axis_index(axis) {}
+
+    const int axis_index;
+
+    CorrectedCurrentLut forward_current, backward_current;
+
+    std::atomic<bool> active = false;
+
+    bool inverted = false; // Inverted axis direction flag
+    int zero_rotor_phase = 0; // Rotor phase for position 0
+    int last_phase = 0; // Last known physical rotor phase
+    #if HAS_BURST_STEPPING()
+    int driver_phase = 0; // Last known phase the driver uses
+    int phase_correction = 0; // Currently applied phase correction
+    #else
+    CoilCurrents last_currents; // Currently applied coil currents
+    #endif
+    float last_position = 0.f; // Last known logical position
+    bool direction = true; // Last non-zero movement direction
+
+    CircularQueue<MoveTarget, 16> pending_targets; // 16 element queue of pre-processed elements
+
+    const move_t *last_processed_move = nullptr;
+    uint64_t current_print_time_ticks = 0;
+
+    uint32_t initial_time = 0; // Initial timestamp when the movement start
+    std::optional<MoveTarget> target; // Current target to move
+
+    std::atomic<bool> is_moving = false;
+    std::atomic<bool> is_cruising = false;
+
+    float initial_hold_multiplier; // Original holding current multiplier
+    int32_t initial_count_position = 0; // Value for updating Stepper::count_position
+    int32_t initial_count_position_from_startup = 0; // Value for updating Stepper::count_position_from_startup
+
+    uint32_t missed_tx_cnt = 0;
+    uint32_t last_timer_tick = 0;
+
+    #if HAS_BURST_STEPPING()
+    int original_microsteps = 0;
+    bool had_interpolation = false;
+    #endif
+};
+
+/**
+ * Initializes phase stepping. It has to be called before any other phase
+ * stepping function.
+ **/
+void init();
+
+/**
+ * Load and enable previous settings, if any.
+ **/
+void load();
+
+/**
+ * Set the axis phase origin for a single axis
+ */
+void set_phase_origin(AxisEnum axis_num, float pos);
+
+/**
+ * Generic function for enabling/disabling axis. Unless needed otherwise, this
+ * should be the default way of enabling/disabling it for an axis. When axis is
+ * already in desired state, it does nothing.
+ **/
+void enable(AxisEnum axis_num, bool enable);
+
+/**
+ * Enables phase stepping for axis. Reconfigures the motor driver. It is not
+ * safe to invoke this procedure within interrupt context. No movement shall be
+ * be in progress.
+ **/
+void enable_phase_stepping(AxisEnum axis_num);
+
+/**
+ * Disable phase stepping for axis. Reconfigures the motor driver. It is not
+ * safe to invoke this procedure within interrupt context. No movement shall be
+ * in progress.
+ **/
+void disable_phase_stepping(AxisEnum axis_num);
+
+/**
+ * Kill immediately all motion on phase-stepped axes. Doesn't perform any
+ * ramp-down.
+ **/
+void stop_immediately();
+
+/**
+ * Public interface for PreciseStepping - given a move and other states, setup
+ * given axis generator with the move in classical mode.
+ **/
+void init_step_generator_classic(
+    const move_t &move,
+    move_segment_step_generator_t &step_generator,
+    step_generator_state_t &step_generator_state);
+
+/**
+ * Public interface for PreciseStepping - given a move and other states, setup
+ * given axis generator with the move in input_shaping mode
+ **/
+void init_step_generator_input_shaping(
+    const move_t &move,
+    input_shaper_step_generator_t &step_generator,
+    step_generator_state_t &step_generator_state);
+
+/**
+ * Public interface pro PreciseStepping - build next step event using classical
+ * step generator
+ */
+step_event_info_t next_step_event_classic(
+    move_segment_step_generator_t &step_generator,
+    step_generator_state_t &step_generator_state);
+
+/**
+ * Public interface pro PreciseStepping - build next step event using input
+ * shaping step generator step generator
+ */
+step_event_info_t next_step_event_input_shaping(
+    input_shaper_step_generator_t &step_generator,
+    step_generator_state_t &step_generator_state);
+
+/**
+ * This function should be invoked periodically at ~90 kHz. It is is safe to
+ * invoke this function within interrupt context.
+ **/
+void handle_periodic_refresh();
+
+/**
+ * Return whether any of the axis is in phase stepping mode
+ */
+bool any_axis_active();
+
+/**
+ * Given position, compute coefficient for converting position to motor phase
+ **/
+int32_t pos_to_phase(int axis, float position);
+
+/**
+ * Given position, compute step equivalent
+ **/
+int32_t pos_to_steps(int axis, float position);
+
+/**
+ * Given position, compute planner msteps equivalent
+ **/
+int32_t pos_to_msteps(int axis, float position);
+
+/**
+ * Given position or speed in length unit, return it in revolution units
+ **/
+float mm_to_rev(int motor, float mm);
+
+/**
+ * Given axis, report number of phase steps for single µstep
+ */
+int phase_per_ustep(int axis);
+
+/**
+ * Return a motor step count for given axis
+ **/
+constexpr int get_motor_steps(AxisEnum axis) {
+    if (axis == AxisEnum::X_AXIS || axis == AxisEnum::Y_AXIS) {
+    #ifdef HAS_LDO_400_STEP
+        return 400;
+    #else
+        return 200;
+    #endif
+    }
+    return 200;
+}
+
+/**
+ * Given axis state and time in µs ticks from movement start, compute axis
+ * speed and position.
+ */
+std::tuple<float, float> axis_position(const AxisState &axis_state, uint32_t move_epoch);
+
+/**
+ * Extracts physical axis position from logical one
+ **/
+template <typename Pos>
+float extract_physical_position(AxisEnum axis, const Pos &pos) {
+    #ifdef COREXY
+    if (axis == X_AXIS) {
+        return pos[0] + pos[1];
+    } else if (axis == Y_AXIS) {
+        return pos[0] - pos[1];
+    } else if (axis == Z_AXIS) {
+        return pos[2];
+    } else {
+        bsod("Unsupported AXIS");
+    }
+    #else
+    return pos[axis];
+    #endif
+}
+
+/**
+ * Compute the smallest difference between motor phases.
+ */
+int phase_difference(int a, int b);
+
+    #if HAS_BURST_STEPPING()
+/**
+ * Given an axis, report the current µstep without phase correction
+ */
+int logical_ustep(AxisEnum axis);
+    #endif
+
+/**
+ * A simple wrapper around planner.synchronize() to avoid recursive planner inclusion
+ */
+void synchronize();
+
+/**
+ * This array keeps axis state (and LUT tables) for each axis
+ **/
+extern std::array<
+    std::unique_ptr<AxisState>,
+    opts::SUPPORTED_AXIS_COUNT>
+    axis_states;
+
+/**
+ * Check if given axis is being used for phase stepping or not.
+ *
+ * Note: This is an in-line definition so this short function can be in-lined
+ */
+inline bool is_enabled(AxisEnum axis_num) {
+    if (axis_num < opts::SUPPORTED_AXIS_COUNT) {
+        return axis_states[axis_num]->active;
+    }
+    return false;
+}
+
+/**
+ * RAII guard for not changing the state
+ */
+class EnsureNoChange {
+public:
+    EnsureNoChange() {
+        // This is work-around for not-triggering unused variable warning on the
+        // dummy guard usage
+        __asm__ __volatile__("nop;\n\t");
+    };
+
+    ~EnsureNoChange() {
+        // This is work-around for not-triggering unused variable warning on the
+        // dummy guard usage
+        __asm__ __volatile__("nop;\n\t");
+    };
+    void release() {};
+};
+
+/**
+ * Check wether init() has been called
+ */
+static inline bool initialized() {
+    return std::ranges::all_of(axis_states, [](const auto &state) { return state != nullptr; });
+}
+
+    /**
+     * Ensure init() has been called
+     */
+    #ifndef _DEBUG
+static constexpr void assert_initialized() {}
+    #else
+void assert_initialized();
+    #endif
+
+/**
+ * RAII guard for temporary disabling/enabling phase stepping with planner synchronization.
+ **/
+template <bool ENABLED>
+class EnsureState {
+    bool released = false;
+    bool any_axis_change = false;
+    std::array<bool, opts::SUPPORTED_AXIS_COUNT> _prev_active = {};
+
+public:
+    EnsureState() {
+        assert_initialized();
+
+        any_axis_change = std::ranges::any_of(axis_states, [](const auto &state) -> bool {
+            return state->active != ENABLED;
+        });
+
+        if (any_axis_change) {
+            synchronize();
+
+            for (std::size_t i = 0; i != axis_states.size(); i++) {
+                _prev_active[i] = axis_states[i]->active;
+                phase_stepping::enable(AxisEnum(i), ENABLED);
+            }
+        }
+    }
+
+    EnsureState(const EnsureState &) = delete;
+    EnsureState(const EnsureState &&) = delete;
+    EnsureState &operator=(const EnsureState &) = delete;
+    EnsureState &operator=(const EnsureState &&) = delete;
+
+    ~EnsureState() {
+        release();
+    }
+
+    void release() {
+        if (released) {
+            return;
+        }
+        released = true;
+        if (any_axis_change) {
+            synchronize();
+            for (std::size_t i = 0; i != axis_states.size(); i++) {
+                phase_stepping::enable(AxisEnum(i), _prev_active[i]);
+            }
+        }
+    }
+};
+
+using EnsureEnabled = EnsureState<true>;
+using EnsureDisabled = EnsureState<false>;
+using EnsureSuitableForHoming = std::conditional_t<
+    option::has_burst_stepping,
+    EnsureNoChange, EnsureDisabled>;
+
+enum class CorrectionType {
+    forward,
+    backward,
+};
+
+constexpr const char *get_correction_file_path(AxisEnum axis, CorrectionType lut_type) {
+    switch (axis) {
+    case AxisEnum::X_AXIS:
+        switch (lut_type) {
+        case CorrectionType::forward:
+            return "/internal/phase_step_x_fwd";
+        case CorrectionType::backward:
+            return "/internal/phase_step_x_bck";
+        }
+        break;
+    case AxisEnum::Y_AXIS:
+        switch (lut_type) {
+        case CorrectionType::forward:
+            return "/internal/phase_step_y_fwd";
+        case CorrectionType::backward:
+            return "/internal/phase_step_y_bck";
+        }
+        break;
+    default:
+        break;
+    }
+    assert(false);
+    return "";
+}
+
+/**
+ * @brief Saves correction to a file
+ *
+ * @param lut
+ * @param file_path
+ */
+void save_correction_to_file(const CorrectedCurrentLut &lut, const char *file_path);
+
+/**
+ * @brief Loads correction from a file
+ *
+ * @param lut
+ * @param file_path
+ */
+void load_correction_from_file(CorrectedCurrentLut &lut, const char *file_path);
+
+/**
+ * @brief Call to save current state into persistent media (ie eeprom/xflash)
+ * state == lookup tables, is enabled/disabled
+ *
+ */
+void save_to_persistent_storage(AxisEnum axis);
+
+/**
+ * @brief Call to load current state from persistent media (ie eeprom/xflash)
+ * state == lookup tables, is enabled/disabled
+ *
+ */
+void load_from_persistent_storage(AxisEnum axis);
+
+/**
+ * Return if some processing is still pending.
+ */
+bool processing();
+
+} // namespace phase_stepping
+
+#endif // if !HAS_PHASE_STEPPING
diff --git a/lib/Marlin/Marlin/src/feature/phase_stepping/phase_stepping_dummies.hpp b/lib/Marlin/Marlin/src/feature/phase_stepping/phase_stepping_dummies.hpp
new file mode 100644
index 0000000000..8d4bb6a37d
--- /dev/null
+++ b/lib/Marlin/Marlin/src/feature/phase_stepping/phase_stepping_dummies.hpp
@@ -0,0 +1,53 @@
+#pragma once
+
+// This header provides "no-op" implementation of some phase stepping features.
+// The goal is to not pollute other code with ifdefs.
+
+#include "../precise_stepping/fwdecl.hpp"
+#include <bsod.h>
+#include <core/types.h>
+
+namespace phase_stepping {
+
+class EnsureStateDummy {
+public:
+    EnsureStateDummy() = default;
+    ~EnsureStateDummy() {
+        // This is work-around for not-triggering unused variable warning on the
+        // dummy guard usage
+        __asm__ __volatile__("nop;\n\t");
+    };
+    void release() {};
+};
+
+using EnsureEnabled = EnsureStateDummy;
+using EnsureDisabled = EnsureStateDummy;
+using EnsureSuitableForHoming = EnsureStateDummy;
+
+static constexpr bool any_axis_active() {
+    return false;
+}
+
+inline void init_step_generator_classic(
+    const move_t &,
+    move_segment_step_generator_t &,
+    step_generator_state_t &) {
+    bsod("Phase stepping enabled when printer doesn't support it");
+}
+
+inline void init_step_generator_input_shaping(
+    const move_t &,
+    move_segment_step_generator_t &,
+    step_generator_state_t &) {
+    bsod("Phase stepping enabled when printer doesn't support it");
+}
+
+inline bool processing() {
+    return false;
+}
+
+inline bool is_enabled(AxisEnum) {
+    return false;
+}
+
+} // namespace phase_stepping
diff --git a/lib/Marlin/Marlin/src/feature/phase_stepping/quick_tmc_spi.cpp b/lib/Marlin/Marlin/src/feature/phase_stepping/quick_tmc_spi.cpp
new file mode 100644
index 0000000000..2a19763446
--- /dev/null
+++ b/lib/Marlin/Marlin/src/feature/phase_stepping/quick_tmc_spi.cpp
@@ -0,0 +1,77 @@
+#include "quick_tmc_spi.hpp"
+
+#include <trinamic.h>
+#include <TMCStepper.h>
+
+#include <device/peripherals.h>
+#include <hwio_pindef.h>
+
+using namespace phase_stepping;
+using namespace phase_stepping::spi;
+using namespace phase_stepping::opts;
+using namespace buddy::hw;
+
+static uint8_t xdirect_comm_buffer[5] = { 0, 0, 0, 0, 0 };
+static int active_axis = 0;
+static const std::array<OutputPin, 3> cs_pins = { { xCs, yCs, zCs } };
+
+struct DMA_Base_Registers {
+    __IO uint32_t ISR; /*!< DMA interrupt status register */
+    __IO uint32_t Reserved0;
+    __IO uint32_t IFCR; /*!< DMA interrupt flag clear register */
+};
+
+static void setup_xdirect_buffer(int current_a, int current_b) {
+    XDIRECT_t reg;
+    // Swapping coils isn't a mistake - TMC in Xdirect mode swaps coils
+    reg.coil_A = current_b;
+    reg.coil_B = current_a;
+    uint32_t raw = reg.sr;
+    xdirect_comm_buffer[0] = 0x80 | XDIRECT_t::address;
+    xdirect_comm_buffer[1] = (raw >> 24) & 0xFF;
+    xdirect_comm_buffer[2] = (raw >> 16) & 0xFF;
+    xdirect_comm_buffer[3] = (raw >> 8) & 0xFF;
+    xdirect_comm_buffer[4] = (raw >> 0) & 0xFF;
+}
+
+bool phase_stepping::spi::initialize_transaction() {
+    return !tmc_serial_lock_requested_by_task() && tmc_serial_lock_acquire_isr();
+}
+
+void phase_stepping::spi::set_xdirect(int axis, const CoilCurrents &currents) {
+    // You might be wondering why we don't set the state of peripheral in HAL
+    // handle: it is a wasted 2 µs ns and since we hold a lock, there cannot be
+    // a race.
+    active_axis = axis;
+    setup_xdirect_buffer(currents.a, currents.b);
+    cs_pins[active_axis].write(Pin::State::low);
+
+    // Setup SPI
+    PHSTEP_TMC_SPI->CR2 = (PHSTEP_TMC_SPI->CR2
+                              & ~(SPI_CR2_RXNEIE_Msk | SPI_CR2_ERRIE_Msk | SPI_CR2_TXEIE_Msk))
+        | SPI_CR2_TXDMAEN_Msk;
+    PHSTEP_TMC_SPI->CR1 |= SPI_CR1_SPE;
+
+    // Setup DMA
+    assert(!busy());
+    PHSTEP_TMC_DMA->NDTR = 5;
+    PHSTEP_TMC_DMA->PAR = reinterpret_cast<uint32_t>(&PHSTEP_TMC_SPI->DR);
+    PHSTEP_TMC_DMA->M0AR = reinterpret_cast<uint32_t>(&xdirect_comm_buffer[0]);
+    PHSTEP_TMC_DMA_REGS->IFCR = 0b111111 << PHSTEP_TMC_DMA_REGS_OFFSET;
+    PHSTEP_TMC_DMA->CR = (PHSTEP_TMC_DMA->CR
+                             & ~(DMA_SxCR_DBM_Msk | DMA_SxCR_DMEIE_Msk | DMA_SxCR_TEIE_Msk | DMA_SxCR_HTIE_Msk | DMA_SxCR_TCIE_Msk))
+        | DMA_SxCR_EN_Msk;
+}
+
+void phase_stepping::spi::finish_transmission() {
+    if (!tmc_serial_lock_held_by_isr()) {
+        return;
+    }
+
+    cs_pins[active_axis].write(Pin::State::high);
+    tmc_serial_lock_release_isr();
+}
+
+bool phase_stepping::spi::busy() {
+    return (PHSTEP_TMC_DMA->NDTR > 0) && (PHSTEP_TMC_DMA->CR & DMA_SxCR_EN_Msk);
+}
diff --git a/lib/Marlin/Marlin/src/feature/phase_stepping/quick_tmc_spi.hpp b/lib/Marlin/Marlin/src/feature/phase_stepping/quick_tmc_spi.hpp
new file mode 100644
index 0000000000..fe03d8141f
--- /dev/null
+++ b/lib/Marlin/Marlin/src/feature/phase_stepping/quick_tmc_spi.hpp
@@ -0,0 +1,27 @@
+#pragma once
+#include "lut.hpp"
+
+// This module has one responsibility: set XDirect register for given TMC driver
+// as quick as possible with as little CPU intervention as possible.
+//
+// To do so we perform minimalistic and direct setup of the peripherals (SPI &
+// DMA). We avoid any interrupts. Also, to ensure precise timing with minimal
+// jitter, the CS line for 2130 is released by output compare of the main phase
+// stepping timer. This ensures that no matter how long does it take to compute
+// position, the command is latched into TMC driver at a constant frequency and
+// phase. This is why also leave some slack between transmission complete and
+// setting CS high.
+//
+// The contract is a follows:
+// - start the transmission via set_xdirect. The invocation may fail if the SPI
+//   line is busy. The function expects for the SPI to be configured for TMC
+//   drivers (clock polarity/speed, etc.)
+// - invoke finish_transmission after sufficient delay from set_xdirect. It is
+//   safe to invoke this even when the previous set_xdirect failed.
+
+namespace phase_stepping::spi {
+bool initialize_transaction();
+void set_xdirect(int axis, const CoilCurrents &currents);
+void finish_transmission();
+bool busy();
+} // namespace phase_stepping::spi
diff --git a/lib/Marlin/Marlin/src/feature/precise_stepping/common.hpp b/lib/Marlin/Marlin/src/feature/precise_stepping/common.hpp
index a2dc5cc8e7..91f43b9f4d 100644
--- a/lib/Marlin/Marlin/src/feature/precise_stepping/common.hpp
+++ b/lib/Marlin/Marlin/src/feature/precise_stepping/common.hpp
@@ -6,9 +6,13 @@
  * in used data structures, and some computations.
  */
 #pragma once
+#include "fwdecl.hpp"
+
 #include "../../inc/MarlinConfig.h"
 #include "../../core/types.h"
 
+#include <option/has_phase_stepping.h>
+
 #define MOVE_SEGMENT_QUEUE_MOD(n) ((n) & (MOVE_SEGMENT_QUEUE_SIZE - 1))
 #define STEP_EVENT_QUEUE_MOD(n)   ((n) & (STEP_EVENT_QUEUE_SIZE - 1))
 
@@ -20,9 +24,9 @@ constexpr const uint32_t MOVE_FLAG_DIR_SHIFT = 4;
 constexpr const uint32_t MOVE_FLAG_AXIS_ACTIVE_SHIFT = 8;
 constexpr const uint32_t MOVE_FLAG_RESET_POSITION_SHIFT = 16;
 
-struct pressure_advance_state_t;
-struct input_shaper_state_t;
-struct input_shaper_pulses_t;
+namespace phase_stepping {
+struct AxisState;
+}
 
 typedef uint32_t MoveFlag_t;
 enum MoveFlag : MoveFlag_t {
@@ -105,7 +109,9 @@ enum StepEventFlag : StepEventFlag_t {
     STEP_EVENT_FLAG_E_ACTIVE = _BV(11),
 
     STEP_EVENT_FLAG_BEGINNING_OF_MOVE_SEGMENT = _BV(12), // Indicate that this step event is the first step event from a move segment.
-    STEP_EVENT_END_OF_MOTION = _BV(13), // Last event before coming to a halt
+    STEP_EVENT_FLAG_END_OF_MOTION = _BV(13), // Last event before coming to a halt
+    STEP_EVENT_FLAG_KEEP_ALIVE = _BV(14), // Step event just for ensuring that the step event queue never dries.
+    STEP_EVENT_FLAG_FIRST_STEP_EVENT = _BV(15) // First produced step event.
 };
 
 // Ensure XYZE bits are always adjacent and ordered as required in most loops
@@ -169,13 +175,31 @@ enum StepGeneratorType : uint8_t {
     INPUT_SHAPER_STEP_GENERATOR_Y = _BV(1),
     INPUT_SHAPER_STEP_GENERATOR_Z = _BV(2),
 
-    PRESSURE_ADVANCE_STEP_GENERATOR_E = _BV(3)
+    PRESSURE_ADVANCE_STEP_GENERATOR_E = _BV(3),
+
+    PHASE_STEPPING_GENERATOR_X = _BV(4),
+    PHASE_STEPPING_GENERATOR_Y = _BV(5),
+    PHASE_STEPPING_GENERATOR_Z = _BV(6)
 };
 
 enum StepEventInfoStatus : uint8_t {
-    STEP_EVENT_INFO_STATUS_NOT_GENERATED = 0, // Step event isn't produced by any step event generator. Such a step event cannot be inserted into the step event queue.
-    STEP_EVENT_INFO_STATUS_GENERATED_INVALID = 1, // Step event is produced by a step event generator but cannot be inserted into the step event queue.
-    STEP_EVENT_INFO_STATUS_GENERATED_VALID = 2, // Step event is produced by a step event generator and can be inserted into the step event queue.
+    // Step event isn't produced by any step event generator. Such a step event cannot be inserted into the step event queue.
+    STEP_EVENT_INFO_STATUS_NOT_GENERATED = 0,
+
+    // Step event is produced by a step event generator but cannot be inserted into the step event queue.
+    STEP_EVENT_INFO_STATUS_GENERATED_INVALID = 1,
+
+    // Step event is produced by a step event generator and can be inserted into the step event queue.
+    STEP_EVENT_INFO_STATUS_GENERATED_VALID = 2,
+
+    // Step event is produced to ensure that the step event queue never dries when an actual step
+    // event isn't produced. This step event can be inserted into the step event queue.
+    STEP_EVENT_INFO_STATUS_GENERATED_KEEP_ALIVE = 3,
+
+    // Step event is produced to signal that a step event generator wasn't able to produce a new
+    // step event for reasons different than the end of the move segment queue was reached. This
+    // step event cannot be inserted into the step event queue.
+    STEP_EVENT_INFO_STATUS_GENERATED_PENDING = 4,
 };
 
 typedef struct step_event_info_t {
@@ -200,6 +224,12 @@ typedef struct move_segment_step_generator_t : basic_step_generator_t {
     float accel = 0.f;
     float start_pos = 0.f;
     bool step_dir = false;
+
+    // We don't use inheritance on purpose – phase stepping is to some degree
+    // orthogonal to classical and advanced step generators
+#if HAS_PHASE_STEPPING()
+    phase_stepping::AxisState *phase_step_state = nullptr;
+#endif
 } move_segment_step_generator_t;
 
 struct step_generator_state_t;
@@ -213,6 +243,7 @@ struct step_generator_state_t {
     step_event_info_t step_events[4];
     std::array<step_index_t, 4> step_event_index;
     double previous_step_time;
+    uint64_t previous_step_time_ticks;
 
     StepEventFlag_t flags; // current axis/direction flags
     step_event_i32_t buffered_step; // accumulator for multi-axis step fusion
diff --git a/lib/Marlin/Marlin/src/feature/precise_stepping/fwdecl.hpp b/lib/Marlin/Marlin/src/feature/precise_stepping/fwdecl.hpp
new file mode 100644
index 0000000000..82d2732945
--- /dev/null
+++ b/lib/Marlin/Marlin/src/feature/precise_stepping/fwdecl.hpp
@@ -0,0 +1,14 @@
+#pragma once
+
+struct step_event_info_t;
+struct step_generator_state_t;
+
+struct move_t;
+struct move_segment_step_generator_t;
+
+struct input_shaper_pulses_t;
+struct input_shaper_state_t;
+struct input_shaper_step_generator_t;
+
+struct pressure_advance_state_t;
+struct pressure_advance_step_generator_t;
diff --git a/lib/Marlin/Marlin/src/feature/precise_stepping/internal.hpp b/lib/Marlin/Marlin/src/feature/precise_stepping/internal.hpp
index d3529c2da1..bdeed299b5 100644
--- a/lib/Marlin/Marlin/src/feature/precise_stepping/internal.hpp
+++ b/lib/Marlin/Marlin/src/feature/precise_stepping/internal.hpp
@@ -12,6 +12,17 @@
 // #define ISR_DEADLINE_DEBUGGING // Enable audible warnings on step deadline misses
 // #define ISR_DEADLINE_TRACKING // Accurate (but expensive) deadline miss tracking
 // #define ISR_EVENT_DEBUGGING // Enable audible warnings on event queue misses
+// #define ISR_DEBUG_NOOPT // Do not optimize ISR functions for debugging
+
+#ifdef ISR_DEADLINE_DEBUGGING
+    #warning "Dedline detection isn't working as intended after PreciseStepping::step_isr() was rewroted."
+#endif
+
+#ifndef ISR_DEBUG_NOOPT
+    #define FORCE_OFAST __attribute__((optimize("-Ofast")))
+#else
+    #define FORCE_OFAST // no-op
+#endif
 
 constexpr const double EPSILON = 0.000000001;
 constexpr const float EPSILON_FLOAT = 0.0000001f;
diff --git a/lib/Marlin/Marlin/src/feature/precise_stepping/precise_stepping.cpp b/lib/Marlin/Marlin/src/feature/precise_stepping/precise_stepping.cpp
index 0156581e9f..eb73cee103 100644
--- a/lib/Marlin/Marlin/src/feature/precise_stepping/precise_stepping.cpp
+++ b/lib/Marlin/Marlin/src/feature/precise_stepping/precise_stepping.cpp
@@ -8,6 +8,7 @@
 #include "precise_stepping.hpp"
 #include "../input_shaper/input_shaper.hpp"
 #include "../pressure_advance/pressure_advance.hpp"
+#include "../phase_stepping/phase_stepping.hpp"
 #include "internal.hpp"
 
 #include "../../module/planner.h"
@@ -19,6 +20,9 @@
 #include <timing_precise.hpp>
 #include <timing.h>
 
+#include "log.h"
+LOG_COMPONENT_DEF(PreciseStepping, LOG_SEVERITY_DEBUG);
+
 #if defined(ISR_DEADLINE_DEBUGGING) || defined(ISR_EVENT_DEBUGGING)
     #include <sound.hpp>
 #endif
@@ -84,6 +88,7 @@ xyze_long_t PreciseStepping::total_start_pos_msteps = { 0, 0, 0, 0 };
 PreciseSteppingFlag_t PreciseStepping::flags = 0;
 
 uint32_t PreciseStepping::waiting_before_delivering_start_time = 0;
+uint32_t PreciseStepping::last_step_isr_delay = 0;
 
 std::atomic<bool> PreciseStepping::stop_pending = false;
 volatile uint8_t PreciseStepping::step_dl_miss = 0;
@@ -300,7 +305,7 @@ FORCE_INLINE float calc_time_for_distance(const classic_step_generator_t &step_g
     return std::max(calc_time_for_distance(step_generator.start_v, step_generator.accel, distance, step_generator.step_dir), 0.f);
 }
 
-FORCE_INLINE float get_move_axis_r(const move_t &move, const int axis) {
+float get_move_axis_r(const move_t &move, const int axis) {
 #ifdef COREXY
     if (axis == A_AXIS) {
         return float(move.axes_r[X_AXIS]) + float(move.axes_r[Y_AXIS]);
@@ -363,59 +368,61 @@ void classic_step_generator_reset_position(classic_step_generator_t &step_genera
 step_event_info_t classic_step_generator_next_step_event(classic_step_generator_t &step_generator, step_generator_state_t &step_generator_state) {
     assert(step_generator.current_move != nullptr);
     step_event_info_t next_step_event = { std::numeric_limits<double>::max(), 0, STEP_EVENT_INFO_STATUS_GENERATED_INVALID };
-    const move_t *next_move = nullptr;
-    do {
-        const float half_step_dist = Planner::mm_per_half_step[step_generator.axis];
-        const float next_target = float(step_generator_state.current_distance[step_generator.axis] + (step_generator.step_dir ? 0 : -1)) * Planner::mm_per_step[step_generator.axis] + half_step_dist;
-        const float next_distance = next_target - step_generator.start_pos;
-        const float step_time = calc_time_for_distance(step_generator, next_distance);
-
-        // When step_time is infinity, it means that next_distance will never be reached.
-        // This happens when next_target exceeds end_position, and deceleration decelerates velocity to zero or negative value.
-        // Also, we need to stop when step_time exceeds local_end.
-        if (const double step_time_d = double(step_time); step_time_d > (step_generator.current_move->move_t + EPSILON)) {
-            if (next_move = PreciseStepping::move_segment_queue_next_move(*step_generator.current_move); next_move != nullptr) {
-                next_step_event.time = next_move->print_time;
-
-                // Reset position in steps (current_distance) based on the difference in the position.
-                if (next_move->flags & (MOVE_FLAG_RESET_POSITION_X << step_generator.axis)) {
-                    classic_step_generator_reset_position(step_generator, step_generator_state, *next_move);
-                }
 
-                // The move segment is fully processed, and in the queue is another unprocessed move segment.
-                // So we decrement reference count of the current move segment and increment reference count of next move segment.
-                --step_generator.current_move->reference_cnt;
-                step_generator.current_move = next_move;
-                ++step_generator.current_move->reference_cnt;
+    const float half_step_dist = Planner::mm_per_half_step[step_generator.axis];
+    const float next_target = float(step_generator_state.current_distance[step_generator.axis] + (step_generator.step_dir ? 0 : -1)) * Planner::mm_per_step[step_generator.axis] + half_step_dist;
+    const float next_distance = next_target - step_generator.start_pos;
+    const float step_time = calc_time_for_distance(step_generator, next_distance);
+
+    // When step_time is infinity, it means that next_distance will never be reached.
+    // This happens when next_target exceeds end_position, and deceleration decelerates velocity to zero or negative value.
+    // Also, we need to stop when step_time exceeds local_end.
+    if (const double step_time_d = double(step_time); step_time_d > (step_generator.current_move->move_t + EPSILON)) {
+        if (const move_t *next_move = PreciseStepping::move_segment_queue_next_move(*step_generator.current_move); next_move != nullptr) {
+            next_step_event.time = next_move->print_time;
+
+            if (!is_ending_empty_move(*next_move)) {
+                next_step_event.flags |= STEP_EVENT_FLAG_KEEP_ALIVE;
+                next_step_event.status = STEP_EVENT_INFO_STATUS_GENERATED_KEEP_ALIVE;
+            }
 
-                classic_step_generator_update(step_generator);
+            // Reset position in steps (current_distance) based on the difference in the position.
+            if (next_move->flags & (MOVE_FLAG_RESET_POSITION_X << step_generator.axis)) {
+                classic_step_generator_reset_position(step_generator, step_generator_state, *next_move);
+            }
 
-                // Update step direction flag, which is cached until this move segment is processed.
-                // It assumes that dir bit flags for step_event_t and move_t are the same position.
-                const StepEventFlag_t current_axis_dir_flag = (STEP_EVENT_FLAG_X_DIR << step_generator.axis);
-                step_generator_state.flags &= ~current_axis_dir_flag;
-                step_generator_state.flags |= !step_generator.step_dir * current_axis_dir_flag;
+            // The move segment is fully processed, and in the queue is another unprocessed move segment.
+            // So we decrement reference count of the current move segment and increment reference count of next move segment.
+            --step_generator.current_move->reference_cnt;
+            step_generator.current_move = next_move;
+            ++step_generator.current_move->reference_cnt;
 
-                // Update active axis flag, which is cached until this move segment is processed.
-                // It assumes that active bit flags for step_event_t and move_t are the same position.
-                const StepEventFlag_t current_axis_active_flag = (STEP_EVENT_FLAG_X_ACTIVE << step_generator.axis);
-                step_generator_state.flags &= ~current_axis_active_flag;
-                step_generator_state.flags |= step_generator.current_move->flags & current_axis_active_flag;
+            classic_step_generator_update(step_generator);
 
-                PreciseStepping::move_segment_processed_handler();
-            } else {
-                next_step_event.time = step_generator.current_move->print_time + step_generator.current_move->move_t;
-            }
+            // Update step direction flag, which is cached until this move segment is processed.
+            // It assumes that dir bit flags for step_event_t and move_t are the same position.
+            const StepEventFlag_t current_axis_dir_flag = (STEP_EVENT_FLAG_X_DIR << step_generator.axis);
+            step_generator_state.flags &= ~current_axis_dir_flag;
+            step_generator_state.flags |= !step_generator.step_dir * current_axis_dir_flag;
+
+            // Update active axis flag, which is cached until this move segment is processed.
+            // It assumes that active bit flags for step_event_t and move_t are the same position.
+            const StepEventFlag_t current_axis_active_flag = (STEP_EVENT_FLAG_X_ACTIVE << step_generator.axis);
+            step_generator_state.flags &= ~current_axis_active_flag;
+            step_generator_state.flags |= step_generator.current_move->flags & current_axis_active_flag;
+
+            PreciseStepping::move_segment_processed_handler();
         } else {
-            const double elapsed_time = step_time_d + step_generator.current_move->print_time;
-            next_step_event.time = elapsed_time;
-            next_step_event.flags = STEP_EVENT_FLAG_STEP_X << step_generator.axis;
-            next_step_event.flags |= step_generator_state.flags;
-            next_step_event.status = STEP_EVENT_INFO_STATUS_GENERATED_VALID;
-            step_generator_state.current_distance[step_generator.axis] += (step_generator.step_dir ? 1 : -1);
-            break;
+            next_step_event.time = step_generator.current_move->print_time + step_generator.current_move->move_t;
         }
-    } while (next_move != nullptr);
+    } else {
+        const double elapsed_time = step_time_d + step_generator.current_move->print_time;
+        next_step_event.time = elapsed_time;
+        next_step_event.flags = STEP_EVENT_FLAG_STEP_X << step_generator.axis;
+        next_step_event.flags |= step_generator_state.flags;
+        next_step_event.status = STEP_EVENT_INFO_STATUS_GENERATED_VALID;
+        step_generator_state.current_distance[step_generator.axis] += (step_generator.step_dir ? 1 : -1);
+    }
 
     // When std::numeric_limits<double>::max() is returned, it means that for the current state of the move segment queue, there isn't any next step event for this axis.
     return next_step_event;
@@ -445,11 +452,14 @@ bool generate_next_step_event(step_event_i32_t &step_event, step_generator_state
 
     // Sorting buffer isn't fulfilled for all active axis, so we need to fulfill.
     // So we don't have anything to put into step_event_buffer.
-    if (step_state.step_events[old_nearest_step_event_idx].status == STEP_EVENT_INFO_STATUS_GENERATED_VALID) {
+    auto step_status = step_state.step_events[old_nearest_step_event_idx].status;
+    if (step_status == STEP_EVENT_INFO_STATUS_GENERATED_VALID || step_status == STEP_EVENT_INFO_STATUS_GENERATED_KEEP_ALIVE) {
         const double step_time_absolute = step_state.step_events[old_nearest_step_event_idx].time;
-        const double step_time_relative = step_time_absolute - step_state.previous_step_time;
+        const uint64_t step_time_absolute_ticks = uint64_t(step_time_absolute * PreciseStepping::ticks_per_sec);
+        const uint64_t step_time_relative_ticks = step_time_absolute_ticks - step_state.previous_step_time_ticks;
+        assert(step_time_relative_ticks < std::numeric_limits<uint32_t>::max());
 
-        step_event.time_ticks = int32_t(step_time_relative * PreciseStepping::ticks_per_sec);
+        step_event.time_ticks = int32_t(step_time_relative_ticks);
         step_event.flags = step_state.step_events[old_nearest_step_event_idx].flags;
         assert(step_event.flags); // ensure flags are non-zero
 
@@ -466,7 +476,12 @@ bool generate_next_step_event(step_event_i32_t &step_event, step_generator_state
             --step_state.left_insert_start_of_move_segment;
         }
 
+        if (step_state.previous_step_time == 0.) {
+            step_event.flags |= STEP_EVENT_FLAG_FIRST_STEP_EVENT;
+        }
+
         step_state.previous_step_time = step_time_absolute;
+        step_state.previous_step_time_ticks = step_time_absolute_ticks;
     } else {
         // Reset flags to indicate no step has been produced
         step_event.flags = 0;
@@ -478,7 +493,9 @@ bool generate_next_step_event(step_event_i32_t &step_event, step_generator_state
 
     // Update nearest step event index.
     step_generator_state_update_nearest_idx(step_state);
-    return StepGeneratorStatus(step_state.step_events[step_state.step_event_index[0]].status == STEP_EVENT_INFO_STATUS_GENERATED_INVALID);
+
+    StepEventInfoStatus nearest_step_event_status = step_state.step_events[step_state.step_event_index[0]].status;
+    return (nearest_step_event_status == STEP_EVENT_INFO_STATUS_GENERATED_INVALID) || (nearest_step_event_status == STEP_EVENT_INFO_STATUS_GENERATED_PENDING);
 }
 
 HAL_MOVE_TIMER_ISR() {
@@ -518,10 +535,17 @@ void PreciseStepping::init() {
     Stepper::count_direction.y = (Stepper::last_direction_bits & STEP_EVENT_FLAG_Y_DIR) ? -1 : 1;
     Stepper::count_direction.z = (Stepper::last_direction_bits & STEP_EVENT_FLAG_Z_DIR) ? -1 : 1;
     Stepper::count_direction.e = (Stepper::last_direction_bits & STEP_EVENT_FLAG_E_DIR) ? -1 : 1;
-
+#if HAS_PHASE_STEPPING()
+    LOOP_XYZ(i) {
+        PreciseStepping::step_generators_pool.classic_step_generator[i].phase_step_state = phase_stepping::axis_states[i].get();
+    }
+#endif
 #ifdef ADVANCED_STEP_GENERATORS
     LOOP_XYZ(i) {
         PreciseStepping::step_generators_pool.input_shaper_step_generator[i].is_state = &InputShaper::is_state[i];
+    #if HAS_PHASE_STEPPING()
+        PreciseStepping::step_generators_pool.input_shaper_step_generator[i].phase_step_state = phase_stepping::axis_states[i].get();
+    #endif
     }
     PreciseStepping::step_generators_pool.pressure_advance_step_generator_e.pa_state = &PressureAdvance::pressure_advance_state;
 #endif
@@ -541,23 +565,27 @@ void PreciseStepping::reset_from_halt(bool preserve_step_fraction) {
     PreciseStepping::flags = 0;
 
     if (preserve_step_fraction) {
-#ifdef COREXY
-        total_start_pos_msteps.x -= (step_generator_state.current_distance.a + step_generator_state.current_distance.b) * PLANNER_STEPS_MULTIPLIER / 2;
-        total_start_pos_msteps.y -= (step_generator_state.current_distance.a - step_generator_state.current_distance.b) * PLANNER_STEPS_MULTIPLIER / 2;
-#else
-        total_start_pos_msteps.x -= step_generator_state.current_distance.x * PLANNER_STEPS_MULTIPLIER;
-        total_start_pos_msteps.y -= step_generator_state.current_distance.y * PLANNER_STEPS_MULTIPLIER;
-#endif
-
-        total_start_pos_msteps.z -= step_generator_state.current_distance.z * PLANNER_STEPS_MULTIPLIER;
-        // Because of pressure advance, the amount of material in total_start_pos_msteps doesn't have to equal to step_generator_state.current_distance.e.
-        // So we always reset extrude steps to zero because losing a fraction of a step in the E-axis shouldn't cause any issues.
+        // Because of pressure advance, the amount of material in total_start_pos_msteps doesn't
+        // have to equal to step_generator_state.current_distance.e. So we always reset extrude
+        // steps to zero because losing a fraction of a step in the E-axis shouldn't cause any
+        // issues.
         total_start_pos_msteps.e = 0;
+
         PreciseStepping::total_start_pos = convert_oriented_msteps_to_distance(PreciseStepping::total_start_pos_msteps);
     } else {
-        PreciseStepping::total_start_pos_msteps = { 0, 0, 0, 0 };
-        PreciseStepping::total_start_pos = { 0., 0., 0., 0. };
+        PreciseStepping::total_start_pos_msteps = stepper.count_position_from_startup * PLANNER_STEPS_MULTIPLIER;
+        PreciseStepping::total_start_pos = convert_oriented_msteps_to_distance(PreciseStepping::total_start_pos_msteps);
     }
+
+#if HAS_PHASE_STEPPING()
+    #ifdef COREXY
+    phase_stepping::set_phase_origin(X_AXIS, total_start_pos[X_AXIS] + total_start_pos[Y_AXIS]);
+    phase_stepping::set_phase_origin(Y_AXIS, total_start_pos[X_AXIS] - total_start_pos[Y_AXIS]);
+    #else
+    phase_stepping::set_phase_origin(X_AXIS, total_start_pos[X_AXIS]);
+    phase_stepping::set_phase_origin(Y_AXIS, total_start_pos[Y_AXIS]);
+    #endif
+#endif
 }
 
 uint16_t PreciseStepping::process_one_step_event_from_queue() {
@@ -592,22 +620,22 @@ uint16_t PreciseStepping::process_one_step_event_from_queue() {
         if (const uint8_t changed_dir_bits = uint8_t(step_dir >> STEP_EVENT_FLAG_DIR_SHIFT) ^ Stepper::last_direction_bits; changed_dir_bits) {
             Stepper::last_direction_bits = uint8_t(step_dir >> STEP_EVENT_FLAG_DIR_SHIFT);
 
-            if (TEST(changed_dir_bits, X_AXIS)) {
+            if (!phase_stepping::is_enabled(X_AXIS) && TEST(changed_dir_bits, X_AXIS)) {
                 X_APPLY_DIR(step_dir_inv & STEP_EVENT_FLAG_X_DIR);
                 Stepper::count_direction.x = (step_dir & STEP_EVENT_FLAG_X_DIR) ? -1 : 1;
             }
 
-            if (TEST(changed_dir_bits, Y_AXIS)) {
+            if (!phase_stepping::is_enabled(Y_AXIS) && TEST(changed_dir_bits, Y_AXIS)) {
                 Y_APPLY_DIR(step_dir_inv & STEP_EVENT_FLAG_Y_DIR);
                 Stepper::count_direction.y = (step_dir & STEP_EVENT_FLAG_Y_DIR) ? -1 : 1;
             }
 
-            if (TEST(changed_dir_bits, Z_AXIS)) {
+            if (!phase_stepping::is_enabled(Z_AXIS) && TEST(changed_dir_bits, Z_AXIS)) {
                 Z_APPLY_DIR(step_dir_inv & STEP_EVENT_FLAG_Z_DIR);
                 Stepper::count_direction.z = (step_dir & STEP_EVENT_FLAG_Z_DIR) ? -1 : 1;
             }
 
-            if (TEST(changed_dir_bits, E_AXIS)) {
+            if (!phase_stepping::is_enabled(E_AXIS) && TEST(changed_dir_bits, E_AXIS)) {
                 E_APPLY_DIR(step_dir_inv & STEP_EVENT_FLAG_E_DIR);
                 Stepper::count_direction.e = (step_dir & STEP_EVENT_FLAG_E_DIR) ? -1 : 1;
             }
@@ -643,7 +671,7 @@ uint16_t PreciseStepping::process_one_step_event_from_queue() {
 
         if (step_event_u16_t *next_step_event = get_current_step_event(); next_step_event != nullptr) {
             ticks_to_next_isr = next_step_event->time_ticks;
-        } else if ((step_flags & STEP_EVENT_END_OF_MOTION) == false) {
+        } else if ((step_flags & STEP_EVENT_FLAG_END_OF_MOTION) == false) {
             ++step_ev_miss;
         }
     } else {
@@ -654,6 +682,16 @@ uint16_t PreciseStepping::process_one_step_event_from_queue() {
     return ticks_to_next_isr;
 }
 
+static int32_t counter_signed_diff(uint16_t timestamp1, uint16_t timestamp2) {
+    int32_t diff = int32_t(timestamp1) - int32_t(timestamp2);
+    if (diff > 0xFFFF / 2 - 1) {
+        diff -= 0xFFFF;
+    } else if (diff < -0xFFFF / 2) {
+        diff += 0xFFFF;
+    }
+    return diff;
+}
+
 void PreciseStepping::step_isr() {
 #ifndef ISR_DEADLINE_TRACKING
     constexpr uint16_t min_delay = 6; // fuse isr for steps below this threshold (us)
@@ -662,7 +700,6 @@ void PreciseStepping::step_isr() {
 #endif
     constexpr uint16_t min_reserve = 5; // minimum interval for isr re-entry (us)
     constexpr uint16_t max_ticks = (UINT16_MAX / 2); // maximum isr interval for skip detection (us)
-    constexpr uint8_t max_steps = 4; // maximum number of steps to per isr to limit latency
 
 #ifdef ISR_DEADLINE_TRACKING
     // in addition to checking for forward misses, check for past ones
@@ -672,18 +709,21 @@ void PreciseStepping::step_isr() {
     }
 #endif
 
-    uint16_t time_increment = 0;
-    for (uint8_t steps = 0; steps != max_steps;) {
+    const uint32_t compare = __HAL_TIM_GET_COMPARE(&TimerHandle[STEP_TIMER_NUM].handle, TIM_CHANNEL_1);
+
+    uint32_t next = 0;
+    uint32_t time_increment = 0;
+    uint32_t timer_remaining_time = 0;
+    do {
         if (stop_pending)
             [[unlikely]] {
-            time_increment = stepper_isr_period_in_ticks;
+            next = compare + stepper_isr_period_in_ticks;
             Stepper::axis_did_move = 0;
             break;
         }
 
         if (!left_ticks_to_next_step_event) {
             left_ticks_to_next_step_event = process_one_step_event_from_queue();
-            ++steps;
         }
 
         // limit the interval to avoid a counter overflow or runout
@@ -695,28 +735,37 @@ void PreciseStepping::step_isr() {
 
         // Compute the number of ticks for the next ISR.
         time_increment += ticks_to_next_step_event;
-        if (ticks_to_next_step_event > min_delay || steps >= max_steps) {
-            break;
+        if (ticks_to_next_step_event <= min_delay) {
+            continue;
         }
 
-        // the next step is too close for a new isr but still within margin,
-        // spin-wait for accurate delivery
-        if (left_ticks_to_next_step_event) {
-            delay_us_precise(left_ticks_to_next_step_event);
-        }
+        next = compare + time_increment;
+
+        const uint32_t counter = __HAL_TIM_GET_COUNTER(&TimerHandle[STEP_TIMER_NUM].handle);
+        timer_remaining_time = next - counter;
+    } while (timer_remaining_time < min_reserve || (timer_remaining_time & 0xFFFF) > max_ticks);
+
+    // What follows is a not-straightforward scheduling of the next step ISR
+    // time event. If this ISR is interrupted by another routine, we might
+    // schedule an event that is in the past from the perspective of the step
+    // timer. Thus, we check if this is the case and possibly adjust the time.
+    // On the next ISR we will pick up the slack.
+    const auto timer_handle_ptr = &TimerHandle[STEP_TIMER_NUM].handle;
+    uint32_t adjusted_next = next - last_step_isr_delay;
+    __disable_irq();
+    int32_t tim_counter = __HAL_TIM_GET_COUNTER(timer_handle_ptr);
+    int32_t diff = counter_signed_diff(adjusted_next, tim_counter);
+    if (diff < min_reserve) {
+        adjusted_next = tim_counter + min_reserve;
     }
+    __HAL_TIM_SET_COMPARE(timer_handle_ptr, TIM_CHANNEL_1, adjusted_next);
+    __enable_irq();
 
-    uint32_t compare = __HAL_TIM_GET_COMPARE(&TimerHandle[STEP_TIMER_NUM].handle, TIM_CHANNEL_1);
-    uint32_t next = compare + time_increment;
-    uint32_t counter = __HAL_TIM_GET_COUNTER(&TimerHandle[STEP_TIMER_NUM].handle);
-    uint32_t deadline = counter + min_reserve;
-    if (((next - deadline) & 0xFFFF) > max_ticks)
-        [[unlikely]] {
-        // next isr too close or missed: reschedule
-        next = __HAL_TIM_GET_COUNTER(&TimerHandle[STEP_TIMER_NUM].handle) + min_reserve;
-        ++step_dl_miss;
+    if (diff < min_delay) {
+        last_step_isr_delay = -diff + min_reserve;
+    } else {
+        last_step_isr_delay = 0;
     }
-    __HAL_TIM_SET_COMPARE(&TimerHandle[STEP_TIMER_NUM].handle, TIM_CHANNEL_1, next);
 
 #ifdef ISR_DEADLINE_TRACKING
     uint32_t scheduled_ticks = (((next & 0xFFFF) - __HAL_TIM_GET_COUNTER(&TimerHandle[STEP_TIMER_NUM].handle)) & 0xFFFF);
@@ -787,7 +836,8 @@ FORCE_INLINE bool append_move_discarding_step_event(step_generator_state_t &step
         step_event->flags = step_state.flags | STEP_EVENT_FLAG_BEGINNING_OF_MOVE_SEGMENT | extra_step_flags;
 
         PreciseStepping::step_event_queue.head = next_step_event_queue_head;
-        step_state.previous_step_time = 0;
+        step_state.previous_step_time = 0.;
+        step_state.previous_step_time_ticks = 0;
         return true;
     }
     return false;
@@ -828,7 +878,7 @@ void PreciseStepping::process_queue_of_blocks() {
     // contains the value bigger then MAX_PRINT_TIME) we're waiting for motion to halt and reset.
     if (PreciseStepping::total_print_time >= MAX_PRINT_TIME) {
         // ensure all motion has stopped
-        if (has_blocks_queued()) {
+        if (has_blocks_queued() || phase_stepping::processing()) {
             return;
         }
 
@@ -997,11 +1047,25 @@ FORCE_INLINE split_step_event_t split_buffered_step(const step_generator_state_t
     return split_step_event;
 }
 
+FORCE_INLINE void trigger_first_step_event_after_specified_ticks(const uint32_t ticks) {
+    assert(ticks <= STEP_TIMER_MAX_TICKS_LIMIT);
+
+    DISABLE_STEPPER_DRIVER_INTERRUPT();
+    const uint16_t counter = __HAL_TIM_GET_COUNTER(&TimerHandle[STEP_TIMER_NUM].handle);
+    const uint16_t deadline = counter + ticks;
+    __HAL_TIM_SET_COMPARE(&TimerHandle[STEP_TIMER_NUM].handle, TIM_CHANNEL_1, deadline);
+    ENABLE_STEPPER_DRIVER_INTERRUPT();
+}
+
 FORCE_INLINE void append_split_step_event(const split_step_event_t &split_step_event, step_event_u16_t *&next_step_event, uint16_t &next_step_event_queue_head) {
     assert(next_step_event != nullptr);
     assert(split_step_event.empty_step_event_cnt + 1 <= PreciseStepping::step_event_queue_free_slots());
 
     for (int32_t empty_step_event_idx = 0; empty_step_event_idx < split_step_event.empty_step_event_cnt; ++empty_step_event_idx) {
+        if ((split_step_event.last_step_event_flags & STEP_EVENT_FLAG_FIRST_STEP_EVENT) && empty_step_event_idx == 0) {
+            trigger_first_step_event_after_specified_ticks(STEP_TIMER_MAX_TICKS_LIMIT);
+        }
+
         next_step_event->time_ticks = STEP_TIMER_MAX_TICKS_LIMIT;
         next_step_event->flags = split_step_event.empty_step_event_flags;
         PreciseStepping::step_event_queue.head = next_step_event_queue_head;
@@ -1011,6 +1075,10 @@ FORCE_INLINE void append_split_step_event(const split_step_event_t &split_step_e
         assert(next_step_event);
     }
 
+    if ((split_step_event.last_step_event_flags & STEP_EVENT_FLAG_FIRST_STEP_EVENT) && split_step_event.empty_step_event_cnt == 0) {
+        trigger_first_step_event_after_specified_ticks(split_step_event.last_step_event_time_ticks);
+    }
+
     next_step_event->time_ticks = split_step_event.last_step_event_time_ticks;
     next_step_event->flags = split_step_event.last_step_event_flags;
 #pragma GCC diagnostic push
@@ -1059,7 +1127,7 @@ StepGeneratorStatus PreciseStepping::process_one_move_segment_from_queue() {
                     step_generator_state.buffered_step = new_step_event;
                 } else if (new_step_event.time_ticks == 0 // zero delay
                     && !((step_generator_state.buffered_step.flags & new_step_event.flags)
-                        & (STEP_EVENT_FLAG_AXIS_MASK | STEP_EVENT_FLAG_AXIS_OTHER_MASK)) // no step or move flag overlap
+                        & ((STEP_EVENT_FLAG_AXIS_MASK | STEP_EVENT_FLAG_AXIS_OTHER_MASK) & ~STEP_EVENT_FLAG_KEEP_ALIVE)) // no step or move flag overlap except keep-alive flag
                     && !((step_generator_state.buffered_step.flags ^ new_step_event.flags) & STEP_EVENT_FLAG_DIR_MASK) // identical direction flags
                 ) {
                     // TODO @wavexx: there are currently cases where a useless change in direction
@@ -1122,7 +1190,7 @@ StepGeneratorStatus PreciseStepping::process_one_move_segment_from_queue() {
                 // we reached an explicit end block with all generators waiting on it, we can advance
                 if (!is_step_event_queue_full()) {
                     discard_current_unprocessed_move_segment();
-                    [[maybe_unused]] const bool appended = append_move_discarding_step_event(step_generator_state, STEP_EVENT_END_OF_MOTION);
+                    [[maybe_unused]] const bool appended = append_move_discarding_step_event(step_generator_state, STEP_EVENT_FLAG_END_OF_MOTION);
                     assert(appended);
                 }
 
@@ -1166,8 +1234,19 @@ void PreciseStepping::step_generator_state_init(const move_t &move) {
 
     step_generator_state.flags = 0;
     step_generator_state.previous_step_time = 0.;
+    step_generator_state.previous_step_time_ticks = 0;
     step_generator_state.buffered_step.flags = 0;
-    step_generator_state.current_distance = { 0, 0, 0, 0 };
+    step_generator_state.current_distance = xyze_long_t {
+#ifdef COREXY
+        LROUND((float(move.start_pos.x) + float(move.start_pos.y)) * Planner::settings.axis_steps_per_mm[X_AXIS]),
+        LROUND((float(move.start_pos.x) - float(move.start_pos.y)) * Planner::settings.axis_steps_per_mm[Y_AXIS]),
+#else
+        LROUND(float(move.start_pos.x) * Planner::settings.axis_steps_per_mm[X_AXIS]),
+        LROUND(float(move.start_pos.y) * Planner::settings.axis_steps_per_mm[Y_AXIS]),
+#endif
+        LROUND(float(move.start_pos.z) * Planner::settings.axis_steps_per_mm[Z_AXIS]),
+        LROUND(float(move.start_pos.e) * Planner::settings.axis_steps_per_mm[E_AXIS])
+    };
     step_generator_state.left_insert_start_of_move_segment = 0;
 
     // Reset step events and index
@@ -1184,12 +1263,24 @@ void PreciseStepping::step_generator_state_init(const move_t &move) {
     LOOP_XYZ(i) {
 #ifdef ADVANCED_STEP_GENERATORS
         if (physical_axis_step_generator_types & (INPUT_SHAPER_STEP_GENERATOR_X << i)) {
-            input_shaper_step_generator_init(move, step_generators_pool.input_shaper_step_generator[i], step_generator_state);
+            if (physical_axis_step_generator_types & (PHASE_STEPPING_GENERATOR_X << i)) {
+                phase_stepping::init_step_generator_input_shaping(move, step_generators_pool.input_shaper_step_generator[i], step_generator_state);
+            } else {
+                input_shaper_step_generator_init(move, step_generators_pool.input_shaper_step_generator[i], step_generator_state);
+            }
         } else {
-            classic_step_generator_init(move, step_generators_pool.classic_step_generator[i], step_generator_state);
+            if (physical_axis_step_generator_types & (PHASE_STEPPING_GENERATOR_X << i)) {
+                phase_stepping::init_step_generator_classic(move, step_generators_pool.classic_step_generator[i], step_generator_state);
+            } else {
+                classic_step_generator_init(move, step_generators_pool.classic_step_generator[i], step_generator_state);
+            }
         }
 #else
-        classic_step_generator_init(move, step_generators_pool.classic_step_generator[i], step_generator_state);
+        if (physical_axis_step_generator_types & (PHASE_STEPPING_GENERATOR_X << i)) {
+            phase_stepping::init_step_generator_classic(move, step_generators_pool.classic_step_generator[i], step_generator_state);
+        } else {
+            classic_step_generator_init(move, step_generators_pool.classic_step_generator[i], step_generator_state);
+        }
 #endif
     }
 
@@ -1221,6 +1312,9 @@ void PreciseStepping::reset_queues() {
     // reset internal state and queues
     step_event_queue_clear();
     move_segment_queue_clear();
+#if HAS_PHASE_STEPPING()
+    phase_stepping::stop_immediately();
+#endif
     reset_from_halt(false);
 
     // at this point the planner might still have queued extra moves, flush them
@@ -1237,3 +1331,12 @@ void PreciseStepping::reset_queues() {
         stepper.wake_up();
     }
 }
+
+void mark_ownership(move_t &move) {
+    move.reference_cnt++;
+}
+
+void discard_ownership(move_t &move) {
+    move.reference_cnt--;
+    PreciseStepping::move_segment_processed_handler();
+}
diff --git a/lib/Marlin/Marlin/src/feature/precise_stepping/precise_stepping.hpp b/lib/Marlin/Marlin/src/feature/precise_stepping/precise_stepping.hpp
index 461a35a150..91803e58d6 100644
--- a/lib/Marlin/Marlin/src/feature/precise_stepping/precise_stepping.hpp
+++ b/lib/Marlin/Marlin/src/feature/precise_stepping/precise_stepping.hpp
@@ -295,6 +295,7 @@ class PreciseStepping {
 
 private:
     static uint32_t waiting_before_delivering_start_time;
+    static uint32_t last_step_isr_delay;
 
     static void step_generator_state_init(const move_t &move);
 
@@ -306,3 +307,8 @@ class PreciseStepping {
 void classic_step_generator_init(const move_t &move, classic_step_generator_t &step_generator, step_generator_state_t &step_generator_state);
 
 FORCE_INLINE void classic_step_generator_update(classic_step_generator_t &step_generator);
+
+// Common functions:
+float get_move_axis_r(const move_t &move, const int axis);
+void mark_ownership(move_t &move);
+void discard_ownership(move_t &move);
diff --git a/lib/Marlin/Marlin/src/feature/pressure_advance/pressure_advance.cpp b/lib/Marlin/Marlin/src/feature/pressure_advance/pressure_advance.cpp
index 4cdf136323..3505d394b8 100644
--- a/lib/Marlin/Marlin/src/feature/pressure_advance/pressure_advance.cpp
+++ b/lib/Marlin/Marlin/src/feature/pressure_advance/pressure_advance.cpp
@@ -382,77 +382,77 @@ void pressure_advance_reset_position(pressure_advance_step_generator_t &step_gen
 step_event_info_t pressure_advance_step_generator_next_step_event(pressure_advance_step_generator_t &step_generator, step_generator_state_t &step_generator_state) {
     assert(step_generator.pa_state != nullptr);
     step_event_info_t next_step_event = { std::numeric_limits<double>::max(), 0, STEP_EVENT_INFO_STATUS_GENERATED_INVALID };
-    const move_t *next_move = nullptr;
-    do {
-        const bool prev_step_dir = step_generator.pa_state->step_dir;
-        const float half_step_dist = Planner::mm_per_half_step[step_generator.axis];
-        const double step_time = calc_time_for_distance_pressure_advance(half_step_dist, step_generator, PressureAdvance::pressure_advance_params, step_generator_state);
-
-        if (prev_step_dir != step_generator.pa_state->step_dir) {
-            // Update step direction flag, which is cached until this move segment is processed.
-            const uint16_t current_axis_dir_flag = (STEP_EVENT_FLAG_X_DIR << step_generator.axis);
-            step_generator_state.flags &= ~current_axis_dir_flag;
-            step_generator_state.flags |= (!step_generator.pa_state->step_dir) * current_axis_dir_flag;
+
+    const bool prev_step_dir = step_generator.pa_state->step_dir;
+    const float half_step_dist = Planner::mm_per_half_step[step_generator.axis];
+    const double step_time = calc_time_for_distance_pressure_advance(half_step_dist, step_generator, PressureAdvance::pressure_advance_params, step_generator_state);
+
+    if (prev_step_dir != step_generator.pa_state->step_dir) {
+        // Update step direction flag, which is cached until this move segment is processed.
+        const uint16_t current_axis_dir_flag = (STEP_EVENT_FLAG_X_DIR << step_generator.axis);
+        step_generator_state.flags &= ~current_axis_dir_flag;
+        step_generator_state.flags |= (!step_generator.pa_state->step_dir) * current_axis_dir_flag;
+    }
+
+    // When step_time is infinity, it means that next_distance will never be reached.
+    // This happens when next_target exceeds end_position, and deceleration decelerates velocity to zero or negative value.
+    // Also, we need to stop when step_time exceeds local_end.
+    const double elapsed_time = step_time;
+    if (step_time >= MAX_PRINT_TIME) {
+        if (is_pressure_advance_reached_end(*step_generator.pa_state)) {
+            assert(step_generator.pa_state->current_move->move_t == MAX_PRINT_TIME);
+            next_step_event.time = step_generator.pa_state->current_move->print_time + step_generator.pa_state->current_move->move_t;
+        } else {
+            next_step_event.time = pressure_advance_step_time_of_next_sample(*step_generator.pa_state, PressureAdvance::pressure_advance_params);
         }
 
-        // When step_time is infinity, it means that next_distance will never be reached.
-        // This happens when next_target exceeds end_position, and deceleration decelerates velocity to zero or negative value.
-        // Also, we need to stop when step_time exceeds local_end.
-        const double elapsed_time = step_time;
-        if (step_time >= MAX_PRINT_TIME) {
-            if (is_pressure_advance_reached_end(*step_generator.pa_state)) {
-                assert(step_generator.pa_state->current_move->move_t == MAX_PRINT_TIME);
-                next_step_event.time = step_generator.pa_state->current_move->print_time + step_generator.pa_state->current_move->move_t;
-            } else {
-                next_step_event.time = pressure_advance_step_time_of_next_sample(*step_generator.pa_state, PressureAdvance::pressure_advance_params);
-            }
+        if (const move_t *next_move = PreciseStepping::move_segment_queue_next_move(*step_generator.pa_state->current_move); next_move != nullptr) {
+            // We are ensuring that the ending empty move segment is always the last move segment in the queue.
+            // So we never step into this branch when current_move is pointing to the ending empty move segment.
+            assert(!is_ending_empty_move(*step_generator.pa_state->current_move));
 
-            if (next_move = PreciseStepping::move_segment_queue_next_move(*step_generator.pa_state->current_move); next_move != nullptr) {
-                // We are ensuring that the ending empty move segment is always the last move segment in the queue.
-                // So we never step into this branch when current_move is pointing to the ending empty move segment.
-                assert(!is_ending_empty_move(*step_generator.pa_state->current_move));
+            next_step_event.flags |= STEP_EVENT_FLAG_KEEP_ALIVE;
+            next_step_event.status = STEP_EVENT_INFO_STATUS_GENERATED_KEEP_ALIVE;
 
-                // We have to update start_post before we reset the pressure advance position because
-                // we are using it during the resetting position.
-                if (is_pressure_advance_active(*next_move)) {
-                    step_generator.pa_state->start_pos = float(get_move_start_pos(*next_move, step_generator.axis)) + float(get_move_start_v(*next_move, step_generator.axis)) * PressureAdvance::pressure_advance_params.pressure_advance_value;
-                } else {
-                    step_generator.pa_state->start_pos = float(get_move_start_pos(*next_move, step_generator.axis));
-                }
+            // We have to update start_post before we reset the pressure advance position because
+            // we are using it during the resetting position.
+            if (is_pressure_advance_active(*next_move)) {
+                step_generator.pa_state->start_pos = float(get_move_start_pos(*next_move, step_generator.axis)) + float(get_move_start_v(*next_move, step_generator.axis)) * PressureAdvance::pressure_advance_params.pressure_advance_value;
+            } else {
+                step_generator.pa_state->start_pos = float(get_move_start_pos(*next_move, step_generator.axis));
+            }
 
-                // Apply reset of position on the pressure advance data structure and adjust position in steps (current_distance).
-                if (next_move->flags & (MOVE_FLAG_RESET_POSITION_X << step_generator.axis)) {
-                    pressure_advance_reset_position(step_generator, step_generator_state, *next_move);
-                }
+            // Apply reset of position on the pressure advance data structure and adjust position in steps (current_distance).
+            if (next_move->flags & (MOVE_FLAG_RESET_POSITION_X << step_generator.axis)) {
+                pressure_advance_reset_position(step_generator, step_generator_state, *next_move);
+            }
 
-                --step_generator.pa_state->current_move->reference_cnt;
-                step_generator.pa_state->current_move = next_move;
-                ++step_generator.pa_state->current_move->reference_cnt;
+            --step_generator.pa_state->current_move->reference_cnt;
+            step_generator.pa_state->current_move = next_move;
+            ++step_generator.pa_state->current_move->reference_cnt;
 
-                step_generator.pa_state->local_sample_idx = 0;
-                step_generator.pa_state->local_sample_time_left = std::max(float((step_generator.pa_state->total_sample_idx * PressureAdvance::pressure_advance_params.sampling_rate) - step_generator.pa_state->current_move->print_time), 0.f);
+            step_generator.pa_state->local_sample_idx = 0;
+            step_generator.pa_state->local_sample_time_left = std::max(float((step_generator.pa_state->total_sample_idx * PressureAdvance::pressure_advance_params.sampling_rate) - step_generator.pa_state->current_move->print_time), 0.f);
 
-                pressure_advance_precalculate_parameters(step_generator, PressureAdvance::pressure_advance_params);
+            pressure_advance_precalculate_parameters(step_generator, PressureAdvance::pressure_advance_params);
 
-                PreciseStepping::move_segment_processed_handler();
-            } else {
+            PreciseStepping::move_segment_processed_handler();
+        } else {
 #ifndef NDEBUG
-                step_generator.pa_state->position_has_to_be_in_range = false;
+            step_generator.pa_state->position_has_to_be_in_range = false;
 #endif
-            }
-        } else {
-            // If the condition above is met, then definitely this axis is active.
-            // And because we always set the bit to a high value, we don't need to clear it.
-            step_generator_state.flags |= (STEP_EVENT_FLAG_X_ACTIVE << step_generator.axis);
-
-            next_step_event.time = elapsed_time;
-            next_step_event.flags = STEP_EVENT_FLAG_STEP_X << step_generator.axis;
-            next_step_event.flags |= step_generator_state.flags;
-            next_step_event.status = STEP_EVENT_INFO_STATUS_GENERATED_VALID;
-            step_generator_state.current_distance[step_generator.axis] += (step_generator.pa_state->step_dir ? 1 : -1);
-            break;
         }
-    } while (next_move != nullptr);
+    } else {
+        // If the condition above is met, then definitely this axis is active.
+        // And because we always set the bit to a high value, we don't need to clear it.
+        step_generator_state.flags |= (STEP_EVENT_FLAG_X_ACTIVE << step_generator.axis);
+
+        next_step_event.time = elapsed_time;
+        next_step_event.flags = STEP_EVENT_FLAG_STEP_X << step_generator.axis;
+        next_step_event.flags |= step_generator_state.flags;
+        next_step_event.status = STEP_EVENT_INFO_STATUS_GENERATED_VALID;
+        step_generator_state.current_distance[step_generator.axis] += (step_generator.pa_state->step_dir ? 1 : -1);
+    }
 
     return next_step_event;
 }
diff --git a/lib/Marlin/Marlin/src/feature/pressure_advance/pressure_advance.hpp b/lib/Marlin/Marlin/src/feature/pressure_advance/pressure_advance.hpp
index d97b6778be..7d9f584e35 100644
--- a/lib/Marlin/Marlin/src/feature/pressure_advance/pressure_advance.hpp
+++ b/lib/Marlin/Marlin/src/feature/pressure_advance/pressure_advance.hpp
@@ -10,13 +10,9 @@
  */
 #pragma once
 #include "pressure_advance_config.hpp"
+#include "../precise_stepping/fwdecl.hpp"
 #include "../../core/types.h"
 
-struct move_t;
-struct step_event_info_t;
-struct step_generator_state_t;
-struct pressure_advance_step_generator_t;
-
 // #define PRESSURE_ADVANCE_SIMPLE_WINDOW_FILTER // Use one value filter instead of the Bartlett window.
 
 constexpr const uint16_t PRESSURE_ADVANCE_MAX_FILTER_LENGTH = 41;
diff --git a/lib/Marlin/Marlin/src/gcode/calibrate/G28.cpp b/lib/Marlin/Marlin/src/gcode/calibrate/G28.cpp
index 6f608c8f04..31f475832d 100644
--- a/lib/Marlin/Marlin/src/gcode/calibrate/G28.cpp
+++ b/lib/Marlin/Marlin/src/gcode/calibrate/G28.cpp
@@ -98,6 +98,7 @@ static inline void MINDA_BROKEN_CABLE_DETECTION__END() {}
 #include "../../core/debug_out.h"
 
 #include "../../../../../../src/common/trinamic.h" // for disabling Wave Table during homing
+#include <feature/phase_stepping/phase_stepping.hpp> // for disabling phase stepping during homing
 
 #if ENABLED(QUICK_HOME)
 
@@ -580,6 +581,9 @@ bool GcodeSuite::G28_no_parser(bool always_home_all, bool O, float R, bool S, bo
 
   TERN_(HAS_DUPLICATION_MODE, set_duplication_enabled(false));
 
+  // Disable phase stepping just before homing XY. This will synchronize only if needed
+  phase_stepping::EnsureSuitableForHoming phstep_disabler;
+
   // Homing feedrate
   float fr_mm_s = no_change ? feedrate_mm_s : 0.0f;
   remember_feedrate_scaling_off();
@@ -847,6 +851,9 @@ bool GcodeSuite::G28_no_parser(bool always_home_all, bool O, float R, bool S, bo
 
   endstops.not_homing();
 
+  // Restore previous phase stepping state before we move again
+  phstep_disabler.release();
+
   if (!failed) {
     // Clear endstop state for polled stallGuard endstops
     TERN_(SPI_ENDSTOPS, endstops.clear_endstop_state());
diff --git a/lib/Marlin/Marlin/src/gcode/calibrate/M958.cpp b/lib/Marlin/Marlin/src/gcode/calibrate/M958.cpp
index d84fd46bf8..dbf3f2939d 100644
--- a/lib/Marlin/Marlin/src/gcode/calibrate/M958.cpp
+++ b/lib/Marlin/Marlin/src/gcode/calibrate/M958.cpp
@@ -115,23 +115,6 @@ class HarmonicGenerator {
     bool m_dir_forward;
 };
 
-/**
- * Turns automatic reports off until destructor is called.
- * Then it sets reports to previous value.
- */
-class Temporary_Report_Off {
-    bool suspend_reports = false;
-
-public:
-    Temporary_Report_Off() {
-        suspend_reports = suspend_auto_report;
-        suspend_auto_report = true;
-    }
-    ~Temporary_Report_Off() {
-        suspend_auto_report = suspend_reports;
-    }
-};
-
 class StepDir {
 public:
     static constexpr float m_ticks_per_second = STEPPER_TIMER_RATE;
@@ -410,7 +393,7 @@ vibrate_measure(StepEventFlag_t axis_flag, bool klipper_mode, float frequency_re
     const uint32_t samples_to_collect = period * cycles / sample_period;
     bool enough_samples_collected = false;
     bool first_loop = true;
-    Temporary_Report_Off stop_busy_messages;
+    TEMPORARY_AUTO_REPORT_OFF(suspend_auto_report);
 #ifdef M958_OUTPUT_SAMPLES
     SERIAL_ECHOLN("Yraw  sinf cosf");
 #endif
@@ -1030,7 +1013,7 @@ static void klipper_tune(const bool subtract_excitation, const StepEventFlag_t a
         psd.put(psd_xyz);
     }
 
-    Temporary_Report_Off stop_busy_messages;
+    TEMPORARY_AUTO_REPORT_OFF(suspend_auto_report);
 
     if (subtract_excitation) {
         SERIAL_ECHOLN("Excitation subtracted power spectrum density");
diff --git a/lib/Marlin/Marlin/src/gcode/feature/phase_stepping/M970-M977.cpp b/lib/Marlin/Marlin/src/gcode/feature/phase_stepping/M970-M977.cpp
new file mode 100644
index 0000000000..fb1269986c
--- /dev/null
+++ b/lib/Marlin/Marlin/src/gcode/feature/phase_stepping/M970-M977.cpp
@@ -0,0 +1,539 @@
+#include <gcode/gcode.h>
+#include <module/planner.h>
+#include <module/prusa/accelerometer.h>
+
+#include <feature/precise_stepping/precise_stepping.hpp>
+#include <feature/phase_stepping/phase_stepping.hpp>
+#include <feature/phase_stepping/calibration.hpp>
+
+#include <log.h>
+#include <vector>
+#include <string_view>
+#include <config_store/store_instance.hpp>
+
+LOG_COMPONENT_REF(PhaseStepping);
+
+using namespace std::literals;
+using phase_stepping::opts::SERIAL_DECIMALS;
+
+static constexpr std::array<std::pair<AxisEnum, char>, 2> SUPPORTED_AXES = {
+    { { X_AXIS, 'X' }, { Y_AXIS, 'Y' } }
+};
+
+// This is lambda on purpose so it can be passed around
+static auto print_error = [](auto... args) {
+    serial_error_start();
+    (SERIAL_ECHO(args), ...);
+    SERIAL_CHAR('\n');
+};
+
+static bool is_one_of(char c, std::string_view sv) {
+    for (char x : sv) {
+        if (c == x) {
+            return true;
+        }
+    }
+    return false;
+}
+
+/**
+ * @brief Enable phase stepping for axis
+ *
+ * - valid axes X, Y
+ */
+void GcodeSuite::M970() {
+    planner.synchronize();
+    for (auto [axis, letter] : SUPPORTED_AXES) {
+        if (!parser.seen(letter)) {
+            continue;
+        }
+        phase_stepping::enable(axis, true);
+        config_store().set_phase_stepping_enabled(axis, true);
+    }
+}
+
+/**
+ * @brief Disable phase stepping for axis
+ *
+ * - valid axes X, Y
+ */
+void GcodeSuite::M971() {
+    planner.synchronize();
+    for (auto [axis, letter] : SUPPORTED_AXES) {
+        if (!parser.seen(letter)) {
+            continue;
+        }
+        phase_stepping::enable(axis, false);
+        config_store().set_phase_stepping_enabled(axis, false);
+    }
+}
+
+/**
+ * @brief Retrieve current correction
+ *
+ * Outputs the current correction table in format: `<axis>, <direction>,
+ * <index>, <mag>, <pha>` per line. Multiple axes can be specified.
+ **/
+void GcodeSuite::M972() {
+    for (auto [axis, letter] : SUPPORTED_AXES) {
+        if (!parser.seen(letter)) {
+            continue;
+        }
+        const phase_stepping::AxisState &axis_state = *phase_stepping::axis_states[axis];
+        for (char dir : "FB"sv) {
+            if (!parser.seen(letter)) {
+                continue;
+            }
+
+            const auto &lut = dir == 'F'
+                ? axis_state.forward_current
+                : axis_state.backward_current;
+
+            const auto &table = lut.get_correction();
+            for (size_t i = 0; i != table.size(); i++) {
+                SERIAL_ECHO(letter);
+                SERIAL_ECHO(", ");
+                SERIAL_ECHO(dir);
+                SERIAL_ECHO(", ");
+                SERIAL_ECHO(i);
+                SERIAL_ECHO(", ");
+                SERIAL_PRINT(table[i].mag, SERIAL_DECIMALS);
+                SERIAL_ECHO(", ");
+                SERIAL_PRINT(table[i].pha, SERIAL_DECIMALS);
+                SERIAL_ECHO('\n');
+            }
+        }
+    }
+}
+
+static std::vector<std::pair<float, float>> parse_pairs(std::string_view str) {
+    std::vector<std::pair<float, float>> pairs;
+
+    while (!str.empty()) {
+        size_t comma_pos = str.find(',');
+        if (comma_pos == std::string_view::npos) {
+            print_error("Malformed input: missing comma");
+            return {}; // Return an empty vector on error
+        }
+
+        char *end_ptr;
+        float first = std::strtod(str.data(), &end_ptr);
+        if (end_ptr != str.data() + comma_pos) {
+            print_error("Malformed input: unable to parse first value of a pair");
+            return {}; // Return an empty vector on error
+        }
+
+        str.remove_prefix(comma_pos + 1);
+
+        size_t space_pos = str.find(' ');
+
+        float second = std::strtod(str.data(), &end_ptr);
+        auto expected_end_ptr = space_pos != std::string_view::npos ? str.data() + space_pos : str.data() + str.size();
+        if (end_ptr != expected_end_ptr) {
+            print_error("Malformed input: unable to parse second value of a pair");
+            return {}; // Return an empty vector on error
+        }
+
+        pairs.emplace_back(first, second);
+
+        str.remove_prefix(space_pos != std::string_view::npos ? space_pos + 1 : str.size());
+    }
+
+    return pairs;
+}
+
+/**
+ * @brief Set single entry for the current correction table.
+ *
+ * Parameters: String argument in format: <X/Y><F/B><list of mag,phase pairs separated by space>
+ **/
+void GcodeSuite::M973() {
+    std::string_view str_arg { parser.string_arg };
+    if (str_arg.size() < 3 || !is_one_of(str_arg[0], "XY") || !is_one_of(str_arg[1], "FB")) {
+        print_error("Invalid format; should be <X/Y><F/B><list of mag,phase pairs separated by space");
+    }
+
+    AxisEnum axis = str_arg[0] == 'X' ? AxisEnum::X_AXIS : AxisEnum::Y_AXIS;
+    phase_stepping::AxisState &axis_state = *phase_stepping::axis_states[axis];
+    const bool forward_correction { str_arg[1] == 'F' };
+    auto &lut = forward_correction
+        ? axis_state.forward_current
+        : axis_state.backward_current;
+
+    str_arg.remove_prefix(2);
+    auto data = parse_pairs(str_arg);
+
+    if (data.empty()) {
+        return;
+    }
+
+    lut.modify_correction([&](auto &table) {
+        for (size_t n = 0; n != table.size(); n++) {
+            if (n < data.size()) {
+                SERIAL_ECHO("Setting ");
+                SERIAL_ECHO(n);
+                SERIAL_ECHO(": ");
+                SERIAL_ECHO(data[n].first);
+                SERIAL_ECHO(", ");
+                SERIAL_ECHOLN(data[n].second);
+                table[n] = phase_stepping::SpectralItem {
+                    .mag = data[n].first,
+                    .pha = data[n].second
+                };
+            } else {
+                table[n] = phase_stepping::SpectralItem {
+                    .mag = 0,
+                    .pha = 0
+                };
+            }
+        }
+    });
+
+    phase_stepping::save_correction_to_file(lut, phase_stepping::get_correction_file_path(axis, forward_correction ? phase_stepping::CorrectionType::forward : phase_stepping::CorrectionType::backward));
+}
+
+template <typename YieldError>
+static bool accelerometer_ok(PrusaAccelerometer &acc, YieldError yield_error) {
+    PrusaAccelerometer::Error error = acc.get_error();
+    switch (error) {
+    case PrusaAccelerometer::Error::none:
+        return true;
+    case PrusaAccelerometer::Error::communication:
+        yield_error("accelerometer communication");
+        return false;
+    case PrusaAccelerometer::Error::no_active_tool:
+        yield_error("no active tool");
+        return false;
+    case PrusaAccelerometer::Error::busy:
+        yield_error("busy");
+        return false;
+#if HAS_REMOTE_ACCELEROMETER()
+    case PrusaAccelerometer::Error::corrupted_dwarf_overflow:
+        yield_error("dwarf overflow");
+        return false;
+    case PrusaAccelerometer::Error::corrupted_transmission_error:
+        yield_error("dwarf transmission error");
+        return false;
+#endif
+    case PrusaAccelerometer::Error::corrupted_buddy_overflow:
+        yield_error("buddy overflow");
+        return false;
+    case PrusaAccelerometer::Error::corrupted_sample_overrun:
+        yield_error("overrun");
+        return false;
+    }
+    bsod("Unrecognized accelerometer error");
+}
+
+/**
+ * @brief Measure print head resonance
+ *
+ * Parameters:
+ * - X/Y - choose motor to use
+ * - F   - motion speed in rev/sec
+ * - R   - number of revolutions
+ *
+ * Outputs raw accelerometer sample <seq>, <X>, <Y>, <Z> per line and real
+ * sampling frequency of the accelerometer as "sample freq: <freq>".
+ **/
+void GcodeSuite::M974() {
+    TEMPORARY_AUTO_REPORT_OFF(suspend_auto_report);
+
+    bool valid = true;
+
+    for (char required : "FR"sv) {
+        if (parser.seenval(required)) {
+            continue;
+        }
+        valid = false;
+        print_error("Missing ", required, "-parameter");
+    }
+
+    int axes_count = 0;
+    for (auto [axis, letter] : SUPPORTED_AXES) {
+        if (parser.seen(letter)) {
+            axes_count++;
+        }
+    }
+    if (axes_count != 1) {
+        print_error("Exactly one axis has to be specified");
+        valid = false;
+    }
+
+    auto axis = parser.seen('X') ? AxisEnum::X_AXIS : AxisEnum::Y_AXIS;
+
+    auto enable_mask = PHASE_STEPPING_GENERATOR_X << axis;
+    if (!(PreciseStepping::physical_axis_step_generator_types & enable_mask)) {
+        print_error("Phase stepping is not enabled");
+        valid = false;
+    }
+
+    if (parser.floatval('F') <= 0) {
+        print_error("Speed has to be positive");
+        valid = false;
+    }
+
+    if (!valid) {
+        print_error("Invalid parameters, no effect");
+        return;
+    }
+
+    double frequency = phase_stepping::capture_samples(
+        axis,
+        parser.floatval('F'),
+        parser.floatval('R'),
+        [sampleNum = 0](const PrusaAccelerometer::Acceleration &sample) mutable {
+            SERIAL_ECHO(sampleNum);
+            SERIAL_ECHO(", ");
+            SERIAL_ECHO(sample.val[0]);
+            SERIAL_ECHO(", ");
+            SERIAL_ECHO(sample.val[1]);
+            SERIAL_ECHO(", ");
+            SERIAL_ECHOLN(sample.val[2]);
+            sampleNum++;
+        });
+    SERIAL_ECHO("sample freq: ");
+    SERIAL_ECHOLN(frequency);
+}
+
+/**
+ * @brief Measure dwarf accelerometer sampling frequency
+ *
+ * Outputs sampling frequency of the accelerometer as "sample freq: <freq>".
+ **/
+void GcodeSuite::M975() {
+    PrusaAccelerometer accelerometer;
+    if (!accelerometer_ok(accelerometer, print_error)) {
+        return;
+    }
+
+    constexpr int request_samples_num = 3'000;
+
+    auto report = [sampleNum = 0](const PrusaAccelerometer::Acceleration &sample) mutable {
+        SERIAL_ECHO(sampleNum);
+        SERIAL_ECHO(", ");
+        SERIAL_ECHO(sample.val[0]);
+        SERIAL_ECHO(", ");
+        SERIAL_ECHO(sample.val[1]);
+        SERIAL_ECHO(", ");
+        SERIAL_ECHOLN(sample.val[2]);
+        sampleNum++;
+    };
+
+    for (int i = 0; i < request_samples_num;) {
+        PrusaAccelerometer::Acceleration measured_acceleration;
+        const int samples = accelerometer.get_sample(measured_acceleration);
+        if (samples) {
+            ++i;
+            report(measured_acceleration);
+        } else {
+            idle(true, true);
+        }
+    }
+
+    accelerometer_ok(accelerometer, print_error);
+    SERIAL_ECHO("sample freq: ");
+    SERIAL_ECHOLN(accelerometer.get_sampling_rate());
+}
+
+/**
+ * @brief Measure print head resonance
+ *
+ * Parameters:
+ * - X/Y - choose motor to use
+ * - F   - motion speed in rev/sec
+ * - R   - number of revolutions
+ *
+ * Outputs frequency response
+ **/
+void GcodeSuite::M976() {
+    TEMPORARY_AUTO_REPORT_OFF(suspend_auto_report);
+
+    bool valid = true;
+
+    for (char required : "FR"sv) {
+        if (parser.seenval(required)) {
+            continue;
+        }
+        valid = false;
+        print_error("Missing ", required, "-parameter");
+    }
+
+    int axes_count = 0;
+    for (auto [axis, letter] : SUPPORTED_AXES) {
+        if (parser.seen(letter)) {
+            axes_count++;
+        }
+    }
+    if (axes_count != 1) {
+        print_error("Exactly one axis has to be specified");
+        valid = false;
+    }
+
+    auto axis = parser.seen('X') ? AxisEnum::X_AXIS : AxisEnum::Y_AXIS;
+
+    auto enable_mask = PHASE_STEPPING_GENERATOR_X << axis;
+    if (!(PreciseStepping::physical_axis_step_generator_types & enable_mask)) {
+        print_error("Phase stepping is not enabled");
+        valid = false;
+    }
+
+    if (parser.floatval('F') <= 0) {
+        print_error("Speed has to be positive");
+        valid = false;
+    }
+
+    if (!valid) {
+        print_error("Invalid parameters, no effect");
+        return;
+    }
+
+    auto analysis = phase_stepping::analyze_resonance(
+        axis, parser.floatval('F'), parser.floatval('R'),
+        { { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 } });
+
+    if (analysis.empty()) {
+        print_error("Unsuccessful data capture");
+    }
+
+    for (std::size_t i = 0; i != analysis.size(); i++) {
+        SERIAL_ECHO(i);
+        SERIAL_ECHO(": ");
+        SERIAL_ECHOLN(analysis[i]);
+    }
+}
+
+class GCodeCalibrationReporter : public phase_stepping::CalibrationReporterBase {
+    std::vector<std::tuple<float, float>> _calibration_results;
+
+public:
+    void set_calibration_phases_count(int phases) override {
+        phase_stepping::CalibrationReporterBase::set_calibration_phases_count(phases);
+        _calibration_results.resize(phases);
+    }
+
+    void on_initial_movement() override {
+        SERIAL_ECHOLN("Moving to calibration position");
+    }
+
+    void on_calibration_phase_progress(int progress) override {
+        SERIAL_ECHO("Phase ");
+        SERIAL_ECHO(_current_calibration_phase + 1);
+        SERIAL_ECHO("/");
+        SERIAL_ECHO(_calibration_phases_count);
+        SERIAL_ECHO(": ");
+        SERIAL_ECHO(progress);
+        SERIAL_ECHOLN("%");
+    }
+
+    void on_calibration_phase_result(float forward_score, float backward_score) override {
+        _calibration_results[_current_calibration_phase] = { forward_score, backward_score };
+        SERIAL_ECHO("Phase ");
+        SERIAL_ECHO(_current_calibration_phase + 1);
+        SERIAL_ECHO(" done. Vibration reduced by: ");
+        SERIAL_ECHO(100.f - forward_score * 100.f);
+        SERIAL_ECHO("%, ");
+        SERIAL_ECHO(100.f - backward_score * 100.f);
+        SERIAL_ECHO("%\n");
+    };
+
+    void on_termination() override {
+        SERIAL_ECHOLN("Calibration done");
+
+#if PRINTER_IS_PRUSA_XL
+        SERIAL_ECHO("Overall score parameter 1: ");
+        auto [p1_f, p1_b] = _calibration_results[0];
+        auto [p3_f, p3_b] = _calibration_results[2];
+        SERIAL_ECHO(100.f * (1.f - p1_f * p3_f));
+        SERIAL_ECHO("%, ");
+        SERIAL_ECHO(100.f * (1.f - p1_b * p3_b));
+        SERIAL_ECHO("%\n");
+
+        SERIAL_ECHO("Overall score parameter 2: ");
+        auto [p2_f, p2_b] = _calibration_results[1];
+        auto [p4_f, p4_b] = _calibration_results[3];
+        SERIAL_ECHO(100.f * (1.f - p2_f * p4_f));
+        SERIAL_ECHO("%, ");
+        SERIAL_ECHO(100.f * (1.f - p2_b * p4_b));
+        SERIAL_ECHO("%\n");
+        phase_stepping::last_calibration_result = phase_stepping::CalibrationResult::make_known(
+            phase_stepping::CalibrationResult::Scores {
+                .p1f = p1_f * p3_f,
+                .p1b = p1_b * p3_b,
+                .p2f = p2_f * p4_f,
+                .p2b = p2_b * p4_b,
+            });
+#endif
+    }
+};
+
+/**
+ * @brief Calibrate motor
+ *
+ * Parameters:
+ * - X/Y - choose motor to use
+ *
+ * Calibrates given motor and sets the newly found compensation.
+ **/
+void GcodeSuite::M977() {
+    TEMPORARY_AUTO_REPORT_OFF(suspend_auto_report);
+    phase_stepping::last_calibration_result = phase_stepping::CalibrationResult::make_error();
+
+    bool valid = true;
+
+    int axes_count = 0;
+    for (auto [axis, letter] : SUPPORTED_AXES) {
+        if (parser.seen(letter)) {
+            axes_count++;
+        }
+    }
+    if (axes_count != 1) {
+        print_error("Exactly one axis has to be specified");
+        valid = false;
+    }
+
+    auto axis = parser.seen('X') ? AxisEnum::X_AXIS : AxisEnum::Y_AXIS;
+
+    if (!valid) {
+        print_error("Invalid parameters, no effect");
+        return;
+    }
+
+    SERIAL_ECHO("Axis: ");
+    SERIAL_ECHOLN(axis);
+
+    G28_no_parser( // home
+        true, // always_home_all
+        true, // home only if needed,
+        3, // raise Z by 3 mm
+        false, // S-parameter,
+        true, true, false // home X, Y but not Z
+    );
+    Planner::synchronize();
+
+    GCodeCalibrationReporter reporter;
+    auto result = phase_stepping::calibrate_axis(axis, reporter);
+
+    if (!result.has_value()) {
+        print_error("Calibration failed");
+        return;
+    }
+
+    auto [forward, backward] = *result;
+
+    for (size_t i = 0; i != forward.size(); i++) {
+        SERIAL_ECHO(i);
+        SERIAL_ECHO(": F");
+        SERIAL_PRINT(forward[i].mag, SERIAL_DECIMALS);
+        SERIAL_ECHO(",");
+        SERIAL_PRINT(forward[i].pha, SERIAL_DECIMALS);
+        SERIAL_ECHO(" B");
+        SERIAL_PRINT(backward[i].mag, SERIAL_DECIMALS);
+        SERIAL_ECHO(",");
+        SERIAL_PRINT(backward[i].pha, SERIAL_DECIMALS);
+        SERIAL_ECHO("\n");
+    }
+
+    phase_stepping::save_correction_to_file(phase_stepping::axis_states[axis]->forward_current, phase_stepping::get_correction_file_path(axis, phase_stepping::CorrectionType::forward));
+    phase_stepping::save_correction_to_file(phase_stepping::axis_states[axis]->backward_current, phase_stepping::get_correction_file_path(axis, phase_stepping::CorrectionType::backward));
+}
diff --git a/lib/Marlin/Marlin/src/gcode/gcode.cpp b/lib/Marlin/Marlin/src/gcode/gcode.cpp
index 7087b8daf6..c9d0d1ee94 100644
--- a/lib/Marlin/Marlin/src/gcode/gcode.cpp
+++ b/lib/Marlin/Marlin/src/gcode/gcode.cpp
@@ -206,9 +206,9 @@ void GcodeSuite::get_destination_from_command() {
 /**
  * Dwell waits immediately. It does not synchronize. Use M400 instead of G4
  */
-void GcodeSuite::dwell(millis_t time) {
+void GcodeSuite::dwell(millis_t time, bool no_stepper_delay) {
   time += millis();
-  while (!planner.draining() && PENDING(millis(), time)) idle(true);
+  while (!planner.draining() && PENDING(millis(), time)) idle(true, no_stepper_delay);
 }
 
 /**
@@ -907,6 +907,17 @@ void GcodeSuite::process_parsed_command(const bool no_ok/*=false*/) {
         case 959: M959(); break;
       #endif
 
+      #if HAS_PHASE_STEPPING()
+        case 970: M970(); break;
+        case 971: M971(); break;
+        case 972: M972(); break;
+        case 973: M973(); break;
+        case 974: M974(); break;
+        case 975: M975(); break;
+        case 976: M976(); break;
+        case 977: M977(); break;
+      #endif
+
       #if ENABLED(Z_STEPPER_AUTO_ALIGN)
         case 422: M422(); break;                                  // M422: Set Z Stepper automatic alignment position using probe
       #endif
diff --git a/lib/Marlin/Marlin/src/gcode/gcode.h b/lib/Marlin/Marlin/src/gcode/gcode.h
index 381a6f3f69..023108e576 100644
--- a/lib/Marlin/Marlin/src/gcode/gcode.h
+++ b/lib/Marlin/Marlin/src/gcode/gcode.h
@@ -275,6 +275,14 @@
  * M928 - Start SD logging: "M928 filename.gco". Stop with M29. (Requires SDSUPPORT)
  * M958 - Excite harmonic vibration and measure amplitude
  * M959 - Tune input shaper
+ * M970 - Enable phase stepping
+ * M971 - Disable phase stepping
+ * M972 - Read phase stepping lookup table
+ * M973 - Write phase stepping lookup table
+ * M974 - Measure print head resonances and return raw data
+ * M975 - Measure accelerometer sampling rate
+ * M976 - Measure print head resonances and return analyzed data
+ * M977 - Calibrate motor for phase stepping
  * M997 - Perform in-application firmware update
  * M999 - Restart after being stopped by error
  *
@@ -290,6 +298,8 @@
 #include <option/has_local_accelerometer.h>
 #include <option/has_remote_accelerometer.h>
 
+#include <option/has_phase_stepping.h>
+
 #if ENABLED(I2C_POSITION_ENCODERS)
   #include "../feature/I2CPositionEncoder.h"
 #endif
@@ -392,7 +402,9 @@ class GcodeSuite {
     #define KEEPALIVE_STATE(N) NOOP
   #endif
 
-  static void dwell(millis_t time);
+  // Dwell waits immediately with low precision (+10ms depending on GUI/background activities)
+  // while allowing background processing. It does not synchronize.
+  static void dwell(millis_t time, bool no_stepper_sleep=false);
 
   /**
    * @brief Home.
@@ -1000,6 +1012,17 @@ class GcodeSuite {
   static void M959();
 #endif
 
+#if HAS_PHASE_STEPPING()
+  static void M970();
+  static void M971();
+  static void M972();
+  static void M973();
+  static void M974();
+  static void M975();
+  static void M976();
+  static void M977();
+#endif
+
   #if ENABLED(PLATFORM_M997_SUPPORT)
     static void M997();
   #endif
diff --git a/lib/Marlin/Marlin/src/gcode/parser.cpp b/lib/Marlin/Marlin/src/gcode/parser.cpp
index ab1438777b..f3efa94f26 100644
--- a/lib/Marlin/Marlin/src/gcode/parser.cpp
+++ b/lib/Marlin/Marlin/src/gcode/parser.cpp
@@ -230,7 +230,7 @@ void GCodeParser::parse(char *p) {
     #if ENABLED(EXPECTED_PRINTER_CHECK)
       case 16:
     #endif
-    case 23: case 28: case 30: case 117: case 118: case 928: string_arg = p; return;
+    case 23: case 28: case 30: case 117: case 118: case 973: case 928: string_arg = p; return;
     default: break;
   }
   #if ENABLED(REDIRECT_GCODE_SUPPORT)
diff --git a/lib/Marlin/Marlin/src/module/planner.h b/lib/Marlin/Marlin/src/module/planner.h
index ad14d7b6f9..bd4ff7e734 100644
--- a/lib/Marlin/Marlin/src/module/planner.h
+++ b/lib/Marlin/Marlin/src/module/planner.h
@@ -35,6 +35,7 @@
 #include "motion.h"
 #include "../gcode/queue.h"
 #include "../feature/precise_stepping/precise_stepping.hpp"
+#include "../feature/phase_stepping/phase_stepping.hpp"
 
 // Value by which steps are multiplied to increase the precision of the Planner.
 constexpr const int PLANNER_STEPS_MULTIPLIER = 4;
@@ -856,7 +857,7 @@ class Planner {
     /**
      * Return if some processing is still pending before all queues are flushed
      */
-    FORCE_INLINE static bool processing() { return has_blocks_queued() || PreciseStepping::processing(); }
+    FORCE_INLINE static bool processing() { return has_blocks_queued() || PreciseStepping::processing() || phase_stepping::processing(); }
 
     /**
      * Returns the current block that PreciseStepping already processed and that is waiting for discarding,
diff --git a/lib/Marlin/Marlin/src/module/prusa/accelerometer.h b/lib/Marlin/Marlin/src/module/prusa/accelerometer.h
index 650c92602f..f0ece4e920 100644
--- a/lib/Marlin/Marlin/src/module/prusa/accelerometer.h
+++ b/lib/Marlin/Marlin/src/module/prusa/accelerometer.h
@@ -58,14 +58,17 @@ class PrusaAccelerometer {
 
     void clear();
     int get_sample(Acceleration &acceleration);
+    float get_sampling_rate() const { return m_sampling_rate; }
     Error get_error() { return m_error; }
 
 #if HAS_REMOTE_ACCELEROMETER()
     static void put_sample(common::puppies::fifo::AccelerometerXyzSample sample);
     static void mark_corrupted(const Error error);
+    static void set_rate(float rate);
 #endif
 private:
     static Error m_error;
+    static float m_sampling_rate;
 #if HAS_LOCAL_ACCELEROMETER()
     Fifo m_fifo;
 #elif HAS_REMOTE_ACCELEROMETER()
diff --git a/lib/Marlin/Marlin/src/module/prusa/accelerometer_local.cpp b/lib/Marlin/Marlin/src/module/prusa/accelerometer_local.cpp
index ed2fe903df..028b9332d0 100644
--- a/lib/Marlin/Marlin/src/module/prusa/accelerometer_local.cpp
+++ b/lib/Marlin/Marlin/src/module/prusa/accelerometer_local.cpp
@@ -29,3 +29,4 @@ int PrusaAccelerometer::get_sample(Acceleration &acceleration) {
     return m_fifo.get(acceleration);
 }
 PrusaAccelerometer::Error PrusaAccelerometer::m_error = Error::none;
+float PrusaAccelerometer::m_sampling_rate = 0;
diff --git a/lib/Marlin/Marlin/src/module/prusa/accelerometer_remote.cpp b/lib/Marlin/Marlin/src/module/prusa/accelerometer_remote.cpp
index 3e9b15a879..5e4640eee3 100644
--- a/lib/Marlin/Marlin/src/module/prusa/accelerometer_remote.cpp
+++ b/lib/Marlin/Marlin/src/module/prusa/accelerometer_remote.cpp
@@ -12,6 +12,7 @@ static_assert(HAS_REMOTE_ACCELEROMETER());
 
 freertos::Mutex PrusaAccelerometer::s_buffer_mutex;
 PrusaAccelerometer::Sample_buffer *PrusaAccelerometer::s_sample_buffer = nullptr;
+float PrusaAccelerometer::m_sampling_rate = 0;
 
 /**
  * If this is the first instance of PrusaAccelerometer
@@ -89,6 +90,7 @@ void PrusaAccelerometer::clear() {
     Acceleration acceleration;
     while (get_sample(acceleration))
         ;
+    m_error = Error::none;
 }
 int PrusaAccelerometer::get_sample(Acceleration &acceleration) {
     std::lock_guard lock(s_buffer_mutex);
@@ -120,4 +122,9 @@ void PrusaAccelerometer::mark_corrupted(const Error error) {
         || error == Error::corrupted_sample_overrun);
     m_error = error;
 }
+
+void PrusaAccelerometer::set_rate(float rate) {
+    m_sampling_rate = rate;
+}
+
 PrusaAccelerometer::Error PrusaAccelerometer::m_error = Error::none;
diff --git a/lib/Marlin/Marlin/src/module/prusa/homing_corexy.cpp b/lib/Marlin/Marlin/src/module/prusa/homing_corexy.cpp
index 2fa2ca614b..25946c7ac8 100644
--- a/lib/Marlin/Marlin/src/module/prusa/homing_corexy.cpp
+++ b/lib/Marlin/Marlin/src/module/prusa/homing_corexy.cpp
@@ -14,20 +14,22 @@
 #endif
 #include "bsod.h"
 
+#include "feature/phase_stepping/phase_stepping.hpp"
+
 // convert raw AB steps to XY mm
 void corexy_ab_to_xy(const xy_long_t &steps, xy_pos_t &mm) {
     float x = static_cast<float>(steps.a + steps.b) / 2.f;
     float y = static_cast<float>(CORESIGN(steps.a - steps.b)) / 2.f;
-    mm.x = x / planner.settings.axis_steps_per_mm[0];
-    mm.y = y / planner.settings.axis_steps_per_mm[1];
+    mm.x = x * planner.mm_per_step[X_AXIS];
+    mm.y = y * planner.mm_per_step[Y_AXIS];
 }
 
 // convert raw AB steps to XY mm and position in mini-steps
 static void corexy_ab_to_xy(const xy_long_t &steps, xy_pos_t &mm, xy_long_t &pos_msteps) {
     float x = static_cast<float>(steps.a + steps.b) / 2.f;
     float y = static_cast<float>(CORESIGN(steps.a - steps.b)) / 2.f;
-    mm.x = x / planner.settings.axis_steps_per_mm[0];
-    mm.y = y / planner.settings.axis_steps_per_mm[1];
+    mm.x = x * planner.mm_per_step[X_AXIS];
+    mm.y = y * planner.mm_per_step[Y_AXIS];
     pos_msteps.x = LROUND(x * PLANNER_STEPS_MULTIPLIER);
     pos_msteps.y = LROUND(y * PLANNER_STEPS_MULTIPLIER);
 }
@@ -65,14 +67,27 @@ static void plan_corexy_raw_move(const xy_long_t &target_steps_ab, const feedRat
 
 // TMC µsteps(phase) per Marlin µsteps
 static int16_t phase_per_ustep(const AxisEnum axis) {
-    return 256 / stepper_axis(axis).microsteps();
-}
+    // Originally, we read the microstep configuration from the driver; this no
+    // longer make sense with 256 microsteps.
+    // Thus, we use the printer defaults instead of stepper_axis(axis).microsteps();
+    assert(axis <= AxisEnum::Z_AXIS);
+    static const int MICROSTEPS[] = { X_MICROSTEPS, Y_MICROSTEPS, Z_MICROSTEPS };
+    return 256 / MICROSTEPS[axis];
+};
 
 // TMC full cycle µsteps per Marlin µsteps
 static int16_t phase_cycle_steps(const AxisEnum axis) {
     return 1024 / phase_per_ustep(axis);
 }
 
+static int16_t axis_mscnt(const AxisEnum axis) {
+#if HAS_BURST_STEPPING()
+    return phase_stepping::logical_ustep(axis);
+#else
+    return stepper_axis(axis).MSCNT();
+#endif
+}
+
 static int16_t phase_backoff_steps(const AxisEnum axis) {
     int16_t effectorBackoutDir; // Direction in which the effector mm coordinates move away from endstop.
     int16_t stepperBackoutDir; // Direction in which the TMC µstep count(phase) move away from endstop.
@@ -89,7 +104,7 @@ static int16_t phase_backoff_steps(const AxisEnum axis) {
         bsod("invalid backoff axis");
     }
 
-    int16_t phaseCurrent = stepper_axis(axis).MSCNT(); // The TMC µsteps(phase) count of the current position
+    int16_t phaseCurrent = axis_mscnt(axis); // The TMC µsteps(phase) count of the current position
     int16_t phaseDelta = (0 - phaseCurrent) * stepperBackoutDir;
     if (phaseDelta < 0) {
         phaseDelta += 1024;
@@ -98,8 +113,12 @@ static int16_t phase_backoff_steps(const AxisEnum axis) {
 }
 
 static bool phase_aligned(AxisEnum axis) {
-    int16_t phase_cur = stepper_axis(axis).MSCNT();
+    int16_t phase_cur = axis_mscnt(axis);
     int16_t ustep_max = phase_per_ustep(axis) / 2;
+#if HAS_BURST_STEPPING()
+    // TODO: temporarily allow for one logical phase of change until motion is step-exact
+    ustep_max += phase_per_ustep(axis);
+#endif
     return (phase_cur <= ustep_max || phase_cur >= (1024 - ustep_max));
 }
 
@@ -298,6 +317,9 @@ bool refine_corexy_origin() {
     xy_long_t origin_steps = { stepper.position(A_AXIS) + phase_backoff_steps(A_AXIS),
         stepper.position(B_AXIS) + phase_backoff_steps(B_AXIS) };
     plan_corexy_raw_move(origin_steps, fr_mm_s);
+    if (stepper.position(A_AXIS) != origin_steps[A_AXIS] || stepper.position(B_AXIS) != origin_steps[B_AXIS]) {
+        bsod("raw move didn't reach requested position");
+    }
 
     // sanity checks
     wait_for_standstill(_BV(A_AXIS) | _BV(B_AXIS));
diff --git a/lib/Marlin/Marlin/src/module/prusa/toolchanger.cpp b/lib/Marlin/Marlin/src/module/prusa/toolchanger.cpp
index f36f412fa0..45a5d89449 100644
--- a/lib/Marlin/Marlin/src/module/prusa/toolchanger.cpp
+++ b/lib/Marlin/Marlin/src/module/prusa/toolchanger.cpp
@@ -674,7 +674,7 @@ bool PrusaToolChanger::park(Dwarf &dwarf) {
         }
     }
 
-    move(info.dock_x, SAFE_Y_WITHOUT_TOOL, feedrate_mm_s); // extract tool
+    move(info.dock_x, SAFE_Y_WITHOUT_TOOL, feedrate_mm_s); // release tool
 
     // Wait until dwarf is registering as not picked
     if (!wait(dwarf_not_picked, WAIT_TIME_TOOL_PARKED_PICKED)) {
@@ -761,6 +761,7 @@ bool PrusaToolChanger::pickup(Dwarf &dwarf) {
     move(info.dock_x, SAFE_Y_WITHOUT_TOOL, feedrate_mm_s); // go in front of the tool
     move(info.dock_x, info.dock_y + PICK_Y_OFFSET, feedrate_mm_s); // pre-insert fast the tool
     planner.settings.travel_acceleration = SLOW_ACCELERATION_MM_S2; // low acceleration
+
     move(info.dock_x, info.dock_y, SLOW_MOVE_MM_S); // insert slowly the last mm to allow part fitting + soft touch between TCM and tool thanks to the gentle deceleration
     planner.synchronize();
 
diff --git a/lib/Marlin/Marlin/src/module/stepper.h b/lib/Marlin/Marlin/src/module/stepper.h
index 45ceb8b749..497a39861d 100644
--- a/lib/Marlin/Marlin/src/module/stepper.h
+++ b/lib/Marlin/Marlin/src/module/stepper.h
@@ -49,6 +49,12 @@
   #include "speed_lookuptable.h"
 #endif
 
+#include <option/has_phase_stepping.h>
+
+#if HAS_PHASE_STEPPING()
+  #include "../feature/phase_stepping/phase_stepping.hpp"
+#endif
+
 // Disable multiple steps per ISR
 //#define DISABLE_MULTI_STEPPING
 
@@ -409,7 +415,7 @@ class Stepper {
     // Get the position of a stepper, in steps
     static int32_t position(const AxisEnum axis);
     static int32_t position_from_startup(const AxisEnum axis);
-    
+
     // Report the positions of the steppers, in steps
     static void report_positions();
 
@@ -522,6 +528,32 @@ class Stepper {
       static uint16_t get_LA_steps() { return LA_current_adv_steps; }
     #endif
 
+    static long get_axis_steps(const AxisEnum a) {
+      return count_position[a];
+    }
+
+    static long get_axis_steps_from_startup(const AxisEnum a) {
+      return count_position_from_startup[a];
+    }
+
+    static void set_axis_steps(const AxisEnum a, long steps_made) {
+      count_position[a] = steps_made;
+    }
+
+    static void set_axis_steps_from_startup(const AxisEnum a, long steps_made) {
+      count_position_from_startup[a] = steps_made;
+    }
+
+    static void report_axis_movement(AxisEnum a, float speed) {
+      uint8_t axis_mask = 1 << a;
+      axis_did_move |= axis_mask;
+
+      if (speed > 0)
+        last_direction_bits |= axis_mask;
+      else
+        last_direction_bits &= ~axis_mask;
+    }
+
 private:
 
     // Set the current position in steps
diff --git a/lib/Marlin/Marlin/src/module/stepper/trinamic.cpp b/lib/Marlin/Marlin/src/module/stepper/trinamic.cpp
index ed1dc1652e..0b3449eae9 100644
--- a/lib/Marlin/Marlin/src/module/stepper/trinamic.cpp
+++ b/lib/Marlin/Marlin/src/module/stepper/trinamic.cpp
@@ -37,6 +37,7 @@
     #include <config_store/store_instance.hpp>
 #endif
 
+#include <feature/phase_stepping/phase_stepping.hpp>
 #include <HardwareSerial.h>
 
 
@@ -675,6 +676,8 @@ void restore_trinamic_drivers() {
 }
 
 void reset_trinamic_drivers() {
+  assert(!phase_stepping::any_axis_active());
+
   static constexpr bool stealthchop_by_axis[] = {
     #if ENABLED(STEALTHCHOP_XY)
       true
diff --git a/lib/Marlin/Marlin/src/module/tool_change.cpp b/lib/Marlin/Marlin/src/module/tool_change.cpp
index 81f024f6ae..d19b04e3e1 100644
--- a/lib/Marlin/Marlin/src/module/tool_change.cpp
+++ b/lib/Marlin/Marlin/src/module/tool_change.cpp
@@ -197,7 +197,7 @@ inline void fast_line_to_current(const AxisEnum fr_axis) { _line_to_current(fr_a
     planner.synchronize();
 
     // Delay before moving tool, to allow magnetic coupling
-    gcode.dwell(150);
+    gcode.dwell(150, true);
 
     // STEP 3
 
@@ -265,7 +265,7 @@ inline void fast_line_to_current(const AxisEnum fr_axis) { _line_to_current(fr_a
       default: OUT_WRITE(SOL0_PIN, state); break;
     }
     #if PARKING_EXTRUDER_SOLENOIDS_DELAY > 0
-      gcode.dwell(PARKING_EXTRUDER_SOLENOIDS_DELAY);
+      gcode.dwell(PARKING_EXTRUDER_SOLENOIDS_DELAY, true);
     #endif
   }
 
diff --git a/lib/Middlewares/Third_Party/LwIP/system/arch/cc.h b/lib/Middlewares/Third_Party/LwIP/system/arch/cc.h
index 5a03c526bc..25f4152661 100644
--- a/lib/Middlewares/Third_Party/LwIP/system/arch/cc.h
+++ b/lib/Middlewares/Third_Party/LwIP/system/arch/cc.h
@@ -128,7 +128,7 @@ extern uint8_t __attribute__((section(".ccmram"))) memp_memory_PBUF_base[];
 extern uint8_t __attribute__((section(".ccmram"))) memp_memory_PBUF_POOL_base[];
 #endif
 extern uint8_t __attribute__((section(".ccmram"))) memp_memory_TCPIP_MSG_INPKT_base[];
-extern uint8_t __attribute__((section(".ccmram"))) memp_memory_TCP_PCB_LISTEN_base[];
-extern uint8_t __attribute__((section(".ccmram"))) memp_memory_REASSDATA_base[];
+extern uint8_t memp_memory_TCP_PCB_LISTEN_base[];
+extern uint8_t memp_memory_REASSDATA_base[];
 
 #endif /* __CC_H__ */
diff --git a/lib/TMCStepper/src/TMCStepper.h b/lib/TMCStepper/src/TMCStepper.h
index dee8ecc7be..81947bd00c 100644
--- a/lib/TMCStepper/src/TMCStepper.h
+++ b/lib/TMCStepper/src/TMCStepper.h
@@ -65,7 +65,7 @@ class TMCStepper {
 		void rms_current(uint16_t mA);
 		void rms_current(uint16_t mA, float mult);
 		uint16_t rms_current();
-		void hold_multiplier(float val) { holdMultiplier = val; }
+		void hold_multiplier(float val) { rms_current(rms_current(), val); }
 		float hold_multiplier() { return holdMultiplier; }
 		uint8_t test_connection();
 
@@ -115,14 +115,19 @@ class TMCStepper {
 		int16_t cur_a();
 		int16_t cur_b();
 
-		struct CommunicationLockGuard {
-			CommunicationLockGuard() {
-				if (!tmc_serial_lock_acquire())
+		class CommunicationLockGuard {
+			bool lock;
+
+		public:
+			CommunicationLockGuard(bool lock=true)
+			: lock(lock) {
+				if (lock && !tmc_serial_lock_acquire())
 					abort();
 			}
 
 			~CommunicationLockGuard() {
-				tmc_serial_lock_release();
+				if (lock)
+					tmc_serial_lock_release();
 			}
 		};
 
diff --git a/lib/TMCStepper/src/source/TMC2130Stepper.cpp b/lib/TMCStepper/src/source/TMC2130Stepper.cpp
index 47be53fec6..819e67230d 100644
--- a/lib/TMCStepper/src/source/TMC2130Stepper.cpp
+++ b/lib/TMCStepper/src/source/TMC2130Stepper.cpp
@@ -8,6 +8,7 @@
 #if HAS_PUPPIES() && HAS_TOOLCHANGER()
   #include "module/prusa/toolchanger.h"
 #endif
+#include <feature/phase_stepping/phase_stepping.hpp>
 
 int8_t TMC2130Stepper::chain_length = 0;
 uint32_t TMC2130Stepper::spi_speed = 16000000/8;
@@ -89,7 +90,13 @@ void TMC2130Stepper::switchCSpin(bool state) {
 
 uint32_t TMC2130Stepper::read(uint8_t addressByte) {
 
-  auto lockGuard = TMCStepper::CommunicationLockGuard();
+#if HAS_PUPPIES() && HAS_TOOLCHANGER()
+  const bool localConnection = (connection != Connection::Remote);
+#else
+  const bool localConnection = true;
+#endif
+  auto lockGuard = TMCStepper::CommunicationLockGuard(localConnection);
+
   uint32_t out = 0UL;
   int8_t i = 1;
 
@@ -183,7 +190,12 @@ uint32_t TMC2130Stepper::read(uint8_t addressByte) {
 
 void TMC2130Stepper::write(uint8_t addressByte, uint32_t config) {
 
-  auto lockGuard = TMCStepper::CommunicationLockGuard();
+#if HAS_PUPPIES() && HAS_TOOLCHANGER()
+  const bool localConnection = (connection != Connection::Remote);
+#else
+  const bool localConnection = true;
+#endif
+  auto lockGuard = TMCStepper::CommunicationLockGuard(localConnection);
 
   tmc_register_write_hook(0, addressByte, config);
   addressByte |= TMC_WRITE;
@@ -261,6 +273,17 @@ void TMC2130Stepper::begin() {
 bool TMC2130Stepper::isEnabled() { return !drv_enn_cfg6() && toff(); }
 
 void TMC2130Stepper::push() {
+#if HAS_PHASE_STEPPING() && _DEBUG
+  // This functions can lock the SPI bus for a long time, preventing the phase stepping ISR to run
+  // frequently enough: ensure it's not called on an active axis
+#if HAS_PUPPIES() && HAS_TOOLCHANGER()
+  const bool localConnection = (connection != Connection::Remote);
+#else
+  const bool localConnection = true;
+#endif
+  assert(!phase_stepping::any_axis_active() || !localConnection);
+#endif
+
   GCONF(GCONF_register.sr);
   IHOLD_IRUN(IHOLD_IRUN_register.sr);
   TPOWERDOWN(TPOWERDOWN_register.sr);
diff --git a/src/buddy/main.cpp b/src/buddy/main.cpp
index 634c606a97..e08d6614e5 100644
--- a/src/buddy/main.cpp
+++ b/src/buddy/main.cpp
@@ -44,6 +44,8 @@
 #include <option/has_mmu2.h>
 #include <option/resources.h>
 #include <option/bootloader_update.h>
+#include <option/has_phase_stepping.h>
+#include <option/has_burst_stepping.h>
 #include "tasks.hpp"
 #include <appmain.hpp>
 #include "safe_state.h"
@@ -81,6 +83,10 @@
     #include "hw_configuration.hpp"
 #endif
 
+#if HAS_PHASE_STEPPING()
+    #include <feature/phase_stepping/phase_stepping.hpp>
+#endif
+
 using namespace crash_dump;
 
 LOG_COMPONENT_REF(Buddy);
@@ -239,6 +245,15 @@ extern "C" void main_cpp(void) {
 #if BOARD_IS_BUDDY || BOARD_IS_XBUDDY
     hw_tim1_init();
 #endif
+
+#if HAS_PHASE_STEPPING()
+    hw_tim13_init();
+#endif
+
+#if HAS_BURST_STEPPING()
+    hw_tim8_init();
+#endif
+
     hw_tim14_init();
 
     SPI_INIT(flash);
@@ -468,7 +483,7 @@ extern "C" void main_cpp(void) {
     osThreadCCMDef(media_prefetch, media_prefetch, TASK_PRIORITY_MEDIA_PREFETCH, 0, 1024);
     prefetch_thread_id = osThreadCreate(osThread(media_prefetch), nullptr);
 
-    osThreadCCMDef(defaultTask, StartDefaultTask, TASK_PRIORITY_DEFAULT_TASK, 0, 1024);
+    osThreadCCMDef(defaultTask, StartDefaultTask, TASK_PRIORITY_DEFAULT_TASK, 0, 1152);
     defaultTaskHandle = osThreadCreate(osThread(defaultTask), NULL);
 
 #if ENABLED(POWER_PANIC)
diff --git a/src/common/appmain.cpp b/src/common/appmain.cpp
index ff3695d67c..59c6fc56b8 100644
--- a/src/common/appmain.cpp
+++ b/src/common/appmain.cpp
@@ -333,6 +333,9 @@ void adc_tick_1ms(void) {
 }
 
 void app_tim14_tick(void) {
+    // run sound first, so it is more synchronized
+    Sound_Update1ms();
+
     Fans::tick();
 
 #if HAS_GUI()
@@ -345,7 +348,6 @@ void app_tim14_tick(void) {
     }
 #endif
 
-    Sound_Update1ms();
     adc_tick_1ms();
 
 #if (BOARD_IS_XLBUDDY && FILAMENT_SENSOR_IS_ADC())
diff --git a/src/common/client_response.hpp b/src/common/client_response.hpp
index 8487c48d6c..66c5001020 100644
--- a/src/common/client_response.hpp
+++ b/src/common/client_response.hpp
@@ -18,6 +18,7 @@
 #include "option/filament_sensor.h"
 #include "option/has_toolchanger.h"
 #include <option/has_mmu2.h>
+#include <option/has_phase_stepping.h>
 
 enum { RESPONSE_BITS = 4, // number of bits used to encode response
     MAX_RESPONSES = (1 << RESPONSE_BITS) }; // maximum number of responses in one phase
@@ -289,6 +290,19 @@ enum class PhasesSelftest : uint16_t {
     ToolOffsets_wait_user_remove_pin,
     _last_Tool_Offsets = ToolOffsets_wait_user_remove_pin,
 
+#if HAS_PHASE_STEPPING()
+    _first_PhaseStepping,
+    PhaseStepping_pick_tool = _first_PhaseStepping,
+    PhaseStepping_calib_x,
+    PhaseStepping_calib_y,
+    PhaseStepping_calib_x_nok,
+    PhaseStepping_calib_y_nok,
+    PhaseStepping_calib_error,
+    PhaseStepping_calib_ok,
+    PhaseStepping_enabling,
+    _last_PhaseStepping = PhaseStepping_enabling,
+#endif
+
     _first_Result,
     Result = _first_Result,
     _last_Result = Result,
@@ -585,6 +599,16 @@ class ClientResponses {
         {}, // ToolOffsets_state_final_park
         { Response::Continue }, // ToolOffsets_wait_user_remove_pin
 
+#if HAS_PHASE_STEPPING()
+        {}, // PhaseStepping_pick_tool
+        {}, // PhaseStepping_calib_x
+        {}, // PhaseStepping_calib_y
+        { Response::Ok }, // PhaseStepping_calib_x_nok
+        { Response::Ok }, // PhaseStepping_calib_y_nok
+        { Response::Ok }, // PhaseStepping_calib_error
+        { Response::Ok }, // PhaseStepping_calib_ok
+        {}, // PhaseStepping_enabling
+#endif
         { Response::Next }, // Result
 
         { Response::Continue }, // WizardEpilogue_ok
@@ -722,6 +746,9 @@ enum class SelftestParts {
 #if HAS_TOOLCHANGER()
     Dock,
     ToolOffsets,
+#endif
+#if HAS_PHASE_STEPPING()
+    PhaseStepping,
 #endif
     _none, // cannot be created, must have same index as _count
     _count = _none
@@ -774,6 +801,10 @@ static constexpr PhasesSelftest SelftestGetFirstPhaseFromPart(SelftestParts part
         return PhasesSelftest::_first_Dock;
     case SelftestParts::ToolOffsets:
         return PhasesSelftest::_first_Tool_Offsets;
+#endif
+#if HAS_PHASE_STEPPING()
+    case SelftestParts::PhaseStepping:
+        return PhasesSelftest::_first_PhaseStepping;
 #endif
     case SelftestParts::Result:
         return PhasesSelftest::_first_Result;
@@ -840,6 +871,10 @@ static constexpr PhasesSelftest SelftestGetLastPhaseFromPart(SelftestParts part)
         return PhasesSelftest::_last_Dock;
     case SelftestParts::ToolOffsets:
         return PhasesSelftest::_last_Tool_Offsets;
+#endif
+#if HAS_PHASE_STEPPING()
+    case SelftestParts::PhaseStepping:
+        return PhasesSelftest::_last_PhaseStepping;
 #endif
     case SelftestParts::Result:
         return PhasesSelftest::_last_Result;
diff --git a/src/common/debug_util.hpp b/src/common/debug_util.hpp
new file mode 100644
index 0000000000..5f08e57a99
--- /dev/null
+++ b/src/common/debug_util.hpp
@@ -0,0 +1,64 @@
+#pragma once
+
+#include <tuple>
+#include <cstdint>
+#include "traits.hpp"
+#include "timing.h"
+#include <Pin.hpp>
+
+/**
+ * Invoke a given function only when its arguments have changed or when given
+ * time elapsed.
+ *
+ * Typical usage:
+ * static RateLimited algorithm_reporter(100, [&](int a, int b) {
+ *        log_debug(MyComponent, "Val: %d, %d", a, b);
+ *     });
+ * algorithm_reporter(resul1, result2);
+ **/
+template <typename F>
+class RateLimited {
+    uint32_t _last_ping = 0;
+
+    int _rate_limit_ms;
+    F _job;
+    function_traits<F>::argument_types _args;
+
+public:
+    RateLimited(int rate_limit, F f)
+        : _rate_limit_ms(rate_limit)
+        , _job(f) {}
+
+    template <typename... Args>
+    void operator()(Args... args) {
+        uint32_t now = ticks_ms();
+        auto args_tuple = typename function_traits<F>::argument_types(args...);
+        if (args_tuple != _args || ticks_diff(now, _last_ping) > _rate_limit_ms) {
+            _job(args...);
+            _args = args_tuple;
+            _last_ping = now;
+        }
+    }
+};
+
+struct TrackTimingViaPin {
+    buddy::hw::OutputPin _pin;
+    bool _stopped = false;
+
+    TrackTimingViaPin(auto pin)
+        : _pin(pin) {
+        _pin.write(buddy::hw::Pin::State::high);
+    }
+
+    void stop() {
+        if (_stopped) {
+            return;
+        }
+        _pin.write(buddy::hw::Pin::State::low);
+        _stopped = true;
+    }
+
+    ~TrackTimingViaPin() {
+        stop();
+    }
+};
diff --git a/src/common/hwio_pindef_XL_dwarf.h b/src/common/hwio_pindef_XL_dwarf.h
index ff698d0760..ff5190d5d4 100644
--- a/src/common/hwio_pindef_XL_dwarf.h
+++ b/src/common/hwio_pindef_XL_dwarf.h
@@ -142,7 +142,7 @@ inline Pin::State zMinReadFn() {
     MACRO_FUNCTION(buddy::hw::InputPin, fanPrintTach, BUDDY_PIN(FAN_TACH0), IMode::input COMMA Pull::none, buddy::hw::noHandler) \
     MACRO_FUNCTION(buddy::hw::InputPin, fanHeatBreakTach, BUDDY_PIN(FAN1_TACH0), IMode::input COMMA Pull::none, buddy::hw::noHandler) \
     MACRO_FUNCTION(buddy::hw::OutputPin, acellCs, BUDDY_PIN(ACC_CS), Pin::State::high COMMA OMode::pushPull COMMA OSpeed::high, buddy::hw::noHandler) \
-    MACRO_FUNCTION(buddy::hw::InterruptPin, lis2dh12_data, buddy::hw::IoPort::B COMMA buddy::hw::IoPin::p1, IMode::IT_rising COMMA Pull::down COMMA ISR_PRIORITY_LIS2DH12 COMMA 0 COMMA false, dwarf::accelerometer::irq)
+    MACRO_FUNCTION(buddy::hw::InterruptPin, lis2dh12_data, buddy::hw::IoPort::B COMMA buddy::hw::IoPin::p1, IMode::IT_rising COMMA Pull::down COMMA ISR_PRIORITY_LIS2DH12 COMMA 0, dwarf::accelerometer::irq)
 
 #define VIRTUAL_PIN_TABLE(MACRO_FUNCTION) \
     MACRO_FUNCTION(buddy::hw::VirtualInterruptPin, buddy::hw::zMinReadFn, endstop_ISR, zMin, BUDDY_PIN(Z_MIN), IMode::IT_rising_falling)
diff --git a/src/common/include/dwarf_registers.hpp b/src/common/include/dwarf_registers.hpp
index 8f37198343..7bd87b2c81 100644
--- a/src/common/include/dwarf_registers.hpp
+++ b/src/common/include/dwarf_registers.hpp
@@ -23,7 +23,6 @@ enum class SystemCoil : uint16_t {
     is_selected = 0x4001,
     loadcell_enable = 0x4002,
     accelerometer_enable = 0x4003,
-    accelerometer_high = 0x4004,
 
     _post_last,
     _last = _post_last - 1,
diff --git a/src/common/marlin_server.cpp b/src/common/marlin_server.cpp
index f83047503b..f5dc07cc63 100644
--- a/src/common/marlin_server.cpp
+++ b/src/common/marlin_server.cpp
@@ -783,6 +783,10 @@ void settings_load(void) {
     // TODO: This is temporary until better offset store method is implemented
     prusa_toolchanger.load_tool_offsets();
 #endif
+
+#if HAS_PHASE_STEPPING()
+    phase_stepping::load();
+#endif
 }
 
 void settings_reset(void) {
diff --git a/src/common/selftest/CMakeLists.txt b/src/common/selftest/CMakeLists.txt
index e31338c4ab..d14fa7ba13 100644
--- a/src/common/selftest/CMakeLists.txt
+++ b/src/common/selftest/CMakeLists.txt
@@ -41,6 +41,10 @@ if(FILAMENT_SENSOR STREQUAL ADC)
   target_sources(firmware PRIVATE selftest_fsensor.cpp selftest_fsensor_interface.cpp)
 endif()
 
+if(HAS_PHASE_STEPPING)
+  target_sources(firmware PRIVATE selftest_phase_stepping.cpp selftest_phase_stepping_result.cpp)
+endif()
+
 if(HAS_DWARF)
   target_sources(
     firmware PRIVATE selftest_dock.cpp selftest_dock_interface.cpp selftest_tool_offsets.cpp
diff --git a/src/common/selftest/include_XL/printer_selftest.hpp b/src/common/selftest/include_XL/printer_selftest.hpp
index 4851749863..fc2d128b2c 100644
--- a/src/common/selftest/include_XL/printer_selftest.hpp
+++ b/src/common/selftest/include_XL/printer_selftest.hpp
@@ -19,6 +19,7 @@ typedef enum {
     stsYAxis,
     stsZcalib,
     stsDocks,
+    stsPhaseStepping,
     stsLoadcell,
     stsWait_loadcell,
     stsNozzleDiameter,
@@ -62,6 +63,7 @@ enum SelftestMask_t : uint32_t {
     stmSelftestStop = to_one_hot(stsSelftestStop),
     stmDocks = to_one_hot(stsDocks),
     stmToolOffsets = to_one_hot(stsToolOffsets),
+    stmPhaseStepping = to_one_hot(stsPhaseStepping),
 };
 
 // class representing whole self-test
@@ -98,6 +100,7 @@ class CSelftest : public AddSuper<ISelftest> {
     selftest::IPartHandler *pToolOffsets;
     std::array<selftest::IPartHandler *, HOTENDS> pFSensor;
     selftest::IPartHandler *pNozzleDiameter;
+    selftest::IPartHandler *pPhaseStepping;
 
     SelftestResult m_result;
 };
diff --git a/src/common/selftest/selftest_XL.cpp b/src/common/selftest/selftest_XL.cpp
index 2bfc07fde1..2041e57adc 100644
--- a/src/common/selftest/selftest_XL.cpp
+++ b/src/common/selftest/selftest_XL.cpp
@@ -32,6 +32,7 @@
 #include "selftest_heater_config.hpp"
 #include "selftest_loadcell_config.hpp"
 #include "selftest_fsensor_config.hpp"
+#include "selftest_phase_stepping.hpp"
 #include "calibration_z.hpp"
 #include "fanctl.hpp"
 #include "timing.h"
@@ -247,6 +248,10 @@ static constexpr std::array<const DockConfig_t, HOTENDS> Config_Docks = { { make
 
 static constexpr ToolOffsetsConfig_t Config_ToolOffsets = {};
 
+namespace {
+constexpr SelftestPhaseSteppingConfig phase_stepping_config {};
+}
+
 CSelftest::CSelftest()
     : m_State(stsIdle)
     , m_Mask(stmNone)
@@ -323,6 +328,11 @@ void CSelftest::Loop() {
             return;
         }
         break;
+    case stsPhaseStepping:
+        if (selftest::phase_phase_stepping(pPhaseStepping, phase_stepping_config)) {
+            return;
+        }
+        break;
     case stsFans:
         if (selftest::phaseFans(pFans, fans_configs)) {
             return;
diff --git a/src/common/selftest/selftest_phase_stepping.cpp b/src/common/selftest/selftest_phase_stepping.cpp
new file mode 100644
index 0000000000..9b2298124a
--- /dev/null
+++ b/src/common/selftest/selftest_phase_stepping.cpp
@@ -0,0 +1,137 @@
+#include "selftest_phase_stepping.hpp"
+#include "wizard_config.hpp"
+#include "i_selftest.hpp"
+
+#include <option/has_toolchanger.h>
+#include <feature/phase_stepping/calibration.hpp>
+
+LOG_COMPONENT_REF(Selftest);
+
+namespace selftest {
+
+static SelftestPhaseSteppingResult static_result; // automatically initialized by PartHandler
+
+namespace {
+
+    constexpr bool is_ok(const phase_stepping::CalibrationResult::Scores &scores) {
+        return scores.p1f < 1.f
+            && scores.p1b < 1.f
+            && scores.p2f < 1.f
+            && scores.p2b < 1.f;
+    }
+
+} // namespace
+
+bool phase_phase_stepping(IPartHandler *&selftest_phase_stepping, const SelftestPhaseSteppingConfig &config) {
+    if (!selftest_phase_stepping) {
+        selftest_phase_stepping = selftest::Factory::CreateDynamical<SelftestPhaseStepping>(
+            config,
+            static_result,
+            &SelftestPhaseStepping::state_calib_pick_tool,
+            &SelftestPhaseStepping::state_wait_until_done,
+            &SelftestPhaseStepping::state_calib_x,
+            &SelftestPhaseStepping::state_wait_until_done,
+            &SelftestPhaseStepping::state_calib_y,
+            &SelftestPhaseStepping::state_wait_until_done,
+            &SelftestPhaseStepping::state_calib_enable,
+            &SelftestPhaseStepping::state_calib_save,
+            &SelftestPhaseStepping::state_wait_until_done);
+    }
+
+    bool in_progress = selftest_phase_stepping->Loop();
+
+    const PhasesSelftest phase = IPartHandler::GetFsmPhase();
+    FSM_CHANGE_WITH_DATA__LOGGING(Selftest, phase, static_result.serialize(phase));
+
+    if (in_progress) {
+        return true;
+    }
+
+    config_store().selftest_result_phase_stepping.set(selftest_phase_stepping->GetResult());
+
+    delete selftest_phase_stepping;
+    selftest_phase_stepping = nullptr;
+
+    return false;
+}
+
+SelftestPhaseStepping::SelftestPhaseStepping(IPartHandler &state_machine, const SelftestPhaseSteppingConfig &config, SelftestPhaseSteppingResult &result)
+    : state_machine(state_machine)
+    , config(config)
+    , result(result) {
+}
+
+LoopResult SelftestPhaseStepping::state_calib_pick_tool() {
+#if HAS_TOOLCHANGER()
+    IPartHandler::SetFsmPhase(PhasesSelftest::PhaseStepping_pick_tool);
+    marlin_server::enqueue_gcode("T0 S1 L0 D0"); // pick zeroth
+#endif
+    return LoopResult::RunNext;
+}
+
+LoopResult SelftestPhaseStepping::state_calib_x() {
+    IPartHandler::SetFsmPhase(PhasesSelftest::PhaseStepping_calib_x);
+    marlin_server::enqueue_gcode("M977 X");
+    return LoopResult::RunNext;
+}
+
+LoopResult SelftestPhaseStepping::state_calib_y() {
+    static_result.result_x = phase_stepping::last_calibration_result;
+    switch (static_result.result_x.get_state()) {
+    case phase_stepping::CalibrationResult::State::unknown:
+        log_error(Selftest, "x calibration result unknown");
+        [[fallthrough]];
+    case phase_stepping::CalibrationResult::State::error:
+        return handle_button(PhasesSelftest::PhaseStepping_calib_error, LoopResult::Abort);
+    case phase_stepping::CalibrationResult::State::known:
+        if (is_ok(static_result.result_x.get_scores())) {
+            IPartHandler::SetFsmPhase(PhasesSelftest::PhaseStepping_calib_y);
+            marlin_server::enqueue_gcode("M977 Y");
+            return LoopResult::RunNext;
+        } else {
+            return handle_button(PhasesSelftest::PhaseStepping_calib_x_nok, LoopResult::Abort);
+        }
+    }
+    abort();
+}
+
+LoopResult SelftestPhaseStepping::state_calib_enable() {
+    static_result.result_y = phase_stepping::last_calibration_result;
+    switch (static_result.result_y.get_state()) {
+    case phase_stepping::CalibrationResult::State::unknown:
+        log_error(Selftest, "y calibration result unknown");
+        [[fallthrough]];
+    case phase_stepping::CalibrationResult::State::error:
+        return handle_button(PhasesSelftest::PhaseStepping_calib_error, LoopResult::Abort);
+    case phase_stepping::CalibrationResult::State::known:
+        if (is_ok(static_result.result_y.get_scores())) {
+            return handle_button(PhasesSelftest::PhaseStepping_calib_ok, LoopResult::RunNext);
+        } else {
+            return handle_button(PhasesSelftest::PhaseStepping_calib_y_nok, LoopResult::Abort);
+        }
+    }
+    abort();
+}
+
+LoopResult SelftestPhaseStepping::state_calib_save() {
+    IPartHandler::SetFsmPhase(PhasesSelftest::PhaseStepping_enabling);
+    marlin_server::enqueue_gcode("M970 X Y");
+    return LoopResult::RunNext;
+}
+
+LoopResult SelftestPhaseStepping::handle_button(PhasesSelftest phase, LoopResult next) {
+    IPartHandler::SetFsmPhase(phase);
+    if (state_machine.GetButtonPressed() != Response::Ok) {
+        return LoopResult::RunCurrent;
+    }
+    return next;
+}
+
+LoopResult SelftestPhaseStepping::state_wait_until_done() {
+    if (queue.has_commands_queued() || planner.processing()) {
+        return LoopResult::RunCurrent;
+    }
+    return LoopResult::RunNext;
+}
+
+} // namespace selftest
diff --git a/src/common/selftest/selftest_phase_stepping.hpp b/src/common/selftest/selftest_phase_stepping.hpp
new file mode 100644
index 0000000000..56bc791a5e
--- /dev/null
+++ b/src/common/selftest/selftest_phase_stepping.hpp
@@ -0,0 +1,32 @@
+#pragma once
+
+#include "i_selftest_part.hpp"
+#include "selftest_phase_stepping_config.hpp"
+#include "selftest_phase_stepping_result.hpp"
+#include "selftest_log.hpp"
+#include <optional>
+
+namespace selftest {
+
+bool phase_phase_stepping(IPartHandler *&selftest_phase_stepping, const SelftestPhaseSteppingConfig &config);
+
+class SelftestPhaseStepping {
+    IPartHandler &state_machine;
+    const SelftestPhaseSteppingConfig &config;
+    SelftestPhaseSteppingResult &result;
+    LogTimer log = 1000;
+
+    LoopResult handle_button(PhasesSelftest, LoopResult);
+
+public:
+    SelftestPhaseStepping(IPartHandler &state_machine, const SelftestPhaseSteppingConfig &config, SelftestPhaseSteppingResult &result);
+
+    LoopResult state_calib_pick_tool();
+    LoopResult state_calib_x();
+    LoopResult state_calib_y();
+    LoopResult state_calib_enable();
+    LoopResult state_calib_save();
+    LoopResult state_wait_until_done();
+};
+
+} // namespace selftest
diff --git a/src/common/selftest/selftest_phase_stepping_config.hpp b/src/common/selftest/selftest_phase_stepping_config.hpp
new file mode 100644
index 0000000000..282901f842
--- /dev/null
+++ b/src/common/selftest/selftest_phase_stepping_config.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "selftest_phase_stepping_result.hpp"
+#include <client_response.hpp>
+
+namespace selftest {
+
+struct SelftestPhaseSteppingConfig {
+    using type_evaluation = SelftestPhaseSteppingResult;
+    static constexpr SelftestParts part_type = SelftestParts::PhaseStepping;
+};
+
+}; // namespace selftest
diff --git a/src/common/selftest/selftest_phase_stepping_result.cpp b/src/common/selftest/selftest_phase_stepping_result.cpp
new file mode 100644
index 0000000000..6eec995263
--- /dev/null
+++ b/src/common/selftest/selftest_phase_stepping_result.cpp
@@ -0,0 +1,48 @@
+#include <common/selftest_phase_stepping_result.hpp>
+
+namespace {
+
+void serialize_axis_nok(fsm::PhaseData &data, const phase_stepping::CalibrationResult &result) {
+    const phase_stepping::CalibrationResult::Scores scores = result.get_scores();
+    // TODO maybe these should be saturated at 255?
+    data[0] = 100 * scores.p1f;
+    data[1] = 100 * scores.p1b;
+    data[2] = 100 * scores.p2f;
+    data[3] = 100 * scores.p2b;
+}
+
+void serialize_ok(fsm::PhaseData &data, const phase_stepping::CalibrationResult &result_x, const phase_stepping::CalibrationResult &result_y) {
+    const phase_stepping::CalibrationResult::Scores scores_x = result_x.get_scores();
+    const phase_stepping::CalibrationResult::Scores scores_y = result_y.get_scores();
+    // take the worst of forward and backward, subtract from 1 to get reduction and scale up to percents
+    data[0] = 100 - 100 * std::max(scores_x.p1f, scores_x.p1b);
+    data[1] = 100 - 100 * std::max(scores_x.p2f, scores_x.p2b);
+    data[2] = 100 - 100 * std::max(scores_y.p1f, scores_y.p1b);
+    data[3] = 100 - 100 * std::max(scores_y.p2f, scores_y.p2b);
+}
+
+} // namespace
+
+fsm::PhaseData SelftestPhaseSteppingResult::serialize(PhasesSelftest phase) const {
+    fsm::PhaseData data;
+    switch (phase) {
+    case PhasesSelftest::PhaseStepping_pick_tool:
+    case PhasesSelftest::PhaseStepping_calib_x:
+    case PhasesSelftest::PhaseStepping_calib_y:
+    case PhasesSelftest::PhaseStepping_calib_error:
+    case PhasesSelftest::PhaseStepping_enabling:
+        break;
+    case PhasesSelftest::PhaseStepping_calib_ok:
+        serialize_ok(data, result_x, result_y);
+        break;
+    case PhasesSelftest::PhaseStepping_calib_x_nok:
+        serialize_axis_nok(data, result_x);
+        break;
+    case PhasesSelftest::PhaseStepping_calib_y_nok:
+        serialize_axis_nok(data, result_y);
+        break;
+    default:
+        abort();
+    }
+    return data;
+}
diff --git a/src/common/selftest_phase_stepping_result.hpp b/src/common/selftest_phase_stepping_result.hpp
new file mode 100644
index 0000000000..c106d4ccd5
--- /dev/null
+++ b/src/common/selftest_phase_stepping_result.hpp
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <common/fsm_base_types.hpp>
+#include "client_response.hpp"
+#include "feature/phase_stepping/calibration.hpp"
+#include "selftest_sub_state.hpp"
+
+struct SelftestPhaseSteppingResult {
+    phase_stepping::CalibrationResult result_x { phase_stepping::CalibrationResult::make_unknown() };
+    phase_stepping::CalibrationResult result_y { phase_stepping::CalibrationResult::make_unknown() };
+
+    constexpr SelftestPhaseSteppingResult() {}
+
+    fsm::PhaseData serialize(PhasesSelftest) const;
+
+    constexpr bool operator==([[maybe_unused]] const SelftestPhaseSteppingResult &other) const {
+        return true;
+    }
+
+    constexpr bool operator!=(const SelftestPhaseSteppingResult &other) const {
+        return !((*this) == other);
+    }
+
+    void Pass() {}
+    void Fail() {}
+    void Abort() {} // currently not needed
+};
diff --git a/src/common/selftest_state_names.hpp b/src/common/selftest_state_names.hpp
index 40559f2cd9..571b502676 100644
--- a/src/common/selftest_state_names.hpp
+++ b/src/common/selftest_state_names.hpp
@@ -6,6 +6,7 @@
 #pragma once
 
 #include "client_response.hpp"
+#include <option/has_phase_stepping.h>
 
 constexpr const char *get_selftest_state_name(PhasesSelftest state) {
 
@@ -178,6 +179,24 @@ constexpr const char *get_selftest_state_name(PhasesSelftest state) {
         return "ToolOffsets_wait_move_away";
     case PhasesSelftest::ToolOffsets_wait_user_remove_pin:
         return "ToolOffsets_wait_user_remove_pin";
+#if HAS_PHASE_STEPPING()
+    case PhasesSelftest::PhaseStepping_pick_tool:
+        return "PhaseStepping_pick_tool";
+    case PhasesSelftest::PhaseStepping_calib_x:
+        return "PhaseStepping_calib_x";
+    case PhasesSelftest::PhaseStepping_calib_y:
+        return "PhaseStepping_calib_y";
+    case PhasesSelftest::PhaseStepping_calib_x_nok:
+        return "PhaseStepping_calib_x_nok";
+    case PhasesSelftest::PhaseStepping_calib_y_nok:
+        return "PhaseStepping_calib_y_nok";
+    case PhasesSelftest::PhaseStepping_calib_error:
+        return "PhaseStepping_calib_error";
+    case PhasesSelftest::PhaseStepping_calib_ok:
+        return "PhaseStepping_calib_ok";
+    case PhasesSelftest::PhaseStepping_enabling:
+        return "PhaseStepping_enabling";
+#endif
     }
     return "ERROR_not_a_selftest_state";
 }
diff --git a/src/common/stubs.cpp b/src/common/stubs.cpp
index cf83e7183a..496109e960 100644
--- a/src/common/stubs.cpp
+++ b/src/common/stubs.cpp
@@ -1,12 +1,18 @@
 #include "bsod.h"
+#include "safe_state.h"
 
 void abort() {
     bsod("aborted");
 }
 
-void __assert_func(const char *file, int line, const char *func, const char *msg) {
-    (void)func;
-    _bsod("ASSERT %s", file, line, msg);
+void __assert_func(const char *file, int line, const char * /*func*/, const char *msg) {
+#if _DEBUG
+    if (CoreDebug->DHCSR & CoreDebug_DHCSR_C_DEBUGEN_Msk) {
+        buddy_disable_heaters(); // put HW to safe state
+        __asm("BKPT #0\n"); /* Only halt mcu if debugger is attached */
+    } else
+#endif
+        _bsod("ASSERT %s", file, line, msg);
 }
 
 int _isatty(int __attribute__((unused)) fd) {
diff --git a/src/common/thread_measurement.cpp b/src/common/thread_measurement.cpp
index a59f4ff823..dec4cb98ea 100644
--- a/src/common/thread_measurement.cpp
+++ b/src/common/thread_measurement.cpp
@@ -10,6 +10,13 @@
 #include "metric.h"
 #include "timing.h"
 #include "printers.h"
+#include <inc/MarlinConfig.h>
+#include <option/has_phase_stepping.h>
+#include <option/has_burst_stepping.h>
+
+#if HAS_PHASE_STEPPING()
+    #include <feature/phase_stepping/phase_stepping.hpp>
+#endif
 
 METRIC_DEF(metric_tmc_sg_x, "tmc_sg_x", METRIC_VALUE_INTEGER, 10, METRIC_HANDLER_DISABLE_ALL);
 METRIC_DEF(metric_tmc_sg_y, "tmc_sg_y", METRIC_VALUE_INTEGER, 10, METRIC_HANDLER_DISABLE_ALL);
@@ -66,9 +73,14 @@ void StartMeasurementTask([[maybe_unused]] void const *argument) {
 
         // sample stallguard
         if (checkTimestampsAscendingOrder(next_sg_cycle, now)) {
-            uint8_t updated_axes = tmc_sample();
-
-            record_trinamic_metrics(updated_axes);
+#if HAS_PHASE_STEPPING() && !HAS_BURST_STEPPING()
+            if (!phase_stepping::any_axis_active()) {
+#endif
+                uint8_t updated_axes = tmc_sample();
+                record_trinamic_metrics(updated_axes);
+#if HAS_PHASE_STEPPING() && !HAS_BURST_STEPPING()
+            }
+#endif
 
             // This represents the lowest samplerate per axis
             uint32_t next_delay = 40;
diff --git a/src/common/traits.hpp b/src/common/traits.hpp
new file mode 100644
index 0000000000..ff2d71621c
--- /dev/null
+++ b/src/common/traits.hpp
@@ -0,0 +1,35 @@
+#pragma once
+
+#include <functional>
+#include <type_traits>
+
+/**
+ * Function trait extracts argument & return type information
+ **/
+template <typename T>
+struct function_traits;
+
+// Function pointer specialization
+template <typename ReturnType, typename... Args>
+struct function_traits<ReturnType (*)(Args...)> {
+    using return_type = ReturnType;
+    using argument_types = std::tuple<Args...>;
+};
+
+// Member function pointer specialization
+template <typename ClassType, typename ReturnType, typename... Args>
+struct function_traits<ReturnType (ClassType::*)(Args...)> {
+    using return_type = ReturnType;
+    using argument_types = std::tuple<Args...>;
+};
+
+// Const member function pointer specialization
+template <typename ClassType, typename ReturnType, typename... Args>
+struct function_traits<ReturnType (ClassType::*)(Args...) const> {
+    using return_type = ReturnType;
+    using argument_types = std::tuple<Args...>;
+};
+
+// Lambda specialization
+template <typename Lambda>
+struct function_traits : public function_traits<decltype(&Lambda::operator())> {};
diff --git a/src/common/trinamic.cpp b/src/common/trinamic.cpp
index fb8d51dfc4..72ca85aed0 100644
--- a/src/common/trinamic.cpp
+++ b/src/common/trinamic.cpp
@@ -11,6 +11,8 @@
 #include <device/board.h>
 #include <config_store/store_instance.hpp>
 
+#include <atomic>
+
 using namespace buddy::hw;
 #if HAS_DRIVER(TMC2130)
 static TMC2130Stepper *pStep[4] = { nullptr, nullptr, nullptr, nullptr };
@@ -91,9 +93,24 @@ tmc_reg_t tmc_reg_map[] = {
     { NULL, 0x00, false, false },
 };
 
+// With phase stepping, mutex is not an ideal synchronization mechanism as
+// high-priority ISR cannot safely take it. Since phase-stepping doesn't mind
+// missing transfers much, we can use atomic variable for storing the current
+// owner. As phase stepping holds the but all the time, we also have a flag that
+// marks that a task wants to access the bus.
+
 osMutexDef(tmc_mutex);
 osMutexId tmc_mutex_id;
 
+enum class BusOwner {
+    NOBODY = 0,
+    TASK = 1,
+    ISR = 2
+};
+
+std::atomic<BusOwner> tmc_bus_owner = BusOwner::NOBODY;
+std::atomic<bool> tmc_bus_requested = false;
+
 extern "C" {
 
 uint8_t tmc_get_sg_mask() { return tmc_sg_mask; }
@@ -237,14 +254,49 @@ void init_tmc_bare_minimum(void) {
 ///
 /// This implements a weak symbol declared within the TMCStepper library
 bool tmc_serial_lock_acquire(void) {
-    return osMutexWait(tmc_mutex_id, osWaitForever) == osOK;
+    auto res = osMutexWait(tmc_mutex_id, osWaitForever) == osOK;
+    // We have taken the mutex, now let's try to take over the lock from ISR in
+    // busy waiting. We will wait at most one period of phase stepping (~25 µs)
+    BusOwner owner = BusOwner::NOBODY;
+    tmc_bus_requested = true;
+    uint32_t start = ticks_ms();
+    while (!tmc_bus_owner.compare_exchange_weak(owner, BusOwner::TASK,
+        std::memory_order_relaxed,
+        std::memory_order_relaxed)) {
+        owner = BusOwner::NOBODY;
+        if (ticks_diff(ticks_ms(), start) > 100) {
+            bsod("Couldn't acquire TMC bus within 100ms");
+        }
+    }
+    return res;
 }
 
 /// Release lock for mutual exclusive access to the trinamic's serial port
 ///
 /// This implements a weak symbol declared within the TMCStepper library
 void tmc_serial_lock_release(void) {
+    tmc_bus_requested = false;
     osMutexRelease(tmc_mutex_id);
+    tmc_bus_owner.store(BusOwner::NOBODY);
+}
+
+bool tmc_serial_lock_acquire_isr(void) {
+    BusOwner owner = BusOwner::NOBODY;
+    return tmc_bus_owner.compare_exchange_weak(owner, BusOwner::ISR,
+        std::memory_order_relaxed,
+        std::memory_order_relaxed);
+}
+
+void tmc_serial_lock_release_isr(void) {
+    tmc_bus_owner.store(BusOwner::NOBODY);
+}
+
+bool tmc_serial_lock_held_by_isr(void) {
+    return tmc_bus_owner.load() == BusOwner::ISR;
+}
+
+bool tmc_serial_lock_requested_by_task(void) {
+    return tmc_bus_requested;
 }
 
 /// Called when an error occurs when communicating with the TMC over serial
diff --git a/src/common/trinamic.h b/src/common/trinamic.h
index 5c6888d4c9..36fb99d359 100644
--- a/src/common/trinamic.h
+++ b/src/common/trinamic.h
@@ -47,6 +47,12 @@ extern void tmc_disable_wavetable(bool X, bool Y, bool Z);
  * \return true if all coils are ok, false otherwise
  */
 extern bool tmc_check_coils(uint8_t axis);
+extern bool tmc_serial_lock_acquire(void);
+extern void tmc_serial_lock_release(void);
+extern bool tmc_serial_lock_acquire_isr(void);
+extern void tmc_serial_lock_release_isr(void);
+extern bool tmc_serial_lock_held_by_isr(void);
+extern bool tmc_serial_lock_requested_by_task(void);
 #ifdef __cplusplus
 }
 
diff --git a/src/device/stm32f4/hal_msp.cpp b/src/device/stm32f4/hal_msp.cpp
index 33b4656960..b5a87fec45 100644
--- a/src/device/stm32f4/hal_msp.cpp
+++ b/src/device/stm32f4/hal_msp.cpp
@@ -5,6 +5,7 @@
 #include "FreeRTOSConfig.h"
 #include <device/peripherals.h>
 #include "priorities_config.h"
+#include <option/has_burst_stepping.h>
 
 void HAL_TIM_MspPostInit(TIM_HandleTypeDef *htim);
 
@@ -422,6 +423,9 @@ void HAL_SPI_MspInit(SPI_HandleTypeDef *hspi) {
         }
 
         __HAL_LINKDMA(hspi, hdmatx, hdma_spi3_tx);
+
+        HAL_NVIC_SetPriority(SPI3_IRQn, ISR_PRIORITY_DEFAULT, 0);
+        HAL_NVIC_EnableIRQ(SPI3_IRQn);
     } else if (hspi->Instance == SPI4) {
         /* Peripheral clock enable */
         __HAL_RCC_SPI4_CLK_ENABLE();
@@ -440,7 +444,10 @@ void HAL_SPI_MspInit(SPI_HandleTypeDef *hspi) {
         GPIO_InitStruct.Alternate = GPIO_AF5_SPI4;
         HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
 
-        /* SPI4 DMA Init */
+    #if HAS_BURST_STEPPING()
+        HAL_NVIC_SetPriority(SPI4_IRQn, ISR_PRIORITY_DEFAULT, 0);
+        HAL_NVIC_EnableIRQ(SPI4_IRQn);
+    #else
         /* SPI4_TX Init */
         hdma_spi4_tx.Instance = DMA2_Stream1;
         hdma_spi4_tx.Init.Channel = DMA_CHANNEL_4;
@@ -457,6 +464,7 @@ void HAL_SPI_MspInit(SPI_HandleTypeDef *hspi) {
         }
 
         __HAL_LINKDMA(hspi, hdmatx, hdma_spi4_tx);
+    #endif // HAS_PHASE_STEPPING()
     } else if (hspi->Instance == SPI5) {
         /* Peripheral clock enable */
         __HAL_RCC_SPI5_CLK_ENABLE();
@@ -705,6 +713,8 @@ void HAL_SPI_MspDeInit(SPI_HandleTypeDef *hspi) {
         /* SPI3 DMA DeInit */
         HAL_DMA_DeInit(hspi->hdmarx);
         HAL_DMA_DeInit(hspi->hdmatx);
+
+        HAL_NVIC_DisableIRQ(SPI3_IRQn);
     } else if (hspi->Instance == SPI4) {
         /* Peripheral clock disable */
         __HAL_RCC_SPI4_CLK_DISABLE();
@@ -795,6 +805,15 @@ void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim_base) {
     } else if (htim_base->Instance == TIM3) {
         /* Peripheral clock enable */
         __HAL_RCC_TIM3_CLK_ENABLE();
+    } else if (htim_base->Instance == TIM8) {
+        /* Peripheral clock enable */
+        __HAL_RCC_TIM8_CLK_ENABLE();
+    } else if (htim_base->Instance == TIM13) {
+        /* Peripheral clock enable */
+        __HAL_RCC_TIM13_CLK_ENABLE();
+
+        HAL_NVIC_SetPriority(TIM8_UP_TIM13_IRQn, ISR_PRIORITY_PHASE_TIMER, 1);
+        HAL_NVIC_EnableIRQ(TIM8_UP_TIM13_IRQn);
     } else if (htim_base->Instance == TIM14) {
         /* Peripheral clock enable */
         __HAL_RCC_TIM14_CLK_ENABLE();
@@ -834,6 +853,23 @@ void HAL_TIM_MspPostInit(TIM_HandleTypeDef *htim) {
         GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
         GPIO_InitStruct.Alternate = GPIO_AF2_TIM3;
         HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+    } else if (htim->Instance == TIM8) {
+        /* TIM8 DMA Init */
+        hdma_tim8.Instance = DMA2_Stream1;
+        hdma_tim8.Init.Channel = DMA_CHANNEL_7;
+        hdma_tim8.Init.Direction = DMA_MEMORY_TO_PERIPH;
+        hdma_tim8.Init.PeriphInc = DMA_PINC_DISABLE;
+        hdma_tim8.Init.MemInc = DMA_MINC_ENABLE;
+        hdma_tim8.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
+        hdma_tim8.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
+        hdma_tim8.Init.Mode = DMA_NORMAL;
+        hdma_tim8.Init.Priority = DMA_PRIORITY_HIGH;
+        hdma_tim8.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
+        if (HAL_DMA_Init(&hdma_tim8) != HAL_OK) {
+            Error_Handler();
+        }
+
+        __HAL_LINKDMA(htim, hdma[TIM_DMA_ID_UPDATE], hdma_tim8);
     }
 }
 
@@ -853,6 +889,9 @@ void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef *htim_base) {
     } else if (htim_base->Instance == TIM3) {
         /* Peripheral clock disable */
         __HAL_RCC_TIM3_CLK_DISABLE();
+    } else if (htim_base->Instance == TIM13) {
+        __HAL_RCC_TIM13_CLK_DISABLE();
+        HAL_NVIC_DisableIRQ(TIM8_UP_TIM13_IRQn);
     } else if (htim_base->Instance == TIM14) {
         /* Peripheral clock disable */
         __HAL_RCC_TIM14_CLK_DISABLE();
diff --git a/src/device/stm32f4/interrupts.cpp b/src/device/stm32f4/interrupts.cpp
index a89921cd1a..e8e6b8689e 100644
--- a/src/device/stm32f4/interrupts.cpp
+++ b/src/device/stm32f4/interrupts.cpp
@@ -15,6 +15,13 @@
 #include "safe_state.h"
 #include "data_exchange.hpp"
 #include <option/buddy_enable_wui.h>
+#include <option/has_phase_stepping.h>
+#include <option/has_burst_stepping.h>
+
+#if HAS_PHASE_STEPPING()
+    #include <feature/phase_stepping/phase_stepping.hpp>
+    #include <feature/phase_stepping/quick_tmc_spi.hpp>
+#endif
 
 #if BUDDY_ENABLE_WUI()
     #include "espif.h"
@@ -225,6 +232,16 @@ void DMA1_Stream3_IRQHandler(void) {
 
 #endif
 
+/**
+ * @brief This function handles TIM8 trigger and commutation interrupts and TIM13 global interrupt.
+ */
+
+// This function is implemented in
+// lib/Marlin/Marlin/src/feature/phase_stepping/phase_stepping.cpp to allow for
+// inlining without enable LTO.
+//
+// void TIM8_UP_TIM13_IRQHandler(void)
+
 /**
  * @brief This function handles TIM8 trigger and commutation interrupts and TIM14 global interrupt.
  */
@@ -348,4 +365,24 @@ void OTG_HS_IRQHandler(void) {
     traceISR_EXIT();
 #endif
 }
+
+/**
+ * @brief This function handles SPI3 global interrupt.
+ */
+void SPI3_IRQHandler(void) {
+    traceISR_ENTER();
+    HAL_SPI_IRQHandler(&hspi3);
+    traceISR_EXIT();
+}
+
+#if HAS_BURST_STEPPING()
+/**
+ * @brief This function handles SPI4 global interrupt.
+ */
+void SPI4_IRQHandler(void) {
+    traceISR_ENTER();
+    HAL_SPI_IRQHandler(&hspi4);
+    traceISR_EXIT();
+}
+#endif
 }
diff --git a/src/device/stm32f4/peripherals.cpp b/src/device/stm32f4/peripherals.cpp
index 3196702a2d..ad541ab06f 100644
--- a/src/device/stm32f4/peripherals.cpp
+++ b/src/device/stm32f4/peripherals.cpp
@@ -1,6 +1,7 @@
 #include <device/board.h>
 #include <device/peripherals.h>
 #include <device/mcu.h>
+#include <buddy/phase_stepping_opts.h>
 #include <atomic>
 #include "Pin.hpp"
 #include "hwio_pindef.h"
@@ -13,6 +14,7 @@
 #include "timing_precise.hpp"
 #include "data_exchange.hpp"
 #include <option/has_puppies.h>
+#include <option/has_burst_stepping.h>
 #include <printers.h>
 
 // breakpoint
@@ -86,6 +88,9 @@ DMA_HandleTypeDef hdma_adc3;
 TIM_HandleTypeDef htim1;
 TIM_HandleTypeDef htim2;
 TIM_HandleTypeDef htim3;
+TIM_HandleTypeDef htim8;
+DMA_HandleTypeDef hdma_tim8;
+TIM_HandleTypeDef htim13;
 TIM_HandleTypeDef htim14;
 
 //
@@ -760,7 +765,7 @@ void hw_spi3_init() {
 #if (BOARD_IS_BUDDY)
     hspi3.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
 #else
-    hspi3.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
+    hspi3.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;
 #endif
     hspi3.Init.FirstBit = SPI_FIRSTBIT_MSB;
     hspi3.Init.TIMode = SPI_TIMODE_DISABLE;
@@ -959,6 +964,45 @@ void hw_tim3_init() {
     HAL_TIM_MspPostInit(&htim3);
 }
 
+void hw_tim8_init() {
+    TIM_ClockConfigTypeDef sClockSourceConfig {};
+    TIM_MasterConfigTypeDef sMasterConfig {};
+
+    htim8.Instance = TIM8;
+    htim8.Init.Prescaler = 0;
+    htim8.Init.CounterMode = TIM_COUNTERMODE_UP;
+    htim8.Init.Period = 168'000'000 / (phase_stepping::opts::REFRESH_FREQ * phase_stepping::opts::GPIO_BUFFER_SIZE) - 1;
+    htim8.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
+    if (HAL_TIM_Base_Init(&htim8) != HAL_OK) {
+        Error_Handler();
+    }
+
+    sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
+    if (HAL_TIM_ConfigClockSource(&htim8, &sClockSourceConfig) != HAL_OK) {
+        Error_Handler();
+    }
+
+    sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
+    sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
+    if (HAL_TIMEx_MasterConfigSynchronization(&htim8, &sMasterConfig) != HAL_OK) {
+        Error_Handler();
+    }
+
+    HAL_TIM_MspPostInit(&htim8);
+}
+
+void hw_tim13_init() {
+    htim13.Instance = TIM13;
+    htim13.Init.Prescaler = 0;
+    htim13.Init.CounterMode = TIM_COUNTERMODE_UP;
+    htim13.Init.Period = 84'000'000 / phase_stepping::opts::REFRESH_FREQ - 1;
+    htim13.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
+    htim13.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
+    if (HAL_TIM_Base_Init(&htim13) != HAL_OK) {
+        Error_Handler();
+    }
+}
+
 void hw_tim14_init() {
     htim14.Instance = TIM14;
     htim14.Init.Prescaler = 84;
diff --git a/src/gui/MItem_crash.cpp b/src/gui/MItem_crash.cpp
index fee238dd05..dfdc7064ba 100644
--- a/src/gui/MItem_crash.cpp
+++ b/src/gui/MItem_crash.cpp
@@ -6,6 +6,7 @@
     #include "menu_spin_config.hpp"
     #include "../lib/Marlin/Marlin/src/module/stepper/trinamic.h"
     #include "../Marlin/src/feature/prusa/crash_recovery.hpp"
+    #include "../Marlin/src/feature/phase_stepping/phase_stepping.hpp"
     #include <config_store/store_instance.hpp>
 
 MI_CRASH_DETECTION::MI_CRASH_DETECTION()
@@ -19,6 +20,23 @@ MI_CRASH_DETECTION::MI_CRASH_DETECTION()
     index = crash_s.is_enabled();
 }
 
+void MI_CRASH_DETECTION::Loop() {
+    #if HAS_PHASE_STEPPING() && !HAS_BURST_STEPPING()
+    // Enable or disable according to the current phase stepping state. We can't really use
+    // invalidation to reduce calls to config_store, as Print() happens and resets the state before
+    // we can trap it here. At the same time, Print is not virtual.
+    bool phstep_enabled = (config_store().phase_stepping_enabled_x.get() || config_store().phase_stepping_enabled_y.get());
+    if (phstep_enabled) {
+        index = 0;
+        Disable();
+    } else {
+        index = crash_s.is_enabled();
+        Enable();
+    }
+    #endif
+    return WI_ICON_SWITCH_OFF_ON_t::Loop();
+}
+
 void MI_CRASH_DETECTION::OnChange([[maybe_unused]] size_t old_index) {
     crash_s.enable(index);
 }
diff --git a/src/gui/MItem_crash.hpp b/src/gui/MItem_crash.hpp
index 5c706388d0..615ce771ac 100644
--- a/src/gui/MItem_crash.hpp
+++ b/src/gui/MItem_crash.hpp
@@ -15,6 +15,7 @@ class MI_CRASH_DETECTION : public WI_ICON_SWITCH_OFF_ON_t {
 
 public:
     MI_CRASH_DETECTION();
+    virtual void Loop() override;
     virtual void OnChange(size_t old_index) override;
 };
 
diff --git a/src/gui/MItem_tools.cpp b/src/gui/MItem_tools.cpp
index 28064020af..604b4a2547 100644
--- a/src/gui/MItem_tools.cpp
+++ b/src/gui/MItem_tools.cpp
@@ -41,6 +41,8 @@
 #include <feature/prusa/e-stall_detector.h>
 #include "connect/marlin_printer.hpp"
 #include <st25dv64k.h>
+#include <option/has_phase_stepping.h>
+#include <RAII.hpp>
 
 namespace {
 void MsgBoxNonBlockInfo(string_view_utf8 txt) {
@@ -815,3 +817,37 @@ void MI_SET_READY::click([[maybe_unused]] IWindowMenu &window_menu) {
         Disable();
     }
 }
+
+#if HAS_PHASE_STEPPING()
+MI_PHASE_STEPPING::MI_PHASE_STEPPING()
+    : WI_ICON_SWITCH_OFF_ON_t(0, _(label), nullptr, is_enabled_t::yes, is_hidden_t::no) {
+    index = config_store().phase_stepping_enabled_x.get() || config_store().phase_stepping_enabled_y.get();
+}
+
+void MI_PHASE_STEPPING::OnChange([[maybe_unused]] size_t old_index) {
+    if (event_in_progress) {
+        return;
+    }
+
+    if (index && (config_store().selftest_result_phase_stepping.get() != TestResult_Passed)) {
+        AutoRestore ar(event_in_progress, true);
+        MsgBoxWarning(_("Phase stepping not ready: perform calibration first."), Responses_Ok);
+        index = old_index;
+        return;
+    }
+
+    if (index) {
+        marlin_server::enqueue_gcode("M970 X Y"); // turn phase stepping on
+    } else {
+        marlin_server::enqueue_gcode("M971 X Y"); // turn phase stepping off
+    }
+
+    // we need to wait until the action actually takes place so that when returning
+    // to the menu (if any) the new state is already reflected
+    gui_dlg_wait([&]() {
+        if (index == config_store().phase_stepping_enabled_x.get()) {
+            Screens::Access()->Close();
+        }
+    });
+}
+#endif
diff --git a/src/gui/MItem_tools.hpp b/src/gui/MItem_tools.hpp
index 7b3fc09bc7..ed1848b669 100644
--- a/src/gui/MItem_tools.hpp
+++ b/src/gui/MItem_tools.hpp
@@ -706,3 +706,14 @@ class MI_SET_READY : public IWindowMenuItem {
 protected:
     virtual void click(IWindowMenu &window_menu) override;
 };
+
+class MI_PHASE_STEPPING : public WI_ICON_SWITCH_OFF_ON_t {
+    static constexpr const char *label = "Phase Stepping";
+    bool event_in_progress { false };
+
+public:
+    MI_PHASE_STEPPING();
+
+protected:
+    void OnChange(size_t old_index) override;
+};
diff --git a/src/gui/ScreenSelftest.cpp b/src/gui/ScreenSelftest.cpp
index 804da0af3d..c67b961a81 100644
--- a/src/gui/ScreenSelftest.cpp
+++ b/src/gui/ScreenSelftest.cpp
@@ -9,6 +9,10 @@
 #include "img_resources.hpp"
 #include "marlin_client.hpp"
 #include <option/has_selftest_snake.h>
+#include <option/has_phase_stepping.h>
+#if HAS_PHASE_STEPPING()
+    #include "selftest_frame_phase_stepping.hpp"
+#endif
 
 static_unique_ptr<SelftestFrame> ScreenSelftest::creator_prologue(ScreenSelftest &rThs, PhasesSelftest phase, fsm::PhaseData data) {
     return rThs.makePtr<SelftestFrameWizardPrologue>(&rThs, phase, data);
@@ -69,6 +73,12 @@ static_unique_ptr<SelftestFrame> ScreenSelftest::creator_epilogue(ScreenSelftest
     return rThs.makePtr<SelftestFrameWizardEpilogue>(&rThs, phase, data);
 }
 
+#if HAS_PHASE_STEPPING()
+static_unique_ptr<SelftestFrame> ScreenSelftest::creator_phase_stepping(ScreenSelftest &rThs, PhasesSelftest phase, fsm::PhaseData data) {
+    return rThs.makePtr<SelftestFramePhaseStepping>(&rThs, phase, data);
+}
+#endif
+
 #if BOARD_IS_XLBUDDY
 static_unique_ptr<SelftestFrame> ScreenSelftest::creator_dock(ScreenSelftest &rThs, PhasesSelftest phase, fsm::PhaseData data) {
     return rThs.makePtr<SelftestFrameDock>(&rThs, phase, data);
@@ -125,6 +135,10 @@ ScreenSelftest::fnc ScreenSelftest::Get(SelftestParts part) {
         break;
 #else
         return creator_specify_hot_end;
+#endif
+#if HAS_PHASE_STEPPING()
+    case SelftestParts::PhaseStepping:
+        return creator_phase_stepping;
 #endif
     case SelftestParts::CalibZ:
         return creator_calib_z;
@@ -219,6 +233,9 @@ string_view_utf8 ScreenSelftest::getCaption(SelftestParts part) {
 #if BOARD_IS_XLBUDDY
     case SelftestParts::Dock:
     case SelftestParts::ToolOffsets:
+#endif
+#if HAS_PHASE_STEPPING()
+    case SelftestParts::PhaseStepping:
 #endif
         return _(en_selftest);
     case SelftestParts::FirstLayer:
@@ -261,6 +278,9 @@ const img::Resource *ScreenSelftest::getIconId(SelftestParts part) {
 #if BOARD_IS_XLBUDDY
     case SelftestParts::Dock:
     case SelftestParts::ToolOffsets:
+#endif
+#if HAS_PHASE_STEPPING()
+    case SelftestParts::PhaseStepping:
 #endif
         return &img::selftest_16x16;
     case SelftestParts::WizardEpilogue_ok:
diff --git a/src/gui/ScreenSelftest.hpp b/src/gui/ScreenSelftest.hpp
index 017455503e..612abde7cf 100644
--- a/src/gui/ScreenSelftest.hpp
+++ b/src/gui/ScreenSelftest.hpp
@@ -29,6 +29,7 @@
 #include "selftest_invalid_state.hpp"
 #include "static_alocation_ptr.hpp"
 #include "printer_selftest.hpp" // SelftestMask_t
+#include <option/has_phase_stepping.h>
 
 class ScreenSelftest : public AddSuperWindow<screen_t> {
     using mem_space = std::aligned_union<0, ScreenSelftestInvalidState, SelftestFrametAxis, SelftestFrameFans, SelftestFrameFSensor, SelftestFrameGearsCalib, SelftestFrameLoadcell, ScreenSelftestTemp, SelftestFrameCalibZ, SelftestFrameFirstLayerQuestions, SelftestFrameResult, SelftestFrameNozzleDiameter
@@ -67,6 +68,9 @@ class ScreenSelftest : public AddSuperWindow<screen_t> {
     static static_unique_ptr<SelftestFrame> creator_tool_offsets(ScreenSelftest &rThs, PhasesSelftest phase, fsm::PhaseData data);
     static static_unique_ptr<SelftestFrame> creator_invalid(ScreenSelftest &rThs, PhasesSelftest phase, fsm::PhaseData data);
     static static_unique_ptr<SelftestFrame> creator_nozzle_diameter(ScreenSelftest &rThs, PhasesSelftest phase, fsm::PhaseData data);
+#if HAS_PHASE_STEPPING()
+    static static_unique_ptr<SelftestFrame> creator_phase_stepping(ScreenSelftest &rThs, PhasesSelftest phase, fsm::PhaseData data);
+#endif
 
     fnc Get(SelftestParts part); // returns factory method
 
diff --git a/src/gui/box_unfinished_selftest.cpp b/src/gui/box_unfinished_selftest.cpp
index df4bdbb28b..cc25ec1fac 100644
--- a/src/gui/box_unfinished_selftest.cpp
+++ b/src/gui/box_unfinished_selftest.cpp
@@ -18,7 +18,7 @@ bool selftest_warning_selftest_finished() {
         return ((results == TestResult_Passed) && ...); // all passed
     };
 #if (PRINTER_IS_PRUSA_XL)
-    if (!all_passed(sr.xaxis, sr.yaxis, sr.zaxis, sr.bed, config_store().selftest_result_nozzle_diameter.get())) {
+    if (!all_passed(sr.xaxis, sr.yaxis, sr.zaxis, sr.bed, config_store().selftest_result_nozzle_diameter.get(), config_store().selftest_result_phase_stepping.get())) {
         return false;
     }
     for (int8_t e = 0; e < HOTENDS; e++) {
diff --git a/src/gui/include_XL/selftest_snake_config.cpp b/src/gui/include_XL/selftest_snake_config.cpp
index c633f83b00..2acc683591 100644
--- a/src/gui/include_XL/selftest_snake_config.cpp
+++ b/src/gui/include_XL/selftest_snake_config.cpp
@@ -74,6 +74,8 @@ TestResult get_test_result(Action action, Tool tool) {
         }
     case Action::NozzleDiameter:
         return evaluate_results(config_store().selftest_result_nozzle_diameter.get());
+    case Action::PhaseSteppingCalibration:
+        return evaluate_results(config_store().selftest_result_phase_stepping.get());
     case Action::_count:
         break;
     }
@@ -130,6 +132,8 @@ uint64_t get_test_mask(Action action) {
         return stmToolOffsets;
     case Action::NozzleDiameter:
         return stmNozzleDiameter;
+    case Action::PhaseSteppingCalibration:
+        return stmPhaseStepping;
     case Action::_count:
         break;
     }
diff --git a/src/gui/include_XL/selftest_snake_config.hpp b/src/gui/include_XL/selftest_snake_config.hpp
index d1caf44cb6..2299122be1 100644
--- a/src/gui/include_XL/selftest_snake_config.hpp
+++ b/src/gui/include_XL/selftest_snake_config.hpp
@@ -41,6 +41,7 @@ enum class Action {
     FilamentSensorCalibration,
     ToolOffsetsCalibration,
     BedHeaters,
+    PhaseSteppingCalibration,
     _count,
     _last = _count - 1,
     _first = Fans,
@@ -127,6 +128,7 @@ inline constexpr MenuItemText blank_item_texts[] {
     { Action::FilamentSensorCalibration, N_("%d Filament Sensor Calibration") },
     { Action::BedHeaters, N_("%d Bed Heater Test") },
     { Action::NozzleHeaters, N_("%d Nozzle Heaters Test") },
+    { Action::PhaseSteppingCalibration, N_("%d Phase Stepping Calibration") },
 };
 
 TestResult get_test_result(Action action, Tool tool);
diff --git a/src/gui/screen_menu_hardware.hpp b/src/gui/screen_menu_hardware.hpp
index 656f7c8ec3..97ce0f68a6 100644
--- a/src/gui/screen_menu_hardware.hpp
+++ b/src/gui/screen_menu_hardware.hpp
@@ -30,6 +30,7 @@
     #include "MItem_mmu.hpp"
 #endif
 #include <screen_menu_hw_setup.hpp>
+#include <option/has_phase_stepping.h>
 
 class MI_MK4_MK39 : public WI_SWITCH_t<2> {
     static constexpr const char *const label = "Current Printer Type";
@@ -74,6 +75,10 @@ using ScreenMenuHardware__ = ScreenMenu<GuiDefaults::MenuFooter,
     MI_CRASH_FILTERING
     #endif
 #endif // ENABLED(CRASH_RECOVERY)
+#if HAS_PHASE_STEPPING()
+    ,
+    MI_PHASE_STEPPING
+#endif
     ,
     MI_FS_AUTOLOAD, MI_EXPERIMENTAL_SETTINGS, MI_XFLASH_RESET, MI_EEPROM
 #if HAS_LOADCELL()
diff --git a/src/gui/screen_menu_tune.hpp b/src/gui/screen_menu_tune.hpp
index 1b97614e14..bf48d85aa6 100644
--- a/src/gui/screen_menu_tune.hpp
+++ b/src/gui/screen_menu_tune.hpp
@@ -48,6 +48,9 @@ using ScreenMenuTune__ = ScreenMenu<EFooter::On, MI_RETURN,
     MI_SOUND_VOLUME,
 #endif
     MI_INPUT_SHAPER,
+#if HAS_PHASE_STEPPING()
+    MI_PHASE_STEPPING,
+#endif
     MI_FAN_CHECK
 #if HAS_MMU2()
     ,
diff --git a/src/gui/screen_splash.cpp b/src/gui/screen_splash.cpp
index 35ef722d2f..c7052e947f 100644
--- a/src/gui/screen_splash.cpp
+++ b/src/gui/screen_splash.cpp
@@ -90,7 +90,8 @@ screen_splash_data_t::screen_splash_data_t()
             if (any_passed(sr.xaxis, sr.yaxis, sr.zaxis, sr.bed
         #if PRINTER_IS_PRUSA_XL
                     ,
-                    config_store().selftest_result_nozzle_diameter.get()
+                    config_store().selftest_result_nozzle_diameter.get(), config_store().selftest_result_phase_stepping.get()
+
         #endif
                         )) {
                 return false;
diff --git a/src/gui/wizard/CMakeLists.txt b/src/gui/wizard/CMakeLists.txt
index 7f44257d4f..9c8405faef 100644
--- a/src/gui/wizard/CMakeLists.txt
+++ b/src/gui/wizard/CMakeLists.txt
@@ -42,3 +42,7 @@ if(${PRINTER} STREQUAL "XL")
                      selftest_frame_tool_offsets.cpp
     )
 endif()
+
+if(HAS_PHASE_STEPPING)
+  target_sources(firmware PRIVATE selftest_frame_phase_stepping.cpp)
+endif()
diff --git a/src/gui/wizard/selftest_frame_phase_stepping.cpp b/src/gui/wizard/selftest_frame_phase_stepping.cpp
new file mode 100644
index 0000000000..2eaf5c0754
--- /dev/null
+++ b/src/gui/wizard/selftest_frame_phase_stepping.cpp
@@ -0,0 +1,71 @@
+#include "selftest_frame_phase_stepping.hpp"
+#include "i18n.h"
+#include "str_utils.hpp"
+#include "wizard_config.hpp"
+#include "selftest_phase_stepping_result.hpp"
+#include "img_resources.hpp"
+
+namespace {
+constexpr const char *txt_header { N_("Phase Stepping Calibration") };
+constexpr const char *txt_picking_tool { N_("Picking Tool") };
+constexpr const char *txt_calibrating_x { N_("Calibrating X") };
+constexpr const char *txt_calibrating_y { N_("Calibrating Y") };
+constexpr const char *txt_calibration_nok { N_("Calibration of axis %c failed.\nParameter 1: forward %3d%%, backward %3d%%\nParameter 2: forward %3d%%, backward %3d%%") };
+constexpr const char *txt_calibration_error { N_("Calibration failed with error.") };
+constexpr const char *txt_enabling { N_("Finishing") };
+constexpr const char *txt_calibration_ok { N_("Axis X vibration A reduced by %2d%%\nAxis X vibration B reduced by %2d%%\nAxis Y vibration A reduced by %2d%%\nAxis Y vibration B reduced by %2d%%") };
+
+string_view_utf8 fmt_calibration_nok(char axis, auto &text_buffer, const fsm::PhaseData &data) {
+    std::array<char, 150> fmt;
+    _(txt_calibration_nok).copyToRAM(fmt.data(), fmt.size());
+    snprintf(text_buffer.data(), text_buffer.size(), fmt.data(), axis, data[0], data[1], data[2], data[3]);
+    return string_view_utf8::MakeRAM((const uint8_t *)text_buffer.data());
+}
+
+string_view_utf8 fmt_calibration_ok(auto &text_buffer, const fsm::PhaseData &data) {
+    std::array<char, 150> fmt;
+    _(txt_calibration_ok).copyToRAM(fmt.data(), fmt.size());
+    snprintf(text_buffer.data(), text_buffer.size(), fmt.data(), data[0], data[1], data[2], data[3]);
+    return string_view_utf8::MakeRAM((const uint8_t *)text_buffer.data());
+}
+
+} // namespace
+
+SelftestFramePhaseStepping::SelftestFramePhaseStepping(window_t *parent, PhasesSelftest ph, fsm::PhaseData data)
+    : AddSuperWindow<SelftestFrameNamedWithRadio>(parent, ph, data, _(txt_header), 1)
+    , footer(this, 0, footer::Item::axis_x, footer::Item::axis_y)
+    , text(this, { 0, GuiDefaults::HeaderHeight, GuiDefaults::ScreenWidth, GuiDefaults::BodyHeight - GuiDefaults::FooterHeight * 3 }, is_multiline::yes) {
+    text.SetAlignment(Align_t::Center()); // looks better with temporary text until this frame gets proper texts
+    change();
+}
+
+void SelftestFramePhaseStepping::change() {
+    switch (phase_current) {
+    case PhasesSelftest::PhaseStepping_pick_tool:
+        text.SetText(_(txt_picking_tool));
+        break;
+    case PhasesSelftest::PhaseStepping_calib_x:
+        text.SetText(_(txt_calibrating_x));
+        break;
+    case PhasesSelftest::PhaseStepping_calib_y:
+        text.SetText(_(txt_calibrating_y));
+        break;
+    case PhasesSelftest::PhaseStepping_calib_x_nok:
+        text.SetText(fmt_calibration_nok('X', text_buffer, data_current));
+        break;
+    case PhasesSelftest::PhaseStepping_calib_y_nok:
+        text.SetText(fmt_calibration_nok('Y', text_buffer, data_current));
+        break;
+    case PhasesSelftest::PhaseStepping_calib_error:
+        text.SetText(_(txt_calibration_error));
+        break;
+    case PhasesSelftest::PhaseStepping_calib_ok:
+        text.SetText(fmt_calibration_ok(text_buffer, data_current));
+        break;
+    case PhasesSelftest::PhaseStepping_enabling:
+        text.SetText(_(txt_enabling));
+        break;
+    default:
+        break;
+    }
+};
diff --git a/src/gui/wizard/selftest_frame_phase_stepping.hpp b/src/gui/wizard/selftest_frame_phase_stepping.hpp
new file mode 100644
index 0000000000..3dccbe423d
--- /dev/null
+++ b/src/gui/wizard/selftest_frame_phase_stepping.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+#include "selftest_frame.hpp"
+#include "window_icon.hpp"
+#include "window_wizard_progress.hpp"
+#include "status_footer.hpp"
+
+class SelftestFramePhaseStepping : public AddSuperWindow<SelftestFrameNamedWithRadio> {
+    FooterLine footer;
+
+    window_text_t text;
+    std::array<char, 150> text_buffer;
+
+protected:
+    virtual void change() override;
+
+public:
+    SelftestFramePhaseStepping(window_t *parent, PhasesSelftest ph, fsm::PhaseData data);
+};
diff --git a/src/guiapi/src/led_lcd_cs_selector.cpp b/src/guiapi/src/led_lcd_cs_selector.cpp
index 033e6d1099..92f05a7684 100644
--- a/src/guiapi/src/led_lcd_cs_selector.cpp
+++ b/src/guiapi/src/led_lcd_cs_selector.cpp
@@ -10,6 +10,7 @@
 #include "gui_time.hpp" //gui::GetTick()
 #include <ccm_thread.hpp>
 #include "option/has_side_leds.h"
+#include <option/has_burst_stepping.h>
 
 using namespace buddy::hw;
 
@@ -59,7 +60,11 @@ void LED_LCD_SPI_switcher::WrBytes(uint8_t *pb, uint16_t size) {
     } else {
         HAL_SPI_Abort(spi);
         assert("Data for DMA cannot be in CCMRAM" && can_be_used_by_dma(reinterpret_cast<uintptr_t>(pb)));
+#if HAS_BURST_STEPPING()
+        HAL_SPI_Transmit_IT(spi, pb, size);
+#else
         HAL_SPI_Transmit_DMA(spi, pb, size);
+#endif
         // wait for transmission complete
         while (HAL_SPI_GetState(spi) == HAL_SPI_STATE_BUSY_TX) {
             osDelay(1);
diff --git a/src/persistent_stores/store_instances/config_store/store_definition.cpp b/src/persistent_stores/store_instances/config_store/store_definition.cpp
index 64bec112a7..dbd8431124 100644
--- a/src/persistent_stores/store_instances/config_store/store_definition.cpp
+++ b/src/persistent_stores/store_instances/config_store/store_definition.cpp
@@ -840,4 +840,33 @@ void CurrentStore::set_input_shaper_config(const input_shaper::Config &config) {
     }
 }
 
+#if HAS_PHASE_STEPPING()
+bool CurrentStore::get_phase_stepping_enabled(AxisEnum axis) {
+    switch (axis) {
+    case AxisEnum::X_AXIS:
+        return phase_stepping_enabled_x.get();
+        break;
+    case AxisEnum::Y_AXIS:
+        return phase_stepping_enabled_y.get();
+        break;
+    default:
+        assert(false && "invalid index");
+        return {};
+    }
+}
+
+void CurrentStore::set_phase_stepping_enabled(AxisEnum axis, bool new_state) {
+    switch (axis) {
+    case AxisEnum::X_AXIS:
+        phase_stepping_enabled_x.set(new_state);
+        break;
+    case AxisEnum::Y_AXIS:
+        phase_stepping_enabled_y.set(new_state);
+        break;
+    default:
+        assert(false && "invalid index");
+        return;
+    }
+}
+#endif
 } // namespace config_store_ns
diff --git a/src/persistent_stores/store_instances/config_store/store_definition.hpp b/src/persistent_stores/store_instances/config_store/store_definition.hpp
index f54dff23db..7fd911d737 100644
--- a/src/persistent_stores/store_instances/config_store/store_definition.hpp
+++ b/src/persistent_stores/store_instances/config_store/store_definition.hpp
@@ -28,6 +28,7 @@
 #include <option/has_mmu2.h>
 #include <option/has_toolchanger.h>
 #include <option/has_selftest.h>
+#include <option/has_phase_stepping.h>
 
 namespace config_store_ns {
 /**
@@ -350,6 +351,10 @@ struct CurrentStore
     StoreItem<TestResult, defaults::test_result_unknown, journal::hash("Selftest Result - Nozzle Diameter")> selftest_result_nozzle_diameter;
 #endif
 
+#if PRINTER_IS_PRUSA_XL
+    StoreItem<TestResult, defaults::test_result_unknown, journal::hash("Test Result Phase Stepping")> selftest_result_phase_stepping;
+#endif
+
     SelftestTool get_selftest_result_tool(uint8_t index);
     void set_selftest_result_tool(uint8_t index, SelftestTool value);
 
@@ -406,6 +411,14 @@ struct CurrentStore
 #if PRINTER_IS_PRUSA_MK3_5
     StoreItem<bool, defaults::bool_false, journal::hash("Has Alt Fans")> has_alt_fans;
 #endif
+
+#if HAS_PHASE_STEPPING()
+    StoreItem<bool, defaults::bool_false, journal::hash("Phase Stepping Enabled X")> phase_stepping_enabled_x;
+    StoreItem<bool, defaults::bool_false, journal::hash("Phase Stepping Enabled Y")> phase_stepping_enabled_y;
+
+    bool get_phase_stepping_enabled(AxisEnum axis);
+    void set_phase_stepping_enabled(AxisEnum axis, bool new_state);
+#endif
 };
 
 /**
diff --git a/src/puppies/Dwarf.cpp b/src/puppies/Dwarf.cpp
index eecdc940f4..ccaade93a3 100644
--- a/src/puppies/Dwarf.cpp
+++ b/src/puppies/Dwarf.cpp
@@ -65,13 +65,6 @@ Dwarf::Dwarf(PuppyModbus &bus, const uint8_t dwarf_nr, uint8_t modbus_address)
 
               // Process sample
               loadcell.ProcessSample(data.loadcell_raw_value, loadcell_samplerate.last_timestamp); },
-          .accelerometer_handler = [this](AccelerometerData data) {
-              // throw away samples if time is not synced
-              if (!this->time_sync.is_time_sync_valid() || !this->selected) {
-                  return;
-              }
-              PrusaAccelerometer::put_sample(data.sample);
-              report_accelerometer(1); },
           .accelerometer_fast_handler = [this](AccelerometerFastData data) {
               // throw away samples if not selected
               if (!this->is_selected()) {
@@ -80,7 +73,12 @@ Dwarf::Dwarf(PuppyModbus &bus, const uint8_t dwarf_nr, uint8_t modbus_address)
               for (AccelerometerXyzSample sample : data) {
                   PrusaAccelerometer::put_sample(sample);
               }
-              report_accelerometer(data.size()); } }) {
+              report_accelerometer(data.size()); },
+          .accelerometer_freq_handler = [this](AccelerometerSamplingRate data) {
+              if (!this->is_selected()) {
+                    return;
+              }
+              PrusaAccelerometer::set_rate(data.frequency); } }) {
 
     RegisterGeneralStatus.value.FaultStatus = dwarf_shared::errors::FaultStatusMask::NO_FAULT;
     RegisterGeneralStatus.value.HotendMeasuredTemperature = HEATER_0_MINTEMP + 1; // Init to temperature that won't immediately trigger mintemp
@@ -176,7 +174,6 @@ CommunicationStatus Dwarf::initial_scan() {
     IsSelectedCoil.dirty = true;
     LoadcellEnableCoil.dirty = true;
     AccelerometerEnableCoil.dirty = true;
-    AccelerometerHighCoil.dirty = true;
     selected = false;
 
     // Write coil values that are not written automatically
@@ -186,9 +183,6 @@ CommunicationStatus Dwarf::initial_scan() {
     if (bus.write(unit, AccelerometerEnableCoil) == CommunicationStatus::ERROR) {
         return CommunicationStatus::ERROR;
     }
-    if (bus.write(unit, AccelerometerHighCoil) == CommunicationStatus::ERROR) {
-        return CommunicationStatus::ERROR;
-    }
 
     return status;
 }
@@ -436,7 +430,7 @@ CommunicationStatus Dwarf::set_selected(bool selected) {
     if (selected) {
         // Enable loadcell for dwarf being selected in case the accelerometer is not already enabled
         // This condition prevents replacing accelerometer with loadcell when recovering from puppy failure
-        if (!AccelerometerHighCoil.value) {
+        if (!AccelerometerEnableCoil.value) {
             if (!set_loadcell(true)) {
                 return CommunicationStatus::ERROR;
             }
@@ -482,9 +476,7 @@ bool Dwarf::raw_set_loadcell(bool enable) {
 bool Dwarf::raw_set_accelerometer(bool enable) {
     AccelerometerEnableCoil.dirty = true;
     AccelerometerEnableCoil.value = enable;
-    AccelerometerHighCoil.dirty = true;
-    AccelerometerHighCoil.value = enable;
-    return bus.write(unit, AccelerometerEnableCoil) == CommunicationStatus::OK && bus.write(unit, AccelerometerHighCoil) == CommunicationStatus::OK;
+    return bus.write(unit, AccelerometerEnableCoil) == CommunicationStatus::OK;
 }
 
 constexpr log_component_t &Dwarf::get_log_component(uint8_t dwarf_nr) {
diff --git a/src/puppies/fifo_decoder.cpp b/src/puppies/fifo_decoder.cpp
index 3108824edc..51db6e7772 100644
--- a/src/puppies/fifo_decoder.cpp
+++ b/src/puppies/fifo_decoder.cpp
@@ -28,12 +28,12 @@ void Decoder::decode(const Callbacks_t callbacks) {
         case MessageType::loadcell:
             make_call(callbacks.loadcell_handler);
             break;
-        case MessageType::accelerometer:
-            make_call(callbacks.accelerometer_handler);
-            break;
         case MessageType::accelerometer_fast:
             make_call(callbacks.accelerometer_fast_handler);
             break;
+        case MessageType::accelerometer_sampling_rate:
+            make_call(callbacks.accelerometer_freq_handler);
+            break;
         default:
             assert(false);
         }
diff --git a/src/puppy/dwarf/accelerometer.cpp b/src/puppy/dwarf/accelerometer.cpp
index c01fdda817..e963fdf7c3 100644
--- a/src/puppy/dwarf/accelerometer.cpp
+++ b/src/puppy/dwarf/accelerometer.cpp
@@ -1,106 +1,41 @@
-#include "log.h"
 #include "accelerometer.hpp"
 #include "timing.h"
 #include <cstdint>
+#include <common/bsod.h>
 #include <common/circular_buffer.hpp>
 #include <atomic>
+#include <cassert>
 #include <lis2dh12_reg.h>
 #include "hwio_pindef.h"
 
-// #define DEBUG_SAMPLERATE
-
 using namespace dwarf::accelerometer;
 using namespace buddy::hw;
 
 namespace {
-static constexpr size_t ACCELEROMETER_BUFFER_RECORDS_NUM = 64;
-static constexpr lis2dh12_odr_t low_sample_rate = LIS2DH12_ODR_400Hz;
-static constexpr lis2dh12_odr_t high_sample_rate = LIS2DH12_ODR_5kHz376_LP_1kHz344_NM_HP;
+static constexpr size_t ACCELEROMETER_BUFFER_RECORDS_NUM = 128;
 
 CircularBuffer<AccelerometerRecord, ACCELEROMETER_BUFFER_RECORDS_NUM> sample_buffer;
+uint32_t first_sample_timestamp = 0;
+uint32_t last_sample_timestamp = 0;
+size_t samples_extracted = 0;
 size_t overflown_count = 0;
-size_t overflown_logged_count = 0;
-lis2dh12_odr_t current_sample_rate = low_sample_rate;
-stmdev_ctx_t dev_ctx;
-std::atomic<bool> initialized = false;
-
-LOG_COMPONENT_DEF(Accel, LOG_SEVERITY_INFO);
-
-#ifdef DEBUG_SAMPLERATE
-class SampleRateDebug {
-public:
-    SampleRateDebug() {
-        clear();
-    }
-
-    void clear() {
-        last_timestamp_us = 0;
-        last_milestone_timestamp_us = 0;
-        max_interval = 0;
-        min_interval = std::numeric_limits<uint32_t>::max();
-        sample_counter = 0;
-        last_milestone_time_us = 0;
-        hist.fill(0);
-    }
-
-    void sample(uint32_t timestamp_us) {
-        if (last_milestone_timestamp_us != 0 && sample_counter % milestone_interval == 0) {
-            last_milestone_time_us = timestamp_us - last_milestone_timestamp_us;
-            log_info(Accel, "%d samples in %d us", milestone_interval, last_milestone_time_us);
-            last_milestone_timestamp_us = timestamp_us;
-        }
-
-        volatile const uint32_t diff = timestamp_us - last_timestamp_us;
-        if (last_timestamp_us != 0 && diff < std::numeric_limits<uint32_t>::max() / 2) {
-            if (max_interval < diff) {
-                max_interval = diff;
-            }
-            if (min_interval > diff) {
-                min_interval = diff;
-            }
 
-            assert(diff < hist.size() * hist_step_us);
-            hist[diff / hist_step_us]++;
-        }
-
-        sample_counter++;
-        last_timestamp_us = timestamp_us;
-    }
-
-    void report() {
-        log_info(Accel, "Sample interval: min: %d us, max: %d us", min_interval, max_interval);
-
-        size_t pos = 0;
-        static char buff[8 * hist_buckets];
-        for (size_t &val : hist) {
-            pos += snprintf(buff + pos, sizeof(buff) - pos, "%d,", val);
-        }
-        log_info(Accel, buff);
-    }
-
-private:
-    static constexpr size_t hist_step_us = 10;
-    static constexpr uint32_t milestone_interval = 1000;
-    static constexpr size_t hist_buckets = 200;
-    std::array<size_t, hist_buckets> hist {};
-
-    uint32_t last_timestamp_us = 0;
-    uint32_t max_interval = 0;
-    uint32_t min_interval = std::numeric_limits<uint32_t>::max();
-    size_t sample_counter = 0;
-    uint32_t last_milestone_timestamp_us = 0;
-    uint32_t last_milestone_time_us = 0;
+enum class State : uint8_t {
+    uninitialized = 0,
+    disabled,
+    enabled,
 };
-#else
-class SampleRateDebug {
-public:
-    void clear() {}
-    void sample([[maybe_unused]] uint32_t timestamp_us) {}
-    void report() {}
-};
-#endif
+State state = State::uninitialized;
 
-SampleRateDebug debug;
+void clear() {
+    taskENTER_CRITICAL();
+    sample_buffer.clear();
+    taskEXIT_CRITICAL();
+    overflown_count = 0;
+    first_sample_timestamp = 0;
+    last_sample_timestamp = 0;
+    samples_extracted = 0;
+}
 
 /*
  * @brief  Write generic device register
@@ -139,75 +74,95 @@ int32_t read_reg(void *handle, uint8_t reg, uint8_t *bufp, uint16_t len) {
     return reg_stat == HAL_OK && data_stat == HAL_OK ? 0 : -1;
 }
 
-void init() {
-    assert(!initialized);
-    debug.clear();
-
-    // Clear buffer
-    taskENTER_CRITICAL();
-    sample_buffer.clear();
-    taskEXIT_CRITICAL();
-    overflown_count = 0;
-    overflown_logged_count = 0;
-
-    // Initialize driver
-    dev_ctx.write_reg = write_reg;
-    dev_ctx.read_reg = read_reg;
-    dev_ctx.handle = &SPI_HANDLE_FOR(accelerometer);
-
-    // Soft reboot device
-    lis2dh12_boot_set(&dev_ctx, PROPERTY_ENABLE);
-    delay_ms(5);
+stmdev_ctx_t dev_ctx {
+    .write_reg = write_reg,
+    .read_reg = read_reg,
+    .mdelay = nullptr,
+    .handle = &SPI_HANDLE_FOR(accelerometer),
+};
 
-    // Check device ID
+void check_device_id() {
     uint8_t who_am_i;
     lis2dh12_device_id_get(&dev_ctx, &who_am_i);
     if (who_am_i != LIS2DH12_ID) {
-        log_critical(Accel, "Invalid device ID: 0x%x", who_am_i);
-        return;
+        bsod("Invalid device ID: 0x%x", who_am_i);
     }
+}
 
-    // Clear filter block by reading reference register
-    uint8_t dummy;
-    lis2dh12_filter_reference_get(&dev_ctx, &dummy);
-
-    // Configure device
-    lis2dh12_block_data_update_set(&dev_ctx, PROPERTY_ENABLE);
+void configure_interrupt() {
     lis2dh12_ctrl_reg3_t reg3 {};
     reg3.i1_zyxda = true;
     lis2dh12_pin_int1_config_set(&dev_ctx, &reg3);
-    lis2dh12_full_scale_set(&dev_ctx, LIS2DH12_2g);
-    lis2dh12_operating_mode_set(&dev_ctx, LIS2DH12_NM_10bit);
-    lis2dh12_data_rate_set(&dev_ctx, current_sample_rate);
+}
 
-    // Wait for sample and throw it away to make sure interrupt is not already pending
-    lis2dh12_status_reg_t status {};
-    while (!status.zyxda) {
-        lis2dh12_status_get(&dev_ctx, &status);
-    }
+void enable_sampling() {
+    constexpr lis2dh12_ctrl_reg1_t ctrl_reg1 {
+        .xen = 1, // enable x axis
+        .yen = 1, // enable y axis
+        .zen = 1, // enable z axis
+        .lpen = 0, // disable low power mode
+        .odr = 0x9, // enable output
+    };
+    write_reg(dev_ctx.handle, LIS2DH12_CTRL_REG1, (const uint8_t *)&ctrl_reg1, 1);
+}
+
+void disable_sampling() {
+    constexpr lis2dh12_ctrl_reg1_t ctrl_reg1 {
+        .xen = 1, // enable x axis
+        .yen = 1, // enable y axis
+        .zen = 1, // enable z axis
+        .lpen = 0, // disable low power mode
+        .odr = 0x0, // disable output
+    };
+    write_reg(dev_ctx.handle, LIS2DH12_CTRL_REG1, (const uint8_t *)&ctrl_reg1, 1);
+}
+
+void throwaway_sample() {
     int16_t dummy_accel[3];
     lis2dh12_acceleration_raw_get(&dev_ctx, dummy_accel);
+}
 
-    // Mark initialized before enabling the IRQ
-    initialized = true;
+} // end anonymous namespace
 
-    // Enable new sample interrupt
-    lis2dh12_data.enableIRQ();
+void dwarf::accelerometer::enable() {
+    switch (state) {
+    case State::uninitialized:
+        check_device_id();
+        configure_interrupt();
+        [[fallthrough]];
+    case State::disabled:
+        clear();
+        enable_sampling();
+        state = State::enabled;
+        return;
+    case State::enabled:
+        return;
+    }
 }
 
-void deinit() {
-    assert(initialized);
-    buddy::hw::lis2dh12_data.disableIRQ();
-    initialized = false;
-    debug.report();
+void dwarf::accelerometer::disable() {
+    switch (state) {
+    case State::uninitialized:
+        return;
+    case State::disabled:
+        return;
+    case State::enabled:
+        state = State::disabled;
+        disable_sampling();
+        throwaway_sample();
+        clear();
+        return;
+    }
 }
 
-} // end anonymous namespace
-
 void dwarf::accelerometer::irq() {
-    assert(initialized);
-    if (!initialized) {
+    switch (state) {
+    case State::uninitialized:
         return;
+    case State::disabled:
+        return;
+    case State::enabled:
+        break;
     }
 
     // Check status for overrun
@@ -215,8 +170,15 @@ void dwarf::accelerometer::irq() {
     lis2dh12_status_get(&dev_ctx, &status);
 
     // Get sample and store sample
+    uint32_t now = ticks_us();
+    if (first_sample_timestamp == 0) {
+        first_sample_timestamp = now;
+        samples_extracted = 0;
+    }
+    last_sample_timestamp = now;
+    ++samples_extracted;
+
     AccelerometerRecord record;
-    record.timestamp = ticks_us();
     record.buffer_overflow = overflown_count > 0;
     record.sample_overrun = status.zyxor;
     lis2dh12_acceleration_raw_get(&dev_ctx, record.raw);
@@ -224,17 +186,6 @@ void dwarf::accelerometer::irq() {
     if (!sample_buffer.try_put(record)) {
         overflown_count++;
     }
-
-    debug.sample(record.timestamp);
-}
-
-void dwarf::accelerometer::accelerometer_loop() {
-    static uint32_t buffer_over_reported_time = 0;
-    if (overflown_count != overflown_logged_count && (buffer_over_reported_time + 5000U) < ticks_ms()) {
-        log_critical(Accel, "accelerometer overflowed, %d samples didn't fit ", overflown_count);
-        buffer_over_reported_time = ticks_ms();
-        overflown_logged_count = overflown_count;
-    }
 }
 
 bool dwarf::accelerometer::accelerometer_get_sample(AccelerometerRecord &sample) {
@@ -253,34 +204,10 @@ size_t dwarf::accelerometer::get_num_samples() {
     return size;
 }
 
-void dwarf::accelerometer::set_enable(bool enabled) {
-    if (initialized == enabled) {
-        return;
-    }
-
-    if (enabled) {
-        init();
-    } else {
-        deinit();
-    }
-}
-
-bool dwarf::accelerometer::is_enabled() {
-    return initialized;
-}
-
-void dwarf::accelerometer::set_high_sample_rate(bool high) {
-    current_sample_rate = high ? high_sample_rate : low_sample_rate;
-
-    if (!initialized) {
-        return;
+float dwarf::accelerometer::measured_sampling_rate() {
+    uint32_t duration = ticks_diff(last_sample_timestamp, first_sample_timestamp);
+    if (duration == 0 || samples_extracted == 0) {
+        return 0;
     }
-
-    lis2dh12_data.disableIRQ();
-    lis2dh12_data_rate_set(&dev_ctx, current_sample_rate);
-    lis2dh12_data.enableIRQ();
-}
-
-bool dwarf::accelerometer::is_high_sample_rate() {
-    return current_sample_rate == high_sample_rate;
+    return (samples_extracted - 1) * 1000000.f / duration;
 }
diff --git a/src/puppy/dwarf/accelerometer.hpp b/src/puppy/dwarf/accelerometer.hpp
index acc775bd80..3c366a3cb6 100644
--- a/src/puppy/dwarf/accelerometer.hpp
+++ b/src/puppy/dwarf/accelerometer.hpp
@@ -5,13 +5,10 @@
 
 namespace dwarf::accelerometer {
 
-void set_enable(bool enabled);
-bool is_enabled();
-void set_high_sample_rate(bool high);
-bool is_high_sample_rate();
-void accelerometer_loop();
-void accelerometer_irq();
 bool accelerometer_get_sample(AccelerometerRecord &sample);
 size_t get_num_samples();
+float measured_sampling_rate();
+void enable();
+void disable();
 void irq();
 } // namespace dwarf::accelerometer
diff --git a/src/puppy/dwarf/modbus/ModbusControl.cpp b/src/puppy/dwarf/modbus/ModbusControl.cpp
index 562333b8db..9d507c4733 100644
--- a/src/puppy/dwarf/modbus/ModbusControl.cpp
+++ b/src/puppy/dwarf/modbus/ModbusControl.cpp
@@ -181,11 +181,11 @@ void ProcessModbusMessages() {
             break;
         }
         case ((uint16_t)ModbusRegisters::SystemCoil::accelerometer_enable): {
-            dwarf::accelerometer::set_enable(msg->m_Value);
-            break;
-        }
-        case ((uint16_t)ModbusRegisters::SystemCoil::accelerometer_high): {
-            dwarf::accelerometer::set_high_sample_rate(msg->m_Value);
+            if (msg->m_Value) {
+                dwarf::accelerometer::enable();
+            } else {
+                dwarf::accelerometer::disable();
+            }
             break;
         }
         case ftrstd::to_underlying(ModbusRegisters::SystemHoldingRegister::nozzle_target_temperature): {
diff --git a/src/puppy/dwarf/modbus/ModbusFIFOHandlers.cpp b/src/puppy/dwarf/modbus/ModbusFIFOHandlers.cpp
index 8c7d4f1958..59b55966b5 100644
--- a/src/puppy/dwarf/modbus/ModbusFIFOHandlers.cpp
+++ b/src/puppy/dwarf/modbus/ModbusFIFOHandlers.cpp
@@ -11,6 +11,12 @@ using namespace common::puppies::fifo;
 
 LOG_COMPONENT_DEF(ModbusFIFOHandlers, LOG_SEVERITY_DEBUG);
 
+/**
+ * @brief Holds number of sent accelerometer samples; used for rate-limiting of
+ * frequency report
+ */
+static int acc_sample_counter = 0;
+
 /**
  * @brief Failed to encode
  *
@@ -37,31 +43,20 @@ static void failed_to_encode() {
  */
 static void pickup_accelerometer_sample(Encoder &encoder, bool &encoded) {
     dwarf::accelerometer::AccelerometerRecord record;
-    if (dwarf::accelerometer::is_high_sample_rate()) {
-        if (encoder.can_encode<AccelerometerFastData>() && (dwarf::accelerometer::get_num_samples() >= std::tuple_size<AccelerometerFastData>::value)) {
-            AccelerometerFastData accelerometer_data;
-            for (auto &xyzSample : accelerometer_data) {
-                if (!dwarf::accelerometer::accelerometer_get_sample(record)) {
-                    // This can never happen as we already checked
-                    // there are enough samples before.
-                    bsod("Get accelerometer sample failed.");
-                }
-                xyzSample = AccelerometerUtils::pack_record(record);
-            }
-            if (encoder.encode(accelerometer_data)) {
-                encoded = true;
-            } else {
-                failed_to_encode();
+    if (encoder.can_encode<AccelerometerFastData>() && (dwarf::accelerometer::get_num_samples() >= std::tuple_size<AccelerometerFastData>::value)) {
+        AccelerometerFastData accelerometer_data;
+        for (auto &xyzSample : accelerometer_data) {
+            if (!dwarf::accelerometer::accelerometer_get_sample(record)) {
+                // This can never happen as we already checked
+                // there are enough samples before.
+                bsod("Get accelerometer sample failed.");
             }
+            xyzSample = AccelerometerUtils::pack_record(record);
         }
-    } else {
-        if (encoder.can_encode<AccelerometerData>() && dwarf::accelerometer::accelerometer_get_sample(record)) {
-            AccelerometerData accelerometer_data = { record.timestamp, AccelerometerUtils::pack_record(record) };
-            if (encoder.encode(accelerometer_data)) {
-                encoded = true;
-            } else {
-                failed_to_encode();
-            }
+        if (encoder.encode(accelerometer_data)) {
+            encoded = true;
+        } else {
+            failed_to_encode();
         }
     }
 }
@@ -83,6 +78,22 @@ size_t handle_encoded_fifo(std::array<uint16_t, MODBUS_FIFO_LEN> &fifo) {
         encoded = false;
 
         pickup_accelerometer_sample(encoder, encoded);
+        if (encoded) {
+            acc_sample_counter++;
+            continue; // Continue packing accelerometer samples - the highest priority
+        }
+
+        if (acc_sample_counter >= 100) {
+            acc_sample_counter = 0;
+            if (encoder.can_encode<AccelerometerSamplingRate>()) {
+                AccelerometerSamplingRate sample = { .frequency = dwarf::accelerometer::measured_sampling_rate() };
+                if (encoder.encode(sample)) {
+                    encoded = true;
+                } else {
+                    failed_to_encode();
+                }
+            }
+        }
 
         // Pickup loadcell sample
         if (encoder.can_encode<LoadcellRecord>()) {
@@ -90,6 +101,7 @@ size_t handle_encoded_fifo(std::array<uint16_t, MODBUS_FIFO_LEN> &fifo) {
             if (dwarf::loadcell::get_loadcell_sample(sample)) {
                 if (encoder.encode(sample)) {
                     encoded = true;
+                    continue; // Continue packing loadcell samples - the second highest priority
                 } else {
                     failed_to_encode();
                 }
diff --git a/src/puppy/dwarf/module_marlin.cpp b/src/puppy/dwarf/module_marlin.cpp
index fee0a2a358..96bce355be 100644
--- a/src/puppy/dwarf/module_marlin.cpp
+++ b/src/puppy/dwarf/module_marlin.cpp
@@ -101,8 +101,6 @@ void dwarf::modules::marlin::start() {
 
         dwarf::loadcell::loadcell_loop();
 
-        dwarf::accelerometer::accelerometer_loop();
-
         Cheese::update();
 
         // process any modbus request that are pending
diff --git a/tests/unit/puppies/fifo_coder_tests.cpp b/tests/unit/puppies/fifo_coder_tests.cpp
index 0e7861d965..dbbf92ac06 100644
--- a/tests/unit/puppies/fifo_coder_tests.cpp
+++ b/tests/unit/puppies/fifo_coder_tests.cpp
@@ -8,7 +8,6 @@ using namespace common::puppies::fifo;
 
 static constexpr LogData log_fragment = { 'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o' };
 static constexpr LoadcellRecord loadcell_fragment = { 0, 0x12345678 };
-static constexpr AccelerometerData accelerometer_fragment = { 1, 0x12345678 };
 static constexpr AccelerometerFastData accelerometer_fast_fragment = { 0x87654321, 0x12354678 };
 
 TEST_CASE("Encoder allignment") {
@@ -203,7 +202,6 @@ TEST_CASE("Encode - decode") {
 
     REQUIRE(encoder.encode(log_fragment));
     REQUIRE(encoder.encode(loadcell_fragment));
-    REQUIRE(encoder.encode(accelerometer_fragment));
     REQUIRE(encoder.encode(accelerometer_fast_fragment));
     encoder.padd();
 
@@ -211,7 +209,6 @@ TEST_CASE("Encode - decode") {
 
     int num_log = 0;
     int num_loadcell = 0;
-    int num_accelerometer = 0;
     int num_accelerometer_fast = 0;
 
     decoder.decode({
@@ -224,11 +221,6 @@ TEST_CASE("Encode - decode") {
             REQUIRE(data.loadcell_raw_value == loadcell_fragment.loadcell_raw_value);
             num_loadcell++;
         },
-        [&num_accelerometer](AccelerometerData data) {
-            REQUIRE(data.timestamp_us == accelerometer_fragment.timestamp_us);
-            REQUIRE(data.sample == accelerometer_fragment.sample);
-            num_accelerometer++;
-        },
         [&num_accelerometer_fast](AccelerometerFastData data) {
             REQUIRE(data[0] == accelerometer_fast_fragment[0]);
             REQUIRE(data[1] == accelerometer_fast_fragment[1]);
@@ -238,7 +230,6 @@ TEST_CASE("Encode - decode") {
 
     CHECK(num_log == 1);
     CHECK(num_loadcell == 1);
-    CHECK(num_accelerometer == 1);
     CHECK(num_accelerometer_fast == 1);
 }
 
diff --git a/utils/gdb/precise_stepping.py b/utils/gdb/precise_stepping.py
index 9117433e6f..ea30dd193d 100644
--- a/utils/gdb/precise_stepping.py
+++ b/utils/gdb/precise_stepping.py
@@ -1,5 +1,12 @@
 import gdb
 
+PS_TICK_FREQ = 1000000
+
+
+def _bit_flag(bits, pos, fmt):
+    v = int((bits & (1 << pos)) != 0)
+    return fmt[v]
+
 
 # StepEventFlag_t prettyprinter
 class StepEventFlagPrinter:
@@ -21,14 +28,19 @@ def dirs(bits):
         return v
 
     def to_string(self):
-        flags = int(self.val)
-        step = self.xyze(flags)
-        dirs = self.dirs(flags >> 4)
-        act = self.xyze(flags >> 8)
-        desc = f'S:{step} D:{dirs} A:{act} F:'
-        desc += 'B' if flags & (1 << 12) else '-'
-        desc += 'E' if flags & (1 << 13) else '-'
-        return '|' + desc + '|'
+        bits = int(self.val)
+
+        step = self.xyze(bits)
+        dirs = self.dirs(bits >> 4)
+        act = self.xyze(bits >> 8)
+
+        flags = ''
+        flags += _bit_flag(bits, 12, '-B')  # BEGINNING_OF_MOVE_SEGMENT
+        flags += _bit_flag(bits, 13, '-E')  # FLAG_END_OF_MOTION
+        flags += _bit_flag(bits, 14, '-K')  # KEEP_ALIVE
+        flags += _bit_flag(bits, 15, '-F')  # FIRST_STEP_EVENT
+
+        return f'|S:{step} D:{dirs} A:{act} F:{flags}|'
 
     @classmethod
     def register(cls, val):
@@ -40,7 +52,7 @@ def register(cls, val):
 gdb.pretty_printers.append(StepEventFlagPrinter.register)
 
 
-# step_event_t prettyprinter
+# step_event_{i32,u16}_t prettyprinter
 class StepEventPrinter:
     def __init__(self, val):
         self.val = val
@@ -48,13 +60,78 @@ def __init__(self, val):
     def to_string(self):
         ticks = int(self.val['time_ticks'])
         flags = str(self.val['flags'])
-        return f'SE +{ticks:04} {flags}'
+
+        if str(self.val.type) == 'step_event_i32_t':
+            return f'SEi32 {ticks:11} {flags}'
+        elif str(self.val.type) == 'step_event_u16_t':
+            return f'SEu16 {ticks:5} {flags}'
+
+        raise Exception('unhandled type')
 
     @classmethod
     def register(cls, val):
-        if str(val.type) == 'step_event_t':
+        if str(val.type) in {'step_event_i32_t', 'step_event_u16_t'}:
             return cls(val)
         return None
 
 
 gdb.pretty_printers.append(StepEventPrinter.register)
+
+
+# Full step-event-queue prettyprinter
+class PrintStepEventQueue(gdb.Command):
+    def __init__(self):
+        super().__init__('ps-step-event-queue', gdb.COMMAND_USER)
+
+    def invoke(self, cmd, from_tty):
+        seq = gdb.lookup_symbol('PreciseStepping::step_event_queue')[0].value()
+        data = seq['data']
+        head = int(seq['head'])
+        tail = int(seq['tail'])
+        size = data.type.range()[1] + 1
+        items = head - tail if head >= tail else (head + size) - tail
+        ticks = 0
+        print(f'step_event_queue: {items}/{size}')
+        for n in range(tail, tail + items):
+            i = n % size
+            ms = ticks / PS_TICK_FREQ * 1000
+            print(f'[{i:4}]', str(data[i]), f'{ms:7.3f}ms')
+            ticks += int(data[i]['time_ticks'])
+
+
+PrintStepEventQueue()
+
+
+# MoveFlag_t prettyprinter
+class MoveFlagPrinter:
+    def __init__(self, val):
+        self.val = val
+
+    def to_string(self):
+        bits = int(self.val)
+
+        dirs = StepEventFlagPrinter.dirs(bits >> 4)
+        act = StepEventFlagPrinter.xyze(bits >> 8)
+        reset = StepEventFlagPrinter.xyze(bits >> 16)
+
+        phase = ''
+        phase += _bit_flag(bits, 0, '-A')  # ACCELERATION_PHASE
+        phase += _bit_flag(bits, 2, '-C')  # CRUISE_PHASE
+        phase += _bit_flag(bits, 1, '-D')  # DECELERATION_PHASE
+
+        flags = ''
+        flags += _bit_flag(bits, 12, '-F')  # FIRST_MOVE_SEGMENT_OF_BLOCK
+        flags += _bit_flag(bits, 13, '-L')  # LAST_MOVE_SEGMENT_OF_BLOCK
+        flags += _bit_flag(bits, 14, '-B')  # BEGINNING_EMPTY_MOVE
+        flags += _bit_flag(bits, 15, '-E')  # ENDING_EMPTY_MOVE
+
+        return f'|P:{phase} D:{dirs} A:{act} R:{reset} F:{flags}|'
+
+    @classmethod
+    def register(cls, val):
+        if str(val.type) == 'MoveFlag_t':
+            return cls(val)
+        return None
+
+
+gdb.pretty_printers.append(MoveFlagPrinter.register)
diff --git a/utils/holly/build-pr.jenkins b/utils/holly/build-pr.jenkins
index d14d7568d3..6945771ae5 100644
--- a/utils/holly/build-pr.jenkins
+++ b/utils/holly/build-pr.jenkins
@@ -129,15 +129,10 @@ pipeline {
                         name 'configuration'
                         // preset,build_type,bootloader(yesboot|noboot|emptyboot)
                         values 'mini-en-cs,release,yesboot',
-                            'mini-en-de,release,yesboot',
-                            'mini-en-es,release,yesboot',
-                            'mini-en-fr,release,yesboot',
-                            'mini-en-it,release,yesboot',
-                            'mini-en-pl,release,yesboot',
                             'mk3.5,release,yesboot',
                             'mk4,release,yesboot',
-                            'mk4,release,noboot', // Needed for integration tests, please don't delete
                             'xl,release,yesboot',
+                            'xl-burst,release,yesboot',
                             'ix,release,yesboot'
                     }
                 }
@@ -242,50 +237,6 @@ pipeline {
                         }
                     }
                 }
-
-                stage('Integration Tests') {
-                    agent {
-                        dockerfile {
-                            label 'integrationtests'
-                            filename 'utils/holly/IntegrationTestsDockerfile'
-                            additionalBuildArgs '-t it-prusa-firmware-buddy'
-                        }
-                    }
-                    steps {
-                        script {
-                            Exception caughtException = null
-
-                            timeout(time: 30, unit: "MINUTES") {
-                                catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
-                                    try {
-                                        unstash "mk4,release,noboot"
-                                        sh """
-                                        ln -fs /work/.dependencies
-                                        ln -fs /work/.venv
-                                        export EASYOCR_MODULE_PATH=./easyocr
-                                        . .venv/bin/activate
-                                        python3 utils/bootstrap.py
-                                        python3 -m pytest tests/integration --firmware build/mk4_release_noboot/firmware.bin --log-cli-level info --log-cli-format="%(asctime)s [%(levelname)8s] (%(filename)s:%(lineno)s) %(message)s" --log-cli-date-format="%Y-%m-%d %H:%M:%S" | grep -v "Bus unhandled low duration"
-                                        """
-                                    } catch (org.jenkinsci.plugins.workflow.steps.FlowInterruptedException e) {
-                                        error "Caught ${e.toString()}"
-                                    } catch (Throwable e) {
-                                        caughtException = e
-                                    }
-                                }
-                            }
-
-                            if (caughtException) {
-                                error caughtException.message
-                            }
-                        }
-                    }
-                    post {
-                        failure {
-                            archiveArtifacts artifacts: '/tmp/pytest-of-root'
-                        }
-                    }
-                }
             }
         }
     }
diff --git a/utils/phase_stepping/__init__.py b/utils/phase_stepping/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/utils/phase_stepping/optimize.py b/utils/phase_stepping/optimize.py
new file mode 100644
index 0000000000..8e714fa700
--- /dev/null
+++ b/utils/phase_stepping/optimize.py
@@ -0,0 +1,166 @@
+from collections import OrderedDict
+import sys
+from typing import Callable, Tuple
+import numpy as np
+
+
+def make2DSimplex(origin, distance):
+    numPoints = 3
+    angle = 2 * np.pi / numPoints
+
+    points = []
+    for i in range(numPoints):
+        x = origin[0] + distance * np.cos(i * angle)
+        y = origin[1] + distance * np.sin(i * angle)
+        points.append((x, y))
+    return points
+
+
+def nelderMead(f,
+               initialSimplex,
+               noImproveThr=10e-6,
+               noImprovCount=10,
+               maxIter=100,
+               alpha=1.,
+               gamma=2.,
+               rho=-0.5,
+               sigma=0.5):
+    dim = len(initialSimplex[0])
+
+    print("Initial measurement")
+
+    target = [(np.array(p), f(p)) for p in initialSimplex]
+    prevBestScore = None
+    noImprov = 0
+
+    for iteration in range(maxIter):
+        target.sort(key=lambda x: x[1])
+        simplex = [t[0] for t in target]
+        bestScore = target[0][1]
+        secondWorstScore = target[-2][1]
+        print(f"Iteration {iteration} - {bestScore}")
+        if prevBestScore is not None:
+            print(f"{prevBestScore - bestScore}")
+
+        print(f"  {simplex}, {bestScore}")
+
+        if prevBestScore is not None and prevBestScore - bestScore < noImproveThr:
+            noImprov += 1
+        else:
+            noImprov = 0
+
+        if noImprov >= noImprovCount:
+            return target[0]
+
+        if prevBestScore is None or bestScore <= prevBestScore:
+            prevBestScore = bestScore
+        else:
+            assert False
+
+        centroid = np.sum(simplex[:-1], axis=0) / dim
+
+        # Reflect...
+        reflection = centroid + alpha * (centroid - simplex[-1])
+        reflectionScore = f(reflection)
+        print(f"  reflection: {reflection}: {reflectionScore}")
+
+        if bestScore <= reflectionScore < secondWorstScore:
+            target[-1] = (reflection, reflectionScore)
+            continue
+
+        if reflectionScore < bestScore:
+            # ... expand
+            expansion = centroid + gamma * (centroid - simplex[-1])
+            expansionScore = f(expansion)
+            print(f"  expansion: {expansion}: {expansionScore}")
+            if expansionScore < reflectionScore:
+                target[-1] = (expansion, expansionScore)
+                continue
+            else:
+                target[-1] = (reflection, reflectionScore)
+                continue
+
+        # Contract
+        contraction = centroid + rho * (centroid - simplex[-1])
+        contractionScore = f(contraction)
+        print(f"  contraction: {contraction}: {contractionScore}")
+        if contractionScore < bestScore:
+            target[-1] = (contraction, contractionScore)
+            continue
+
+        # Shrink
+        print("  shrink")
+        for i in range(1, dim + 1):
+            p = simplex[0] + sigma * (simplex[i] - simplex[0])
+            target[i] = (p, f(p))
+            print(f"    {simplex[i]} -> {target[i][0]} {target[i][1]}")
+
+    target.sort(key=lambda x: x[1])
+    return target[0]
+
+
+def goldenSearch(func: Callable[[float], float],
+                 brack: Tuple[float, float],
+                 tol=1e-5,
+                 maxiter: int = 1000):
+    phi = (1 + 5**0.5) / 2.0
+    invPhi = 1 / phi
+
+    # Initial bracketing
+    a, b = brack
+    c = b - invPhi * (b - a)
+    d = a + invPhi * (b - a)
+
+    fc, fd = func(c), func(d)
+    print(f"  Initial bracket ({c}, {d}) = ({fc}, {fd})")
+
+    numIterations = 0
+    while abs(b - a) > tol and numIterations < maxiter:
+        if fc < fd:
+            b, d, fd = d, c, fc
+            c = b - invPhi * (b - a)
+            fc = func(c)
+        else:
+            a, c, fc = c, d, fd
+            d = a + invPhi * (b - a)
+            fd = func(d)
+        print(f"  Iteration bracket ({c}, {d}) = ({fc}, {fd})")
+        numIterations += 1
+
+    if fc < fd:
+        return c, fc, numIterations
+    else:
+        return d, fd, numIterations
+
+
+def intervalSearch(func: Callable[[float], float],
+                   brack: Tuple[float, float],
+                   tol=1e-5,
+                   maxiter: int = 1000,
+                   n: int = 4):
+    a, b = brack
+    print(f"  Initial interval ({a}, {b})")
+    resArg, resVal = None, None
+    funcCalls = 0
+    arg = np.linspace(a, b, n)
+    dInt = arg[1] - arg[0]
+
+    while dInt > tol:
+        print(f"  Eval {arg} = ", end="")
+        sys.stdout.flush()
+
+        fx = [func(x) for x in arg]
+        funcCalls += len(fx)
+
+        print(f" {fx}")
+
+        i = np.argmin(fx)
+        resArg = arg[i]
+        resVal = fx[i]
+
+        a, b = arg[i] - 4 * dInt / 7, arg[i] + 4 * dInt / 7
+        print(f"  Interval interval ({a}, {b})")
+        arg = np.linspace(a, b, n)
+        dInt = arg[1] - arg[0]
+
+    return resArg, resVal, funcCalls
diff --git a/utils/phase_stepping/phase_stepping.py b/utils/phase_stepping/phase_stepping.py
new file mode 100644
index 0000000000..69d8fe25f0
--- /dev/null
+++ b/utils/phase_stepping/phase_stepping.py
@@ -0,0 +1,901 @@
+from __future__ import annotations
+import itertools
+import time
+
+import click
+
+from copy import copy
+import json
+from contextlib import contextmanager
+import sys
+from typing import ClassVar, Generator, List, Optional, Tuple
+from dataclasses import dataclass, field
+
+import serial.tools.list_ports
+from serial import Serial  # type: ignore
+
+from scipy.fft import rfft, rfftfreq
+import scipy.signal
+import numpy as np
+import plotly.graph_objects as go
+from plotly.express.colors import sample_colorscale
+
+from optimize import intervalSearch, nelderMead, make2DSimplex, goldenSearch
+
+PRUSA_VID = 0x2c99
+MOTOR_PERIOD = 1024
+
+
+class Machine:
+    def __init__(self, port: Serial) -> None:
+        self._port = port
+        self.accFreq = None
+
+    @contextmanager
+    def _preserveTimeout(self) -> Generator[None, None, None]:
+        originalTimeout = self._port.timeout
+        try:
+            yield
+        finally:
+            self._port.timeout = originalTimeout
+
+    def waitForBoot(self) -> None:
+        """
+        Wait for the board to boot up - that is no new info is echoed
+        """
+        self.command("G")
+
+    def command(self, command: str, timeout: float = 10) -> List[str]:
+        """
+        Issue G-code command, waits for completion and returns a list of
+        returned values (lines of response)
+        """
+        if not command.endswith("\n"):
+            command += "\n"
+        with self._preserveTimeout():
+            # Clear pending data
+            self._port.timeout = None
+            self._port.read_all()
+            # Send command
+            self._port.write(command.encode("utf-8"))
+            # Wait for response
+            response = []
+            if timeout != 0:
+                self._port.timeout = timeout
+            else:
+                self._port.timeout = 3
+            while True:
+                line = self._port.readline().decode("utf-8").strip()
+                if line == "":
+                    if timeout != 0:
+                        raise TimeoutError(
+                            f"No response on command {command.strip()}")
+                    else:
+                        return response
+                line = line.strip()
+                if line.endswith("ok"):
+                    if line[:-2] != "":
+                        response.append(line[:-2])
+                    return response
+                response.append(line)
+
+    def multiCommand(self, commands: List[str],
+                     timeout: float = 10) -> List[str]:
+        """
+        Issue multiple G-code commands at once, return line summary.
+        """
+        command = "\n".join(commands) + "\n"
+        okCount = 0
+        with self._preserveTimeout():
+            # Clear pending data
+            self._port.timeout = None
+            self._port.read_all()
+            # Send command
+            self._port.write(command.encode("utf-8"))
+            # Wait for response
+            response = []
+            if timeout != 0:
+                self._port.timeout = timeout
+            else:
+                self._port.timeout = 3
+            while True:
+                line = self._port.readline().decode("utf-8").strip()
+                if line == "":
+                    if timeout != 0:
+                        raise TimeoutError(
+                            f"No response on command {command.strip()}")
+                    else:
+                        return response
+                line = line.strip()
+                if line.endswith("ok"):
+                    if line[:-2] != "":
+                        response.append(line[:-2])
+                    okCount += 1
+                    if okCount == len(commands):
+                        return response
+                response.append(line)
+
+    def measureAccSampligFreq(self) -> None:
+        response = self.command("M975")
+        self.accFreq = [
+            float(x.split(":")[1]) for x in response
+            if x.startswith("sample freq:")
+        ][-1]
+
+
+def getPrusaPort() -> Optional[str]:
+    """
+    Return first port that belongs to a Prusa machine
+    """
+    for port in serial.tools.list_ports.comports():
+        if port.vid == PRUSA_VID:
+            return port.device
+    return None
+
+
+@contextmanager
+def machineConnection(port: str = getPrusaPort()
+                      ) -> Generator[Machine, None, None]:
+    with Serial(port) as s:
+        yield Machine(s)
+
+
+@contextmanager
+def enabledMachineConnection(port: str = getPrusaPort()
+                             ) -> Generator[Machine, None, None]:
+    with Serial(port) as s:
+        m = Machine(s)
+        m.waitForBoot()
+        m.command("M17")
+        m.command("M970 X Y")
+        yield m
+        m.command("M18")
+
+
+@dataclass
+class PhaseCorrection:
+    spectrum: List[Tuple[float, float]] = field(
+        default_factory=lambda: [(0, 0) for _ in range(17)])
+
+    def phaseShift(self) -> List[float]:
+        phaseSeq = []
+        for i in range(MOTOR_PERIOD):
+            pha = i * 2 * np.pi / MOTOR_PERIOD
+            res = 0
+            for n, (mag, phase) in enumerate(self.spectrum):
+                res += mag * np.sin(n * pha + phase)
+            phaseSeq.append(res)
+        return phaseSeq
+
+    def currents(self) -> List[Tuple(int, int)]:
+        currents = []
+        for i, phasehift in enumerate(self.phaseShift()):
+            pha = i * 2 * np.pi / 1024 + phasehift
+            a = np.round(248 * np.sin(pha))
+            b = np.round(248 * np.cos(pha))
+            currents.append((a, b))
+        return currents
+
+
+def adjustedCorrection(corr: PhaseCorrection, n: int, mag: float,
+                       pha: float) -> PhaseCorrection:
+    newC = PhaseCorrection(copy(corr.spectrum))
+    newC.spectrum[n] = newC.spectrum[n][0] + mag, newC.spectrum[n][1] + pha
+    return newC
+
+
+def projectTo(what: Tuple[float, float], dir: Tuple[float, float]) -> float:
+    l = np.sqrt(dir[0] * dir[0] + dir[1] * dir[1])
+    return (what[0] * dir[0] + what[1] * dir[1]) / l
+
+
+@dataclass
+class ResonanceMeasurement:
+    samplesPerPeriod: ClassVar[int] = 1024
+
+    speed: float  # rps
+    realSamplingFreq: float
+    rawSamples: List[Tuple[float, float]]
+
+    @staticmethod
+    def measure(machine: Machine,
+                axis: str,
+                speed: float,
+                revs: float = 1,
+                ret: bool = True,
+                retries: int = 5) -> ResonanceMeasurement:
+        try:
+            machine.multiCommand(["M400", "G92 X0 Y0"])
+            samples, freq = captureAccSamples(machine, axis, revs, speed)
+            if ret:
+                machine.command("G0 F10000 X0 Y0")
+        except RuntimeError:
+            if ret:
+                machine.command("G0 F10000 X0 Y0")
+            if retries <= 0:
+                raise
+            return ResonanceMeasurement.measure(machine, axis, speed, revs,
+                                                ret, retries - 1)
+
+        realFreq = machine.accFreq
+        if realFreq is None:
+            realFreq = freq
+        samples = [(x, y) for x, y, z in samples]
+        return ResonanceMeasurement(speed, realFreq, samples)
+
+    @property
+    def signal(self) -> List[float]:
+        """
+        Compute signal magnitude and resample it to the frequency of motor phase
+        change.
+        """
+        motorFreq = self.speed * 50  # 200-step motor
+        measDur = len(self.rawSamples) / self.realSamplingFreq
+        expectedSampleCount = int(
+            np.round(measDur * motorFreq * self.samplesPerPeriod))
+        magnSig = scipy.signal.detrend(
+            [projectTo(s, (1, 1)) for s in self.rawSamples])
+        return scipy.signal.resample(magnSig, expectedSampleCount)
+
+    @property
+    def signalPeriodChunks(self) -> List[List[float]]:
+        signal = self.signal
+        signal = self.signal
+        chunks = [
+            signal[i:i + self.samplesPerPeriod]
+            for i in range(0, len(signal), self.samplesPerPeriod)
+        ]
+        if len(chunks[-1]) != self.samplesPerPeriod:
+            chunks.pop()
+        return chunks[len(chunks) // 2:]
+
+    @property
+    def avgSignalPeriod(self) -> List[float]:
+        chunks = self.signalPeriodChunks
+        return np.sum(chunks, axis=0) / len(chunks)
+
+    def rawWholePlot(self) -> go.Figure:
+        fig = go.Figure()
+
+        trace = [(i / self.realSamplingFreq, projectTo(s, (1, 1)))
+                 for i, s in enumerate(self.rawSamples)]
+        fig.add_trace(
+            go.Scatter(x=[x[0] for x in trace], y=[x[1] for x in trace]))
+
+        return fig
+
+    def rawPeriodPlot(self) -> go.Figure:
+        fig = go.Figure()
+
+        trace = [(i / self.realSamplingFreq, projectTo(s, (1, 1)))
+                 for i, s in enumerate(self.rawSamples)]
+        period = 1 / (self.speed * 50)
+        chunks = []
+        i = 0
+        while i < len(trace):
+            l = []
+            limit = (1 + len(chunks)) * period
+            while i < len(trace) and trace[i][0] < limit:
+                l.append((trace[i][0] + period - limit, trace[i][1]))
+                i += 1
+            if len(l) > 0:
+                chunks.append(l)
+
+        traceColors = sample_colorscale("jet",
+                                        list(np.linspace(0, 1, len(chunks))))
+        for i, c in enumerate(chunks):
+            fig.add_trace(
+                go.Scatter(x=[x[0] for x in c],
+                           y=[x[1] for x in c],
+                           line=dict(color=traceColors[i])))
+        return fig
+
+    def periodPlot(self) -> go.Figure:
+        fig = go.Figure()
+        chunks = self.signalPeriodChunks
+        traceColors = sample_colorscale("jet",
+                                        list(np.linspace(0, 1, len(chunks))))
+        for i, c in enumerate(chunks):
+            fig.add_trace(go.Scatter(y=c, line=dict(color=traceColors[i])))
+        fig.add_trace(
+            go.Scatter(y=self.avgSignalPeriod,
+                       name="Average",
+                       mode="lines",
+                       line=dict(color="black", width=7)))
+        return fig
+
+    def autocorrPlot(self) -> go.Figure:
+        signal = self.signal
+        autocorr = scipy.signal.correlate(signal, signal, mode='full')
+        lags = np.arange(-len(signal) + 1, len(signal)) / self.samplesPerPeriod
+
+        peaks, _ = scipy.signal.find_peaks(autocorr)
+        peaksY = [autocorr[x] for x in peaks]
+        peaksX = [lags[x] for x in peaks]
+
+        fig = go.Figure()
+        fig.add_trace(
+            go.Scatter(x=lags,
+                       y=autocorr,
+                       mode="lines",
+                       line=dict(color="red")))
+        fig.add_trace(go.Scatter(x=peaksX, y=peaksY, mode="markers"))
+        return fig
+
+    def periodicityPlot(self) -> go.Figure:
+        signal = scipy.signal.detrend(
+            [projectTo(s, (1, 1)) for s in self.rawSamples])
+
+        fft = rfft(signal)
+        timebins = rfftfreq(len(signal), 1 / self.realSamplingFreq)
+
+        fig = go.Figure()
+        fig.update_layout(
+            yaxis={
+                "title": "Amplitude",
+                "range": [0, 8000]
+            },
+            xaxis={"title": "Frequency"},
+        )
+        fig.add_trace(go.Scatter(y=np.abs(fft), x=timebins))
+        return fig
+
+    def plotSpectrum(self, spectrum) -> go.Figure:
+        fig = go.Figure()
+        fig.update_layout(
+            yaxis={
+                "title": "Amplitude",
+                "range": [0, 1500]
+            },
+            xaxis={"title": "Frequency"},
+        )
+        fig.add_trace(
+            go.Bar(x=list(range(16))[1:], y=[x[0] for x in spectrum][1:16]))
+        return fig
+
+    @property
+    def averageSpectrum(self) -> List[Tuple[float, float]]:
+        fft = rfft(self.avgSignalPeriod)
+        return zip(np.abs(fft), np.angle(fft))
+
+    @property
+    def singleChunkSpectrum(self) -> List[Tuple[float, float]]:
+        fft = rfft(self.signalPeriodChunks[0])
+        return zip(np.abs(fft), np.angle(fft))
+
+    @property
+    def wholeSpectrum(self) -> List[Tuple[float, float]]:
+        signal = self.signal
+        periods = int(len(signal) / self.samplesPerPeriod)
+        signal = signal[:periods * self.samplesPerPeriod]
+        fft = rfft(signal)
+
+        chunks = [fft[i:i + periods] for i in range(0, len(fft), periods)]
+        chunkedFft = [np.mean(x) for x in chunks]
+
+        return zip(np.abs(chunkedFft), np.angle(chunkedFft))
+
+    @property
+    def chunkedSpectrum(self) -> List[Tuple[float, float]]:
+        chunks = self.signalPeriodChunks
+        fftChunks = list(rfft(x) for x in chunks)
+        mags = np.sum([np.abs(x) for x in fftChunks], axis=0) / len(fftChunks)
+        phases = np.sum([np.angle(x)
+                         for x in fftChunks], axis=0) / len(fftChunks)
+        return zip(mags, phases)
+
+    @property
+    def directSpectrum(self) -> List[Tuple[float, float]]:
+        motorPeriodDuration = 1 / (self.speed * 50)  # 200-step motor
+        samplingDuration = len(self.rawSamples) / self.realSamplingFreq
+        motorPeriodCount = int(samplingDuration / motorPeriodDuration)
+        relevantSamplesCount = int(motorPeriodCount * motorPeriodDuration /
+                                   samplingDuration * len(self.rawSamples))
+
+        signal = [projectTo(s, (1, 1)) for s in self.rawSamples]
+
+        fft = rfft(signal[:relevantSamplesCount])
+
+        mags = np.abs(fft)
+        phas = np.angle(fft)
+
+        spectrum = [(0, 0)]
+        while True:
+            idx = len(spectrum) * motorPeriodCount
+            if idx >= len(fft):
+                break
+            spectrum.append(((mags[idx - 1] + mags[idx] + mags[idx + 1]) / 3,
+                             (phas[idx - 1] + phas[idx] + phas[idx + 1]) / 3))
+        return spectrum
+
+
+def valuesInRange(start: float, end: float, count: int) -> List[float]:
+    return [start + (end - start) * i / (count - 1) for i in range(count)]
+
+
+def readLut(machine: Machine, axis: str, direction: str) -> PhaseCorrection:
+    rawResponse = machine.command(f"M972 {axis} {direction}")
+
+    correction = PhaseCorrection()
+    for line in rawResponse:
+        if not line.startswith(axis):
+            continue
+        values = line.split(",")
+        dir = values[1].strip()
+        if dir != direction:
+            continue
+        n = int(values[2])
+        mag = float(values[3])
+        pha = float(values[4])
+
+        correction.spectrum[n] = (mag, pha)
+    return correction
+
+
+def writeLut(machine: Machine, axis: str, direction: str,
+             correction: PhaseCorrection) -> None:
+    tableStr = " ".join(
+        [f"{mag:.7g},{pha:.7g}" for mag, pha in correction.spectrum[:16]])
+    command = f"M973 {axis}{direction} {tableStr}"
+    if len(command) > 256:
+        raise RuntimeError("Too long LUT command")
+    machine.command(command)
+    return
+
+
+def captureAccSamples(machine: Machine, axis: str, revs: float, speed: float
+                      ) -> Tuple[List[Tuple[float, float, float, int]], float]:
+    """
+    Move with the print head and capture samples. Return sample in the format: <x>, <y>, <z>, <time_ticks>
+    """
+    rawResponse = machine.command(f"M974 {axis} R{revs} F{speed}")
+    if any("Error:" in x for x in rawResponse):
+        textResponse = "\n".join(rawResponse)
+        raise RuntimeError(
+            f"Cannot capture acc samples for {axis}: {textResponse}")
+    accSamples = [
+        map(float,
+            x.split(",")[1:]) for x in rawResponse if x[0].isdigit()
+    ]
+    freq = [
+        float(x.split(":")[1]) for x in rawResponse
+        if x.startswith("sample freq:")
+    ][0]
+
+    return [(x, y, z) for x, y, z in accSamples], freq
+
+
+def evaluateCorrection(machine: Machine, axis: str, direction: str,
+                       correction: PhaseCorrection,
+                       speed: float) -> List[float]:
+    """
+    Given correction, return "badness" of individual harmonics
+    """
+    assert axis in "XY"
+    assert direction in "FB"
+
+    MEAS_COUNT = 1
+    REVS = 0.5
+    writeLut(machine, axis, direction, correction)
+    measurements = [
+        ResonanceMeasurement.measure(machine,
+                                     axis,
+                                     speed,
+                                     revs=REVS if direction == "B" else -REVS)
+        for _ in range(MEAS_COUNT)
+    ]
+    magnitudes = [map(lambda x: x[0], m.directSpectrum) for m in measurements]
+    return [np.median(samples) for samples in zip(*magnitudes)]
+
+
+def reacalibrate(machine: Machine,
+                 axis: str,
+                 direction: str,
+                 initialCorrection: PhaseCorrection,
+                 n: int,
+                 magRange: float,
+                 phaseRange: float,
+                 speed=float) -> Tuple[float, float]:
+    """
+    Given a machine and initial correction recalibrate magnitude and phase of
+    the n-th harmonics. Returns a tuple (magnitude change, phase change)
+    """
+    print(f"Recalibrating {n}, {magRange}, {phaseRange}")
+    evaluate = lambda x: evaluateCorrection(
+        machine, axis, direction,
+        adjustedCorrection(initialCorrection, n, x[0], x[1]), speed)[n]
+
+    #initialSimplex = make2DSimplex([0, 0], 0.01)
+    initialSimplex = [[0, 0], [magRange, -phaseRange], [-magRange, phaseRange]]
+    res, score = nelderMead(evaluate,
+                            initialSimplex,
+                            noImproveThr=1,
+                            noImprovCount=5)
+    return res
+
+
+def findPhaseMin(machine: Machine,
+                 axis: str,
+                 direction: str,
+                 initialCorrection: PhaseCorrection,
+                 n: int,
+                 mag: float,
+                 speed: float,
+                 guess: Optional[float] = None) -> float:
+    evaluate = lambda x: evaluateCorrection(
+        machine, axis, direction,
+        adjustedCorrection(initialCorrection, n, mag, x), speed)[n]
+    print(f"Finding pha {n}")
+    if guess is None:
+        brack = [0, 2 * np.pi]
+    else:
+        GUESS_WINDOW = 0.5
+        brack = [guess - GUESS_WINDOW, guess + GUESS_WINDOW]
+
+    res, fval, calls = goldenSearch(evaluate, brack=brack, tol=0.005)
+    res = res % (2 * np.pi)
+    print(f"Found f({res}) = {fval} in {calls}")
+    return res
+
+
+def findMagMin(machine: Machine,
+               axis: str,
+               direction: str,
+               initialCorrection: PhaseCorrection,
+               n: int,
+               maxMag: float,
+               speed: float,
+               guess: Optional[float] = None) -> float:
+    evaluate = lambda x: evaluateCorrection(
+        machine, axis, direction, adjustedCorrection(initialCorrection, n, x, 0
+                                                     ), speed)[n]
+    print(f"Finding mag {n}")
+    if guess is None:
+        brack = [0, maxMag]
+    else:
+        GUESS_WINDOW = 0.1
+        brack = [guess - GUESS_WINDOW, guess + GUESS_WINDOW]
+
+    res, fval, calls = goldenSearch(evaluate, brack=brack, tol=0.0002)
+    print(f"Found f({res}) = {fval} in {calls}")
+    return res
+
+
+@click.command("readLut")
+@click.option("--axis",
+              type=click.Choice(["X", "Y"]),
+              help="Axis for reading LUT")
+@click.option("--dir",
+              type=click.Choice(["F", "B"]),
+              help="Table for which direction")
+@click.option("--port", type=str, default=getPrusaPort(), help="Machine port")
+def readLutCmd(axis: str, dir: str, port: str) -> None:
+    with machineConnection(port) as machine:
+        machine.waitForBoot()
+        currents = readLut(machine, axis, dir)
+        json.dump(currents.spectrum, sys.stdout, indent=4)
+
+
+@click.command("writeLut")
+@click.argument("filepath",
+                type=click.Path(file_okay=True, exists=True, dir_okay=False))
+@click.option("--axis",
+              type=click.Choice(["X", "Y"]),
+              help="Axis for reading LUT")
+@click.option("--dir",
+              type=click.Choice(["F", "B"]),
+              help="Table for which direction")
+@click.option("--port", type=str, default=getPrusaPort(), help="Machine port")
+def writeLutCmd(axis: str, dir: str, port: str, filepath: str) -> None:
+    with open(filepath) as f:
+        correction = json.load(f)
+    with machineConnection(port) as machine:
+        machine.waitForBoot()
+        writeLut(machine, axis, dir, PhaseCorrection(correction))
+
+
+@click.command("analyseResonance")
+@click.option("--axis", type=click.Choice(["X", "Y"]))
+@click.option("--port", type=str, default=getPrusaPort(), help="Machine port")
+@click.option("--speedStart", type=float, default=0.5)
+@click.option("--speedStep", type=float, default=0.1)
+@click.option("--speedEnd", type=float, default=5)
+@click.option("--revs", type=float, default=0.5)
+def analyseResonanceCmd(axis: str, port: str, speedstart: float,
+                        speedend: float, speedstep: float,
+                        revs: float) -> None:
+    HARMONICS_COUNT = 16
+
+    fig = go.Figure()
+    fig.update_layout(
+        margin=dict(l=0, r=0, t=20, b=0),
+        yaxis={"title": "Amplitude"},
+        xaxis={"title": "Speeds"},
+    )
+
+    forwardTraces = [[] for _ in range(HARMONICS_COUNT)]
+    forwardMaxTrace = []
+    backwardTraces = [[] for _ in range(HARMONICS_COUNT)]
+    backwardMaxTrace = []
+    speeds = []
+
+    with machineConnection(port) as machine:
+        machine.waitForBoot()
+        machine.command("M17")
+        machine.command("M970 X Y")
+
+        testspeed = speedstart
+        while testspeed <= speedend:
+            speeds.append(testspeed)
+
+            measurements = [
+                ResonanceMeasurement.measure(machine, axis, testspeed,
+                                             revs if i % 2 == 0 else -revs,
+                                             False) for i in range(2)
+            ]
+            magnitudes = [[x[0] for x in m.averageSpectrum]
+                          for m in measurements]
+
+            for n in range(HARMONICS_COUNT):
+                forwardTraces[n].append(magnitudes[0][n])
+                backwardTraces[n].append(magnitudes[1][n])
+            forwardMaxTrace.append(np.max(magnitudes[0][1:HARMONICS_COUNT]))
+            backwardMaxTrace.append(np.max(magnitudes[1][1:HARMONICS_COUNT]))
+
+            testspeed += speedstep
+        machine.command("M18")
+
+    for name, trace in {
+            "Forward max": forwardMaxTrace,
+            "Backward max": backwardMaxTrace
+    }.items():
+        fig.add_trace(
+            go.Scatter(x=speeds,
+                       y=trace,
+                       name=name,
+                       mode="lines",
+                       line=dict(color="black", width=4)))
+
+    traceColors = sample_colorscale(
+        "jet", list(np.linspace(0, 1, len(forwardTraces))))
+    for n in range(HARMONICS_COUNT):
+        fig.add_trace(
+            go.Scatter(x=speeds,
+                       y=forwardTraces[n],
+                       name=f"F {n}",
+                       line=dict(color=traceColors[n])))
+    for n in range(HARMONICS_COUNT):
+        fig.add_trace(
+            go.Scatter(x=speeds,
+                       y=backwardTraces[n],
+                       name=f"B {n}",
+                       visible='legendonly',
+                       line=dict(color=traceColors[n])))
+
+    fig.show()
+
+
+@click.command("calibrateIndiv")
+@click.option("--axis",
+              type=click.Choice(["X", "Y"]),
+              help="Axis for reading LUT")
+@click.option("--dir",
+              type=click.Choice(["F", "B"]),
+              help="Table for which direction")
+@click.option("--port", type=str, default=getPrusaPort(), help="Machine port")
+@click.option("--speed", type=float, default=1.4)
+@click.option("--output",
+              type=click.Path(file_okay=True, dir_okay=False),
+              default=None)
+def calibrateIndivCmd(axis: str, dir: str, port: str, speed: float,
+                      output: str) -> None:
+    with machineConnection(port) as machine:
+        machine.waitForBoot()
+        machine.command("M17")
+        machine.command("M970 X Y")
+
+        def calib(initialCorrection: PhaseCorrection, n: int,
+                  expectedMag: float) -> PhaseCorrection:
+            baseline = evaluateCorrection(machine, axis, dir,
+                                          initialCorrection, speed)[n]
+            print(f"Baseline for {n}: {baseline}")
+            correction = PhaseCorrection(initialCorrection.spectrum)
+            pha = findPhaseMin(machine, axis, dir, correction, n, expectedMag,
+                               speed)
+            print(f"Got min {n}. pha: {pha}")
+            correction.spectrum[n] = (correction.spectrum[n][0], pha)
+            mag = findMagMin(machine, axis, dir, correction, n,
+                             2 * expectedMag, speed)
+            print(f"Got min {n}. mag: {mag}")
+            correction.spectrum[n] = (mag, correction.spectrum[n][1])
+
+            # print("Refinment")
+            # correction.spectrum[n] = (correction.spectrum[n][0], 0)
+            # pha = findPhaseMin(machine, axis, dir, correction, n, mag,
+            #                    speed, pha)
+            # print(f"Got ref min {n}. pha: {pha}")
+            # correction.spectrum[n] = (0, pha)
+            # mag = findMagMin(machine, axis, dir, correction, n,
+            #                  2 * expectedMag, speed, mag)
+            # print(f"Got ref min {n}. mag: {mag}")
+            # correction.spectrum[n] = (mag, correction.spectrum[n][1])
+            return correction
+
+        c = PhaseCorrection()
+        c = calib(c, 2, 0.028)
+        c = calib(c, 4, 0.022)
+        # c = calib(c, 8, 0.005)
+        # c = calib(c, 3, 0.005)
+
+        writeLut(machine, "X", dir, c)
+
+    print(c.spectrum)
+    if output is not None:
+        with open(output, "w") as f:
+            json.dump(c.spectrum, f)
+
+
+@click.command("analyzeSamples")
+@click.option("--axis",
+              type=click.Choice(["X", "Y"]),
+              help="Axis for reading LUT")
+@click.option("--port", type=str, default=getPrusaPort(), help="Machine port")
+@click.option("--speed", type=float, default=1)
+@click.option("--revs", type=float, default=0.2)
+def analyzeSamplesCmd(axis: str, port: str, speed: float, revs: float):
+    """
+    Plot sample analysis
+    """
+    with enabledMachineConnection(port) as machine:
+        measurement = ResonanceMeasurement.measure(machine, axis, speed, revs)
+
+    # measurement.periodPlot().show()
+    # measurement.autocorrPlot().show()
+    # measurement.plotSpectrum(measurement.averageSpectrum).show()
+    measurement.plotSpectrum(measurement.directSpectrum).show()
+    measurement.rawPeriodPlot().show()
+    measurement.rawWholePlot().show()
+    # measurement.periodicityPlot().show()
+
+
+@click.command("analyzeMachineSamples")
+@click.option("--axis",
+              type=click.Choice(["X", "Y"]),
+              help="Axis for reading LUT")
+@click.option("--port", type=str, default=getPrusaPort(), help="Machine port")
+@click.option("--speed", type=float, default=1)
+@click.option("--revs", type=float, default=0.2)
+def analyzeMachineSamplesCmd(axis: str, port: str, speed: float, revs: float):
+    """
+    Plot sample analysis performed by the machine
+    """
+    with enabledMachineConnection(port) as machine:
+        machine.multiCommand(["M400", "G92 X0 Y0"])
+        rawResponse = machine.command(f"M976 {axis} R{revs} F{speed}")
+        machine.command("G0 F10000 X0 Y0")
+
+    print(rawResponse)
+    dataPoints = [float(x.split(":")[1]) for x in rawResponse]
+
+    fig = go.Figure()
+    fig.update_layout(
+        yaxis={
+            "title": "Amplitude",
+            # "range": [0, 1500]
+        },
+        xaxis={"title": "Frequency"},
+    )
+    fig.add_trace(go.Bar(x=list(range(len(dataPoints)))[1:], y=dataPoints[1:]))
+    fig.show()
+
+
+@click.command("analyzeConsistency")
+@click.option("--axis",
+              type=click.Choice(["X", "Y"]),
+              help="Axis for reading LUT")
+@click.option("--port", type=str, default=getPrusaPort(), help="Machine port")
+@click.option("--speed", type=float, default=1)
+@click.option("--revs", type=float, default=0.2)
+@click.option("--n", type=int, default=20)
+def analyzeConsistencyCmd(axis: str, port: str, speed: float, revs: float,
+                          n: int):
+    """
+    Analyze consistency of measurement by repeated measurement and comparing the
+    results.
+    """
+    with enabledMachineConnection(port) as machine:
+        measurements = [
+            ResonanceMeasurement.measure(machine, axis, speed, revs)
+            for _ in range(n)
+        ]
+    fig = go.Figure()
+    fig.update_layout(
+        yaxis={
+            "title": "Amplitude",
+            "range": [0, 3000]
+        },
+        xaxis={"title": "Harmonic"},
+    )
+    for i, meas in enumerate(measurements):
+        fig.add_trace(
+            go.Bar(x=list(range(16))[1:],
+                   y=[x[0] for x in meas.averageSpectrum][1:16],
+                   name=f"{'R' if i % 2 == 1 else 'F'}{i // 2}"))
+    fig.show()
+
+
+@click.command("plotCorrectionValues")
+@click.option("--axis",
+              type=click.Choice(["X", "Y"]),
+              help="Axis for reading LUT")
+@click.option("--dir",
+              type=click.Choice(["F", "B"]),
+              default="F",
+              help="Table for which direction")
+@click.option("--port", type=str, default=getPrusaPort(), help="Machine port")
+@click.option("--speed", type=float, default=1.4)
+@click.option("--n", type=int, default=2)
+@click.option("--mag", type=float, default=0.02)
+@click.option("--segments", type=int, default=10)
+@click.option("--output", type=click.Path(), default=None)
+def plotCorrectionValuesCmd(axis: str, dir: str, port: str, speed: float,
+                            n: int, mag: float, segments: int,
+                            output: Optional[str]):
+    samples = {}
+    i = 0
+    with enabledMachineConnection(port) as machine:
+        for phase, mag in itertools.product(
+                valuesInRange(0, 2 * np.pi, segments),
+                valuesInRange(0, mag, segments)):
+            i += 1
+            print(
+                f"Measuring {i}/{segments * segments}: {phase:.3f}, {mag:.5f}: ",
+                end="")
+            sys.stdout.flush()
+            correction = PhaseCorrection()
+            correction.spectrum[n] = (mag, phase)
+            badness = evaluateCorrection(machine, axis, dir, correction,
+                                         speed)[n]
+            print(badness)
+            samples[(phase, mag)] = badness
+    print(samples)
+
+    unique_x = sorted(set(x for x, y in samples.keys()))
+    unique_y = sorted(set(y for x, y in samples.keys()))
+
+    x, y = np.meshgrid(unique_x, unique_y)
+
+    # Step 3: Create a grid for z
+    z = np.zeros_like(x, dtype=float)
+    for i, xi in enumerate(unique_x):
+        for j, yj in enumerate(unique_y):
+            z[j, i] = samples.get((xi, yj), np.nan)
+
+    fig = go.Figure()
+    fig.update_layout(margin=dict(l=0, r=0, t=0, b=0),
+                      yaxis={"title": "magnitude"},
+                      xaxis={"title": "phase"})
+    fig.add_trace(go.Surface(x=x, y=y, z=z))
+    if output is not None:
+        fig.write_html(output)
+    fig.show()
+
+
+@click.group()
+def cli():
+    """
+    Test & calibration scripts
+    """
+
+
+cli.add_command(readLutCmd)
+cli.add_command(writeLutCmd)
+cli.add_command(analyseResonanceCmd)
+cli.add_command(calibrateIndivCmd)
+cli.add_command(analyzeSamplesCmd)
+cli.add_command(analyzeMachineSamplesCmd)
+cli.add_command(analyzeConsistencyCmd)
+cli.add_command(plotCorrectionValuesCmd)
+
+if __name__ == "__main__":
+    cli()
diff --git a/utils/phase_stepping/requirements.txt b/utils/phase_stepping/requirements.txt
new file mode 100644
index 0000000000..f6e9cdbdf7
--- /dev/null
+++ b/utils/phase_stepping/requirements.txt
@@ -0,0 +1,6 @@
+pyserial
+click
+pandas
+plotly
+numpy
+scipy
diff --git a/utils/phase_stepping/test_phase_stepping.py b/utils/phase_stepping/test_phase_stepping.py
new file mode 100644
index 0000000000..696e181ba0
--- /dev/null
+++ b/utils/phase_stepping/test_phase_stepping.py
@@ -0,0 +1,16 @@
+from .phase_stepping import PhaseCorrection
+import numpy as np
+
+
+def test_phase_correction():
+    c1 = PhaseCorrection()
+    c1.spectrum[2] = (1, 0)
+
+    c2 = PhaseCorrection()
+    c2.spectrum[2] = (1, 2 * np.pi)
+
+    c3 = PhaseCorrection()
+    c3.spectrum[2] = (1, np.pi)
+
+    assert c1.currents() == c2.currents()
+    assert c1.currents() != c3.currents()
diff --git a/utils/presets/presets.json b/utils/presets/presets.json
index 804f8920cf..f349205355 100644
--- a/utils/presets/presets.json
+++ b/utils/presets/presets.json
@@ -146,6 +146,27 @@
                 "IS_KNOBLET":"FALSE"
             }
         },
+        {
+            "name": "xl-burst",
+            "description": "Original Prusa XL with Burst Stepping",
+            "cacheVariables": {
+                "CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
+                "PRINTER": "XL",
+                "BOARD": "<default>",
+                "BOARD_VERSION": "0.9.0",
+                "DWARF_BINARY_DIR": {
+                    "type": "FILEPATH",
+                    "value": "build-vscode-dwarf"
+                },
+                "MODULARBED_BINARY_DIR": {
+                    "type": "FILEPATH",
+                    "value": "build-vscode-modularbed"
+                },
+                "PRESET_COMPILE_OPTIONS": "",
+                "ENABLE_BURST":true,
+                "IS_KNOBLET":"FALSE"
+            }
+        },
         {
             "name": "xl-knoblet",
             "description": "Knoblet of Original Prusa XL",