🚸 Optional X-Axis (#25418)

Co-authored-by: alextrical <35117191+alextrical@users.noreply.github.com>
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>

Marlin/src/core/language.h

@@ -324,10 +324,12 @@
 //
 // Endstop Names used by Endstops::report_states
 //
-#define STR_X_MIN                           "x_min"
+#if HAS_X_AXIS
-#define STR_X_MAX                           "x_max"
+  #define STR_X_MIN                         "x_min"
-#define STR_X2_MIN                          "x2_min"
+  #define STR_X_MAX                         "x_max"
-#define STR_X2_MAX                          "x2_max"
+  #define STR_X2_MIN                        "x2_min"
+  #define STR_X2_MAX                        "x2_max"
+#endif
 
 #if HAS_Y_AXIS
   #define STR_Y_MIN                         "y_min"

Marlin/src/core/serial.cpp

@@ -96,10 +96,12 @@ void print_bin(uint16_t val) {
   }
 }
 
-void print_pos(NUM_AXIS_ARGS(const_float_t), FSTR_P const prefix/*=nullptr*/, FSTR_P const suffix/*=nullptr*/) {
+void print_pos(NUM_AXIS_ARGS_(const_float_t) FSTR_P const prefix/*=nullptr*/, FSTR_P const suffix/*=nullptr*/) {
   if (prefix) serial_print(prefix);
+  #if NUM_AXES
     SERIAL_ECHOPGM_P(
       LIST_N(DOUBLE(NUM_AXES), SP_X_STR, x, SP_Y_STR, y, SP_Z_STR, z, SP_I_STR, i, SP_J_STR, j, SP_K_STR, k, SP_U_STR, u, SP_V_STR, v, SP_W_STR, w)
     );
+  #endif
   if (suffix) serial_print(suffix); else SERIAL_EOL();
 }

Marlin/src/core/serial.h

@@ -340,10 +340,10 @@ void serial_spaces(uint8_t count);
 void serial_offset(const_float_t v, const uint8_t sp=0); // For v==0 draw space (sp==1) or plus (sp==2)
 
 void print_bin(const uint16_t val);
-void print_pos(NUM_AXIS_ARGS(const_float_t), FSTR_P const prefix=nullptr, FSTR_P const suffix=nullptr);
+void print_pos(NUM_AXIS_ARGS_(const_float_t) FSTR_P const prefix=nullptr, FSTR_P const suffix=nullptr);
 
 inline void print_pos(const xyze_pos_t &xyze, FSTR_P const prefix=nullptr, FSTR_P const suffix=nullptr) {
-  print_pos(NUM_AXIS_ELEM(xyze), prefix, suffix);
+  print_pos(NUM_AXIS_ELEM_(xyze) prefix, suffix);
 }
 
 #define SERIAL_POS(SUFFIX,VAR) do { print_pos(VAR, F("  " STRINGIFY(VAR) "="), F(" : " SUFFIX "\n")); }while(0)

Marlin/src/core/types.h

@@ -46,9 +46,25 @@ template <class L, class R> struct IF<true, L, R> { typedef L type; };
 #define NUM_AXIS_ELEM(O)      NUM_AXIS_LIST(O.x, O.y, O.z, O.i, O.j, O.k, O.u, O.v, O.w)
 #define NUM_AXIS_DEFS(T,V)    NUM_AXIS_LIST(T x=V, T y=V, T z=V, T i=V, T j=V, T k=V, T u=V, T v=V, T w=V)
 #define MAIN_AXIS_NAMES       NUM_AXIS_LIST(X, Y, Z, I, J, K, U, V, W)
-#define MAIN_AXIS_MAP(F)    MAP(F, MAIN_AXIS_NAMES)
 #define STR_AXES_MAIN         NUM_AXIS_GANG("X", "Y", "Z", STR_I, STR_J, STR_K, STR_U, STR_V, STR_W)
 
+#if NUM_AXES
+  #define NUM_AXES_SEP ,
+  #define MAIN_AXIS_MAP(F)    MAP(F, MAIN_AXIS_NAMES)
+  #define OPTARGS_LOGICAL(T)  , LOGICAL_AXIS_ARGS(T)
+#else
+  #define NUM_AXES_SEP
+  #define MAIN_AXIS_MAP(F)
+  #define OPTARGS_LOGICAL(T)
+#endif
+
+#define NUM_AXIS_GANG_(V...)    NUM_AXIS_GANG(V) NUM_AXES_SEP
+#define NUM_AXIS_LIST_(V...)    NUM_AXIS_LIST(V) NUM_AXES_SEP
+#define NUM_AXIS_LIST_1_(V...)  NUM_AXIS_LIST_1(V) NUM_AXES_SEP
+#define NUM_AXIS_ARGS_(T)       NUM_AXIS_ARGS(T) NUM_AXES_SEP
+#define NUM_AXIS_ELEM_(T)       NUM_AXIS_ELEM(T) NUM_AXES_SEP
+#define MAIN_AXIS_NAMES_        MAIN_AXIS_NAMES NUM_AXES_SEP
+
 #define LOGICAL_AXIS_GANG(E,V...)  NUM_AXIS_GANG(V) GANG_ITEM_E(E)
 #define LOGICAL_AXIS_CODE(E,V...)  NUM_AXIS_CODE(V) CODE_ITEM_E(E)
 #define LOGICAL_AXIS_LIST(E,V...)  NUM_AXIS_LIST(V) LIST_ITEM_E(E)
@@ -75,8 +91,13 @@ template <class L, class R> struct IF<true, L, R> { typedef L type; };
 #endif
 
 #if HAS_EXTRUDERS
+  #if NUM_AXES
     #define LIST_ITEM_E(N) , N
     #define CODE_ITEM_E(N) ; N
+  #else
+    #define LIST_ITEM_E(N) N
+    #define CODE_ITEM_E(N) N
+  #endif
   #define GANG_ITEM_E(N) N
 #else
   #define LIST_ITEM_E(N)
@@ -166,37 +187,38 @@ typedef struct AxisFlags {
 enum AxisEnum : uint8_t {
 
   // Linear axes may be controlled directly or indirectly
-  NUM_AXIS_LIST(X_AXIS, Y_AXIS, Z_AXIS, I_AXIS, J_AXIS, K_AXIS, U_AXIS, V_AXIS, W_AXIS)
+  NUM_AXIS_LIST_(X_AXIS, Y_AXIS, Z_AXIS, I_AXIS, J_AXIS, K_AXIS, U_AXIS, V_AXIS, W_AXIS)
 
-  // Extruder axes may be considered distinctly
+  #define _EN_ITEM(N) E##N##_AXIS,
-  #define _EN_ITEM(N) , E##N##_AXIS
   REPEAT(EXTRUDERS, _EN_ITEM)
   #undef _EN_ITEM
 
   // Core also keeps toolhead directions
   #if ANY(IS_CORE, MARKFORGED_XY, MARKFORGED_YX)
-    , X_HEAD, Y_HEAD, Z_HEAD
+    X_HEAD, Y_HEAD, Z_HEAD,
   #endif
 
   // Distinct axes, including all E and Core
-  , NUM_AXIS_ENUMS
+  NUM_AXIS_ENUMS,
 
   // Most of the time we refer only to the single E_AXIS
   #if HAS_EXTRUDERS
-    , E_AXIS = E0_AXIS
+    E_AXIS = E0_AXIS,
   #endif
 
   // A, B, and C are for DELTA, SCARA, etc.
-  , A_AXIS = X_AXIS
+  #if HAS_X_AXIS
+    A_AXIS = X_AXIS,
+  #endif
   #if HAS_Y_AXIS
-    , B_AXIS = Y_AXIS
+    B_AXIS = Y_AXIS,
   #endif
   #if HAS_Z_AXIS
-    , C_AXIS = Z_AXIS
+    C_AXIS = Z_AXIS,
   #endif
 
   // To refer to all or none
-  , ALL_AXES_ENUM = 0xFE, NO_AXIS_ENUM = 0xFF
+  ALL_AXES_ENUM = 0xFE, NO_AXIS_ENUM = 0xFF
 };
 
 //
@@ -336,7 +358,9 @@ struct XYval {
   FI void reset()                                       { x = y = 0; }
 
   // Setters taking struct types and arrays
+  #if HAS_X_AXIS
     FI void set(const T px)                             { x = px; }
+  #endif
   #if HAS_Y_AXIS
     FI void set(const T px, const T py)                 { x = px; y = py; }
     FI void set(const T (&arr)[XY])                     { x = arr[0]; y = arr[1]; }
@@ -453,9 +477,9 @@ struct XYval {
   FI XYval<T>& operator<<=(const int &p)                { _LS(x);    _LS(y);    return *this; }
 
   // Exact comparisons. For floats a "NEAR" operation may be better.
-  FI bool      operator==(const XYval<T>   &rs)   const { return NUM_AXIS_GANG(x == rs.x, && y == rs.y,,,,,,, ); }
+  FI bool      operator==(const XYval<T>   &rs)   const { return true NUM_AXIS_GANG(&& x == rs.x, && y == rs.y,,,,,,, ); }
-  FI bool      operator==(const XYZval<T>  &rs)   const { return NUM_AXIS_GANG(x == rs.x, && y == rs.y,,,,,,, ); }
+  FI bool      operator==(const XYZval<T>  &rs)   const { return true NUM_AXIS_GANG(&& x == rs.x, && y == rs.y,,,,,,, ); }
-  FI bool      operator==(const XYZEval<T> &rs)   const { return NUM_AXIS_GANG(x == rs.x, && y == rs.y,,,,,,, ); }
+  FI bool      operator==(const XYZEval<T> &rs)   const { return true NUM_AXIS_GANG(&& x == rs.x, && y == rs.y,,,,,,, ); }
   FI bool      operator!=(const XYval<T>   &rs)   const { return !operator==(rs); }
   FI bool      operator!=(const XYZval<T>  &rs)   const { return !operator==(rs); }
   FI bool      operator!=(const XYZEval<T> &rs)   const { return !operator==(rs); }
@@ -467,13 +491,15 @@ struct XYval {
 template<typename T>
 struct XYZval {
   union {
+    #if NUM_AXES
       struct { T NUM_AXIS_ARGS(); };
       struct { T NUM_AXIS_LIST(a, b, c, _i, _j, _k, _u, _v, _w); };
+    #endif
     T pos[NUM_AXES];
   };
 
   // Set all to 0
-  FI void reset()                                      { NUM_AXIS_GANG(x =, y =, z =, i =, j =, k =, u =, v =, w =) 0; }
+  FI void reset()                                { NUM_AXIS_CODE(x = 0, y = 0, z = 0, i = 0, j = 0, k = 0, u = 0, v = 0, w = 0); }
 
   // Setters taking struct types and arrays
   FI void set(const XYval<T> pxy)                { NUM_AXIS_CODE(x = pxy.x, y = pxy.y,,,,,,,); }
@@ -517,15 +543,15 @@ struct XYZval {
   #endif
 
   // Length reduced to one dimension
-  FI T magnitude()                               const { return (T)sqrtf(NUM_AXIS_GANG(x*x, + y*y, + z*z, + i*i, + j*j, + k*k, + u*u, + v*v, + w*w)); }
+  FI T magnitude()                               const { return (T)TERN(HAS_X_AXIS, sqrtf(NUM_AXIS_GANG(x*x, + y*y, + z*z, + i*i, + j*j, + k*k, + u*u, + v*v, + w*w)), 0); }
   // Pointer to the data as a simple array
-  FI operator T* ()                                    { return pos; }
+  FI operator T* ()                                    { return (T*)this; }
   // If any element is true then it's true
-  FI operator bool()                                   { return NUM_AXIS_GANG(x, || y, || z, || i, || j, || k, || u, || v, || w); }
+  FI operator bool()                                   { return 0 NUM_AXIS_GANG(|| x, || y, || z, || i, || j, || k, || u, || v, || w); }
   // Smallest element
-  FI T small()                                   const { return _MIN(NUM_AXIS_LIST(x, y, z, i, j, k, u, v, w)); }
+  FI T small()                                   const { return TERN(HAS_X_AXIS,_MIN(NUM_AXIS_LIST(x, y, z, i, j, k, u, v, w));,0;) }
   // Largest element
-  FI T large()                                   const { return _MAX(NUM_AXIS_LIST(x, y, z, i, j, k, u, v, w)); }
+  FI T large()                                   const { return TERN(HAS_X_AXIS,_MAX(NUM_AXIS_LIST(x, y, z, i, j, k, u, v, w));,0;) }
 
   // Explicit copy and copies with conversion
   FI XYZval<T>          copy()                   const { XYZval<T> o = *this; return o; }
@@ -637,7 +663,7 @@ struct XYZEval {
   FI void reset()                                { LOGICAL_AXIS_GANG(e =, x =, y =, z =, i =, j =, k =, u =, v =, w =) 0; }
 
   // Setters taking struct types and arrays
-  FI void set(const XYval<T> pxy)                           { x = pxy.x; OPTCODE(HAS_Y_AXIS, y = pxy.y) }
+  FI void set(const XYval<T> pxy)                           { OPTCODE(HAS_X_AXIS, x = pxy.x) OPTCODE(HAS_Y_AXIS, y = pxy.y) }
   FI void set(const XYZval<T> pxyz)                         { set(NUM_AXIS_ELEM(pxyz)); }
   FI void set(const XYval<T> pxy, const T pz)               { set(pxy); TERN_(HAS_Z_AXIS, z = pz); }
   FI void set(const T (&arr)[NUM_AXES])                     { NUM_AXIS_CODE(x = arr[0], y = arr[1], z = arr[2], i = arr[3], j = arr[4], k = arr[5], u = arr[6], v = arr[7], w = arr[8]); }

Marlin/src/feature/fwretract.cpp

@@ -195,8 +195,6 @@ void FWRetract::retract(const bool retracting E_OPTARG(bool swapping/*=false*/))
   //*/
 }
 
-//extern const char SP_Z_STR[];
-
 /**
  * M207: Set firmware retraction values
  *

Marlin/src/feature/tmc_util.cpp

@@ -773,8 +773,8 @@
     }
   }
 
-  static void tmc_debug_loop(const TMC_debug_enum n, LOGICAL_AXIS_ARGS(const bool)) {
+  static void tmc_debug_loop(const TMC_debug_enum n OPTARGS_LOGICAL(const bool)) {
-    if (x) {
+    if (TERN0(HAS_X_AXIS, x)) {
       #if AXIS_IS_TMC(X)
         tmc_status(stepperX, n);
       #endif
@@ -856,8 +856,8 @@
     SERIAL_EOL();
   }
 
-  static void drv_status_loop(const TMC_drv_status_enum n, LOGICAL_AXIS_ARGS(const bool)) {
+  static void drv_status_loop(const TMC_drv_status_enum n OPTARGS_LOGICAL(const bool)) {
-    if (x) {
+    if (TERN0(HAS_X_AXIS, x)) {
       #if AXIS_IS_TMC(X)
         tmc_parse_drv_status(stepperX, n);
       #endif
@@ -944,8 +944,8 @@
    */
 
   void tmc_report_all(LOGICAL_AXIS_ARGS(const bool)) {
-    #define TMC_REPORT(LABEL, ITEM) do{ SERIAL_ECHOPGM(LABEL); tmc_debug_loop(ITEM, LOGICAL_AXIS_ARGS()); }while(0)
+    #define TMC_REPORT(LABEL, ITEM) do{ SERIAL_ECHOPGM(LABEL); tmc_debug_loop(ITEM OPTARGS_LOGICAL()); }while(0)
-    #define DRV_REPORT(LABEL, ITEM) do{ SERIAL_ECHOPGM(LABEL); drv_status_loop(ITEM, LOGICAL_AXIS_ARGS()); }while(0)
+    #define DRV_REPORT(LABEL, ITEM) do{ SERIAL_ECHOPGM(LABEL); drv_status_loop(ITEM OPTARGS_LOGICAL()); }while(0)
 
     TMC_REPORT("\t",                 TMC_CODES);
     #if HAS_DRIVER(TMC2209)
@@ -1070,8 +1070,8 @@
     }
   #endif
 
-  static void tmc_get_registers(TMC_get_registers_enum n, LOGICAL_AXIS_ARGS(const bool)) {
+  static void tmc_get_registers(TMC_get_registers_enum n OPTARGS_LOGICAL(const bool)) {
-    if (x) {
+    if (TERN0(HAS_X_AXIS, x)) {
       #if AXIS_IS_TMC(X)
         tmc_get_registers(stepperX, n);
       #endif
@@ -1154,7 +1154,7 @@
   }
 
   void tmc_get_registers(LOGICAL_AXIS_ARGS(bool)) {
-    #define _TMC_GET_REG(LABEL, ITEM) do{ SERIAL_ECHOPGM(LABEL); tmc_get_registers(ITEM, LOGICAL_AXIS_ARGS()); }while(0)
+    #define _TMC_GET_REG(LABEL, ITEM) do{ SERIAL_ECHOPGM(LABEL); tmc_get_registers(ITEM OPTARGS_LOGICAL()); }while(0)
     #define TMC_GET_REG(NAME, TABS) _TMC_GET_REG(STRINGIFY(NAME) TABS, TMC_GET_##NAME)
     _TMC_GET_REG("\t", TMC_AXIS_CODES);
     TMC_GET_REG(GCONF, "\t\t");
@@ -1236,7 +1236,7 @@ static bool test_connection(TMC &st) {
 void test_tmc_connection(LOGICAL_AXIS_ARGS(const bool)) {
   uint8_t axis_connection = 0;
 
-  if (x) {
+    if (TERN0(HAS_X_AXIS, x)) {
     #if AXIS_IS_TMC(X)
       axis_connection += test_connection(stepperX);
     #endif

Marlin/src/feature/tmc_util.h

@@ -348,7 +348,7 @@ void test_tmc_connection(LOGICAL_AXIS_DECL(const bool, true));
 #if USE_SENSORLESS
 
   // Track enabled status of stealthChop and only re-enable where applicable
-  struct sensorless_t { bool NUM_AXIS_ARGS(), x2, y2, z2, z3, z4; };
+  struct sensorless_t { bool NUM_AXIS_ARGS_() x2, y2, z2, z3, z4; };
 
   #if ENABLED(IMPROVE_HOMING_RELIABILITY)
     extern millis_t sg_guard_period;

Marlin/src/gcode/calibrate/G28.cpp

@@ -206,20 +206,6 @@ void GcodeSuite::G28() {
   DEBUG_SECTION(log_G28, "G28", DEBUGGING(LEVELING));
   if (DEBUGGING(LEVELING)) log_machine_info();
 
-  TERN_(BD_SENSOR, bdl.config_state = 0);
-
-  /**
-   * Set the laser power to false to stop the planner from processing the current power setting.
-   */
-  #if ENABLED(LASER_FEATURE)
-    planner.laser_inline.status.isPowered = false;
-  #endif
-
-  #if ENABLED(DUAL_X_CARRIAGE)
-    bool IDEX_saved_duplication_state = extruder_duplication_enabled;
-    DualXMode IDEX_saved_mode = dual_x_carriage_mode;
-  #endif
-
   #if ENABLED(MARLIN_DEV_MODE)
     if (parser.seen_test('S')) {
       LOOP_NUM_AXES(a) set_axis_is_at_home((AxisEnum)a);
@@ -230,12 +216,21 @@ void GcodeSuite::G28() {
     }
   #endif
 
+  /**
+   * Set the laser power to false to stop the planner from processing the current power setting.
+   */
+  #if ENABLED(LASER_FEATURE)
+    planner.laser_inline.status.isPowered = false;
+  #endif
+
   // Home (O)nly if position is unknown
   if (!axes_should_home() && parser.seen_test('O')) {
     if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("> homing not needed, skip");
     return;
   }
 
+  TERN_(BD_SENSOR, bdl.config_state = 0);
+
   #if ENABLED(FULL_REPORT_TO_HOST_FEATURE)
     const M_StateEnum old_grblstate = M_State_grbl;
     set_and_report_grblstate(M_HOMING);
@@ -246,6 +241,16 @@ void GcodeSuite::G28() {
 
   planner.synchronize();          // Wait for planner moves to finish!
 
+  // Count this command as movement / activity
+  reset_stepper_timeout();
+
+  #if NUM_AXES
+
+    #if ENABLED(DUAL_X_CARRIAGE)
+      bool IDEX_saved_duplication_state = extruder_duplication_enabled;
+      DualXMode IDEX_saved_mode = dual_x_carriage_mode;
+    #endif
+
     SET_SOFT_ENDSTOP_LOOSE(false);  // Reset a leftover 'loose' motion state
 
     // Disable the leveling matrix before homing
@@ -262,9 +267,6 @@ void GcodeSuite::G28() {
     // Reset to the XY plane
     TERN_(CNC_WORKSPACE_PLANES, workspace_plane = PLANE_XY);
 
-  // Count this command as movement / activity
-  reset_stepper_timeout();
-
     #define HAS_CURRENT_HOME(N) (defined(N##_CURRENT_HOME) && N##_CURRENT_HOME != N##_CURRENT)
     #if HAS_CURRENT_HOME(X) || HAS_CURRENT_HOME(X2) || HAS_CURRENT_HOME(Y) || HAS_CURRENT_HOME(Y2) || (ENABLED(DELTA) && HAS_CURRENT_HOME(Z)) || HAS_CURRENT_HOME(I) || HAS_CURRENT_HOME(J) || HAS_CURRENT_HOME(K) || HAS_CURRENT_HOME(U) || HAS_CURRENT_HOME(V) || HAS_CURRENT_HOME(W)
       #define HAS_HOMING_CURRENT 1
@@ -372,29 +374,29 @@ void GcodeSuite::G28() {
 
       home_TPARA();
 
-  #else
+    #else // !DELTA && !AXEL_TPARA
 
       #define _UNSAFE(A) (homeZ && TERN0(Z_SAFE_HOMING, axes_should_home(_BV(A##_AXIS))))
 
       const bool homeZ = TERN0(HAS_Z_AXIS, parser.seen_test('Z')),
-               NUM_AXIS_LIST(              // Other axes should be homed before Z safe-homing
+                 NUM_AXIS_LIST_(             // Other axes should be homed before Z safe-homing
                    needX = _UNSAFE(X), needY = _UNSAFE(Y), needZ = false, // UNUSED
                    needI = _UNSAFE(I), needJ = _UNSAFE(J), needK = _UNSAFE(K),
                    needU = _UNSAFE(U), needV = _UNSAFE(V), needW = _UNSAFE(W)
-               ),
+                 )
-               NUM_AXIS_LIST(              // Home each axis if needed or flagged
+                 NUM_AXIS_LIST_(             // Home each axis if needed or flagged
                    homeX = needX || parser.seen_test('X'),
                    homeY = needY || parser.seen_test('Y'),
                    homeZZ = homeZ,
                    homeI = needI || parser.seen_test(AXIS4_NAME), homeJ = needJ || parser.seen_test(AXIS5_NAME),
                    homeK = needK || parser.seen_test(AXIS6_NAME), homeU = needU || parser.seen_test(AXIS7_NAME),
                    homeV = needV || parser.seen_test(AXIS8_NAME), homeW = needW || parser.seen_test(AXIS9_NAME)
-               ),
+                 )
-               home_all = NUM_AXIS_GANG(   // Home-all if all or none are flagged
+                 home_all = NUM_AXIS_GANG_(  // Home-all if all or none are flagged
                       homeX == homeX, && homeY == homeX, && homeZ == homeX,
                    && homeI == homeX, && homeJ == homeX, && homeK == homeX,
                    && homeU == homeX, && homeV == homeX, && homeW == homeX
-               ),
+                 )
                  NUM_AXIS_LIST(
                    doX = home_all || homeX, doY = home_all || homeY, doZ = home_all || homeZ,
                    doI = home_all || homeI, doJ = home_all || homeJ, doK = home_all || homeK,
@@ -421,7 +423,7 @@ void GcodeSuite::G28() {
         float z_homing_height = seenR ? parser.value_linear_units() : Z_CLEARANCE_FOR_HOMING;
 
         // Check for any lateral motion that might require clearance
-      const bool may_skate = seenR || NUM_AXIS_GANG(doX, || doY, || TERN0(Z_SAFE_HOMING, doZ), || doI, || doJ, || doK, || doU, || doV, || doW);
+        const bool may_skate = seenR NUM_AXIS_GANG(|| doX, || doY, || TERN0(Z_SAFE_HOMING, doZ), || doI, || doJ, || doK, || doU, || doV, || doW);
 
         if (seenR && z_homing_height == 0) {
           if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("R0 = No Z raise");
@@ -457,6 +459,7 @@ void GcodeSuite::G28() {
       #endif
 
       // Home X
+      #if HAS_X_AXIS
         if (doX || (doY && ENABLED(CODEPENDENT_XY_HOMING) && DISABLED(HOME_Y_BEFORE_X))) {
 
           #if ENABLED(DUAL_X_CARRIAGE)
@@ -481,6 +484,7 @@ void GcodeSuite::G28() {
 
           #endif
         }
+      #endif // HAS_X_AXIS
 
       #if BOTH(FOAMCUTTER_XYUV, HAS_I_AXIS)
         // Home I (after X)
@@ -638,6 +642,11 @@ void GcodeSuite::G28() {
 
     restore_feedrate_and_scaling();
 
+    if (ENABLED(NANODLP_Z_SYNC) && (ENABLED(NANODLP_ALL_AXIS) || TERN0(HAS_Z_AXIS, doZ)))
+      SERIAL_ECHOLNPGM(STR_Z_MOVE_COMP);
+
+  #endif // NUM_AXES
+
   ui.refresh();
 
   TERN_(HAS_DWIN_E3V2_BASIC, DWIN_HomingDone());
@@ -645,9 +654,6 @@ void GcodeSuite::G28() {
 
   report_current_position();
 
-  if (ENABLED(NANODLP_Z_SYNC) && (ENABLED(NANODLP_ALL_AXIS) || TERN0(HAS_Z_AXIS, doZ)))
-    SERIAL_ECHOLNPGM(STR_Z_MOVE_COMP);
-
   TERN_(FULL_REPORT_TO_HOST_FEATURE, set_and_report_grblstate(old_grblstate));
 
 }

Marlin/src/gcode/calibrate/G425.cpp

@@ -70,7 +70,7 @@
   #define CALIBRATION_MEASUREMENT_CERTAIN   0.5 // mm
 #endif
 
-#if BOTH(CALIBRATION_MEASURE_LEFT, CALIBRATION_MEASURE_RIGHT)
+#if ALL(HAS_X_AXIS, CALIBRATION_MEASURE_LEFT, CALIBRATION_MEASURE_RIGHT)
   #define HAS_X_CENTER 1
 #endif
 #if ALL(HAS_Y_AXIS, CALIBRATION_MEASURE_FRONT, CALIBRATION_MEASURE_BACK)
@@ -398,12 +398,14 @@ inline void probe_sides(measurements_t &m, const float uncertainty) {
     #if AXIS_CAN_CALIBRATE(Z)
       SERIAL_ECHOLNPGM("  Top: ", m.obj_side[TOP]);
     #endif
+    #if HAS_X_AXIS
       #if ENABLED(CALIBRATION_MEASURE_LEFT)
         SERIAL_ECHOLNPGM("  Left: ", m.obj_side[LEFT]);
       #endif
       #if ENABLED(CALIBRATION_MEASURE_RIGHT)
         SERIAL_ECHOLNPGM("  Right: ", m.obj_side[RIGHT]);
       #endif
+    #endif
     #if HAS_Y_AXIS
       #if ENABLED(CALIBRATION_MEASURE_FRONT)
         SERIAL_ECHOLNPGM("  Front: ", m.obj_side[FRONT]);

Marlin/src/gcode/calibrate/M425.cpp

@@ -112,6 +112,7 @@ void GcodeSuite::M425_report(const bool forReplay/*=true*/) {
     #ifdef BACKLASH_SMOOTHING_MM
       , PSTR(" S"), LINEAR_UNIT(backlash.get_smoothing_mm())
     #endif
+    #if NUM_AXES
       , LIST_N(DOUBLE(NUM_AXES),
           SP_X_STR, LINEAR_UNIT(backlash.get_distance_mm(X_AXIS)),
           SP_Y_STR, LINEAR_UNIT(backlash.get_distance_mm(Y_AXIS)),
@@ -123,6 +124,7 @@ void GcodeSuite::M425_report(const bool forReplay/*=true*/) {
           SP_V_STR, V_AXIS_UNIT(backlash.get_distance_mm(V_AXIS)),
           SP_W_STR, W_AXIS_UNIT(backlash.get_distance_mm(W_AXIS))
         )
+    #endif
   );
 }
 

Marlin/src/gcode/config/M200-M205.cpp

@@ -143,7 +143,8 @@ void GcodeSuite::M201() {
 
 void GcodeSuite::M201_report(const bool forReplay/*=true*/) {
   report_heading_etc(forReplay, F(STR_MAX_ACCELERATION));
-  SERIAL_ECHOLNPGM_P(
+  #if NUM_AXES
+    SERIAL_ECHOPGM_P(
       LIST_N(DOUBLE(NUM_AXES),
         PSTR("  M201 X"), LINEAR_UNIT(planner.settings.max_acceleration_mm_per_s2[X_AXIS]),
         SP_Y_STR, LINEAR_UNIT(planner.settings.max_acceleration_mm_per_s2[Y_AXIS]),
@@ -155,10 +156,17 @@ void GcodeSuite::M201_report(const bool forReplay/*=true*/) {
         SP_V_STR, V_AXIS_UNIT(planner.settings.max_acceleration_mm_per_s2[V_AXIS]),
         SP_W_STR, W_AXIS_UNIT(planner.settings.max_acceleration_mm_per_s2[W_AXIS])
       )
-    #if HAS_EXTRUDERS && DISABLED(DISTINCT_E_FACTORS)
-      , SP_E_STR, VOLUMETRIC_UNIT(planner.settings.max_acceleration_mm_per_s2[E_AXIS])
-    #endif
     );
+  #endif
+
+  #if HAS_EXTRUDERS && DISABLED(DISTINCT_E_FACTORS)
+    SERIAL_ECHOPGM_P(SP_E_STR, VOLUMETRIC_UNIT(planner.settings.max_acceleration_mm_per_s2[E_AXIS]));
+  #endif
+
+  #if NUM_AXES || (HAS_EXTRUDERS && DISABLED(DISTINCT_E_FACTORS))
+    SERIAL_EOL();
+  #endif
+
   #if ENABLED(DISTINCT_E_FACTORS)
     LOOP_L_N(i, E_STEPPERS) {
       report_echo_start(forReplay);
@@ -191,7 +199,8 @@ void GcodeSuite::M203() {
 
 void GcodeSuite::M203_report(const bool forReplay/*=true*/) {
   report_heading_etc(forReplay, F(STR_MAX_FEEDRATES));
-  SERIAL_ECHOLNPGM_P(
+  #if NUM_AXES
+    SERIAL_ECHOPGM_P(
       LIST_N(DOUBLE(NUM_AXES),
         PSTR("  M203 X"), LINEAR_UNIT(planner.settings.max_feedrate_mm_s[X_AXIS]),
         SP_Y_STR, LINEAR_UNIT(planner.settings.max_feedrate_mm_s[Y_AXIS]),
@@ -203,10 +212,17 @@ void GcodeSuite::M203_report(const bool forReplay/*=true*/) {
         SP_V_STR, LINEAR_UNIT(planner.settings.max_feedrate_mm_s[V_AXIS]),
         SP_W_STR, LINEAR_UNIT(planner.settings.max_feedrate_mm_s[W_AXIS])
       )
-    #if HAS_EXTRUDERS && DISABLED(DISTINCT_E_FACTORS)
-      , SP_E_STR, VOLUMETRIC_UNIT(planner.settings.max_feedrate_mm_s[E_AXIS])
-    #endif
     );
+  #endif
+
+  #if HAS_EXTRUDERS && DISABLED(DISTINCT_E_FACTORS)
+    SERIAL_ECHOPGM_P(SP_E_STR, VOLUMETRIC_UNIT(planner.settings.max_feedrate_mm_s[E_AXIS]));
+  #endif
+
+  #if NUM_AXES || (HAS_EXTRUDERS && DISABLED(DISTINCT_E_FACTORS))
+    SERIAL_EOL();
+  #endif
+
   #if ENABLED(DISTINCT_E_FACTORS)
     LOOP_L_N(i, E_STEPPERS) {
       if (!forReplay) SERIAL_ECHO_START();
@@ -336,7 +352,7 @@ void GcodeSuite::M205_report(const bool forReplay/*=true*/) {
     #if HAS_JUNCTION_DEVIATION
       , PSTR(" J"), LINEAR_UNIT(planner.junction_deviation_mm)
     #endif
-    #if HAS_CLASSIC_JERK
+    #if HAS_CLASSIC_JERK && NUM_AXES
       , LIST_N(DOUBLE(NUM_AXES),
         SP_X_STR, LINEAR_UNIT(planner.max_jerk.x),
         SP_Y_STR, LINEAR_UNIT(planner.max_jerk.y),

Marlin/src/gcode/config/M217.cpp

@@ -95,7 +95,9 @@ void GcodeSuite::M217() {
 
   #if ENABLED(TOOLCHANGE_PARK)
     if (parser.seenval('W')) { toolchange_settings.enable_park = parser.value_linear_units(); }
+    #if HAS_X_AXIS
       if (parser.seenval('X')) { const int16_t v = parser.value_linear_units(); toolchange_settings.change_point.x = constrain(v, X_MIN_POS, X_MAX_POS); }
+    #endif
     #if HAS_Y_AXIS
       if (parser.seenval('Y')) { const int16_t v = parser.value_linear_units(); toolchange_settings.change_point.y = constrain(v, Y_MIN_POS, Y_MAX_POS); }
     #endif
@@ -183,8 +185,9 @@ void GcodeSuite::M217_report(const bool forReplay/*=true*/) {
     #endif
 
     #if ENABLED(TOOLCHANGE_PARK)
-    {
       SERIAL_ECHOPGM(" W", LINEAR_UNIT(toolchange_settings.enable_park));
+      #if NUM_AXES
+      {
         SERIAL_ECHOPGM_P(
           SP_X_STR, LINEAR_UNIT(toolchange_settings.change_point.x)
           #if HAS_Y_AXIS
@@ -203,6 +206,7 @@ void GcodeSuite::M217_report(const bool forReplay/*=true*/) {
         );
       }
       #endif
+    #endif
 
     #if ENABLED(TOOLCHANGE_FS_PRIME_FIRST_USED)
       SERIAL_ECHOPGM(" V", LINEAR_UNIT(enable_first_prime));

Marlin/src/gcode/config/M218.cpp

@@ -46,9 +46,15 @@ void GcodeSuite::M218() {
   const int8_t target_extruder = get_target_extruder_from_command();
   if (target_extruder < 0) return;
 
+  #if HAS_X_AXIS
     if (parser.seenval('X')) hotend_offset[target_extruder].x = parser.value_linear_units();
+  #endif
+  #if HAS_Y_AXIS
     if (parser.seenval('Y')) hotend_offset[target_extruder].y = parser.value_linear_units();
+  #endif
+  #if HAS_Z_AXIS
     if (parser.seenval('Z')) hotend_offset[target_extruder].z = parser.value_linear_units();
+  #endif
 
   #if ENABLED(DELTA)
     if (target_extruder == active_extruder)

Marlin/src/gcode/config/M92.cpp

@@ -92,6 +92,7 @@ void GcodeSuite::M92() {
 
 void GcodeSuite::M92_report(const bool forReplay/*=true*/, const int8_t e/*=-1*/) {
   report_heading_etc(forReplay, F(STR_STEPS_PER_UNIT));
+  #if NUM_AXES
     SERIAL_ECHOPGM_P(LIST_N(DOUBLE(NUM_AXES),
       PSTR("  M92 X"), LINEAR_UNIT(planner.settings.axis_steps_per_mm[X_AXIS]),
       SP_Y_STR, LINEAR_UNIT(planner.settings.axis_steps_per_mm[Y_AXIS]),
@@ -103,10 +104,15 @@ void GcodeSuite::M92_report(const bool forReplay/*=true*/, const int8_t e/*=-1*/
       SP_V_STR, V_AXIS_UNIT(planner.settings.axis_steps_per_mm[V_AXIS]),
       SP_W_STR, W_AXIS_UNIT(planner.settings.axis_steps_per_mm[W_AXIS])
     ));
+  #endif
+
   #if HAS_EXTRUDERS && DISABLED(DISTINCT_E_FACTORS)
     SERIAL_ECHOPGM_P(SP_E_STR, VOLUMETRIC_UNIT(planner.settings.axis_steps_per_mm[E_AXIS]));
   #endif
+
+  #if NUM_AXES || (HAS_EXTRUDERS && DISABLED(DISTINCT_E_FACTORS))
     SERIAL_EOL();
+  #endif
 
   #if ENABLED(DISTINCT_E_FACTORS)
     LOOP_L_N(i, E_STEPPERS) {

Marlin/src/gcode/control/M17_M18_M84.cpp

@@ -48,6 +48,7 @@ inline stepper_flags_t selected_axis_bits() {
         selected.bits = e_axis_mask;
     }
   #endif
+  #if NUM_AXES
     selected.bits |= NUM_AXIS_GANG(
         (parser.seen_test('X')        << X_AXIS),
       | (parser.seen_test('Y')        << Y_AXIS),
@@ -59,6 +60,7 @@ inline stepper_flags_t selected_axis_bits() {
       | (parser.seen_test(AXIS8_NAME) << V_AXIS),
       | (parser.seen_test(AXIS9_NAME) << W_AXIS)
     );
+  #endif
   return selected;
 }
 

Marlin/src/gcode/feature/pause/G60.cpp

@@ -50,16 +50,19 @@ void GcodeSuite::G60() {
   {
     const xyze_pos_t &pos = stored_position[slot];
     DEBUG_ECHOPGM(STR_SAVED_POS " S", slot, " :");
-    DEBUG_ECHOLNPGM_P(
+    #if NUM_AXES
+      DEBUG_ECHOPGM_P(
         LIST_N(DOUBLE(NUM_AXES),
           SP_X_LBL, pos.x, SP_Y_LBL, pos.y, SP_Z_LBL, pos.z,
           SP_I_LBL, pos.i, SP_J_LBL, pos.j, SP_K_LBL, pos.k,
           SP_U_LBL, pos.u, SP_V_LBL, pos.v, SP_W_LBL, pos.w
         )
-      #if HAS_EXTRUDERS
-        , SP_E_LBL, pos.e
-      #endif
       );
+    #endif
+    #if HAS_EXTRUDERS
+      DEBUG_ECHOPGM_P(SP_E_LBL, pos.e);
+    #endif
+    DEBUG_EOL();
   }
   #endif
 }

Marlin/src/gcode/feature/trinamic/M569.cpp

@@ -57,10 +57,12 @@ static void set_stealth_status(const bool enable, const int8_t eindex) {
 
   LOOP_LOGICAL_AXES(i) if (parser.seen(AXIS_CHAR(i))) {
     switch (i) {
+      #if HAS_X_AXIS
         case X_AXIS:
           TERN_(X_HAS_STEALTHCHOP,  if (index < 0 || index == 0) TMC_SET_STEALTH(X));
           TERN_(X2_HAS_STEALTHCHOP, if (index < 0 || index == 1) TMC_SET_STEALTH(X2));
           break;
+      #endif
 
       #if HAS_Y_AXIS
         case Y_AXIS:
@@ -198,13 +200,13 @@ void GcodeSuite::M569_report(const bool forReplay/*=true*/) {
 
   if (chop_x2 || chop_y2 || chop_z2) {
     say_M569(forReplay, F("I1"));
-    if (chop_x2) SERIAL_ECHOPGM_P(SP_X_STR);
+    NUM_AXIS_CODE(
-    #if HAS_Y_AXIS
+      if (chop_x2) SERIAL_ECHOPGM_P(SP_X_STR),
-      if (chop_y2) SERIAL_ECHOPGM_P(SP_Y_STR);
+      if (chop_y2) SERIAL_ECHOPGM_P(SP_Y_STR),
-    #endif
+      if (chop_z2) SERIAL_ECHOPGM_P(SP_Z_STR),
-    #if HAS_Z_AXIS
+      NOOP, NOOP, NOOP,
-      if (chop_z2) SERIAL_ECHOPGM_P(SP_Z_STR);
+      NOOP, NOOP, NOOP
-    #endif
+    );
     SERIAL_EOL();
   }
 

Marlin/src/gcode/feature/trinamic/M911-M914.cpp

@@ -35,7 +35,7 @@
   #define M91x_USE(ST) (AXIS_DRIVER_TYPE(ST, TMC2130) || AXIS_DRIVER_TYPE(ST, TMC2160) || AXIS_DRIVER_TYPE(ST, TMC2208) || AXIS_DRIVER_TYPE(ST, TMC2209) || AXIS_DRIVER_TYPE(ST, TMC2660) || AXIS_DRIVER_TYPE(ST, TMC5130) || AXIS_DRIVER_TYPE(ST, TMC5160))
   #define M91x_USE_E(N) (E_STEPPERS > N && M91x_USE(E##N))
 
-  #if M91x_USE(X) || M91x_USE(X2)
+  #if HAS_X_AXIS && (M91x_USE(X) || M91x_USE(X2))
     #define M91x_SOME_X 1
   #endif
   #if HAS_Y_AXIS && (M91x_USE(Y) || M91x_USE(Y2))

Marlin/src/inc/Conditionals_LCD.h

@@ -796,10 +796,14 @@
   #define NUM_AXES 3
 #elif defined(Y_DRIVER_TYPE)
   #define NUM_AXES 2
-#else
+#elif defined(X_DRIVER_TYPE)
   #define NUM_AXES 1
+#else
+  #define NUM_AXES 0
+#endif
+#if NUM_AXES >= 1
+  #define HAS_X_AXIS 1
 #endif
-#define HAS_X_AXIS 1
 #if NUM_AXES >= XY
   #define HAS_Y_AXIS 1
 #endif
@@ -825,6 +829,23 @@
   #define HAS_W_AXIS 1
 #endif
 
+#if !HAS_X_AXIS
+  #undef ENDSTOPPULLUP_XMIN
+  #undef ENDSTOPPULLUP_XMAX
+  #undef X_MIN_ENDSTOP_INVERTING
+  #undef X_MAX_ENDSTOP_INVERTING
+  #undef X2_DRIVER_TYPE
+  #undef X_ENABLE_ON
+  #undef DISABLE_X
+  #undef INVERT_X_DIR
+  #undef X_HOME_DIR
+  #undef X_MIN_POS
+  #undef X_MAX_POS
+  #undef MANUAL_X_HOME_POS
+  #undef MIN_SOFTWARE_ENDSTOPS
+  #undef MAX_SOFTWARE_ENDSTOPS
+#endif
+
 #if !HAS_Y_AXIS
   #undef AVOID_OBSTACLES
   #undef ENDSTOPPULLUP_YMIN
@@ -1318,10 +1339,12 @@
 #endif // FILAMENT_SWITCH_AND_MOTION
 
 // Homing to Min or Max
-#if X_HOME_DIR > 0
+#if HAS_X_AXIS
+  #if X_HOME_DIR > 0
     #define X_HOME_TO_MAX 1
-#elif X_HOME_DIR < 0
+  #elif X_HOME_DIR < 0
     #define X_HOME_TO_MIN 1
+  #endif
 #endif
 #if HAS_Y_AXIS
   #if Y_HOME_DIR > 0

Marlin/src/inc/Conditionals_adv.h

@@ -94,8 +94,26 @@
 #endif
 
 // Some options are disallowed without required axes
+#if !HAS_X_AXIS
+  //#define LCD_SHOW_E_TOTAL
+  #define NO_WORKSPACE_OFFSETS
+  #undef AUTOTEMP
+  #undef CALIBRATION_MEASURE_LEFT
+  #undef CALIBRATION_MEASURE_RIGHT
+  #undef CALIBRATION_MEASURE_XMAX
+  #undef CALIBRATION_MEASURE_XMIN
+  #undef DISABLE_IDLE_X
+  #undef INPUT_SHAPING_X
+  #undef SAFE_BED_LEVELING_START_X
+  #undef SHAPING_BUFFER_X
+  #undef SHAPING_FREQ_X
+  #undef STEALTHCHOP_X
+#endif
+
 #if !HAS_Y_AXIS
   #undef ARC_SUPPORT
+  #undef CALIBRATION_MEASURE_BACK
+  #undef CALIBRATION_MEASURE_FRONT
   #undef CALIBRATION_MEASURE_YMAX
   #undef CALIBRATION_MEASURE_YMIN
   #undef DISABLE_IDLE_Y

Marlin/src/inc/Conditionals_post.h

@@ -105,7 +105,9 @@
   #define HAS_ROTATIONAL_AXES 1
 #endif
 
-#define X_MAX_LENGTH (X_MAX_POS - (X_MIN_POS))
+#if HAS_X_AXIS
+  #define X_MAX_LENGTH (X_MAX_POS - (X_MIN_POS))
+#endif
 #if HAS_Y_AXIS
   #define Y_MAX_LENGTH (Y_MAX_POS - (Y_MIN_POS))
 #endif
@@ -134,7 +136,7 @@
 #endif
 
 // Defined only if the sanity-check is bypassed
-#ifndef X_BED_SIZE
+#if HAS_X_AXIS && !defined(X_BED_SIZE)
   #define X_BED_SIZE X_MAX_LENGTH
 #endif
 #if HAS_Y_AXIS && !defined(Y_BED_SIZE)
@@ -165,7 +167,9 @@
 #endif
 
 // Define center values for future use
-#define _X_HALF_BED ((X_BED_SIZE) / 2)
+#if HAS_X_AXIS
+  #define _X_HALF_BED ((X_BED_SIZE) / 2)
+#endif
 #if HAS_Y_AXIS
   #define _Y_HALF_BED ((Y_BED_SIZE) / 2)
 #endif
@@ -188,7 +192,9 @@
   #define _W_HALF_WMAX ((W_BED_SIZE) / 2)
 #endif
 
-#define X_CENTER TERN(BED_CENTER_AT_0_0, 0, _X_HALF_BED)
+#if HAS_X_AXIS
+  #define X_CENTER TERN(BED_CENTER_AT_0_0, 0, _X_HALF_BED)
+#endif
 #if HAS_Y_AXIS
   #define Y_CENTER TERN(BED_CENTER_AT_0_0, 0, _Y_HALF_BED)
   #define XY_CENTER { X_CENTER, Y_CENTER }
@@ -213,8 +219,10 @@
 #endif
 
 // Get the linear boundaries of the bed
-#define X_MIN_BED (X_CENTER - _X_HALF_BED)
+#if HAS_X_AXIS
-#define X_MAX_BED (X_MIN_BED + X_BED_SIZE)
+  #define X_MIN_BED (X_CENTER - _X_HALF_BED)
+  #define X_MAX_BED (X_MIN_BED + X_BED_SIZE)
+#endif
 #if HAS_Y_AXIS
   #define Y_MIN_BED (Y_CENTER - _Y_HALF_BED)
   #define Y_MAX_BED (Y_MIN_BED + Y_BED_SIZE)
@@ -292,15 +300,17 @@
 /**
  * Set the home position based on settings or manual overrides
  */
-#ifdef MANUAL_X_HOME_POS
+#if HAS_X_AXIS
+  #ifdef MANUAL_X_HOME_POS
     #define X_HOME_POS MANUAL_X_HOME_POS
-#else
+  #else
     #define X_END_POS TERN(X_HOME_TO_MIN, X_MIN_POS, X_MAX_POS)
     #if ENABLED(BED_CENTER_AT_0_0)
       #define X_HOME_POS TERN(DELTA, 0, X_END_POS)
     #else
       #define X_HOME_POS TERN(DELTA, X_MIN_POS + (X_BED_SIZE) * 0.5, X_END_POS)
     #endif
+  #endif
 #endif
 
 #if HAS_Y_AXIS
@@ -1021,30 +1031,32 @@
  */
 
 // Steppers
-#if PIN_EXISTS(X_ENABLE) || (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(X))
+#if HAS_X_AXIS
+  #if PIN_EXISTS(X_ENABLE) || (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(X))
     #define HAS_X_ENABLE 1
-#endif
+  #endif
-#if PIN_EXISTS(X_DIR)
+  #if PIN_EXISTS(X_DIR)
     #define HAS_X_DIR 1
-#endif
+  #endif
-#if PIN_EXISTS(X_STEP)
+  #if PIN_EXISTS(X_STEP)
     #define HAS_X_STEP 1
-#endif
+  #endif
-#if PIN_EXISTS(X_MS1)
+  #if PIN_EXISTS(X_MS1)
     #define HAS_X_MS_PINS 1
-#endif
+  #endif
 
-#if PIN_EXISTS(X2_ENABLE) || (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(X2))
+  #if PIN_EXISTS(X2_ENABLE) || (ENABLED(SOFTWARE_DRIVER_ENABLE) && AXIS_IS_TMC(X2))
     #define HAS_X2_ENABLE 1
-#endif
+  #endif
-#if PIN_EXISTS(X2_DIR)
+  #if PIN_EXISTS(X2_DIR)
     #define HAS_X2_DIR 1
-#endif
+  #endif
-#if PIN_EXISTS(X2_STEP)
+  #if PIN_EXISTS(X2_STEP)
     #define HAS_X2_STEP 1
-#endif
+  #endif
-#if PIN_EXISTS(X2_MS1)
+  #if PIN_EXISTS(X2_MS1)
     #define HAS_X2_MS_PINS 1
+  #endif
 #endif
 
 /**

Marlin/src/inc/SanityCheck.h

@@ -260,7 +260,7 @@ static_assert(COUNT(arm) == LOGICAL_AXES, "AXIS_RELATIVE_MODES must contain " _L
  * Validate bed size
  */
 #if !defined(X_BED_SIZE) || !defined(Y_BED_SIZE)
-  #error "X_BED_SIZE and Y_BED_SIZE are now required!"
+  #error "X_BED_SIZE and Y_BED_SIZE are required!"
 #else
   #if HAS_X_AXIS
     static_assert(X_MAX_LENGTH >= X_BED_SIZE, "Movement bounds (X_MIN_POS, X_MAX_POS) are too narrow to contain X_BED_SIZE.");
@@ -3372,9 +3372,11 @@ static_assert(COUNT(sanity_arr_3) >= LOGICAL_AXES,  "DEFAULT_MAX_ACCELERATION re
 static_assert(COUNT(sanity_arr_3) <= DISTINCT_AXES, "DEFAULT_MAX_ACCELERATION has too many elements." _EXTRA_NOTE);
 static_assert(_PLUS_TEST(3), "DEFAULT_MAX_ACCELERATION values must be positive.");
 
-constexpr float sanity_arr_4[] = HOMING_FEEDRATE_MM_M;
+#if NUM_AXES
-static_assert(COUNT(sanity_arr_4) == NUM_AXES,  "HOMING_FEEDRATE_MM_M requires " _NUM_AXES_STR "elements (and no others).");
+  constexpr float sanity_arr_4[] = HOMING_FEEDRATE_MM_M;
-static_assert(_PLUS_TEST(4), "HOMING_FEEDRATE_MM_M values must be positive.");
+  static_assert(COUNT(sanity_arr_4) == NUM_AXES,  "HOMING_FEEDRATE_MM_M requires " _NUM_AXES_STR "elements (and no others).");
+  static_assert(_PLUS_TEST(4), "HOMING_FEEDRATE_MM_M values must be positive.");
+#endif
 
 #ifdef MAX_ACCEL_EDIT_VALUES
   constexpr float sanity_arr_5[] = MAX_ACCEL_EDIT_VALUES;
@@ -3571,7 +3573,7 @@ static_assert(_PLUS_TEST(4), "HOMING_FEEDRATE_MM_M values must be positive.");
   #if ENABLED(DUAL_X_CARRIAGE)
     #error "DUAL_X_CARRIAGE requires both MIN_ and MAX_SOFTWARE_ENDSTOPS."
   #elif HAS_HOTEND_OFFSET
-    #error "MIN_ and MAX_SOFTWARE_ENDSTOPS are both required with offset hotends."
+    #error "Multi-hotends with offset requires both MIN_ and MAX_SOFTWARE_ENDSTOPS."
   #endif
 #endif
 

Marlin/src/lcd/HD44780/marlinui_HD44780.cpp

@@ -975,7 +975,7 @@ void MarlinUI::draw_status_screen() {
 
           #else // !HAS_DUAL_MIXING
 
-            const bool show_e_total = TERN0(LCD_SHOW_E_TOTAL, printingIsActive());
+            const bool show_e_total = TERN1(HAS_X_AXIS, TERN0(LCD_SHOW_E_TOTAL, printingIsActive()));
 
             if (show_e_total) {
               #if ENABLED(LCD_SHOW_E_TOTAL)
@@ -986,10 +986,14 @@ void MarlinUI::draw_status_screen() {
               #endif
             }
             else {
+              #if HAS_X_AXIS
                 const xy_pos_t lpos = current_position.asLogical();
                 _draw_axis_value(X_AXIS, ftostr4sign(lpos.x), blink);
-              lcd_put_u8str(F(" "));
+              #endif
+              #if HAS_Y_AXIS
+                TERN_(HAS_X_AXIS, lcd_put_u8str(F(" ")));
                 _draw_axis_value(Y_AXIS, ftostr4sign(lpos.y), blink);
+              #endif
             }
 
           #endif // !HAS_DUAL_MIXING
@@ -1065,8 +1069,10 @@ void MarlinUI::draw_status_screen() {
     //
     // Z Coordinate
     //
+    #if HAS_Z_AXIS
       lcd_moveto(LCD_WIDTH - 9, 0);
       _draw_axis_value(Z_AXIS, ftostr52sp(LOGICAL_Z_POSITION(current_position.z)), blink);
+    #endif
 
     #if HAS_LEVELING && (HAS_MULTI_HOTEND || !HAS_HEATED_BED)
       lcd_put_lchar(LCD_WIDTH - 1, 0, planner.leveling_active || blink ? '_' : ' ');

Marlin/src/lcd/TFTGLCD/marlinui_TFTGLCD.cpp

@@ -820,11 +820,17 @@ void MarlinUI::draw_status_screen() {
   // Line 1 - XYZ coordinates
   //
 
+  #if NUM_AXES
     lcd_moveto(0, 0);
     const xyz_pos_t lpos = current_position.asLogical();
-  _draw_axis_value(X_AXIS, ftostr4sign(lpos.x), blink); lcd.write(' ');
+    _draw_axis_value(X_AXIS, ftostr4sign(lpos.x), blink);
-  _draw_axis_value(Y_AXIS, ftostr4sign(lpos.y), blink); lcd.write(' ');
+    #if HAS_Y_AXIS
-  _draw_axis_value(Z_AXIS, ftostr52sp(lpos.z), blink);
+      lcd.write(' '); _draw_axis_value(Y_AXIS, ftostr4sign(lpos.y), blink);
+    #endif
+    #if HAS_Z_AXIS
+      lcd.write(' '); _draw_axis_value(Z_AXIS, ftostr52sp(lpos.z), blink);
+    #endif
+  #endif
 
   #if HAS_LEVELING && !HAS_HEATED_BED
     lcd.write(planner.leveling_active || blink ? '_' : ' ');

Marlin/src/lcd/dogm/status_screen_DOGM.cpp

@@ -510,20 +510,24 @@ FORCE_INLINE void _draw_axis_value(const AxisEnum axis, const char *value, const
  * Use the PAGE_CONTAINS macros to avoid pointless draw calls.
  */
 void MarlinUI::draw_status_screen() {
+  #if NUM_AXES
     constexpr int xystorage = TERN(INCH_MODE_SUPPORT, 8, 5);
+    #if EITHER(HAS_X_AXIS, LCD_SHOW_E_TOTAL)
       static char xstring[TERN(LCD_SHOW_E_TOTAL, 12, xystorage)];
+    #endif
     #if HAS_Y_AXIS
       static char ystring[xystorage];
     #endif
     #if HAS_Z_AXIS
       static char zstring[8];
     #endif
+  #endif
 
   #if ENABLED(FILAMENT_LCD_DISPLAY)
     static char wstring[5], mstring[4];
   #endif
 
-  const bool show_e_total = TERN0(LCD_SHOW_E_TOTAL, printingIsActive());
+  const bool show_e_total = TERN1(HAS_X_AXIS, TERN0(LCD_SHOW_E_TOTAL, printingIsActive()));
 
   #if HAS_PRINT_PROGRESS
     static u8g_uint_t progress_bar_solid_width = 0;
@@ -544,10 +548,9 @@ void MarlinUI::draw_status_screen() {
       draw_bits = new_bits;
     #endif
 
+    #if NUM_AXES
       const xyz_pos_t lpos = current_position.asLogical();
       const bool is_inch = parser.using_inch_units();
-    #if HAS_Z_AXIS
-      strcpy(zstring, is_inch ? ftostr42_52(LINEAR_UNIT(lpos.z)) : ftostr52sp(lpos.z));
     #endif
 
     if (show_e_total) {
@@ -557,10 +560,12 @@ void MarlinUI::draw_status_screen() {
       #endif
     }
     else {
-      strcpy(xstring, is_inch ? ftostr53_63(LINEAR_UNIT(lpos.x)) : ftostr4sign(lpos.x));
+      TERN_(HAS_X_AXIS, strcpy(xstring, is_inch ? ftostr53_63(LINEAR_UNIT(lpos.x)) : ftostr4sign(lpos.x)));
       TERN_(HAS_Y_AXIS, strcpy(ystring, is_inch ? ftostr53_63(LINEAR_UNIT(lpos.y)) : ftostr4sign(lpos.y)));
     }
 
+    TERN_(HAS_Z_AXIS, strcpy(zstring, is_inch ? ftostr42_52(LINEAR_UNIT(lpos.z)) : ftostr52sp(lpos.z)));
+
     #if ENABLED(FILAMENT_LCD_DISPLAY)
       strcpy(wstring, ftostr12ns(filwidth.measured_mm));
       strcpy(mstring, i16tostr3rj(planner.volumetric_percent(parser.volumetric_enabled)));
@@ -839,15 +844,13 @@ void MarlinUI::draw_status_screen() {
           #endif
         }
         else {
-          _draw_axis_value(X_AXIS, xstring, blink);
+          TERN_(HAS_X_AXIS, _draw_axis_value(X_AXIS, xstring, blink));
           TERN_(HAS_Y_AXIS, _draw_axis_value(Y_AXIS, ystring, blink));
         }
 
       #endif
 
-      #if HAS_Z_AXIS
+      TERN_(HAS_Z_AXIS, _draw_axis_value(Z_AXIS, zstring, blink));
-        _draw_axis_value(Z_AXIS, zstring, blink);
-      #endif
 
       #if NONE(XYZ_NO_FRAME, XYZ_HOLLOW_FRAME)
         u8g.setColorIndex(1); // black on white

Marlin/src/lcd/e3v2/jyersui/dwin.cpp

@@ -2365,6 +2365,7 @@ void CrealityDWINClass::Menu_Item_Handler(const uint8_t menu, const uint8_t item
           else
             Draw_Menu(Motion, MOTION_SPEED);
           break;
+        #if HAS_X_AXIS
           case SPEED_X:
             if (draw) {
               Draw_Menu_Item(row, ICON_MaxSpeedX, F("X Axis"));
@@ -2373,6 +2374,7 @@ void CrealityDWINClass::Menu_Item_Handler(const uint8_t menu, const uint8_t item
             else
               Modify_Value(planner.settings.max_feedrate_mm_s[X_AXIS], 0, default_max_feedrate[X_AXIS] * 2, 1);
             break;
+        #endif
 
         #if HAS_Y_AXIS
           case SPEED_Y:

Marlin/src/lcd/e3v2/marlinui/ui_status_480x272.cpp

@@ -308,14 +308,14 @@ void MarlinUI::draw_status_screen() {
 
   // Axis values
   const xyz_pos_t lpos = current_position.asLogical();
-  const bool show_e_total = TERN0(LCD_SHOW_E_TOTAL, printingIsActive()); UNUSED(show_e_total);
+  const bool show_e_total = TERN1(HAS_X_AXIS, TERN0(LCD_SHOW_E_TOTAL, printingIsActive()));
 
   constexpr int16_t cpy = TERN(DWIN_MARLINUI_PORTRAIT, 195, 117);
   if (show_e_total) {
     TERN_(LCD_SHOW_E_TOTAL, _draw_e_value(e_move_accumulator, TERN(DWIN_MARLINUI_PORTRAIT, 6, 75), cpy));
   }
   else {
-                      _draw_axis_value(X_AXIS, ftostr4sign(lpos.x), blink, TERN(DWIN_MARLINUI_PORTRAIT,  6,  75), cpy);
+    TERN_(HAS_X_AXIS, _draw_axis_value(X_AXIS, ftostr4sign(lpos.x), blink, TERN(DWIN_MARLINUI_PORTRAIT,  6,  75), cpy));
     TERN_(HAS_Y_AXIS, _draw_axis_value(Y_AXIS, ftostr4sign(lpos.y), blink, TERN(DWIN_MARLINUI_PORTRAIT, 95, 184), cpy));
   }
   TERN_(HAS_Z_AXIS, _draw_axis_value(Z_AXIS, ftostr52sp(lpos.z), blink, TERN(DWIN_MARLINUI_PORTRAIT, 165, 300), cpy));

Marlin/src/lcd/extui/dgus/fysetc/DGUSScreenHandler.cpp

@@ -162,10 +162,12 @@ void DGUSScreenHandler::HandleManualMove(DGUS_VP_Variable &var, void *val_ptr) {
   switch (var.VP) {
     default: return;
 
+    #if HAS_X_AXIS
       case VP_MOVE_X:
         axiscode = 'X';
         if (!ExtUI::canMove(ExtUI::axis_t::X)) goto cannotmove;
         break;
+    #endif
 
     #if HAS_Y_AXIS
       case VP_MOVE_Y:

Marlin/src/lcd/extui/dgus/hiprecy/DGUSScreenHandler.cpp

@@ -162,10 +162,12 @@ void DGUSScreenHandler::HandleManualMove(DGUS_VP_Variable &var, void *val_ptr) {
   switch (var.VP) {
     default: return;
 
+    #if HAS_X_AXIS
       case VP_MOVE_X:
         axiscode = 'X';
         if (!ExtUI::canMove(ExtUI::axis_t::X)) goto cannotmove;
         break;
+    #endif
 
     #if HAS_Y_AXIS
       case VP_MOVE_Y:

Marlin/src/lcd/extui/dgus/mks/DGUSScreenHandler.cpp

@@ -743,10 +743,12 @@ void DGUSScreenHandler::HandleManualMove(DGUS_VP_Variable &var, void *val_ptr) {
 
   switch (var.VP) { // switch X Y Z or Home
     default: return;
+    #if HAS_X_AXIS
       case VP_MOVE_X:
         axiscode = 'X';
         if (!ExtUI::canMove(ExtUI::axis_t::X)) goto cannotmove;
         break;
+    #endif
 
     #if HAS_Y_AXIS
       case VP_MOVE_Y:
@@ -773,10 +775,12 @@ void DGUSScreenHandler::HandleManualMove(DGUS_VP_Variable &var, void *val_ptr) {
       movevalue = 0; // ignore value sent from display, this VP is _ONLY_ for homing.
       break;
 
+    #if HAS_X_AXIS
       case VP_X_HOME:
         axiscode = 'X';
         movevalue = 0;
         break;
+    #endif
 
     #if HAS_Y_AXIS
       case VP_Y_HOME:

Marlin/src/lcd/extui/dgus/origin/DGUSScreenHandler.cpp

@@ -162,10 +162,12 @@ void DGUSScreenHandler::HandleManualMove(DGUS_VP_Variable &var, void *val_ptr) {
   switch (var.VP) {
     default: return;
 
+    #if HAS_X_AXIS
       case VP_MOVE_X:
         axiscode = 'X';
         if (!ExtUI::canMove(ExtUI::axis_t::X)) goto cannotmove;
         break;
+    #endif
 
     #if HAS_Y_AXIS
       case VP_MOVE_Y:

Marlin/src/lcd/extui/ftdi_eve_touch_ui/generic/move_axis_screen.cpp

@@ -77,8 +77,10 @@ bool BaseMoveAxisScreen::onTouchHeld(const uint8_t tag) {
   #define UI_DECREMENT_AXIS(axis) setManualFeedrate(axis, increment); UI_DECREMENT(AxisPosition_mm, axis);
   const float increment = getIncrement();
   switch (tag) {
+    #if HAS_X_AXIS
       case  2: UI_DECREMENT_AXIS(X); break;
       case  3: UI_INCREMENT_AXIS(X); break;
+    #endif
     #if HAS_EXTRUDERS
       // For extruders, also update relative distances.
       case  8: UI_DECREMENT_AXIS(E0); mydata.e_rel[0] -= increment; break;

Marlin/src/lcd/extui/mks_ui/draw_acceleration_settings.cpp

@@ -124,8 +124,10 @@ void lv_draw_acceleration_settings() {
     lv_screen_menu_item_1_edit(scr, machine_menu.TravelAcceleration, PARA_UI_POS_X, y, event_handler, ID_ACCE_TRAVEL, 2, public_buf_l);
 
     y += PARA_UI_POS_Y;
+    #if HAS_X_AXIS
       itoa(planner.settings.max_acceleration_mm_per_s2[X_AXIS], public_buf_l, 10);
       lv_screen_menu_item_1_edit(scr, machine_menu.X_Acceleration, PARA_UI_POS_X, y, event_handler, ID_ACCE_X, 3, public_buf_l);
+    #endif
 
     lv_big_button_create(scr, "F:/bmp_back70x40.bin", machine_menu.next, PARA_UI_TURN_PAGE_POS_X, PARA_UI_TURN_PAGE_POS_Y, event_handler, ID_ACCE_DOWN, true);
   }

Marlin/src/lcd/extui/mks_ui/mks_hardware.cpp

@@ -194,7 +194,9 @@
     void mks_hardware_test() {
       if (millis() % 2000 < 1000) {
         thermalManager.fan_speed[0] = 255;
+        #if HAS_X_AXIS
           WRITE(X_DIR_PIN, LOW);
+        #endif
         #if HAS_Y_AXIS
           WRITE(Y_DIR_PIN, LOW);
         #endif
@@ -219,7 +221,9 @@
       }
       else {
         thermalManager.fan_speed[0] = 0;
+        #if HAS_X_AXIS
           WRITE(X_DIR_PIN, HIGH);
+        #endif
         #if HAS_Y_AXIS
           WRITE(Y_DIR_PIN, HIGH);
         #endif

Marlin/src/lcd/extui/ui_api.cpp

@@ -375,7 +375,7 @@ namespace ExtUI {
   bool canMove(const axis_t axis) {
     switch (axis) {
       #if IS_KINEMATIC || ENABLED(NO_MOTION_BEFORE_HOMING)
-        case X: return !axis_should_home(X_AXIS);
+        OPTCODE(HAS_X_AXIS, case X: return !axis_should_home(X_AXIS))
         OPTCODE(HAS_Y_AXIS, case Y: return !axis_should_home(Y_AXIS))
         OPTCODE(HAS_Z_AXIS, case Z: return !axis_should_home(Z_AXIS))
       #else
@@ -773,7 +773,9 @@ namespace ExtUI {
     bool babystepAxis_steps(const int16_t steps, const axis_t axis) {
       switch (axis) {
         #if ENABLED(BABYSTEP_XY)
+          #if HAS_X_AXIS
             case X: babystep.add_steps(X_AXIS, steps); break;
+          #endif
           #if HAS_Y_AXIS
             case Y: babystep.add_steps(Y_AXIS, steps); break;
           #endif
@@ -818,7 +820,7 @@ namespace ExtUI {
             if (e != active_extruder)
               hotend_offset[e][axis] += mm;
 
-          normalizeNozzleOffset(X);
+          TERN_(HAS_X_AXIS, normalizeNozzleOffset(X));
           TERN_(HAS_Y_AXIS, normalizeNozzleOffset(Y));
           TERN_(HAS_Z_AXIS, normalizeNozzleOffset(Z));
         }

Marlin/src/lcd/marlinui.cpp

@@ -506,7 +506,7 @@ void MarlinUI::init() {
         ui.manual_move.menu_scale = REPRAPWORLD_KEYPAD_MOVE_STEP;
         ui.encoderPosition = dir;
         switch (axis) {
-          case X_AXIS:
+          TERN_(HAS_X_AXIS, case X_AXIS:)
           TERN_(HAS_Y_AXIS, case Y_AXIS:)
           TERN_(HAS_Z_AXIS, case Z_AXIS:)
             lcd_move_axis(axis);

Marlin/src/lcd/menu/menu_advanced.cpp

@@ -475,9 +475,23 @@ void menu_backlash();
 
   // M201 / M204 Accelerations
   void menu_advanced_acceleration() {
-    float max_accel = planner.settings.max_acceleration_mm_per_s2[A_AXIS];
+    float max_accel = (
-    TERN_(HAS_Y_AXIS, NOLESS(max_accel, planner.settings.max_acceleration_mm_per_s2[B_AXIS]));
+      #if NUM_AXES
-    TERN_(HAS_Z_AXIS, NOLESS(max_accel, planner.settings.max_acceleration_mm_per_s2[C_AXIS]));
+        _MAX(NUM_AXIS_LIST(
+          planner.settings.max_acceleration_mm_per_s2[A_AXIS],
+          planner.settings.max_acceleration_mm_per_s2[B_AXIS],
+          planner.settings.max_acceleration_mm_per_s2[C_AXIS],
+          planner.settings.max_acceleration_mm_per_s2[I_AXIS],
+          planner.settings.max_acceleration_mm_per_s2[J_AXIS],
+          planner.settings.max_acceleration_mm_per_s2[K_AXIS],
+          planner.settings.max_acceleration_mm_per_s2[U_AXIS],
+          planner.settings.max_acceleration_mm_per_s2[V_AXIS],
+          planner.settings.max_acceleration_mm_per_s2[W_AXIS]
+        ))
+      #else
+        0
+      #endif
+    );
 
     // M201 settings
     constexpr xyze_ulong_t max_accel_edit =

Marlin/src/lcd/menu/menu_backlash.cpp

@@ -50,7 +50,9 @@ void menu_backlash() {
     EDIT_ITEM_FAST_N(float43, _AXIS(N), MSG_BACKLASH_N, &editable.decimal, 0.0f, 9.9f, []{ backlash.set_distance_mm(_AXIS(N), editable.decimal); }); \
   } while (0);
 
-  if (_CAN_CALI(A)) EDIT_BACKLASH_DISTANCE(A);
+  #if HAS_X_AXIS && _CAN_CALI(A)
+    EDIT_BACKLASH_DISTANCE(A);
+  #endif
   #if HAS_Y_AXIS && _CAN_CALI(B)
     EDIT_BACKLASH_DISTANCE(B);
   #endif

Marlin/src/lcd/menu/menu_motion.cpp

@@ -28,7 +28,7 @@
 
 #if HAS_MARLINUI_MENU
 
-#define HAS_LARGE_AREA ((X_BED_SIZE) >= 1000 || TERN0(HAS_Y_AXIS, (Y_BED_SIZE) >= 1000) || TERN0(HAS_Z_AXIS, (Z_MAX_POS) >= 1000))
+#define HAS_LARGE_AREA (TERN0(HAS_X_AXIS, (X_BED_SIZE) >= 1000) || TERN0(HAS_Y_AXIS, (Y_BED_SIZE) >= 1000) || TERN0(HAS_Z_AXIS, (Z_MAX_POS) >= 1000))
 #if ENABLED(LARGE_MOVE_ITEMS)
   #define HAS_LARGE_MOVES true
 #elif ENABLED(SLIM_LCD_MENUS)
@@ -214,7 +214,9 @@ void menu_move() {
   // Move submenu for each axis
   if (NONE(IS_KINEMATIC, NO_MOTION_BEFORE_HOMING) || all_axes_homed()) {
     if (TERN1(DELTA, current_position.z <= delta_clip_start_height)) {
+      #if HAS_X_AXIS
         SUBMENU_N(X_AXIS, MSG_MOVE_N, []{ _menu_move_distance(X_AXIS, []{ lcd_move_axis(X_AXIS); }); });
+      #endif
       #if HAS_Y_AXIS
         SUBMENU_N(Y_AXIS, MSG_MOVE_N, []{ _menu_move_distance(Y_AXIS, []{ lcd_move_axis(Y_AXIS); }); });
       #endif

Marlin/src/libs/vector_3.h

@@ -50,9 +50,9 @@ struct vector_3 {
     float pos[3];
   };
   vector_3(const_float_t _x, const_float_t _y, const_float_t _z) : x(_x), y(_y), z(_z) {}
-  vector_3(const xy_float_t   &in) { x = in.x; TERN_(HAS_Y_AXIS, y = in.y); }
+  vector_3(const xy_float_t   &in) { TERN_(HAS_X_AXIS, x = in.x); TERN_(HAS_Y_AXIS, y = in.y); }
-  vector_3(const xyz_float_t  &in) { x = in.x; TERN_(HAS_Y_AXIS, y = in.y); TERN_(HAS_Z_AXIS, z = in.z); }
+  vector_3(const xyz_float_t  &in) { TERN_(HAS_X_AXIS, x = in.x); TERN_(HAS_Y_AXIS, y = in.y); TERN_(HAS_Z_AXIS, z = in.z); }
-  vector_3(const xyze_float_t &in) { x = in.x; TERN_(HAS_Y_AXIS, y = in.y); TERN_(HAS_Z_AXIS, z = in.z); }
+  vector_3(const xyze_float_t &in) { TERN_(HAS_X_AXIS, x = in.x); TERN_(HAS_Y_AXIS, y = in.y); TERN_(HAS_Z_AXIS, z = in.z); }
   vector_3() { x = y = z = 0; }
 
   // Factory method
@@ -75,8 +75,8 @@ struct vector_3 {
   vector_3 operator-(const vector_3 &v) { return vector_3(x - v.x, y - v.y, z - v.z); }
   vector_3 operator*(const float &v)    { return vector_3(x * v, y * v, z * v); }
 
-  operator xy_float_t() { return xy_float_t({ x OPTARG(HAS_Y_AXIS, y) }); }
+  operator xy_float_t() { return xy_float_t({ TERN_(HAS_X_AXIS, x) OPTARG(HAS_Y_AXIS, y) }); }
-  operator xyz_float_t() { return xyz_float_t({ x OPTARG(HAS_Y_AXIS, y) OPTARG(HAS_Z_AXIS, z) }); }
+  operator xyz_float_t() { return xyz_float_t({ TERN_(HAS_X_AXIS, x) OPTARG(HAS_Y_AXIS, y) OPTARG(HAS_Z_AXIS, z) }); }
 
   void debug(FSTR_P const title);
 };

Marlin/src/module/endstops.cpp

@@ -300,7 +300,7 @@ void Endstops::event_handler() {
   prev_hit_state = hit_state;
   if (hit_state) {
     #if HAS_STATUS_MESSAGE
-      char NUM_AXIS_LIST(chrX = ' ', chrY = ' ', chrZ = ' ', chrI = ' ', chrJ = ' ', chrK = ' ', chrU = ' ', chrV = ' ', chrW = ' '),
+      char NUM_AXIS_LIST_(chrX = ' ', chrY = ' ', chrZ = ' ', chrI = ' ', chrJ = ' ', chrK = ' ', chrU = ' ', chrV = ' ', chrW = ' ')
            chrP = ' ';
       #define _SET_STOP_CHAR(A,C) (chr## A = C)
     #else
@@ -348,7 +348,7 @@ void Endstops::event_handler() {
       ui.status_printf(0,
         F(S_FMT GANG_N_1(NUM_AXES, " %c") " %c"),
         GET_TEXT(MSG_LCD_ENDSTOPS),
-        NUM_AXIS_LIST(chrX, chrY, chrZ, chrI, chrJ, chrK, chrU, chrV, chrW), chrP
+        NUM_AXIS_LIST_(chrX, chrY, chrZ, chrI, chrJ, chrK, chrU, chrV, chrW) chrP
       )
     );
 
@@ -367,18 +367,22 @@ void Endstops::event_handler() {
   }
 }
 
-#pragma GCC diagnostic push
+#if NUM_AXES
-#if GCC_VERSION <= 50000
-  #pragma GCC diagnostic ignored "-Wunused-function"
-#endif
 
-static void print_es_state(const bool is_hit, FSTR_P const flabel=nullptr) {
+  #pragma GCC diagnostic push
+  #if GCC_VERSION <= 50000
+    #pragma GCC diagnostic ignored "-Wunused-function"
+  #endif
+
+  static void print_es_state(const bool is_hit, FSTR_P const flabel=nullptr) {
     if (flabel) SERIAL_ECHOF(flabel);
     SERIAL_ECHOPGM(": ");
     SERIAL_ECHOLNF(is_hit ? F(STR_ENDSTOP_HIT) : F(STR_ENDSTOP_OPEN));
-}
+  }
 
-#pragma GCC diagnostic pop
+  #pragma GCC diagnostic pop
+
+#endif
 
 void __O2 Endstops::report_states() {
   TERN_(BLTOUCH, bltouch._set_SW_mode());

Marlin/src/module/motion.cpp

@@ -203,6 +203,7 @@ inline void report_more_positions() {
 // Report the logical position for a given machine position
 inline void report_logical_position(const xyze_pos_t &rpos) {
   const xyze_pos_t lpos = rpos.asLogical();
+  #if NUM_AXES
     SERIAL_ECHOPGM_P(
       LIST_N(DOUBLE(NUM_AXES),
            X_LBL, lpos.x,
@@ -215,10 +216,11 @@ inline void report_logical_position(const xyze_pos_t &rpos) {
         SP_V_LBL, lpos.v,
         SP_W_LBL, lpos.w
       )
-    #if HAS_EXTRUDERS
-      , SP_E_LBL, lpos.e
-    #endif
     );
+  #endif
+  #if HAS_EXTRUDERS
+    SERIAL_ECHOPGM_P(SP_E_LBL, lpos.e);
+  #endif
 }
 
 // Report the real current position according to the steppers.
@@ -367,7 +369,7 @@ void report_current_position_projected() {
 #else // CARTESIAN
 
   // Return true if the given position is within the machine bounds.
-  bool position_is_reachable(const_float_t rx, const_float_t ry) {
+  bool position_is_reachable(TERN_(HAS_X_AXIS, const_float_t rx) OPTARG(HAS_Y_AXIS, const_float_t ry)) {
     if (TERN0(HAS_Y_AXIS, !COORDINATE_OKAY(ry, Y_MIN_POS - fslop, Y_MAX_POS + fslop))) return false;
     #if ENABLED(DUAL_X_CARRIAGE)
       if (active_extruder)
@@ -375,7 +377,8 @@ void report_current_position_projected() {
       else
         return COORDINATE_OKAY(rx, X1_MIN_POS - fslop, X1_MAX_POS + fslop);
     #else
-      return COORDINATE_OKAY(rx, X_MIN_POS - fslop, X_MAX_POS + fslop);
+      if (TERN0(HAS_X_AXIS, !COORDINATE_OKAY(rx, X_MIN_POS - fslop, X_MAX_POS + fslop))) return false;
+      return true;
     #endif
   }
 
@@ -567,7 +570,7 @@ void _internal_move_to_destination(const_feedRate_t fr_mm_s/*=0.0f*/
  * - Delta may lower Z first to get into the free motion zone.
  * - Before returning, wait for the planner buffer to empty.
  */
-void do_blocking_move_to(NUM_AXIS_ARGS(const_float_t), const_feedRate_t fr_mm_s/*=0.0f*/) {
+void do_blocking_move_to(NUM_AXIS_ARGS_(const_float_t) const_feedRate_t fr_mm_s/*=0.0f*/) {
   DEBUG_SECTION(log_move, "do_blocking_move_to", DEBUGGING(LEVELING));
   if (DEBUGGING(LEVELING)) DEBUG_XYZ("> ", NUM_AXIS_ARGS());
 
@@ -642,7 +645,7 @@ void do_blocking_move_to(NUM_AXIS_ARGS(const_float_t), const_feedRate_t fr_mm_s/
       if (current_position.z < z) { current_position.z = z; line_to_current_position(z_feedrate); }
     #endif
 
-    current_position.set(x OPTARG(HAS_Y_AXIS, y)); line_to_current_position(xy_feedrate);
+    current_position.set(TERN_(HAS_X_AXIS, x) OPTARG(HAS_Y_AXIS, y)); line_to_current_position(xy_feedrate);
 
     #if SECONDARY_AXES
       secondary_axis_moves(SECONDARY_AXIS_LIST(i, j, k, u, v, w), fr_mm_s);
@@ -659,30 +662,33 @@ void do_blocking_move_to(NUM_AXIS_ARGS(const_float_t), const_feedRate_t fr_mm_s/
 }
 
 void do_blocking_move_to(const xy_pos_t &raw, const_feedRate_t fr_mm_s/*=0.0f*/) {
-  do_blocking_move_to(NUM_AXIS_LIST(raw.x, raw.y, current_position.z, current_position.i, current_position.j, current_position.k,
+  do_blocking_move_to(NUM_AXIS_LIST_(raw.x, raw.y, current_position.z, current_position.i, current_position.j, current_position.k,
-                                    current_position.u, current_position.v, current_position.w), fr_mm_s);
+                                    current_position.u, current_position.v, current_position.w) fr_mm_s);
 }
 void do_blocking_move_to(const xyz_pos_t &raw, const_feedRate_t fr_mm_s/*=0.0f*/) {
-  do_blocking_move_to(NUM_AXIS_ELEM(raw), fr_mm_s);
+  do_blocking_move_to(NUM_AXIS_ELEM_(raw) fr_mm_s);
 }
 void do_blocking_move_to(const xyze_pos_t &raw, const_feedRate_t fr_mm_s/*=0.0f*/) {
-  do_blocking_move_to(NUM_AXIS_ELEM(raw), fr_mm_s);
+  do_blocking_move_to(NUM_AXIS_ELEM_(raw) fr_mm_s);
 }
-void do_blocking_move_to_x(const_float_t rx, const_feedRate_t fr_mm_s/*=0.0*/) {
+
+#if HAS_X_AXIS
+  void do_blocking_move_to_x(const_float_t rx, const_feedRate_t fr_mm_s/*=0.0*/) {
     if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("do_blocking_move_to_x(", rx, ", ", fr_mm_s, ")");
     do_blocking_move_to(
-    NUM_AXIS_LIST(rx, current_position.y, current_position.z, current_position.i, current_position.j, current_position.k,
+      NUM_AXIS_LIST_(rx, current_position.y, current_position.z, current_position.i, current_position.j, current_position.k,
-                  current_position.u, current_position.v, current_position.w),
+                     current_position.u, current_position.v, current_position.w)
       fr_mm_s
     );
-}
+  }
+#endif
 
 #if HAS_Y_AXIS
   void do_blocking_move_to_y(const_float_t ry, const_feedRate_t fr_mm_s/*=0.0*/) {
     if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("do_blocking_move_to_y(", ry, ", ", fr_mm_s, ")");
     do_blocking_move_to(
-      NUM_AXIS_LIST(current_position.x, ry, current_position.z, current_position.i, current_position.j, current_position.k,
+      NUM_AXIS_LIST_(current_position.x, ry, current_position.z, current_position.i, current_position.j, current_position.k,
-                    current_position.u, current_position.v, current_position.w),
+                    current_position.u, current_position.v, current_position.w)
       fr_mm_s
     );
   }
@@ -701,7 +707,7 @@ void do_blocking_move_to_x(const_float_t rx, const_feedRate_t fr_mm_s/*=0.0*/) {
   }
   void do_blocking_move_to_xyz_i(const xyze_pos_t &raw, const_float_t i, const_feedRate_t fr_mm_s/*=0.0f*/) {
     do_blocking_move_to(
-      NUM_AXIS_LIST(raw.x, raw.y, raw.z, i, raw.j, raw.k, raw.u, raw.v, raw.w),
+      NUM_AXIS_LIST_(raw.x, raw.y, raw.z, i, raw.j, raw.k, raw.u, raw.v, raw.w)
       fr_mm_s
     );
   }
@@ -713,7 +719,7 @@ void do_blocking_move_to_x(const_float_t rx, const_feedRate_t fr_mm_s/*=0.0*/) {
   }
   void do_blocking_move_to_xyzi_j(const xyze_pos_t &raw, const_float_t j, const_feedRate_t fr_mm_s/*=0.0f*/) {
     do_blocking_move_to(
-      NUM_AXIS_LIST(raw.x, raw.y, raw.z, raw.i, j, raw.k, raw.u, raw.v, raw.w),
+      NUM_AXIS_LIST_(raw.x, raw.y, raw.z, raw.i, j, raw.k, raw.u, raw.v, raw.w)
       fr_mm_s
     );
   }
@@ -725,7 +731,7 @@ void do_blocking_move_to_x(const_float_t rx, const_feedRate_t fr_mm_s/*=0.0*/) {
   }
   void do_blocking_move_to_xyzij_k(const xyze_pos_t &raw, const_float_t k, const_feedRate_t fr_mm_s/*=0.0f*/) {
     do_blocking_move_to(
-      NUM_AXIS_LIST(raw.x, raw.y, raw.z, raw.i, raw.j, k, raw.u, raw.v, raw.w),
+      NUM_AXIS_LIST_(raw.x, raw.y, raw.z, raw.i, raw.j, k, raw.u, raw.v, raw.w)
       fr_mm_s
     );
   }
@@ -737,7 +743,7 @@ void do_blocking_move_to_x(const_float_t rx, const_feedRate_t fr_mm_s/*=0.0*/) {
   }
   void do_blocking_move_to_xyzijk_u(const xyze_pos_t &raw, const_float_t u, const_feedRate_t fr_mm_s/*=0.0f*/) {
     do_blocking_move_to(
-      NUM_AXIS_LIST(raw.x, raw.y, raw.z, raw.i, raw.j, raw.k, u, raw.v, raw.w),
+      NUM_AXIS_LIST_(raw.x, raw.y, raw.z, raw.i, raw.j, raw.k, u, raw.v, raw.w)
       fr_mm_s
     );
   }
@@ -749,7 +755,7 @@ void do_blocking_move_to_x(const_float_t rx, const_feedRate_t fr_mm_s/*=0.0*/) {
   }
   void do_blocking_move_to_xyzijku_v(const xyze_pos_t &raw, const_float_t v, const_feedRate_t fr_mm_s/*=0.0f*/) {
     do_blocking_move_to(
-      NUM_AXIS_LIST(raw.x, raw.y, raw.z, raw.i, raw.j, raw.k, raw.u, v, raw.w),
+      NUM_AXIS_LIST_(raw.x, raw.y, raw.z, raw.i, raw.j, raw.k, raw.u, v, raw.w)
       fr_mm_s
     );
   }
@@ -761,7 +767,7 @@ void do_blocking_move_to_x(const_float_t rx, const_feedRate_t fr_mm_s/*=0.0*/) {
   }
   void do_blocking_move_to_xyzijkuv_w(const xyze_pos_t &raw, const_float_t w, const_feedRate_t fr_mm_s/*=0.0f*/) {
     do_blocking_move_to(
-      NUM_AXIS_LIST(raw.x, raw.y, raw.z, raw.i, raw.j, raw.k, raw.u, raw.v, w),
+      NUM_AXIS_LIST_(raw.x, raw.y, raw.z, raw.i, raw.j, raw.k, raw.u, raw.v, w)
       fr_mm_s
     );
   }
@@ -771,8 +777,8 @@ void do_blocking_move_to_x(const_float_t rx, const_feedRate_t fr_mm_s/*=0.0*/) {
   void do_blocking_move_to_xy(const_float_t rx, const_float_t ry, const_feedRate_t fr_mm_s/*=0.0*/) {
     if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("do_blocking_move_to_xy(", rx, ", ", ry, ", ", fr_mm_s, ")");
     do_blocking_move_to(
-      NUM_AXIS_LIST(rx, ry, current_position.z, current_position.i, current_position.j, current_position.k,
+      NUM_AXIS_LIST_(rx, ry, current_position.z, current_position.i, current_position.j, current_position.k,
-                    current_position.u, current_position.v, current_position.w),
+                    current_position.u, current_position.v, current_position.w)
       fr_mm_s
     );
   }
@@ -784,8 +790,8 @@ void do_blocking_move_to_x(const_float_t rx, const_feedRate_t fr_mm_s/*=0.0*/) {
 #if HAS_Z_AXIS
   void do_blocking_move_to_xy_z(const xy_pos_t &raw, const_float_t z, const_feedRate_t fr_mm_s/*=0.0f*/) {
     do_blocking_move_to(
-      NUM_AXIS_LIST(raw.x, raw.y, z, current_position.i, current_position.j, current_position.k,
+      NUM_AXIS_LIST_(raw.x, raw.y, z, current_position.i, current_position.j, current_position.k,
-                    current_position.u, current_position.v, current_position.w),
+                    current_position.u, current_position.v, current_position.w)
       fr_mm_s
     );
   }
@@ -966,6 +972,7 @@ void restore_feedrate_and_scaling() {
 
     #else
 
+      #if HAS_X_AXIS
         if (axis_was_homed(X_AXIS)) {
           #if !HAS_SOFTWARE_ENDSTOPS || ENABLED(MIN_SOFTWARE_ENDSTOP_X)
             NOLESS(target.x, soft_endstop.min.x);
@@ -974,6 +981,7 @@ void restore_feedrate_and_scaling() {
             NOMORE(target.x, soft_endstop.max.x);
           #endif
         }
+      #endif
 
       #if HAS_Y_AXIS
         if (axis_was_homed(Y_AXIS)) {
@@ -1079,6 +1087,8 @@ FORCE_INLINE void segment_idle(millis_t &next_idle_ms) {
  * Get distance from displacements along axes and, if required, update move type.
  */
 float get_move_distance(const xyze_pos_t &diff OPTARG(HAS_ROTATIONAL_AXES, bool &is_cartesian_move)) {
+  #if NUM_AXES
+
     if (!(NUM_AXIS_GANG(diff.x, || diff.y, /* skip z */, || diff.i, || diff.j, || diff.k, || diff.u, || diff.v, || diff.w)))
       return TERN0(HAS_Z_AXIS, ABS(diff.z));
 
@@ -1155,6 +1165,12 @@ float get_move_distance(const xyze_pos_t &diff OPTARG(HAS_ROTATIONAL_AXES, bool
     #endif
 
     return SQRT(distance_sqr);
+
+  #else
+
+    return 0;
+
+  #endif
 }
 
 #if IS_KINEMATIC
@@ -1702,7 +1718,9 @@ void prepare_line_to_destination() {
 
       #if ENABLED(SPI_ENDSTOPS)
         switch (axis) {
+          #if HAS_X_AXIS
             case X_AXIS: if (ENABLED(X_SPI_SENSORLESS)) endstops.tmc_spi_homing.x = true; break;
+          #endif
           #if HAS_Y_AXIS
             case Y_AXIS: if (ENABLED(Y_SPI_SENSORLESS)) endstops.tmc_spi_homing.y = true; break;
           #endif
@@ -1796,7 +1814,9 @@ void prepare_line_to_destination() {
 
       #if ENABLED(SPI_ENDSTOPS)
         switch (axis) {
+          #if HAS_X_AXIS
             case X_AXIS: if (ENABLED(X_SPI_SENSORLESS)) endstops.tmc_spi_homing.x = false; break;
+          #endif
           #if HAS_Y_AXIS
             case Y_AXIS: if (ENABLED(Y_SPI_SENSORLESS)) endstops.tmc_spi_homing.y = false; break;
           #endif

Marlin/src/module/motion.h

@@ -153,9 +153,9 @@ inline float home_bump_mm(const AxisEnum axis) {
   extern xyz_pos_t hotend_offset[HOTENDS];
   void reset_hotend_offsets();
 #elif HOTENDS
-  constexpr xyz_pos_t hotend_offset[HOTENDS] = { { 0 } };
+  constexpr xyz_pos_t hotend_offset[HOTENDS] = { { TERN_(HAS_X_AXIS, 0) } };
 #else
-  constexpr xyz_pos_t hotend_offset[1] = { { 0 } };
+  constexpr xyz_pos_t hotend_offset[1] = { { TERN_(HAS_X_AXIS, 0) } };
 #endif
 
 #if HAS_SOFTWARE_ENDSTOPS
@@ -169,10 +169,12 @@ inline float home_bump_mm(const AxisEnum axis) {
       amin = -100000; amax = 100000; // "No limits"
       #if HAS_SOFTWARE_ENDSTOPS
         if (enabled()) switch (axis) {
+          #if HAS_X_AXIS
             case X_AXIS:
               TERN_(MIN_SOFTWARE_ENDSTOP_X, amin = min.x);
               TERN_(MAX_SOFTWARE_ENDSTOP_X, amax = max.x);
               break;
+          #endif
           #if HAS_Y_AXIS
             case Y_AXIS:
               TERN_(MIN_SOFTWARE_ENDSTOP_Y, amin = min.y);
@@ -350,12 +352,14 @@ inline void prepare_internal_move_to_destination(const_feedRate_t fr_mm_s=0.0f)
 /**
  * Blocking movement and shorthand functions
  */
-void do_blocking_move_to(NUM_AXIS_ARGS(const_float_t), const_feedRate_t fr_mm_s=0.0f);
+void do_blocking_move_to(NUM_AXIS_ARGS_(const_float_t) const_feedRate_t fr_mm_s=0.0f);
 void do_blocking_move_to(const xy_pos_t &raw, const_feedRate_t fr_mm_s=0.0f);
 void do_blocking_move_to(const xyz_pos_t &raw, const_feedRate_t fr_mm_s=0.0f);
 void do_blocking_move_to(const xyze_pos_t &raw, const_feedRate_t fr_mm_s=0.0f);
 
-void do_blocking_move_to_x(const_float_t rx, const_feedRate_t fr_mm_s=0.0f);
+#if HAS_X_AXIS
+    void do_blocking_move_to_x(const_float_t rx, const_feedRate_t fr_mm_s=0.0f);
+#endif
 #if HAS_Y_AXIS
   void do_blocking_move_to_y(const_float_t ry, const_feedRate_t fr_mm_s=0.0f);
 #endif
@@ -515,8 +519,10 @@ void home_if_needed(const bool keeplev=false);
   FORCE_INLINE void toNative(xyz_pos_t&)   {}
   FORCE_INLINE void toNative(xyze_pos_t&)  {}
 #endif
-#define LOGICAL_X_POSITION(POS) NATIVE_TO_LOGICAL(POS, X_AXIS)
+#if HAS_X_AXIS
-#define RAW_X_POSITION(POS)     LOGICAL_TO_NATIVE(POS, X_AXIS)
+  #define LOGICAL_X_POSITION(POS) NATIVE_TO_LOGICAL(POS, X_AXIS)
+  #define RAW_X_POSITION(POS)     LOGICAL_TO_NATIVE(POS, X_AXIS)
+#endif
 #if HAS_Y_AXIS
   #define LOGICAL_Y_POSITION(POS) NATIVE_TO_LOGICAL(POS, Y_AXIS)
   #define RAW_Y_POSITION(POS)     LOGICAL_TO_NATIVE(POS, Y_AXIS)
@@ -569,9 +575,9 @@ void home_if_needed(const bool keeplev=false);
 #else
 
   // Return true if the given position is within the machine bounds.
-  bool position_is_reachable(const_float_t rx, const_float_t ry);
+  bool position_is_reachable(TERN_(HAS_X_AXIS, const_float_t rx) OPTARG(HAS_Y_AXIS, const_float_t ry));
   inline bool position_is_reachable(const xy_pos_t &pos) {
-    return position_is_reachable(pos.x, pos.y);
+    return position_is_reachable(TERN_(HAS_X_AXIS, pos.x) OPTARG(HAS_Y_AXIS, pos.y));
   }
 
 #endif

Marlin/src/module/planner.cpp

@@ -1903,7 +1903,9 @@ bool Planner::_populate_block(
   /* <-- add a slash to enable
     SERIAL_ECHOLNPGM(
       "  _populate_block FR:", fr_mm_s,
+      #if HAS_X_AXIS
         " A:", target.a, " (", da, " steps)"
+      #endif
       #if HAS_Y_AXIS
         " B:", target.b, " (", db, " steps)"
       #endif
@@ -2204,11 +2206,17 @@ bool Planner::_populate_block(
 
   TERN_(HAS_EXTRUDERS, block->steps.e = esteps);
 
-  block->step_event_count = _MAX(LOGICAL_AXIS_LIST(esteps,
+  block->step_event_count = (
+    #if NUM_AXES
+      _MAX(LOGICAL_AXIS_LIST(esteps,
         block->steps.a, block->steps.b, block->steps.c,
         block->steps.i, block->steps.j, block->steps.k,
         block->steps.u, block->steps.v, block->steps.w
-  ));
+      ))
+    #elif HAS_EXTRUDERS
+      esteps
+    #endif
+  );
 
   // Bail if this is a zero-length block
   if (block->step_event_count < MIN_STEPS_PER_SEGMENT) return false;
@@ -2474,8 +2482,8 @@ bool Planner::_populate_block(
   #if ENABLED(LIN_ADVANCE)
     bool use_advance_lead = false;
   #endif
-  if (NUM_AXIS_GANG(
+  if (true NUM_AXIS_GANG(
-         !block->steps.a, && !block->steps.b, && !block->steps.c,
+      && !block->steps.a, && !block->steps.b, && !block->steps.c,
       && !block->steps.i, && !block->steps.j, && !block->steps.k,
       && !block->steps.u, && !block->steps.v, && !block->steps.w)
   ) {                                                             // Is this a retract / recover move?

Marlin/src/module/probe.h

@@ -182,7 +182,7 @@ public:
 
     static bool set_deployed(const bool, const bool=false) { return false; }
 
-    static bool can_reach(const_float_t rx, const_float_t ry, const bool=true) { return position_is_reachable(rx, ry); }
+    static bool can_reach(const_float_t rx, const_float_t ry, const bool=true) { return position_is_reachable(TERN_(HAS_X_AXIS, rx) OPTARG(HAS_Y_AXIS, ry)); }
 
   #endif // !HAS_BED_PROBE
 

Marlin/src/module/settings.cpp

@@ -181,10 +181,10 @@
 #define _EN_ITEM(N) , E##N
 #define _EN1_ITEM(N) , E##N:1
 
-typedef struct { uint16_t MAIN_AXIS_NAMES, X2, Y2, Z2, Z3, Z4 REPEAT(E_STEPPERS, _EN_ITEM); } per_stepper_uint16_t;
+typedef struct { uint16_t MAIN_AXIS_NAMES_ X2, Y2, Z2, Z3, Z4 REPEAT(E_STEPPERS, _EN_ITEM); } per_stepper_uint16_t;
-typedef struct { uint32_t MAIN_AXIS_NAMES, X2, Y2, Z2, Z3, Z4 REPEAT(E_STEPPERS, _EN_ITEM); } per_stepper_uint32_t;
+typedef struct { uint32_t MAIN_AXIS_NAMES_ X2, Y2, Z2, Z3, Z4 REPEAT(E_STEPPERS, _EN_ITEM); } per_stepper_uint32_t;
-typedef struct {  int16_t MAIN_AXIS_NAMES, X2, Y2, Z2, Z3, Z4;                              } mot_stepper_int16_t;
+typedef struct {  int16_t MAIN_AXIS_NAMES_ X2, Y2, Z2, Z3, Z4;                              } mot_stepper_int16_t;
-typedef struct {     bool NUM_AXIS_LIST(X:1, Y:1, Z:1, I:1, J:1, K:1, U:1, V:1, W:1), X2:1, Y2:1, Z2:1, Z3:1, Z4:1 REPEAT(E_STEPPERS, _EN1_ITEM); } per_stepper_bool_t;
+typedef struct {     bool NUM_AXIS_LIST_(X:1, Y:1, Z:1, I:1, J:1, K:1, U:1, V:1, W:1) X2:1, Y2:1, Z2:1, Z3:1, Z4:1 REPEAT(E_STEPPERS, _EN1_ITEM); } per_stepper_bool_t;
 
 #undef _EN_ITEM
 
@@ -225,7 +225,9 @@ typedef struct SettingsDataStruct {
   //
   // Home Offset
   //
+  #if NUM_AXES
     xyz_pos_t home_offset;                              // M206 XYZ / M665 TPZ
+  #endif
 
   //
   // Hotend Offset
@@ -264,8 +266,9 @@ typedef struct SettingsDataStruct {
   //
   // HAS_BED_PROBE
   //
-
+  #if NUM_AXES
     xyz_pos_t probe_offset;                             // M851 X Y Z
+  #endif
 
   //
   // ABL_PLANAR
@@ -475,7 +478,9 @@ typedef struct SettingsDataStruct {
   //
   // CNC_COORDINATE_SYSTEMS
   //
+  #if NUM_AXES
     xyz_pos_t coordinate_system[MAX_COORDINATE_SYSTEMS]; // G54-G59.3
+  #endif
 
   //
   // SKEW_CORRECTION
@@ -501,9 +506,11 @@ typedef struct SettingsDataStruct {
   //
   // BACKLASH_COMPENSATION
   //
+  #if NUM_AXES
     xyz_float_t backlash_distance_mm;                   // M425 X Y Z
     uint8_t backlash_correction;                        // M425 F
     float backlash_smoothing_mm;                        // M425 S
+  #endif
 
   //
   // EXTENSIBLE_UI
@@ -813,6 +820,7 @@ void MarlinSettings::postprocess() {
     //
     // Home Offset
     //
+    #if NUM_AXES
     {
       _FIELD_TEST(home_offset);
 
@@ -825,6 +833,7 @@ void MarlinSettings::postprocess() {
         EEPROM_WRITE(home_offset);
       #endif
     }
+    #endif // NUM_AXES
 
     //
     // Hotend Offsets, if any
@@ -905,6 +914,7 @@ void MarlinSettings::postprocess() {
     //
     // Probe XYZ Offsets
     //
+    #if NUM_AXES
     {
       _FIELD_TEST(probe_offset);
       #if HAS_BED_PROBE
@@ -914,6 +924,7 @@ void MarlinSettings::postprocess() {
       #endif
       EEPROM_WRITE(zpo);
     }
+    #endif
 
     //
     // Planar Bed Leveling matrix
@@ -1364,7 +1375,7 @@ void MarlinSettings::postprocess() {
       #else
         #define _EN_ITEM(N) , .E##N =  30
         const per_stepper_uint32_t tmc_hybrid_threshold = {
-          NUM_AXIS_LIST(.X = 100, .Y = 100, .Z = 3, .I = 3, .J = 3, .K = 3, .U = 3, .V = 3, .W = 3),
+          NUM_AXIS_LIST_(.X = 100, .Y = 100, .Z = 3, .I = 3, .J = 3, .K = 3, .U = 3, .V = 3, .W = 3)
           .X2 = 100, .Y2 = 100, .Z2 = 3, .Z3 = 3, .Z4 = 3
           REPEAT(E_STEPPERS, _EN_ITEM)
         };
@@ -1462,13 +1473,13 @@ void MarlinSettings::postprocess() {
     //
     // CNC Coordinate Systems
     //
-
+    #if NUM_AXES
       _FIELD_TEST(coordinate_system);
-
       #if DISABLED(CNC_COORDINATE_SYSTEMS)
         const xyz_pos_t coordinate_system[MAX_COORDINATE_SYSTEMS] = { { 0 } };
       #endif
       EEPROM_WRITE(TERN(CNC_COORDINATE_SYSTEMS, gcode.coordinate_system, coordinate_system));
+    #endif
 
     //
     // Skew correction factors
@@ -1503,6 +1514,7 @@ void MarlinSettings::postprocess() {
     //
     // Backlash Compensation
     //
+    #if NUM_AXES
     {
       #if ENABLED(BACKLASH_GCODE)
         xyz_float_t backlash_distance_mm;
@@ -1522,6 +1534,7 @@ void MarlinSettings::postprocess() {
       EEPROM_WRITE(backlash_correction);
       EEPROM_WRITE(backlash_smoothing_mm);
     }
+    #endif // NUM_AXES
 
     //
     // Extensible UI User Data
@@ -1775,6 +1788,7 @@ void MarlinSettings::postprocess() {
       //
       // Home Offset (M206 / M665)
       //
+      #if NUM_AXES
       {
         _FIELD_TEST(home_offset);
 
@@ -1787,6 +1801,7 @@ void MarlinSettings::postprocess() {
           EEPROM_READ(home_offset);
         #endif
       }
+      #endif // NUM_AXES
 
       //
       // Hotend Offsets, if any
@@ -1862,6 +1877,7 @@ void MarlinSettings::postprocess() {
       //
       // Probe Z Offset
       //
+      #if NUM_AXES
       {
         _FIELD_TEST(probe_offset);
         #if HAS_BED_PROBE
@@ -1871,6 +1887,7 @@ void MarlinSettings::postprocess() {
         #endif
         EEPROM_READ(zpo);
       }
+      #endif
 
       //
       // Planar Bed Leveling matrix
@@ -2439,6 +2456,7 @@ void MarlinSettings::postprocess() {
       //
       // CNC Coordinate System
       //
+      #if NUM_AXES
       {
         _FIELD_TEST(coordinate_system);
         #if ENABLED(CNC_COORDINATE_SYSTEMS)
@@ -2449,6 +2467,7 @@ void MarlinSettings::postprocess() {
           EEPROM_READ(coordinate_system);
         #endif
       }
+      #endif
 
       //
       // Skew correction factors
@@ -2494,6 +2513,7 @@ void MarlinSettings::postprocess() {
       //
       // Backlash Compensation
       //
+      #if NUM_AXES
       {
         xyz_float_t backlash_distance_mm;
         uint8_t backlash_correction;
@@ -2512,6 +2532,7 @@ void MarlinSettings::postprocess() {
           #endif
         #endif
       }
+      #endif // NUM_AXES
 
       //
       // Extensible UI User Data
@@ -2903,7 +2924,7 @@ void MarlinSettings::reset() {
   planner.settings.min_travel_feedrate_mm_s = feedRate_t(DEFAULT_MINTRAVELFEEDRATE);
 
   #if HAS_CLASSIC_JERK
-    #ifndef DEFAULT_XJERK
+    #if HAS_X_AXIS && !defined(DEFAULT_XJERK)
       #define DEFAULT_XJERK 0
     #endif
     #if HAS_Y_AXIS && !defined(DEFAULT_YJERK)

Marlin/src/module/stepper.cpp

@@ -398,7 +398,7 @@ xyze_int8_t Stepper::count_direction{0};
     if (extruder_duplication_enabled || ALWAYS) { X_STEP_WRITE(v); X2_STEP_WRITE(v); } \
     else if (last_moved_extruder) X2_STEP_WRITE(v); else X_STEP_WRITE(v); \
   }while(0)
-#else
+#elif HAS_X_AXIS
   #define X_APPLY_DIR(v,Q) X_DIR_WRITE(v)
   #define X_APPLY_STEP(v,Q) X_STEP_WRITE(v)
 #endif
@@ -3407,6 +3407,7 @@ int32_t Stepper::triggered_position(const AxisEnum axis) {
 #endif
 
 void Stepper::report_a_position(const xyz_long_t &pos) {
+  #if NUM_AXES
     SERIAL_ECHOLNPGM_P(
       LIST_N(DOUBLE(NUM_AXES),
         TERN(SAYS_A, PSTR(STR_COUNT_A), PSTR(STR_COUNT_X)), pos.x,
@@ -3420,6 +3421,7 @@ void Stepper::report_a_position(const xyz_long_t &pos) {
         SP_W_LBL, pos.w
       )
     );
+  #endif
 }
 
 void Stepper::report_positions() {

Marlin/src/module/stepper.h

@@ -83,7 +83,7 @@ typedef struct {
 
 // All the stepper enable pins
 constexpr pin_t ena_pins[] = {
-  NUM_AXIS_LIST(X_ENABLE_PIN, Y_ENABLE_PIN, Z_ENABLE_PIN, I_ENABLE_PIN, J_ENABLE_PIN, K_ENABLE_PIN, U_ENABLE_PIN, V_ENABLE_PIN, W_ENABLE_PIN),
+  NUM_AXIS_LIST_(X_ENABLE_PIN, Y_ENABLE_PIN, Z_ENABLE_PIN, I_ENABLE_PIN, J_ENABLE_PIN, K_ENABLE_PIN, U_ENABLE_PIN, V_ENABLE_PIN, W_ENABLE_PIN)
   LIST_N(E_STEPPERS, E0_ENABLE_PIN, E1_ENABLE_PIN, E2_ENABLE_PIN, E3_ENABLE_PIN, E4_ENABLE_PIN, E5_ENABLE_PIN, E6_ENABLE_PIN, E7_ENABLE_PIN)
 };
 

Marlin/src/module/stepper/indirection.h

@@ -83,21 +83,23 @@ void reset_stepper_drivers();    // Called by settings.load / settings.reset
 #define INVERT_DIR(AXIS, D) (TERN_(INVERT_## AXIS ##_DIR, !)(D))
 
 // X Stepper
-#ifndef X_ENABLE_INIT
+#if HAS_X_AXIS
+  #ifndef X_ENABLE_INIT
     #define X_ENABLE_INIT() SET_OUTPUT(X_ENABLE_PIN)
     #define X_ENABLE_WRITE(STATE) WRITE(X_ENABLE_PIN,STATE)
     #define X_ENABLE_READ() bool(READ(X_ENABLE_PIN))
-#endif
+  #endif
-#ifndef X_DIR_INIT
+  #ifndef X_DIR_INIT
     #define X_DIR_INIT() SET_OUTPUT(X_DIR_PIN)
     #define X_DIR_WRITE(STATE) WRITE(X_DIR_PIN,INVERT_DIR(X, STATE))
     #define X_DIR_READ() INVERT_DIR(X, bool(READ(X_DIR_PIN)))
-#endif
+  #endif
-#define X_STEP_INIT() SET_OUTPUT(X_STEP_PIN)
+  #define X_STEP_INIT() SET_OUTPUT(X_STEP_PIN)
-#ifndef X_STEP_WRITE
+  #ifndef X_STEP_WRITE
     #define X_STEP_WRITE(STATE) WRITE(X_STEP_PIN,STATE)
+  #endif
+  #define X_STEP_READ() bool(READ(X_STEP_PIN))
 #endif
-#define X_STEP_READ() bool(READ(X_STEP_PIN))
 
 // Y Stepper
 #if HAS_Y_AXIS
@@ -977,8 +979,13 @@ void reset_stepper_drivers();    // Called by settings.load / settings.reset
   #define AFTER_CHANGE(N,TF) NOOP
 #endif
 
-#define  ENABLE_AXIS_X() if (SHOULD_ENABLE(x))  {  ENABLE_STEPPER_X();  ENABLE_STEPPER_X2(); AFTER_CHANGE(x, true); }
+#if HAS_X_AXIS
-#define DISABLE_AXIS_X() if (SHOULD_DISABLE(x)) { DISABLE_STEPPER_X(); DISABLE_STEPPER_X2(); AFTER_CHANGE(x, false); set_axis_untrusted(X_AXIS); }
+  #define  ENABLE_AXIS_X() if (SHOULD_ENABLE(x))  {  ENABLE_STEPPER_X();  ENABLE_STEPPER_X2(); AFTER_CHANGE(x, true); }
+  #define DISABLE_AXIS_X() if (SHOULD_DISABLE(x)) { DISABLE_STEPPER_X(); DISABLE_STEPPER_X2(); AFTER_CHANGE(x, false); set_axis_untrusted(X_AXIS); }
+#else
+  #define  ENABLE_AXIS_X() NOOP
+  #define DISABLE_AXIS_X() NOOP
+#endif
 
 #if HAS_Y_AXIS
   #define  ENABLE_AXIS_Y() if (SHOULD_ENABLE(y))  {  ENABLE_STEPPER_Y();  ENABLE_STEPPER_Y2(); AFTER_CHANGE(y, true); }

Marlin/src/module/stepper/trinamic.cpp

@@ -493,7 +493,7 @@ enum StealthIndex : uint8_t {
   #endif
 
   #define _EN_ITEM(N) , E##N
-  enum TMCAxis : uint8_t { MAIN_AXIS_NAMES, X2, Y2, Z2, Z3, Z4 REPEAT(EXTRUDERS, _EN_ITEM), TOTAL };
+  enum TMCAxis : uint8_t { MAIN_AXIS_NAMES_ X2, Y2, Z2, Z3, Z4 REPEAT(EXTRUDERS, _EN_ITEM), TOTAL };
   #undef _EN_ITEM
 
   void tmc_serial_begin() {

Marlin/src/module/stepper/trinamic.h

@@ -77,7 +77,7 @@
   #define TMC_CLASS_E(N) TMC_CLASS(E##N, E)
 #endif
 
-#ifndef CHOPPER_TIMING_X
+#if HAS_X_AXIS && !defined(CHOPPER_TIMING_X)
   #define CHOPPER_TIMING_X CHOPPER_TIMING
 #endif
 #if HAS_Y_AXIS && !defined(CHOPPER_TIMING_Y)

Marlin/src/pins/sensitive_pins.h

@@ -24,44 +24,51 @@
 //
 // Prepare a list of protected pins for M42/M43
 //
+#if HAS_X_AXIS
 
-#if PIN_EXISTS(X_MIN)
+  #if PIN_EXISTS(X_MIN)
     #define _X_MIN X_MIN_PIN,
-#else
+  #else
     #define _X_MIN
-#endif
+  #endif
-#if PIN_EXISTS(X_MAX)
+  #if PIN_EXISTS(X_MAX)
     #define _X_MAX X_MAX_PIN,
-#else
+  #else
     #define _X_MAX
-#endif
+  #endif
-#if PIN_EXISTS(X_CS) && AXIS_HAS_SPI(X)
+  #if PIN_EXISTS(X_CS) && AXIS_HAS_SPI(X)
     #define _X_CS X_CS_PIN,
-#else
+  #else
     #define _X_CS
-#endif
+  #endif
-#if PIN_EXISTS(X_MS1)
+  #if PIN_EXISTS(X_MS1)
     #define _X_MS1 X_MS1_PIN,
-#else
+  #else
     #define _X_MS1
-#endif
+  #endif
-#if PIN_EXISTS(X_MS2)
+  #if PIN_EXISTS(X_MS2)
     #define _X_MS2 X_MS2_PIN,
-#else
+  #else
     #define _X_MS2
-#endif
+  #endif
-#if PIN_EXISTS(X_MS3)
+  #if PIN_EXISTS(X_MS3)
     #define _X_MS3 X_MS3_PIN,
-#else
+  #else
     #define _X_MS3
-#endif
+  #endif
-#if PIN_EXISTS(X_ENABLE)
+  #if PIN_EXISTS(X_ENABLE)
     #define _X_ENABLE_PIN X_ENABLE_PIN,
-#else
+  #else
     #define _X_ENABLE_PIN
-#endif
+  #endif
 
-#define _X_PINS X_STEP_PIN, X_DIR_PIN, _X_ENABLE_PIN _X_MIN _X_MAX _X_MS1 _X_MS2 _X_MS3 _X_CS
+  #define _X_PINS X_STEP_PIN, X_DIR_PIN, _X_ENABLE_PIN _X_MIN _X_MAX _X_MS1 _X_MS2 _X_MS3 _X_CS
+
+#else
+
+  #define _X_PINS
+
+#endif
 
 #if HAS_Y_AXIS
 

buildroot/tests/mega2560

@@ -71,6 +71,19 @@ opt_enable VIKI2 BOOT_MARLIN_LOGO_ANIMATED SDSUPPORT AUTO_REPORT_SD_STATUS \
            FILAMENT_RUNOUT_SENSOR NOZZLE_PARK_FEATURE ADVANCED_PAUSE_FEATURE Z_SAFE_HOMING FIL_RUNOUT3_PULLUP
 exec_test $1 $2 "Z Servo Probe | Multiple runout sensors (x5)" "$3"
 
+#
+# Extruder Only. No XYZ axes at all.
+#
+restore_configs
+opt_set DEFAULT_AXIS_STEPS_PER_UNIT '{ 4000 }' \
+        DEFAULT_MAX_FEEDRATE '{ 5 }' \
+        DEFAULT_MAX_ACCELERATION '{ 100 }' \
+        MANUAL_FEEDRATE '{ 4*60 }' \
+        AXIS_RELATIVE_MODES '{ false }' \
+        HOMING_BUMP_MM '{}' HOMING_BUMP_DIVISOR '{}' HOMING_FEEDRATE_MM_M '{}'
+opt_enable REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER
+opt_disable X_DRIVER_TYPE Y_DRIVER_TYPE Z_DRIVER_TYPE
+exec_test $1 $2 "E Axis Only | DOGM MarlinUI" "$3"
 
 #
 # Mixing Extruder with 5 steppers, Greek

ini/stm32g0.ini

@@ -36,9 +36,10 @@ platform_packages           = framework-arduinoststm32@https://github.com/stm32d
 board                       = marlin_BTT_EBB42_V1_1
 board_build.offset          = 0x0000
 board_upload.offset_address = 0x08000000
-build_flags                 = ${stm32_variant.build_flags} ${stm32g0_I2C2.build_flags}
+build_flags                 = ${stm32_variant.build_flags} ${stm32g0_I2C2.build_flags} -flto
-upload_protocol             = stlink
 debug_tool                  = stlink
+upload_protocol             = dfu
+upload_command              = dfu-util -a 0 -s 0x08000000:leave -D "$SOURCE"
 
 #
 # BigTreeTech SKR Mini E3 V3.0 (STM32G0B1RET6 ARM Cortex-M0+)