diff --git a/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj2/command/sysid/SysIdRoutine.java b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj2/command/sysid/SysIdRoutine.java
index 48c3a37190..1935c84fdc 100644
--- a/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj2/command/sysid/SysIdRoutine.java
+++ b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj2/command/sysid/SysIdRoutine.java
@@ -10,7 +10,6 @@ import static edu.wpi.first.units.Units.Volts;
 import static java.util.Map.entry;
 
 import edu.wpi.first.units.VoltageUnit;
-import edu.wpi.first.units.measure.MutVoltage;
 import edu.wpi.first.units.measure.Time;
 import edu.wpi.first.units.measure.Velocity;
 import edu.wpi.first.units.measure.Voltage;
@@ -42,7 +41,6 @@ import java.util.function.Consumer;
 public class SysIdRoutine extends SysIdRoutineLog {
   private final Config m_config;
   private final Mechanism m_mechanism;
-  private final MutVoltage m_outputVolts = Volts.mutable(0);
   private final Consumer<State> m_recordState;
 
   /**
@@ -225,9 +223,7 @@ public class SysIdRoutine extends SysIdRoutineLog {
             m_mechanism.m_subsystem.run(
                 () -> {
                   m_mechanism.m_drive.accept(
-                      m_outputVolts.mut_replace(
-                          outputSign * timer.get() * m_config.m_rampRate.in(Volts.per(Second)),
-                          Volts));
+                      (Voltage) m_config.m_rampRate.times(Seconds.of(timer.get() * outputSign)));
                   m_mechanism.m_log.accept(this);
                   m_recordState.accept(state);
                 }))
@@ -258,15 +254,15 @@ public class SysIdRoutine extends SysIdRoutineLog {
                 entry(Direction.kForward, State.kDynamicForward),
                 entry(Direction.kReverse, State.kDynamicReverse))
             .get(direction);
+    Voltage[] output = {Volts.zero()};
 
     return m_mechanism
         .m_subsystem
-        .runOnce(
-            () -> m_outputVolts.mut_replace(m_config.m_stepVoltage.in(Volts) * outputSign, Volts))
+        .runOnce(() -> output[0] = m_config.m_stepVoltage.times(outputSign))
         .andThen(
             m_mechanism.m_subsystem.run(
                 () -> {
-                  m_mechanism.m_drive.accept(m_outputVolts);
+                  m_mechanism.m_drive.accept(output[0]);
                   m_mechanism.m_log.accept(this);
                   m_recordState.accept(state);
                 }))
diff --git a/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/sysidroutine/subsystems/Drive.java b/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/sysidroutine/subsystems/Drive.java
index 490b38acab..735b8bba0b 100644
--- a/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/sysidroutine/subsystems/Drive.java
+++ b/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/sysidroutine/subsystems/Drive.java
@@ -8,9 +8,6 @@ import static edu.wpi.first.units.Units.Meters;
 import static edu.wpi.first.units.Units.MetersPerSecond;
 import static edu.wpi.first.units.Units.Volts;
 
-import edu.wpi.first.units.measure.MutDistance;
-import edu.wpi.first.units.measure.MutLinearVelocity;
-import edu.wpi.first.units.measure.MutVoltage;
 import edu.wpi.first.wpilibj.Encoder;
 import edu.wpi.first.wpilibj.RobotController;
 import edu.wpi.first.wpilibj.drive.DifferentialDrive;
@@ -46,13 +43,6 @@ public class Drive extends SubsystemBase {
           DriveConstants.kRightEncoderPorts[1],
           DriveConstants.kRightEncoderReversed);
 
-  // Mutable holder for unit-safe voltage values, persisted to avoid reallocation.
-  private final MutVoltage m_appliedVoltage = Volts.mutable(0);
-  // Mutable holder for unit-safe linear distance values, persisted to avoid reallocation.
-  private final MutDistance m_distance = Meters.mutable(0);
-  // Mutable holder for unit-safe linear velocity values, persisted to avoid reallocation.
-  private final MutLinearVelocity m_velocity = MetersPerSecond.mutable(0);
-
   // Create a new SysId routine for characterizing the drive.
   private final SysIdRoutine m_sysIdRoutine =
       new SysIdRoutine(
@@ -70,21 +60,15 @@ public class Drive extends SubsystemBase {
                 // Record a frame for the left motors.  Since these share an encoder, we consider
                 // the entire group to be one motor.
                 log.motor("drive-left")
-                    .voltage(
-                        m_appliedVoltage.mut_replace(
-                            m_leftMotor.get() * RobotController.getBatteryVoltage(), Volts))
-                    .linearPosition(m_distance.mut_replace(m_leftEncoder.getDistance(), Meters))
-                    .linearVelocity(
-                        m_velocity.mut_replace(m_leftEncoder.getRate(), MetersPerSecond));
+                    .voltage(Volts.of(m_leftMotor.get() * RobotController.getBatteryVoltage()))
+                    .linearPosition(Meters.of(m_leftEncoder.getDistance()))
+                    .linearVelocity(MetersPerSecond.of(m_leftEncoder.getRate()));
                 // Record a frame for the right motors.  Since these share an encoder, we consider
                 // the entire group to be one motor.
                 log.motor("drive-right")
-                    .voltage(
-                        m_appliedVoltage.mut_replace(
-                            m_rightMotor.get() * RobotController.getBatteryVoltage(), Volts))
-                    .linearPosition(m_distance.mut_replace(m_rightEncoder.getDistance(), Meters))
-                    .linearVelocity(
-                        m_velocity.mut_replace(m_rightEncoder.getRate(), MetersPerSecond));
+                    .voltage(Volts.of(m_rightMotor.get() * RobotController.getBatteryVoltage()))
+                    .linearPosition(Meters.of(m_rightEncoder.getDistance()))
+                    .linearVelocity(MetersPerSecond.of(m_rightEncoder.getRate()));
               },
               // Tell SysId to make generated commands require this subsystem, suffix test state in
               // WPILog with this subsystem's name ("drive")
diff --git a/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/sysidroutine/subsystems/Shooter.java b/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/sysidroutine/subsystems/Shooter.java
index a8dd04e7f0..e7815f9b19 100644
--- a/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/sysidroutine/subsystems/Shooter.java
+++ b/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/sysidroutine/subsystems/Shooter.java
@@ -4,17 +4,12 @@
 
 package edu.wpi.first.wpilibj.examples.sysidroutine.subsystems;
 
-import static edu.wpi.first.units.Units.Radians;
-import static edu.wpi.first.units.Units.RadiansPerSecond;
 import static edu.wpi.first.units.Units.Rotations;
 import static edu.wpi.first.units.Units.RotationsPerSecond;
 import static edu.wpi.first.units.Units.Volts;
 
 import edu.wpi.first.math.controller.PIDController;
 import edu.wpi.first.math.controller.SimpleMotorFeedforward;
-import edu.wpi.first.units.measure.MutAngle;
-import edu.wpi.first.units.measure.MutAngularVelocity;
-import edu.wpi.first.units.measure.MutVoltage;
 import edu.wpi.first.wpilibj.Encoder;
 import edu.wpi.first.wpilibj.RobotController;
 import edu.wpi.first.wpilibj.examples.sysidroutine.Constants.ShooterConstants;
@@ -38,13 +33,6 @@ public class Shooter extends SubsystemBase {
           ShooterConstants.kEncoderPorts[1],
           ShooterConstants.kEncoderReversed);
 
-  // Mutable holder for unit-safe voltage values, persisted to avoid reallocation.
-  private final MutVoltage m_appliedVoltage = Volts.mutable(0);
-  // Mutable holder for unit-safe linear distance values, persisted to avoid reallocation.
-  private final MutAngle m_angle = Radians.mutable(0);
-  // Mutable holder for unit-safe linear velocity values, persisted to avoid reallocation.
-  private final MutAngularVelocity m_velocity = RadiansPerSecond.mutable(0);
-
   // Create a new SysId routine for characterizing the shooter.
   private final SysIdRoutine m_sysIdRoutine =
       new SysIdRoutine(
@@ -58,12 +46,9 @@ public class Shooter extends SubsystemBase {
               log -> {
                 // Record a frame for the shooter motor.
                 log.motor("shooter-wheel")
-                    .voltage(
-                        m_appliedVoltage.mut_replace(
-                            m_shooterMotor.get() * RobotController.getBatteryVoltage(), Volts))
-                    .angularPosition(m_angle.mut_replace(m_shooterEncoder.getDistance(), Rotations))
-                    .angularVelocity(
-                        m_velocity.mut_replace(m_shooterEncoder.getRate(), RotationsPerSecond));
+                    .voltage(Volts.of(m_shooterMotor.get() * RobotController.getBatteryVoltage()))
+                    .angularPosition(Rotations.of(m_shooterEncoder.getDistance()))
+                    .angularVelocity(RotationsPerSecond.of(m_shooterEncoder.getRate()));
               },
               // Tell SysId to make generated commands require this subsystem, suffix test state in
               // WPILog with this subsystem's name ("shooter")
diff --git a/wpiunits/generate_units.py b/wpiunits/generate_units.py
index 3f35152b61..05bd7c06db 100755
--- a/wpiunits/generate_units.py
+++ b/wpiunits/generate_units.py
@@ -81,7 +81,7 @@ UNIT_CONFIGURATIONS = {
         "divide": {"Time": "AngularAcceleration"},
         "extra": inspect.cleandoc(
             """
-          default Frequency asFrequency() { return Hertz.of(baseUnitMagnitude()); }
+          public Frequency asFrequency() { return Hertz.of(baseUnitMagnitude()); }
         """
         ),
     },
@@ -164,7 +164,7 @@ UNIT_CONFIGURATIONS = {
         "extra": inspect.cleandoc(
             """
           /** Converts this frequency to the time period between cycles. */
-          default Time asPeriod() { return Seconds.of(1 / baseUnitMagnitude()); }
+          public Time asPeriod() { return Seconds.of(1 / baseUnitMagnitude()); }
         """
         ),
     },
@@ -206,11 +206,11 @@ UNIT_CONFIGURATIONS = {
         "divide": {},
         "extra": inspect.cleandoc(
             """
-          default Measure<Dividend> timesDivisor(Measure<? extends Divisor> multiplier) {
+          public Measure<Dividend> timesDivisor(Measure<? extends Divisor> multiplier) {
             return (Measure<Dividend>) baseUnit().numerator().ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
           }
 
-          default Measure<? extends PerUnit<Divisor, Dividend>> reciprocal() {
+          public Measure<? extends PerUnit<Divisor, Dividend>> reciprocal() {
             // May return a velocity if Divisor == TimeUnit, so we can't guarantee a "Per" instance
             return baseUnit().reciprocal().ofBaseUnits(1 / baseUnitMagnitude());
           }
@@ -252,7 +252,7 @@ UNIT_CONFIGURATIONS = {
         },
         "extra": inspect.cleandoc(
             """
-          default Frequency asFrequency() { return Hertz.of(1 / baseUnitMagnitude()); }
+          public Frequency asFrequency() { return Hertz.of(1 / baseUnitMagnitude()); }
         """
         ),
     },
@@ -269,7 +269,7 @@ UNIT_CONFIGURATIONS = {
                 "implementation": inspect.cleandoc(
                     """
                   @Override
-                  default Measure<D> times(Time multiplier) {
+                  public Measure<D> times(Time multiplier) {
                     return (Measure<D>) unit().numerator().ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
                   }
                 """
@@ -352,9 +352,7 @@ def generate_units(output_directory: Path, template_directory: Path):
         keep_trailing_newline=True,
     )
 
-    interfaceTemplate = env.get_template("Measure-interface.java.jinja")
-    immutableTemplate = env.get_template("Measure-immutable.java.jinja")
-    mutableTemplate = env.get_template("Measure-mutable.java.jinja")
+    interfaceTemplate = env.get_template("Measure-implementation.java.jinja")
     rootPath = output_directory / "main/java/edu/wpi/first/units"
 
     helpers = {
@@ -373,22 +371,8 @@ def generate_units(output_directory: Path, template_directory: Path):
             config=UNIT_CONFIGURATIONS,
             helpers=helpers,
         )
-        immutableContents = immutableTemplate.render(
-            name=unit_name,
-            units=MATH_OPERATION_UNITS,
-            config=UNIT_CONFIGURATIONS,
-            helpers=helpers,
-        )
-        mutableContents = mutableTemplate.render(
-            name=unit_name,
-            units=MATH_OPERATION_UNITS,
-            config=UNIT_CONFIGURATIONS,
-            helpers=helpers,
-        )
 
         output(rootPath / "measure", f"{unit_name}.java", interfaceContents)
-        output(rootPath / "measure", f"Immutable{unit_name}.java", immutableContents)
-        output(rootPath / "measure", f"Mut{unit_name}.java", mutableContents)
 
 
 def main():
diff --git a/wpiunits/src/generate/main/java/Measure-immutable.java.jinja b/wpiunits/src/generate/main/java/Measure-immutable.java.jinja
deleted file mode 100644
index 526c950977..0000000000
--- a/wpiunits/src/generate/main/java/Measure-immutable.java.jinja
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public record Immutable{{ helpers['type_decl'](name) }}(double magnitude, double baseUnitMagnitude, {{ helpers['mtou'](name) }} unit) implements {{ helpers['type_usage'](name) }} {
-  @Override
-  public {{ helpers['type_usage'](name) }} copy() {
-    return this;
-  }
-
-  @Override
-  public String toString() {
-    return toShortString();
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    return o instanceof Measure<?> m && isEquivalent(m);
-  }
-}
diff --git a/wpiunits/src/generate/main/java/Measure-interface.java.jinja b/wpiunits/src/generate/main/java/Measure-implementation.java.jinja
similarity index 59%
rename from wpiunits/src/generate/main/java/Measure-interface.java.jinja
rename to wpiunits/src/generate/main/java/Measure-implementation.java.jinja
index 608900f2b5..d61c9c6b27 100644
--- a/wpiunits/src/generate/main/java/Measure-interface.java.jinja
+++ b/wpiunits/src/generate/main/java/Measure-implementation.java.jinja
@@ -10,36 +10,45 @@ import static edu.wpi.first.units.Units.*;
 import edu.wpi.first.units.*;
 
 @SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public interface {{ helpers['type_decl'](name) }} extends Measure<{{ helpers['mtou'](name) }}> {
-  static {{ helpers['generics_list'](name) }} {{ helpers['type_usage'](name) }} ofRelativeUnits(double magnitude, {{ helpers['mtou'](name) }} unit) {
-    return new Immutable{{ helpers['type_usage'](name) }}(magnitude, unit.toBaseUnits(magnitude), unit);
+public record {{ helpers['type_decl'](name) }}(double magnitude, double baseUnitMagnitude, {{ helpers['mtou'](name) }} unit) implements Measure<{{ helpers['mtou'](name) }}> {
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link {{ name }}Unit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static {{ helpers['generics_list'](name) }} {{ helpers['type_usage'](name) }} ofRelativeUnits(double magnitude, {{ helpers['mtou'](name) }} unit) {
+    return new {{ helpers['type_usage'](name) }}(magnitude, unit.toBaseUnits(magnitude), unit);
   }
 
-  static {{ helpers['generics_list'](name) }} {{ helpers['type_usage'](name) }} ofBaseUnits(double baseUnitMagnitude, {{ helpers['mtou'](name) }} unit) {
-    return new Immutable{{ helpers['type_usage'](name) }}(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link {{ name }}Unit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit's base unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static {{ helpers['generics_list'](name) }} {{ helpers['type_usage'](name) }} ofBaseUnits(double baseUnitMagnitude, {{ helpers['mtou'](name) }} unit) {
+    return new {{ helpers['type_usage'](name) }}(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
   }
 
   @Override
-  {{ helpers['type_usage'](name) }} copy();
+  public {{ helpers['mtou'](name) }} baseUnit() { return ({{ helpers['mtou'](name) }}) unit().getBaseUnit(); }
 
   @Override
-  default Mut{{ helpers['type_usage'](name) }} mutableCopy() {
-    return new Mut{{ helpers['type_usage'](name) }}(magnitude(), baseUnitMagnitude(), unit());
-  }
-
-  @Override
-  {{ helpers['mtou'](name) }} unit();
-
-  @Override
-  default {{ helpers['mtou'](name) }} baseUnit() { return ({{ helpers['mtou'](name) }}) unit().getBaseUnit(); }
-
-  @Override
-  default double in({{ helpers['mtou'](name) }} unit) {
+  public double in({{ helpers['mtou'](name) }} unit) {
     return unit.fromBaseUnits(baseUnitMagnitude());
   }
 
   @Override
-  default {{ helpers['type_usage'](name) }} unaryMinus() {
+  @SuppressWarnings("rawtypes")
+  public boolean equals(Object object) {
+    return object instanceof {{ name }} m && isEquivalent(m);
+  }
+
+  @Override
+  public {{ helpers['type_usage'](name) }} unaryMinus() {
     return ({{ helpers['type_usage'](name) }}) unit().ofBaseUnits(0 - baseUnitMagnitude());
   }
 
@@ -51,27 +60,27 @@ public interface {{ helpers['type_decl'](name) }} extends Measure<{{ helpers['mt
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default {{ helpers['type_usage'](name) }} negate() {
+  public {{ helpers['type_usage'](name) }} negate() {
     return ({{ helpers['type_usage'](name) }}) unaryMinus();
   }
 
   @Override
-  default {{ helpers['type_usage'](name) }} plus(Measure<? extends {{ helpers['mtou'](name) }}> other) {
+  public {{ helpers['type_usage'](name) }} plus(Measure<? extends {{ helpers['mtou'](name) }}> other) {
     return ({{ helpers['type_usage'](name) }}) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
   }
 
   @Override
-  default {{ helpers['type_usage'](name) }} minus(Measure<? extends {{ helpers['mtou'](name) }}> other) {
+  public {{ helpers['type_usage'](name) }} minus(Measure<? extends {{ helpers['mtou'](name) }}> other) {
     return ({{ helpers['type_usage'](name) }}) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
   }
 
   @Override
-  default {{ helpers['type_usage'](name) }} times(double multiplier) {
+  public {{ helpers['type_usage'](name) }} times(double multiplier) {
     return ({{ helpers['type_usage'](name) }}) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
   }
 
   @Override
-  default {{ helpers['type_usage'](name) }} div(double divisor) {
+  public {{ helpers['type_usage'](name) }} div(double divisor) {
     return ({{ helpers['type_usage'](name) }}) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
@@ -83,13 +92,13 @@ public interface {{ helpers['type_decl'](name) }} extends Measure<{{ helpers['mt
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default {{ helpers['type_usage'](name) }} divide(double divisor) {
+  public {{ helpers['type_usage'](name) }} divide(double divisor) {
     return ({{ helpers['type_usage'](name) }}) div(divisor);
   }
 {% for unit in math_units -%}
 {% if unit == "Dimensionless" %}
   @Override
-  default {{ helpers['type_usage'](name) }} div({{ unit }} divisor) {
+  public {{ helpers['type_usage'](name) }} div({{ unit }} divisor) {
     return ({{ helpers['type_usage'](name) }}) {{ config[name]['base_unit'] }}.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -101,12 +110,12 @@ public interface {{ helpers['type_decl'](name) }} extends Measure<{{ helpers['mt
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default {{ helpers['type_usage'](name) }} divide({{ unit }} divisor) {
+  public {{ helpers['type_usage'](name) }} divide({{ unit }} divisor) {
     return ({{ helpers['type_usage'](name) }}) div(divisor);
   }
 
   @Override
-  default {{ helpers['type_usage'](name) }} times({{ unit }} multiplier) {
+  public {{ helpers['type_usage'](name) }} times({{ unit }} multiplier) {
     return ({{ helpers['type_usage'](name) }}) {{ config[name]['base_unit'] }}.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 {% else %}
@@ -115,19 +124,19 @@ public interface {{ helpers['type_decl'](name) }} extends Measure<{{ helpers['mt
 {{ helpers['indent'](config[name]['multiply'][unit]['implementation'], 2) }}
 {%- else %}
   @Override
-  default {{ config[name]['multiply'][unit] }} times({{ unit }} multiplier) {
+  public {{ config[name]['multiply'][unit] }} times({{ unit }} multiplier) {
     return {{ config[config[name]['multiply'][unit]]['base_unit'] }}.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 {%- endif %}
 {% else %}
   @Override
-  default Mult<{{ helpers['mtou'](name) }}, {{ helpers['mtou'](unit) }}> times({{ unit }} multiplier) {
+  public Mult<{{ helpers['mtou'](name) }}, {{ helpers['mtou'](unit) }}> times({{ unit }} multiplier) {
     return (Mult<{{ helpers['mtou'](name) }}, {{ helpers['mtou'](unit) }}>) Measure.super.times(multiplier);
   }
 {% endif -%}
 {% if unit in config[name]['divide'] %}
   @Override
-  default {{ config[name]['divide'][unit] }} div({{ unit }} divisor) {
+  public {{ config[name]['divide'][unit] }} div({{ unit }} divisor) {
     return {{ config[config[name]['divide'][unit]]['base_unit'] }}.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -139,12 +148,12 @@ public interface {{ helpers['type_decl'](name) }} extends Measure<{{ helpers['mt
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default {{ config[name]['divide'][unit] }} divide({{ unit }} divisor) {
+  public {{ config[name]['divide'][unit] }} divide({{ unit }} divisor) {
     return div(divisor);
   }
 
   @Override
-  default {{ config[name]['divide'][unit] }} per({{ helpers['mtou'](unit) }} divisorUnit) {
+  public {{ config[name]['divide'][unit] }} per({{ helpers['mtou'](unit) }} divisorUnit) {
 {%- if unit == "Mult<?, ?>" or unit == "Per<?, ?>" %}
     return div(divisorUnit.ofNative(1));
 {%- else %}
@@ -153,7 +162,7 @@ public interface {{ helpers['type_decl'](name) }} extends Measure<{{ helpers['mt
   }
 {% elif unit == "Time" %}
   @Override
-  default Velocity<{{ helpers['mtou'](name) }}> div({{ unit }} divisor) {
+  public Velocity<{{ helpers['mtou'](name) }}> div({{ unit }} divisor) {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -165,12 +174,12 @@ public interface {{ helpers['type_decl'](name) }} extends Measure<{{ helpers['mt
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Velocity<{{ helpers['mtou'](name) }}> divide({{ unit }} divisor) {
+  public Velocity<{{ helpers['mtou'](name) }}> divide({{ unit }} divisor) {
     return div(divisor);
   }
 
   @Override
-  default Velocity<{{ helpers['mtou'](name) }}> per({{ helpers['mtou'](unit) }} divisorUnit) {
+  public Velocity<{{ helpers['mtou'](name) }}> per({{ helpers['mtou'](unit) }} divisorUnit) {
 {%- if unit == "Mult<?, ?>" or unit == "Per<?, ?>" %}
     return div(divisorUnit.ofNative(1));
 {%- else %}
@@ -179,7 +188,7 @@ public interface {{ helpers['type_decl'](name) }} extends Measure<{{ helpers['mt
   }
 {% elif unit == name %}
   @Override
-  default Dimensionless div({{ unit }} divisor) {
+  public Dimensionless div({{ unit }} divisor) {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -191,17 +200,17 @@ public interface {{ helpers['type_decl'](name) }} extends Measure<{{ helpers['mt
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Dimensionless divide({{ unit }} divisor) {
+  public Dimensionless divide({{ unit }} divisor) {
     return div(divisor);
   }
 
   @Override
-  default Dimensionless per({{ helpers['mtou'](unit) }} divisorUnit) {
+  public Dimensionless per({{ helpers['mtou'](unit) }} divisorUnit) {
     return div(divisorUnit.one());
   }
 {% else %}
   @Override
-  default Per<{{ helpers['mtou'](name) }}, {{ helpers['mtou'](unit) }}> div({{ unit }} divisor) {
+  public Per<{{ helpers['mtou'](name) }}, {{ helpers['mtou'](unit) }}> div({{ unit }} divisor) {
     return (Per<{{ helpers['mtou'](name) }}, {{ helpers['mtou'](unit) }}>) Measure.super.div(divisor);
   }
 
@@ -213,12 +222,12 @@ public interface {{ helpers['type_decl'](name) }} extends Measure<{{ helpers['mt
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<{{ helpers['mtou'](name) }}, {{ helpers['mtou'](unit) }}> divide({{ unit }} divisor) {
+  public Per<{{ helpers['mtou'](name) }}, {{ helpers['mtou'](unit) }}> divide({{ unit }} divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<{{ helpers['mtou'](name) }}, {{ helpers['mtou'](unit) }}> per({{ helpers['mtou'](unit) }} divisorUnit) {
+  public Per<{{ helpers['mtou'](name) }}, {{ helpers['mtou'](unit) }}> per({{ helpers['mtou'](unit) }} divisorUnit) {
 {%- if unit == "Mult<?, ?>" or unit == "Per<?, ?>" %}
     return div(divisorUnit.ofNative(1));
 {%- else %}
diff --git a/wpiunits/src/generate/main/java/Measure-mutable.java.jinja b/wpiunits/src/generate/main/java/Measure-mutable.java.jinja
deleted file mode 100644
index 8adf22f74d..0000000000
--- a/wpiunits/src/generate/main/java/Measure-mutable.java.jinja
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-import edu.wpi.first.units.mutable.MutableMeasureBase;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public final class Mut{{ helpers['type_decl'](name) }}
-  extends MutableMeasureBase<{{ helpers['mtou'](name) }}, {{ helpers['type_usage'](name) }}, Mut{{ helpers['type_usage'](name) }}>
-  implements {{ helpers['type_usage'](name) }} {
-  public Mut{{ name }}(double magnitude, double baseUnitMagnitude, {{ helpers['mtou'](name) }} unit) {
-    super(magnitude, baseUnitMagnitude, unit);
-  }
-
-  @Override
-  public {{ helpers['type_usage'](name) }} copy() {
-    return new Immutable{{ helpers['type_usage'](name) }}(magnitude(), baseUnitMagnitude(), unit());
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Acceleration.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Acceleration.java
index 9a007dae74..c1382b1dd0 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Acceleration.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Acceleration.java
@@ -10,36 +10,45 @@ import static edu.wpi.first.units.Units.*;
 import edu.wpi.first.units.*;
 
 @SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D>> {
-  static <D extends Unit> Acceleration<D> ofRelativeUnits(double magnitude, AccelerationUnit<D> unit) {
-    return new ImmutableAcceleration<D>(magnitude, unit.toBaseUnits(magnitude), unit);
+public record Acceleration<D extends Unit>(double magnitude, double baseUnitMagnitude, AccelerationUnit<D> unit) implements Measure<AccelerationUnit<D>> {
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link AccelerationUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static <D extends Unit> Acceleration<D> ofRelativeUnits(double magnitude, AccelerationUnit<D> unit) {
+    return new Acceleration<D>(magnitude, unit.toBaseUnits(magnitude), unit);
   }
 
-  static <D extends Unit> Acceleration<D> ofBaseUnits(double baseUnitMagnitude, AccelerationUnit<D> unit) {
-    return new ImmutableAcceleration<D>(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link AccelerationUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit's base unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static <D extends Unit> Acceleration<D> ofBaseUnits(double baseUnitMagnitude, AccelerationUnit<D> unit) {
+    return new Acceleration<D>(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
   }
 
   @Override
-  Acceleration<D> copy();
+  public AccelerationUnit<D> baseUnit() { return (AccelerationUnit<D>) unit().getBaseUnit(); }
 
   @Override
-  default MutAcceleration<D> mutableCopy() {
-    return new MutAcceleration<D>(magnitude(), baseUnitMagnitude(), unit());
-  }
-
-  @Override
-  AccelerationUnit<D> unit();
-
-  @Override
-  default AccelerationUnit<D> baseUnit() { return (AccelerationUnit<D>) unit().getBaseUnit(); }
-
-  @Override
-  default double in(AccelerationUnit<D> unit) {
+  public double in(AccelerationUnit<D> unit) {
     return unit.fromBaseUnits(baseUnitMagnitude());
   }
 
   @Override
-  default Acceleration<D> unaryMinus() {
+  @SuppressWarnings("rawtypes")
+  public boolean equals(Object object) {
+    return object instanceof Acceleration m && isEquivalent(m);
+  }
+
+  @Override
+  public Acceleration<D> unaryMinus() {
     return (Acceleration<D>) unit().ofBaseUnits(0 - baseUnitMagnitude());
   }
 
@@ -51,27 +60,27 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Acceleration<D> negate() {
+  public Acceleration<D> negate() {
     return (Acceleration<D>) unaryMinus();
   }
 
   @Override
-  default Acceleration<D> plus(Measure<? extends AccelerationUnit<D>> other) {
+  public Acceleration<D> plus(Measure<? extends AccelerationUnit<D>> other) {
     return (Acceleration<D>) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
   }
 
   @Override
-  default Acceleration<D> minus(Measure<? extends AccelerationUnit<D>> other) {
+  public Acceleration<D> minus(Measure<? extends AccelerationUnit<D>> other) {
     return (Acceleration<D>) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
   }
 
   @Override
-  default Acceleration<D> times(double multiplier) {
+  public Acceleration<D> times(double multiplier) {
     return (Acceleration<D>) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
   }
 
   @Override
-  default Acceleration<D> div(double divisor) {
+  public Acceleration<D> div(double divisor) {
     return (Acceleration<D>) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
@@ -83,18 +92,18 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Acceleration<D> divide(double divisor) {
+  public Acceleration<D> divide(double divisor) {
     return (Acceleration<D>) div(divisor);
   }
 
 
   @Override
-  default Mult<AccelerationUnit<D>, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+  public Mult<AccelerationUnit<D>, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
     return (Mult<AccelerationUnit<D>, AccelerationUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, AccelerationUnit<?>> div(Acceleration<?> divisor) {
+  public Per<AccelerationUnit<D>, AccelerationUnit<?>> div(Acceleration<?> divisor) {
     return (Per<AccelerationUnit<D>, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -106,23 +115,23 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AccelerationUnit<D>, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+  public Per<AccelerationUnit<D>, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
+  public Per<AccelerationUnit<D>, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AccelerationUnit<D>, AngleUnit> times(Angle multiplier) {
+  public Mult<AccelerationUnit<D>, AngleUnit> times(Angle multiplier) {
     return (Mult<AccelerationUnit<D>, AngleUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, AngleUnit> div(Angle divisor) {
+  public Per<AccelerationUnit<D>, AngleUnit> div(Angle divisor) {
     return (Per<AccelerationUnit<D>, AngleUnit>) Measure.super.div(divisor);
   }
 
@@ -134,23 +143,23 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AccelerationUnit<D>, AngleUnit> divide(Angle divisor) {
+  public Per<AccelerationUnit<D>, AngleUnit> divide(Angle divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, AngleUnit> per(AngleUnit divisorUnit) {
+  public Per<AccelerationUnit<D>, AngleUnit> per(AngleUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AccelerationUnit<D>, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+  public Mult<AccelerationUnit<D>, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
     return (Mult<AccelerationUnit<D>, AngularAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, AngularAccelerationUnit> div(AngularAcceleration divisor) {
+  public Per<AccelerationUnit<D>, AngularAccelerationUnit> div(AngularAcceleration divisor) {
     return (Per<AccelerationUnit<D>, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -162,23 +171,23 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AccelerationUnit<D>, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+  public Per<AccelerationUnit<D>, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
+  public Per<AccelerationUnit<D>, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AccelerationUnit<D>, AngularMomentumUnit> times(AngularMomentum multiplier) {
+  public Mult<AccelerationUnit<D>, AngularMomentumUnit> times(AngularMomentum multiplier) {
     return (Mult<AccelerationUnit<D>, AngularMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, AngularMomentumUnit> div(AngularMomentum divisor) {
+  public Per<AccelerationUnit<D>, AngularMomentumUnit> div(AngularMomentum divisor) {
     return (Per<AccelerationUnit<D>, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -190,23 +199,23 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AccelerationUnit<D>, AngularMomentumUnit> divide(AngularMomentum divisor) {
+  public Per<AccelerationUnit<D>, AngularMomentumUnit> divide(AngularMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
+  public Per<AccelerationUnit<D>, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AccelerationUnit<D>, AngularVelocityUnit> times(AngularVelocity multiplier) {
+  public Mult<AccelerationUnit<D>, AngularVelocityUnit> times(AngularVelocity multiplier) {
     return (Mult<AccelerationUnit<D>, AngularVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, AngularVelocityUnit> div(AngularVelocity divisor) {
+  public Per<AccelerationUnit<D>, AngularVelocityUnit> div(AngularVelocity divisor) {
     return (Per<AccelerationUnit<D>, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -218,23 +227,23 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AccelerationUnit<D>, AngularVelocityUnit> divide(AngularVelocity divisor) {
+  public Per<AccelerationUnit<D>, AngularVelocityUnit> divide(AngularVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
+  public Per<AccelerationUnit<D>, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AccelerationUnit<D>, CurrentUnit> times(Current multiplier) {
+  public Mult<AccelerationUnit<D>, CurrentUnit> times(Current multiplier) {
     return (Mult<AccelerationUnit<D>, CurrentUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, CurrentUnit> div(Current divisor) {
+  public Per<AccelerationUnit<D>, CurrentUnit> div(Current divisor) {
     return (Per<AccelerationUnit<D>, CurrentUnit>) Measure.super.div(divisor);
   }
 
@@ -246,17 +255,17 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AccelerationUnit<D>, CurrentUnit> divide(Current divisor) {
+  public Per<AccelerationUnit<D>, CurrentUnit> divide(Current divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, CurrentUnit> per(CurrentUnit divisorUnit) {
+  public Per<AccelerationUnit<D>, CurrentUnit> per(CurrentUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
   @Override
-  default Acceleration<D> div(Dimensionless divisor) {
+  public Acceleration<D> div(Dimensionless divisor) {
     return (Acceleration<D>) unit().of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -268,23 +277,23 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Acceleration<D> divide(Dimensionless divisor) {
+  public Acceleration<D> divide(Dimensionless divisor) {
     return (Acceleration<D>) div(divisor);
   }
 
   @Override
-  default Acceleration<D> times(Dimensionless multiplier) {
+  public Acceleration<D> times(Dimensionless multiplier) {
     return (Acceleration<D>) unit().of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
 
   @Override
-  default Mult<AccelerationUnit<D>, DistanceUnit> times(Distance multiplier) {
+  public Mult<AccelerationUnit<D>, DistanceUnit> times(Distance multiplier) {
     return (Mult<AccelerationUnit<D>, DistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, DistanceUnit> div(Distance divisor) {
+  public Per<AccelerationUnit<D>, DistanceUnit> div(Distance divisor) {
     return (Per<AccelerationUnit<D>, DistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -296,23 +305,23 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AccelerationUnit<D>, DistanceUnit> divide(Distance divisor) {
+  public Per<AccelerationUnit<D>, DistanceUnit> divide(Distance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, DistanceUnit> per(DistanceUnit divisorUnit) {
+  public Per<AccelerationUnit<D>, DistanceUnit> per(DistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AccelerationUnit<D>, EnergyUnit> times(Energy multiplier) {
+  public Mult<AccelerationUnit<D>, EnergyUnit> times(Energy multiplier) {
     return (Mult<AccelerationUnit<D>, EnergyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, EnergyUnit> div(Energy divisor) {
+  public Per<AccelerationUnit<D>, EnergyUnit> div(Energy divisor) {
     return (Per<AccelerationUnit<D>, EnergyUnit>) Measure.super.div(divisor);
   }
 
@@ -324,23 +333,23 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AccelerationUnit<D>, EnergyUnit> divide(Energy divisor) {
+  public Per<AccelerationUnit<D>, EnergyUnit> divide(Energy divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, EnergyUnit> per(EnergyUnit divisorUnit) {
+  public Per<AccelerationUnit<D>, EnergyUnit> per(EnergyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AccelerationUnit<D>, ForceUnit> times(Force multiplier) {
+  public Mult<AccelerationUnit<D>, ForceUnit> times(Force multiplier) {
     return (Mult<AccelerationUnit<D>, ForceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, ForceUnit> div(Force divisor) {
+  public Per<AccelerationUnit<D>, ForceUnit> div(Force divisor) {
     return (Per<AccelerationUnit<D>, ForceUnit>) Measure.super.div(divisor);
   }
 
@@ -352,23 +361,23 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AccelerationUnit<D>, ForceUnit> divide(Force divisor) {
+  public Per<AccelerationUnit<D>, ForceUnit> divide(Force divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, ForceUnit> per(ForceUnit divisorUnit) {
+  public Per<AccelerationUnit<D>, ForceUnit> per(ForceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AccelerationUnit<D>, FrequencyUnit> times(Frequency multiplier) {
+  public Mult<AccelerationUnit<D>, FrequencyUnit> times(Frequency multiplier) {
     return (Mult<AccelerationUnit<D>, FrequencyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, FrequencyUnit> div(Frequency divisor) {
+  public Per<AccelerationUnit<D>, FrequencyUnit> div(Frequency divisor) {
     return (Per<AccelerationUnit<D>, FrequencyUnit>) Measure.super.div(divisor);
   }
 
@@ -380,23 +389,23 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AccelerationUnit<D>, FrequencyUnit> divide(Frequency divisor) {
+  public Per<AccelerationUnit<D>, FrequencyUnit> divide(Frequency divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, FrequencyUnit> per(FrequencyUnit divisorUnit) {
+  public Per<AccelerationUnit<D>, FrequencyUnit> per(FrequencyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AccelerationUnit<D>, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+  public Mult<AccelerationUnit<D>, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
     return (Mult<AccelerationUnit<D>, LinearAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, LinearAccelerationUnit> div(LinearAcceleration divisor) {
+  public Per<AccelerationUnit<D>, LinearAccelerationUnit> div(LinearAcceleration divisor) {
     return (Per<AccelerationUnit<D>, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -408,23 +417,23 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AccelerationUnit<D>, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+  public Per<AccelerationUnit<D>, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
+  public Per<AccelerationUnit<D>, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AccelerationUnit<D>, LinearMomentumUnit> times(LinearMomentum multiplier) {
+  public Mult<AccelerationUnit<D>, LinearMomentumUnit> times(LinearMomentum multiplier) {
     return (Mult<AccelerationUnit<D>, LinearMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, LinearMomentumUnit> div(LinearMomentum divisor) {
+  public Per<AccelerationUnit<D>, LinearMomentumUnit> div(LinearMomentum divisor) {
     return (Per<AccelerationUnit<D>, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -436,23 +445,23 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AccelerationUnit<D>, LinearMomentumUnit> divide(LinearMomentum divisor) {
+  public Per<AccelerationUnit<D>, LinearMomentumUnit> divide(LinearMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
+  public Per<AccelerationUnit<D>, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AccelerationUnit<D>, LinearVelocityUnit> times(LinearVelocity multiplier) {
+  public Mult<AccelerationUnit<D>, LinearVelocityUnit> times(LinearVelocity multiplier) {
     return (Mult<AccelerationUnit<D>, LinearVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, LinearVelocityUnit> div(LinearVelocity divisor) {
+  public Per<AccelerationUnit<D>, LinearVelocityUnit> div(LinearVelocity divisor) {
     return (Per<AccelerationUnit<D>, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -464,23 +473,23 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AccelerationUnit<D>, LinearVelocityUnit> divide(LinearVelocity divisor) {
+  public Per<AccelerationUnit<D>, LinearVelocityUnit> divide(LinearVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
+  public Per<AccelerationUnit<D>, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AccelerationUnit<D>, MassUnit> times(Mass multiplier) {
+  public Mult<AccelerationUnit<D>, MassUnit> times(Mass multiplier) {
     return (Mult<AccelerationUnit<D>, MassUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, MassUnit> div(Mass divisor) {
+  public Per<AccelerationUnit<D>, MassUnit> div(Mass divisor) {
     return (Per<AccelerationUnit<D>, MassUnit>) Measure.super.div(divisor);
   }
 
@@ -492,23 +501,23 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AccelerationUnit<D>, MassUnit> divide(Mass divisor) {
+  public Per<AccelerationUnit<D>, MassUnit> divide(Mass divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, MassUnit> per(MassUnit divisorUnit) {
+  public Per<AccelerationUnit<D>, MassUnit> per(MassUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AccelerationUnit<D>, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+  public Mult<AccelerationUnit<D>, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
     return (Mult<AccelerationUnit<D>, MomentOfInertiaUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
+  public Per<AccelerationUnit<D>, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
     return (Per<AccelerationUnit<D>, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
@@ -520,23 +529,23 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AccelerationUnit<D>, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+  public Per<AccelerationUnit<D>, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
+  public Per<AccelerationUnit<D>, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AccelerationUnit<D>, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+  public Mult<AccelerationUnit<D>, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
     return (Mult<AccelerationUnit<D>, MultUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
+  public Per<AccelerationUnit<D>, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
     return (Per<AccelerationUnit<D>, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -548,23 +557,23 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AccelerationUnit<D>, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+  public Per<AccelerationUnit<D>, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
+  public Per<AccelerationUnit<D>, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<AccelerationUnit<D>, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+  public Mult<AccelerationUnit<D>, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
     return (Mult<AccelerationUnit<D>, PerUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, PerUnit<?, ?>> div(Per<?, ?> divisor) {
+  public Per<AccelerationUnit<D>, PerUnit<?, ?>> div(Per<?, ?> divisor) {
     return (Per<AccelerationUnit<D>, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -576,23 +585,23 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AccelerationUnit<D>, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+  public Per<AccelerationUnit<D>, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
+  public Per<AccelerationUnit<D>, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<AccelerationUnit<D>, PowerUnit> times(Power multiplier) {
+  public Mult<AccelerationUnit<D>, PowerUnit> times(Power multiplier) {
     return (Mult<AccelerationUnit<D>, PowerUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, PowerUnit> div(Power divisor) {
+  public Per<AccelerationUnit<D>, PowerUnit> div(Power divisor) {
     return (Per<AccelerationUnit<D>, PowerUnit>) Measure.super.div(divisor);
   }
 
@@ -604,23 +613,23 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AccelerationUnit<D>, PowerUnit> divide(Power divisor) {
+  public Per<AccelerationUnit<D>, PowerUnit> divide(Power divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, PowerUnit> per(PowerUnit divisorUnit) {
+  public Per<AccelerationUnit<D>, PowerUnit> per(PowerUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AccelerationUnit<D>, ResistanceUnit> times(Resistance multiplier) {
+  public Mult<AccelerationUnit<D>, ResistanceUnit> times(Resistance multiplier) {
     return (Mult<AccelerationUnit<D>, ResistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, ResistanceUnit> div(Resistance divisor) {
+  public Per<AccelerationUnit<D>, ResistanceUnit> div(Resistance divisor) {
     return (Per<AccelerationUnit<D>, ResistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -632,23 +641,23 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AccelerationUnit<D>, ResistanceUnit> divide(Resistance divisor) {
+  public Per<AccelerationUnit<D>, ResistanceUnit> divide(Resistance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, ResistanceUnit> per(ResistanceUnit divisorUnit) {
+  public Per<AccelerationUnit<D>, ResistanceUnit> per(ResistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AccelerationUnit<D>, TemperatureUnit> times(Temperature multiplier) {
+  public Mult<AccelerationUnit<D>, TemperatureUnit> times(Temperature multiplier) {
     return (Mult<AccelerationUnit<D>, TemperatureUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, TemperatureUnit> div(Temperature divisor) {
+  public Per<AccelerationUnit<D>, TemperatureUnit> div(Temperature divisor) {
     return (Per<AccelerationUnit<D>, TemperatureUnit>) Measure.super.div(divisor);
   }
 
@@ -660,23 +669,23 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AccelerationUnit<D>, TemperatureUnit> divide(Temperature divisor) {
+  public Per<AccelerationUnit<D>, TemperatureUnit> divide(Temperature divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, TemperatureUnit> per(TemperatureUnit divisorUnit) {
+  public Per<AccelerationUnit<D>, TemperatureUnit> per(TemperatureUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AccelerationUnit<D>, TimeUnit> times(Time multiplier) {
+  public Mult<AccelerationUnit<D>, TimeUnit> times(Time multiplier) {
     return (Mult<AccelerationUnit<D>, TimeUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Velocity<AccelerationUnit<D>> div(Time divisor) {
+  public Velocity<AccelerationUnit<D>> div(Time divisor) {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -688,23 +697,23 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Velocity<AccelerationUnit<D>> divide(Time divisor) {
+  public Velocity<AccelerationUnit<D>> divide(Time divisor) {
     return div(divisor);
   }
 
   @Override
-  default Velocity<AccelerationUnit<D>> per(TimeUnit divisorUnit) {
+  public Velocity<AccelerationUnit<D>> per(TimeUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AccelerationUnit<D>, TorqueUnit> times(Torque multiplier) {
+  public Mult<AccelerationUnit<D>, TorqueUnit> times(Torque multiplier) {
     return (Mult<AccelerationUnit<D>, TorqueUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, TorqueUnit> div(Torque divisor) {
+  public Per<AccelerationUnit<D>, TorqueUnit> div(Torque divisor) {
     return (Per<AccelerationUnit<D>, TorqueUnit>) Measure.super.div(divisor);
   }
 
@@ -716,23 +725,23 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AccelerationUnit<D>, TorqueUnit> divide(Torque divisor) {
+  public Per<AccelerationUnit<D>, TorqueUnit> divide(Torque divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, TorqueUnit> per(TorqueUnit divisorUnit) {
+  public Per<AccelerationUnit<D>, TorqueUnit> per(TorqueUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AccelerationUnit<D>, VelocityUnit<?>> times(Velocity<?> multiplier) {
+  public Mult<AccelerationUnit<D>, VelocityUnit<?>> times(Velocity<?> multiplier) {
     return (Mult<AccelerationUnit<D>, VelocityUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, VelocityUnit<?>> div(Velocity<?> divisor) {
+  public Per<AccelerationUnit<D>, VelocityUnit<?>> div(Velocity<?> divisor) {
     return (Per<AccelerationUnit<D>, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -744,23 +753,23 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AccelerationUnit<D>, VelocityUnit<?>> divide(Velocity<?> divisor) {
+  public Per<AccelerationUnit<D>, VelocityUnit<?>> divide(Velocity<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
+  public Per<AccelerationUnit<D>, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AccelerationUnit<D>, VoltageUnit> times(Voltage multiplier) {
+  public Mult<AccelerationUnit<D>, VoltageUnit> times(Voltage multiplier) {
     return (Mult<AccelerationUnit<D>, VoltageUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, VoltageUnit> div(Voltage divisor) {
+  public Per<AccelerationUnit<D>, VoltageUnit> div(Voltage divisor) {
     return (Per<AccelerationUnit<D>, VoltageUnit>) Measure.super.div(divisor);
   }
 
@@ -772,12 +781,12 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AccelerationUnit<D>, VoltageUnit> divide(Voltage divisor) {
+  public Per<AccelerationUnit<D>, VoltageUnit> divide(Voltage divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AccelerationUnit<D>, VoltageUnit> per(VoltageUnit divisorUnit) {
+  public Per<AccelerationUnit<D>, VoltageUnit> per(VoltageUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Angle.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Angle.java
index 812b239a7b..1ecadb1a0b 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Angle.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Angle.java
@@ -10,36 +10,45 @@ import static edu.wpi.first.units.Units.*;
 import edu.wpi.first.units.*;
 
 @SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public interface Angle extends Measure<AngleUnit> {
-  static  Angle ofRelativeUnits(double magnitude, AngleUnit unit) {
-    return new ImmutableAngle(magnitude, unit.toBaseUnits(magnitude), unit);
+public record Angle(double magnitude, double baseUnitMagnitude, AngleUnit unit) implements Measure<AngleUnit> {
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link AngleUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  Angle ofRelativeUnits(double magnitude, AngleUnit unit) {
+    return new Angle(magnitude, unit.toBaseUnits(magnitude), unit);
   }
 
-  static  Angle ofBaseUnits(double baseUnitMagnitude, AngleUnit unit) {
-    return new ImmutableAngle(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link AngleUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit's base unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  Angle ofBaseUnits(double baseUnitMagnitude, AngleUnit unit) {
+    return new Angle(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
   }
 
   @Override
-  Angle copy();
+  public AngleUnit baseUnit() { return (AngleUnit) unit().getBaseUnit(); }
 
   @Override
-  default MutAngle mutableCopy() {
-    return new MutAngle(magnitude(), baseUnitMagnitude(), unit());
-  }
-
-  @Override
-  AngleUnit unit();
-
-  @Override
-  default AngleUnit baseUnit() { return (AngleUnit) unit().getBaseUnit(); }
-
-  @Override
-  default double in(AngleUnit unit) {
+  public double in(AngleUnit unit) {
     return unit.fromBaseUnits(baseUnitMagnitude());
   }
 
   @Override
-  default Angle unaryMinus() {
+  @SuppressWarnings("rawtypes")
+  public boolean equals(Object object) {
+    return object instanceof Angle m && isEquivalent(m);
+  }
+
+  @Override
+  public Angle unaryMinus() {
     return (Angle) unit().ofBaseUnits(0 - baseUnitMagnitude());
   }
 
@@ -51,27 +60,27 @@ public interface Angle extends Measure<AngleUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Angle negate() {
+  public Angle negate() {
     return (Angle) unaryMinus();
   }
 
   @Override
-  default Angle plus(Measure<? extends AngleUnit> other) {
+  public Angle plus(Measure<? extends AngleUnit> other) {
     return (Angle) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
   }
 
   @Override
-  default Angle minus(Measure<? extends AngleUnit> other) {
+  public Angle minus(Measure<? extends AngleUnit> other) {
     return (Angle) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
   }
 
   @Override
-  default Angle times(double multiplier) {
+  public Angle times(double multiplier) {
     return (Angle) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
   }
 
   @Override
-  default Angle div(double divisor) {
+  public Angle div(double divisor) {
     return (Angle) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
@@ -83,18 +92,18 @@ public interface Angle extends Measure<AngleUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Angle divide(double divisor) {
+  public Angle divide(double divisor) {
     return (Angle) div(divisor);
   }
 
 
   @Override
-  default Mult<AngleUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+  public Mult<AngleUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
     return (Mult<AngleUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngleUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
+  public Per<AngleUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
     return (Per<AngleUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -106,23 +115,23 @@ public interface Angle extends Measure<AngleUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngleUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+  public Per<AngleUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngleUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
+  public Per<AngleUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngleUnit, AngleUnit> times(Angle multiplier) {
+  public Mult<AngleUnit, AngleUnit> times(Angle multiplier) {
     return (Mult<AngleUnit, AngleUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Dimensionless div(Angle divisor) {
+  public Dimensionless div(Angle divisor) {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -134,23 +143,23 @@ public interface Angle extends Measure<AngleUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Dimensionless divide(Angle divisor) {
+  public Dimensionless divide(Angle divisor) {
     return div(divisor);
   }
 
   @Override
-  default Dimensionless per(AngleUnit divisorUnit) {
+  public Dimensionless per(AngleUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngleUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+  public Mult<AngleUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
     return (Mult<AngleUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngleUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
+  public Per<AngleUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
     return (Per<AngleUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -162,23 +171,23 @@ public interface Angle extends Measure<AngleUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngleUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+  public Per<AngleUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngleUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
+  public Per<AngleUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngleUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+  public Mult<AngleUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
     return (Mult<AngleUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngleUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
+  public Per<AngleUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
     return (Per<AngleUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -190,23 +199,23 @@ public interface Angle extends Measure<AngleUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngleUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+  public Per<AngleUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngleUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
+  public Per<AngleUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngleUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+  public Mult<AngleUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
     return (Mult<AngleUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngleUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
+  public Per<AngleUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
     return (Per<AngleUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -218,23 +227,23 @@ public interface Angle extends Measure<AngleUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngleUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+  public Per<AngleUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngleUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
+  public Per<AngleUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngleUnit, CurrentUnit> times(Current multiplier) {
+  public Mult<AngleUnit, CurrentUnit> times(Current multiplier) {
     return (Mult<AngleUnit, CurrentUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngleUnit, CurrentUnit> div(Current divisor) {
+  public Per<AngleUnit, CurrentUnit> div(Current divisor) {
     return (Per<AngleUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
@@ -246,17 +255,17 @@ public interface Angle extends Measure<AngleUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngleUnit, CurrentUnit> divide(Current divisor) {
+  public Per<AngleUnit, CurrentUnit> divide(Current divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngleUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
+  public Per<AngleUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
   @Override
-  default Angle div(Dimensionless divisor) {
+  public Angle div(Dimensionless divisor) {
     return (Angle) Radians.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -268,23 +277,23 @@ public interface Angle extends Measure<AngleUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Angle divide(Dimensionless divisor) {
+  public Angle divide(Dimensionless divisor) {
     return (Angle) div(divisor);
   }
 
   @Override
-  default Angle times(Dimensionless multiplier) {
+  public Angle times(Dimensionless multiplier) {
     return (Angle) Radians.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
 
   @Override
-  default Mult<AngleUnit, DistanceUnit> times(Distance multiplier) {
+  public Mult<AngleUnit, DistanceUnit> times(Distance multiplier) {
     return (Mult<AngleUnit, DistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngleUnit, DistanceUnit> div(Distance divisor) {
+  public Per<AngleUnit, DistanceUnit> div(Distance divisor) {
     return (Per<AngleUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -296,23 +305,23 @@ public interface Angle extends Measure<AngleUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngleUnit, DistanceUnit> divide(Distance divisor) {
+  public Per<AngleUnit, DistanceUnit> divide(Distance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngleUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
+  public Per<AngleUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngleUnit, EnergyUnit> times(Energy multiplier) {
+  public Mult<AngleUnit, EnergyUnit> times(Energy multiplier) {
     return (Mult<AngleUnit, EnergyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngleUnit, EnergyUnit> div(Energy divisor) {
+  public Per<AngleUnit, EnergyUnit> div(Energy divisor) {
     return (Per<AngleUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
@@ -324,23 +333,23 @@ public interface Angle extends Measure<AngleUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngleUnit, EnergyUnit> divide(Energy divisor) {
+  public Per<AngleUnit, EnergyUnit> divide(Energy divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngleUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
+  public Per<AngleUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngleUnit, ForceUnit> times(Force multiplier) {
+  public Mult<AngleUnit, ForceUnit> times(Force multiplier) {
     return (Mult<AngleUnit, ForceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngleUnit, ForceUnit> div(Force divisor) {
+  public Per<AngleUnit, ForceUnit> div(Force divisor) {
     return (Per<AngleUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
@@ -352,23 +361,23 @@ public interface Angle extends Measure<AngleUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngleUnit, ForceUnit> divide(Force divisor) {
+  public Per<AngleUnit, ForceUnit> divide(Force divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngleUnit, ForceUnit> per(ForceUnit divisorUnit) {
+  public Per<AngleUnit, ForceUnit> per(ForceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default AngularVelocity times(Frequency multiplier) {
+  public AngularVelocity times(Frequency multiplier) {
     return RadiansPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<AngleUnit, FrequencyUnit> div(Frequency divisor) {
+  public Per<AngleUnit, FrequencyUnit> div(Frequency divisor) {
     return (Per<AngleUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
@@ -380,23 +389,23 @@ public interface Angle extends Measure<AngleUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngleUnit, FrequencyUnit> divide(Frequency divisor) {
+  public Per<AngleUnit, FrequencyUnit> divide(Frequency divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngleUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
+  public Per<AngleUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngleUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+  public Mult<AngleUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
     return (Mult<AngleUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngleUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
+  public Per<AngleUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
     return (Per<AngleUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -408,23 +417,23 @@ public interface Angle extends Measure<AngleUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngleUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+  public Per<AngleUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngleUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
+  public Per<AngleUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngleUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+  public Mult<AngleUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
     return (Mult<AngleUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngleUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
+  public Per<AngleUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
     return (Per<AngleUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -436,23 +445,23 @@ public interface Angle extends Measure<AngleUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngleUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+  public Per<AngleUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngleUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
+  public Per<AngleUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngleUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+  public Mult<AngleUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
     return (Mult<AngleUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngleUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
+  public Per<AngleUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
     return (Per<AngleUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -464,23 +473,23 @@ public interface Angle extends Measure<AngleUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngleUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+  public Per<AngleUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngleUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
+  public Per<AngleUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngleUnit, MassUnit> times(Mass multiplier) {
+  public Mult<AngleUnit, MassUnit> times(Mass multiplier) {
     return (Mult<AngleUnit, MassUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngleUnit, MassUnit> div(Mass divisor) {
+  public Per<AngleUnit, MassUnit> div(Mass divisor) {
     return (Per<AngleUnit, MassUnit>) Measure.super.div(divisor);
   }
 
@@ -492,23 +501,23 @@ public interface Angle extends Measure<AngleUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngleUnit, MassUnit> divide(Mass divisor) {
+  public Per<AngleUnit, MassUnit> divide(Mass divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngleUnit, MassUnit> per(MassUnit divisorUnit) {
+  public Per<AngleUnit, MassUnit> per(MassUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngleUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+  public Mult<AngleUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
     return (Mult<AngleUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngleUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
+  public Per<AngleUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
     return (Per<AngleUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
@@ -520,23 +529,23 @@ public interface Angle extends Measure<AngleUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngleUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+  public Per<AngleUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngleUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
+  public Per<AngleUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngleUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+  public Mult<AngleUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
     return (Mult<AngleUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngleUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
+  public Per<AngleUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
     return (Per<AngleUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -548,23 +557,23 @@ public interface Angle extends Measure<AngleUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngleUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+  public Per<AngleUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngleUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
+  public Per<AngleUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<AngleUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+  public Mult<AngleUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
     return (Mult<AngleUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngleUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
+  public Per<AngleUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
     return (Per<AngleUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -576,23 +585,23 @@ public interface Angle extends Measure<AngleUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngleUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+  public Per<AngleUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngleUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
+  public Per<AngleUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<AngleUnit, PowerUnit> times(Power multiplier) {
+  public Mult<AngleUnit, PowerUnit> times(Power multiplier) {
     return (Mult<AngleUnit, PowerUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngleUnit, PowerUnit> div(Power divisor) {
+  public Per<AngleUnit, PowerUnit> div(Power divisor) {
     return (Per<AngleUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
@@ -604,23 +613,23 @@ public interface Angle extends Measure<AngleUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngleUnit, PowerUnit> divide(Power divisor) {
+  public Per<AngleUnit, PowerUnit> divide(Power divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngleUnit, PowerUnit> per(PowerUnit divisorUnit) {
+  public Per<AngleUnit, PowerUnit> per(PowerUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngleUnit, ResistanceUnit> times(Resistance multiplier) {
+  public Mult<AngleUnit, ResistanceUnit> times(Resistance multiplier) {
     return (Mult<AngleUnit, ResistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngleUnit, ResistanceUnit> div(Resistance divisor) {
+  public Per<AngleUnit, ResistanceUnit> div(Resistance divisor) {
     return (Per<AngleUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -632,23 +641,23 @@ public interface Angle extends Measure<AngleUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngleUnit, ResistanceUnit> divide(Resistance divisor) {
+  public Per<AngleUnit, ResistanceUnit> divide(Resistance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngleUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
+  public Per<AngleUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngleUnit, TemperatureUnit> times(Temperature multiplier) {
+  public Mult<AngleUnit, TemperatureUnit> times(Temperature multiplier) {
     return (Mult<AngleUnit, TemperatureUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngleUnit, TemperatureUnit> div(Temperature divisor) {
+  public Per<AngleUnit, TemperatureUnit> div(Temperature divisor) {
     return (Per<AngleUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
@@ -660,23 +669,23 @@ public interface Angle extends Measure<AngleUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngleUnit, TemperatureUnit> divide(Temperature divisor) {
+  public Per<AngleUnit, TemperatureUnit> divide(Temperature divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngleUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
+  public Per<AngleUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngleUnit, TimeUnit> times(Time multiplier) {
+  public Mult<AngleUnit, TimeUnit> times(Time multiplier) {
     return (Mult<AngleUnit, TimeUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default AngularVelocity div(Time divisor) {
+  public AngularVelocity div(Time divisor) {
     return RadiansPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -688,23 +697,23 @@ public interface Angle extends Measure<AngleUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default AngularVelocity divide(Time divisor) {
+  public AngularVelocity divide(Time divisor) {
     return div(divisor);
   }
 
   @Override
-  default AngularVelocity per(TimeUnit divisorUnit) {
+  public AngularVelocity per(TimeUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngleUnit, TorqueUnit> times(Torque multiplier) {
+  public Mult<AngleUnit, TorqueUnit> times(Torque multiplier) {
     return (Mult<AngleUnit, TorqueUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngleUnit, TorqueUnit> div(Torque divisor) {
+  public Per<AngleUnit, TorqueUnit> div(Torque divisor) {
     return (Per<AngleUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
@@ -716,23 +725,23 @@ public interface Angle extends Measure<AngleUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngleUnit, TorqueUnit> divide(Torque divisor) {
+  public Per<AngleUnit, TorqueUnit> divide(Torque divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngleUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
+  public Per<AngleUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngleUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+  public Mult<AngleUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
     return (Mult<AngleUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngleUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
+  public Per<AngleUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
     return (Per<AngleUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -744,23 +753,23 @@ public interface Angle extends Measure<AngleUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngleUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+  public Per<AngleUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngleUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
+  public Per<AngleUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngleUnit, VoltageUnit> times(Voltage multiplier) {
+  public Mult<AngleUnit, VoltageUnit> times(Voltage multiplier) {
     return (Mult<AngleUnit, VoltageUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngleUnit, VoltageUnit> div(Voltage divisor) {
+  public Per<AngleUnit, VoltageUnit> div(Voltage divisor) {
     return (Per<AngleUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
@@ -772,12 +781,12 @@ public interface Angle extends Measure<AngleUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngleUnit, VoltageUnit> divide(Voltage divisor) {
+  public Per<AngleUnit, VoltageUnit> divide(Voltage divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngleUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
+  public Per<AngleUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularAcceleration.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularAcceleration.java
index d90cbe2056..663ba6e6ab 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularAcceleration.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularAcceleration.java
@@ -10,36 +10,45 @@ import static edu.wpi.first.units.Units.*;
 import edu.wpi.first.units.*;
 
 @SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
-  static  AngularAcceleration ofRelativeUnits(double magnitude, AngularAccelerationUnit unit) {
-    return new ImmutableAngularAcceleration(magnitude, unit.toBaseUnits(magnitude), unit);
+public record AngularAcceleration(double magnitude, double baseUnitMagnitude, AngularAccelerationUnit unit) implements Measure<AngularAccelerationUnit> {
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link AngularAccelerationUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  AngularAcceleration ofRelativeUnits(double magnitude, AngularAccelerationUnit unit) {
+    return new AngularAcceleration(magnitude, unit.toBaseUnits(magnitude), unit);
   }
 
-  static  AngularAcceleration ofBaseUnits(double baseUnitMagnitude, AngularAccelerationUnit unit) {
-    return new ImmutableAngularAcceleration(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link AngularAccelerationUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit's base unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  AngularAcceleration ofBaseUnits(double baseUnitMagnitude, AngularAccelerationUnit unit) {
+    return new AngularAcceleration(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
   }
 
   @Override
-  AngularAcceleration copy();
+  public AngularAccelerationUnit baseUnit() { return (AngularAccelerationUnit) unit().getBaseUnit(); }
 
   @Override
-  default MutAngularAcceleration mutableCopy() {
-    return new MutAngularAcceleration(magnitude(), baseUnitMagnitude(), unit());
-  }
-
-  @Override
-  AngularAccelerationUnit unit();
-
-  @Override
-  default AngularAccelerationUnit baseUnit() { return (AngularAccelerationUnit) unit().getBaseUnit(); }
-
-  @Override
-  default double in(AngularAccelerationUnit unit) {
+  public double in(AngularAccelerationUnit unit) {
     return unit.fromBaseUnits(baseUnitMagnitude());
   }
 
   @Override
-  default AngularAcceleration unaryMinus() {
+  @SuppressWarnings("rawtypes")
+  public boolean equals(Object object) {
+    return object instanceof AngularAcceleration m && isEquivalent(m);
+  }
+
+  @Override
+  public AngularAcceleration unaryMinus() {
     return (AngularAcceleration) unit().ofBaseUnits(0 - baseUnitMagnitude());
   }
 
@@ -51,27 +60,27 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default AngularAcceleration negate() {
+  public AngularAcceleration negate() {
     return (AngularAcceleration) unaryMinus();
   }
 
   @Override
-  default AngularAcceleration plus(Measure<? extends AngularAccelerationUnit> other) {
+  public AngularAcceleration plus(Measure<? extends AngularAccelerationUnit> other) {
     return (AngularAcceleration) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
   }
 
   @Override
-  default AngularAcceleration minus(Measure<? extends AngularAccelerationUnit> other) {
+  public AngularAcceleration minus(Measure<? extends AngularAccelerationUnit> other) {
     return (AngularAcceleration) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
   }
 
   @Override
-  default AngularAcceleration times(double multiplier) {
+  public AngularAcceleration times(double multiplier) {
     return (AngularAcceleration) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
   }
 
   @Override
-  default AngularAcceleration div(double divisor) {
+  public AngularAcceleration div(double divisor) {
     return (AngularAcceleration) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
@@ -83,18 +92,18 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default AngularAcceleration divide(double divisor) {
+  public AngularAcceleration divide(double divisor) {
     return (AngularAcceleration) div(divisor);
   }
 
 
   @Override
-  default Mult<AngularAccelerationUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+  public Mult<AngularAccelerationUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
     return (Mult<AngularAccelerationUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
+  public Per<AngularAccelerationUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
     return (Per<AngularAccelerationUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -106,23 +115,23 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularAccelerationUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+  public Per<AngularAccelerationUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
+  public Per<AngularAccelerationUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularAccelerationUnit, AngleUnit> times(Angle multiplier) {
+  public Mult<AngularAccelerationUnit, AngleUnit> times(Angle multiplier) {
     return (Mult<AngularAccelerationUnit, AngleUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, AngleUnit> div(Angle divisor) {
+  public Per<AngularAccelerationUnit, AngleUnit> div(Angle divisor) {
     return (Per<AngularAccelerationUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
@@ -134,23 +143,23 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularAccelerationUnit, AngleUnit> divide(Angle divisor) {
+  public Per<AngularAccelerationUnit, AngleUnit> divide(Angle divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, AngleUnit> per(AngleUnit divisorUnit) {
+  public Per<AngularAccelerationUnit, AngleUnit> per(AngleUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularAccelerationUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+  public Mult<AngularAccelerationUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
     return (Mult<AngularAccelerationUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Dimensionless div(AngularAcceleration divisor) {
+  public Dimensionless div(AngularAcceleration divisor) {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -162,23 +171,23 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Dimensionless divide(AngularAcceleration divisor) {
+  public Dimensionless divide(AngularAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Dimensionless per(AngularAccelerationUnit divisorUnit) {
+  public Dimensionless per(AngularAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularAccelerationUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+  public Mult<AngularAccelerationUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
     return (Mult<AngularAccelerationUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
+  public Per<AngularAccelerationUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
     return (Per<AngularAccelerationUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -190,23 +199,23 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularAccelerationUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+  public Per<AngularAccelerationUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
+  public Per<AngularAccelerationUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularAccelerationUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+  public Mult<AngularAccelerationUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
     return (Mult<AngularAccelerationUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
+  public Per<AngularAccelerationUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
     return (Per<AngularAccelerationUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -218,23 +227,23 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularAccelerationUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+  public Per<AngularAccelerationUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
+  public Per<AngularAccelerationUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularAccelerationUnit, CurrentUnit> times(Current multiplier) {
+  public Mult<AngularAccelerationUnit, CurrentUnit> times(Current multiplier) {
     return (Mult<AngularAccelerationUnit, CurrentUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, CurrentUnit> div(Current divisor) {
+  public Per<AngularAccelerationUnit, CurrentUnit> div(Current divisor) {
     return (Per<AngularAccelerationUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
@@ -246,17 +255,17 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularAccelerationUnit, CurrentUnit> divide(Current divisor) {
+  public Per<AngularAccelerationUnit, CurrentUnit> divide(Current divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
+  public Per<AngularAccelerationUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
   @Override
-  default AngularAcceleration div(Dimensionless divisor) {
+  public AngularAcceleration div(Dimensionless divisor) {
     return (AngularAcceleration) RadiansPerSecondPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -268,23 +277,23 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default AngularAcceleration divide(Dimensionless divisor) {
+  public AngularAcceleration divide(Dimensionless divisor) {
     return (AngularAcceleration) div(divisor);
   }
 
   @Override
-  default AngularAcceleration times(Dimensionless multiplier) {
+  public AngularAcceleration times(Dimensionless multiplier) {
     return (AngularAcceleration) RadiansPerSecondPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
 
   @Override
-  default Mult<AngularAccelerationUnit, DistanceUnit> times(Distance multiplier) {
+  public Mult<AngularAccelerationUnit, DistanceUnit> times(Distance multiplier) {
     return (Mult<AngularAccelerationUnit, DistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, DistanceUnit> div(Distance divisor) {
+  public Per<AngularAccelerationUnit, DistanceUnit> div(Distance divisor) {
     return (Per<AngularAccelerationUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -296,23 +305,23 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularAccelerationUnit, DistanceUnit> divide(Distance divisor) {
+  public Per<AngularAccelerationUnit, DistanceUnit> divide(Distance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
+  public Per<AngularAccelerationUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularAccelerationUnit, EnergyUnit> times(Energy multiplier) {
+  public Mult<AngularAccelerationUnit, EnergyUnit> times(Energy multiplier) {
     return (Mult<AngularAccelerationUnit, EnergyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, EnergyUnit> div(Energy divisor) {
+  public Per<AngularAccelerationUnit, EnergyUnit> div(Energy divisor) {
     return (Per<AngularAccelerationUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
@@ -324,23 +333,23 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularAccelerationUnit, EnergyUnit> divide(Energy divisor) {
+  public Per<AngularAccelerationUnit, EnergyUnit> divide(Energy divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
+  public Per<AngularAccelerationUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularAccelerationUnit, ForceUnit> times(Force multiplier) {
+  public Mult<AngularAccelerationUnit, ForceUnit> times(Force multiplier) {
     return (Mult<AngularAccelerationUnit, ForceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, ForceUnit> div(Force divisor) {
+  public Per<AngularAccelerationUnit, ForceUnit> div(Force divisor) {
     return (Per<AngularAccelerationUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
@@ -352,23 +361,23 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularAccelerationUnit, ForceUnit> divide(Force divisor) {
+  public Per<AngularAccelerationUnit, ForceUnit> divide(Force divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, ForceUnit> per(ForceUnit divisorUnit) {
+  public Per<AngularAccelerationUnit, ForceUnit> per(ForceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularAccelerationUnit, FrequencyUnit> times(Frequency multiplier) {
+  public Mult<AngularAccelerationUnit, FrequencyUnit> times(Frequency multiplier) {
     return (Mult<AngularAccelerationUnit, FrequencyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default AngularVelocity div(Frequency divisor) {
+  public AngularVelocity div(Frequency divisor) {
     return RadiansPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -380,23 +389,23 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default AngularVelocity divide(Frequency divisor) {
+  public AngularVelocity divide(Frequency divisor) {
     return div(divisor);
   }
 
   @Override
-  default AngularVelocity per(FrequencyUnit divisorUnit) {
+  public AngularVelocity per(FrequencyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularAccelerationUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+  public Mult<AngularAccelerationUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
     return (Mult<AngularAccelerationUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
+  public Per<AngularAccelerationUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
     return (Per<AngularAccelerationUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -408,23 +417,23 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularAccelerationUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+  public Per<AngularAccelerationUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
+  public Per<AngularAccelerationUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularAccelerationUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+  public Mult<AngularAccelerationUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
     return (Mult<AngularAccelerationUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
+  public Per<AngularAccelerationUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
     return (Per<AngularAccelerationUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -436,23 +445,23 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularAccelerationUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+  public Per<AngularAccelerationUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
+  public Per<AngularAccelerationUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularAccelerationUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+  public Mult<AngularAccelerationUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
     return (Mult<AngularAccelerationUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
+  public Per<AngularAccelerationUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
     return (Per<AngularAccelerationUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -464,23 +473,23 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularAccelerationUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+  public Per<AngularAccelerationUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
+  public Per<AngularAccelerationUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularAccelerationUnit, MassUnit> times(Mass multiplier) {
+  public Mult<AngularAccelerationUnit, MassUnit> times(Mass multiplier) {
     return (Mult<AngularAccelerationUnit, MassUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, MassUnit> div(Mass divisor) {
+  public Per<AngularAccelerationUnit, MassUnit> div(Mass divisor) {
     return (Per<AngularAccelerationUnit, MassUnit>) Measure.super.div(divisor);
   }
 
@@ -492,23 +501,23 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularAccelerationUnit, MassUnit> divide(Mass divisor) {
+  public Per<AngularAccelerationUnit, MassUnit> divide(Mass divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, MassUnit> per(MassUnit divisorUnit) {
+  public Per<AngularAccelerationUnit, MassUnit> per(MassUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularAccelerationUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+  public Mult<AngularAccelerationUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
     return (Mult<AngularAccelerationUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
+  public Per<AngularAccelerationUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
     return (Per<AngularAccelerationUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
@@ -520,23 +529,23 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularAccelerationUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+  public Per<AngularAccelerationUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
+  public Per<AngularAccelerationUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularAccelerationUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+  public Mult<AngularAccelerationUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
     return (Mult<AngularAccelerationUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
+  public Per<AngularAccelerationUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
     return (Per<AngularAccelerationUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -548,23 +557,23 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularAccelerationUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+  public Per<AngularAccelerationUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
+  public Per<AngularAccelerationUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<AngularAccelerationUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+  public Mult<AngularAccelerationUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
     return (Mult<AngularAccelerationUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
+  public Per<AngularAccelerationUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
     return (Per<AngularAccelerationUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -576,23 +585,23 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularAccelerationUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+  public Per<AngularAccelerationUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
+  public Per<AngularAccelerationUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<AngularAccelerationUnit, PowerUnit> times(Power multiplier) {
+  public Mult<AngularAccelerationUnit, PowerUnit> times(Power multiplier) {
     return (Mult<AngularAccelerationUnit, PowerUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, PowerUnit> div(Power divisor) {
+  public Per<AngularAccelerationUnit, PowerUnit> div(Power divisor) {
     return (Per<AngularAccelerationUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
@@ -604,23 +613,23 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularAccelerationUnit, PowerUnit> divide(Power divisor) {
+  public Per<AngularAccelerationUnit, PowerUnit> divide(Power divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, PowerUnit> per(PowerUnit divisorUnit) {
+  public Per<AngularAccelerationUnit, PowerUnit> per(PowerUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularAccelerationUnit, ResistanceUnit> times(Resistance multiplier) {
+  public Mult<AngularAccelerationUnit, ResistanceUnit> times(Resistance multiplier) {
     return (Mult<AngularAccelerationUnit, ResistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, ResistanceUnit> div(Resistance divisor) {
+  public Per<AngularAccelerationUnit, ResistanceUnit> div(Resistance divisor) {
     return (Per<AngularAccelerationUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -632,23 +641,23 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularAccelerationUnit, ResistanceUnit> divide(Resistance divisor) {
+  public Per<AngularAccelerationUnit, ResistanceUnit> divide(Resistance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
+  public Per<AngularAccelerationUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularAccelerationUnit, TemperatureUnit> times(Temperature multiplier) {
+  public Mult<AngularAccelerationUnit, TemperatureUnit> times(Temperature multiplier) {
     return (Mult<AngularAccelerationUnit, TemperatureUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, TemperatureUnit> div(Temperature divisor) {
+  public Per<AngularAccelerationUnit, TemperatureUnit> div(Temperature divisor) {
     return (Per<AngularAccelerationUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
@@ -660,23 +669,23 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularAccelerationUnit, TemperatureUnit> divide(Temperature divisor) {
+  public Per<AngularAccelerationUnit, TemperatureUnit> divide(Temperature divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
+  public Per<AngularAccelerationUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default AngularVelocity times(Time multiplier) {
+  public AngularVelocity times(Time multiplier) {
     return RadiansPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Velocity<AngularAccelerationUnit> div(Time divisor) {
+  public Velocity<AngularAccelerationUnit> div(Time divisor) {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -688,23 +697,23 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Velocity<AngularAccelerationUnit> divide(Time divisor) {
+  public Velocity<AngularAccelerationUnit> divide(Time divisor) {
     return div(divisor);
   }
 
   @Override
-  default Velocity<AngularAccelerationUnit> per(TimeUnit divisorUnit) {
+  public Velocity<AngularAccelerationUnit> per(TimeUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularAccelerationUnit, TorqueUnit> times(Torque multiplier) {
+  public Mult<AngularAccelerationUnit, TorqueUnit> times(Torque multiplier) {
     return (Mult<AngularAccelerationUnit, TorqueUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, TorqueUnit> div(Torque divisor) {
+  public Per<AngularAccelerationUnit, TorqueUnit> div(Torque divisor) {
     return (Per<AngularAccelerationUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
@@ -716,23 +725,23 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularAccelerationUnit, TorqueUnit> divide(Torque divisor) {
+  public Per<AngularAccelerationUnit, TorqueUnit> divide(Torque divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
+  public Per<AngularAccelerationUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularAccelerationUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+  public Mult<AngularAccelerationUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
     return (Mult<AngularAccelerationUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
+  public Per<AngularAccelerationUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
     return (Per<AngularAccelerationUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -744,23 +753,23 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularAccelerationUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+  public Per<AngularAccelerationUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
+  public Per<AngularAccelerationUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularAccelerationUnit, VoltageUnit> times(Voltage multiplier) {
+  public Mult<AngularAccelerationUnit, VoltageUnit> times(Voltage multiplier) {
     return (Mult<AngularAccelerationUnit, VoltageUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, VoltageUnit> div(Voltage divisor) {
+  public Per<AngularAccelerationUnit, VoltageUnit> div(Voltage divisor) {
     return (Per<AngularAccelerationUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
@@ -772,12 +781,12 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularAccelerationUnit, VoltageUnit> divide(Voltage divisor) {
+  public Per<AngularAccelerationUnit, VoltageUnit> divide(Voltage divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularAccelerationUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
+  public Per<AngularAccelerationUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularMomentum.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularMomentum.java
index ab1b0f15fd..407087f980 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularMomentum.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularMomentum.java
@@ -10,36 +10,45 @@ import static edu.wpi.first.units.Units.*;
 import edu.wpi.first.units.*;
 
 @SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public interface AngularMomentum extends Measure<AngularMomentumUnit> {
-  static  AngularMomentum ofRelativeUnits(double magnitude, AngularMomentumUnit unit) {
-    return new ImmutableAngularMomentum(magnitude, unit.toBaseUnits(magnitude), unit);
+public record AngularMomentum(double magnitude, double baseUnitMagnitude, AngularMomentumUnit unit) implements Measure<AngularMomentumUnit> {
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link AngularMomentumUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  AngularMomentum ofRelativeUnits(double magnitude, AngularMomentumUnit unit) {
+    return new AngularMomentum(magnitude, unit.toBaseUnits(magnitude), unit);
   }
 
-  static  AngularMomentum ofBaseUnits(double baseUnitMagnitude, AngularMomentumUnit unit) {
-    return new ImmutableAngularMomentum(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link AngularMomentumUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit's base unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  AngularMomentum ofBaseUnits(double baseUnitMagnitude, AngularMomentumUnit unit) {
+    return new AngularMomentum(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
   }
 
   @Override
-  AngularMomentum copy();
+  public AngularMomentumUnit baseUnit() { return (AngularMomentumUnit) unit().getBaseUnit(); }
 
   @Override
-  default MutAngularMomentum mutableCopy() {
-    return new MutAngularMomentum(magnitude(), baseUnitMagnitude(), unit());
-  }
-
-  @Override
-  AngularMomentumUnit unit();
-
-  @Override
-  default AngularMomentumUnit baseUnit() { return (AngularMomentumUnit) unit().getBaseUnit(); }
-
-  @Override
-  default double in(AngularMomentumUnit unit) {
+  public double in(AngularMomentumUnit unit) {
     return unit.fromBaseUnits(baseUnitMagnitude());
   }
 
   @Override
-  default AngularMomentum unaryMinus() {
+  @SuppressWarnings("rawtypes")
+  public boolean equals(Object object) {
+    return object instanceof AngularMomentum m && isEquivalent(m);
+  }
+
+  @Override
+  public AngularMomentum unaryMinus() {
     return (AngularMomentum) unit().ofBaseUnits(0 - baseUnitMagnitude());
   }
 
@@ -51,27 +60,27 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default AngularMomentum negate() {
+  public AngularMomentum negate() {
     return (AngularMomentum) unaryMinus();
   }
 
   @Override
-  default AngularMomentum plus(Measure<? extends AngularMomentumUnit> other) {
+  public AngularMomentum plus(Measure<? extends AngularMomentumUnit> other) {
     return (AngularMomentum) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
   }
 
   @Override
-  default AngularMomentum minus(Measure<? extends AngularMomentumUnit> other) {
+  public AngularMomentum minus(Measure<? extends AngularMomentumUnit> other) {
     return (AngularMomentum) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
   }
 
   @Override
-  default AngularMomentum times(double multiplier) {
+  public AngularMomentum times(double multiplier) {
     return (AngularMomentum) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
   }
 
   @Override
-  default AngularMomentum div(double divisor) {
+  public AngularMomentum div(double divisor) {
     return (AngularMomentum) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
@@ -83,18 +92,18 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default AngularMomentum divide(double divisor) {
+  public AngularMomentum divide(double divisor) {
     return (AngularMomentum) div(divisor);
   }
 
 
   @Override
-  default Mult<AngularMomentumUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+  public Mult<AngularMomentumUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
     return (Mult<AngularMomentumUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularMomentumUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
+  public Per<AngularMomentumUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
     return (Per<AngularMomentumUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -106,23 +115,23 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularMomentumUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+  public Per<AngularMomentumUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularMomentumUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
+  public Per<AngularMomentumUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularMomentumUnit, AngleUnit> times(Angle multiplier) {
+  public Mult<AngularMomentumUnit, AngleUnit> times(Angle multiplier) {
     return (Mult<AngularMomentumUnit, AngleUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularMomentumUnit, AngleUnit> div(Angle divisor) {
+  public Per<AngularMomentumUnit, AngleUnit> div(Angle divisor) {
     return (Per<AngularMomentumUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
@@ -134,23 +143,23 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularMomentumUnit, AngleUnit> divide(Angle divisor) {
+  public Per<AngularMomentumUnit, AngleUnit> divide(Angle divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularMomentumUnit, AngleUnit> per(AngleUnit divisorUnit) {
+  public Per<AngularMomentumUnit, AngleUnit> per(AngleUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularMomentumUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+  public Mult<AngularMomentumUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
     return (Mult<AngularMomentumUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularMomentumUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
+  public Per<AngularMomentumUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
     return (Per<AngularMomentumUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -162,23 +171,23 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularMomentumUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+  public Per<AngularMomentumUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularMomentumUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
+  public Per<AngularMomentumUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularMomentumUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+  public Mult<AngularMomentumUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
     return (Mult<AngularMomentumUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Dimensionless div(AngularMomentum divisor) {
+  public Dimensionless div(AngularMomentum divisor) {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -190,23 +199,23 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Dimensionless divide(AngularMomentum divisor) {
+  public Dimensionless divide(AngularMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Dimensionless per(AngularMomentumUnit divisorUnit) {
+  public Dimensionless per(AngularMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularMomentumUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+  public Mult<AngularMomentumUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
     return (Mult<AngularMomentumUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default MomentOfInertia div(AngularVelocity divisor) {
+  public MomentOfInertia div(AngularVelocity divisor) {
     return KilogramSquareMeters.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -218,23 +227,23 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default MomentOfInertia divide(AngularVelocity divisor) {
+  public MomentOfInertia divide(AngularVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default MomentOfInertia per(AngularVelocityUnit divisorUnit) {
+  public MomentOfInertia per(AngularVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularMomentumUnit, CurrentUnit> times(Current multiplier) {
+  public Mult<AngularMomentumUnit, CurrentUnit> times(Current multiplier) {
     return (Mult<AngularMomentumUnit, CurrentUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularMomentumUnit, CurrentUnit> div(Current divisor) {
+  public Per<AngularMomentumUnit, CurrentUnit> div(Current divisor) {
     return (Per<AngularMomentumUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
@@ -246,17 +255,17 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularMomentumUnit, CurrentUnit> divide(Current divisor) {
+  public Per<AngularMomentumUnit, CurrentUnit> divide(Current divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularMomentumUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
+  public Per<AngularMomentumUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
   @Override
-  default AngularMomentum div(Dimensionless divisor) {
+  public AngularMomentum div(Dimensionless divisor) {
     return (AngularMomentum) KilogramMetersSquaredPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -268,23 +277,23 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default AngularMomentum divide(Dimensionless divisor) {
+  public AngularMomentum divide(Dimensionless divisor) {
     return (AngularMomentum) div(divisor);
   }
 
   @Override
-  default AngularMomentum times(Dimensionless multiplier) {
+  public AngularMomentum times(Dimensionless multiplier) {
     return (AngularMomentum) KilogramMetersSquaredPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
 
   @Override
-  default Mult<AngularMomentumUnit, DistanceUnit> times(Distance multiplier) {
+  public Mult<AngularMomentumUnit, DistanceUnit> times(Distance multiplier) {
     return (Mult<AngularMomentumUnit, DistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularMomentumUnit, DistanceUnit> div(Distance divisor) {
+  public Per<AngularMomentumUnit, DistanceUnit> div(Distance divisor) {
     return (Per<AngularMomentumUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -296,23 +305,23 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularMomentumUnit, DistanceUnit> divide(Distance divisor) {
+  public Per<AngularMomentumUnit, DistanceUnit> divide(Distance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularMomentumUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
+  public Per<AngularMomentumUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularMomentumUnit, EnergyUnit> times(Energy multiplier) {
+  public Mult<AngularMomentumUnit, EnergyUnit> times(Energy multiplier) {
     return (Mult<AngularMomentumUnit, EnergyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularMomentumUnit, EnergyUnit> div(Energy divisor) {
+  public Per<AngularMomentumUnit, EnergyUnit> div(Energy divisor) {
     return (Per<AngularMomentumUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
@@ -324,23 +333,23 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularMomentumUnit, EnergyUnit> divide(Energy divisor) {
+  public Per<AngularMomentumUnit, EnergyUnit> divide(Energy divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularMomentumUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
+  public Per<AngularMomentumUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularMomentumUnit, ForceUnit> times(Force multiplier) {
+  public Mult<AngularMomentumUnit, ForceUnit> times(Force multiplier) {
     return (Mult<AngularMomentumUnit, ForceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularMomentumUnit, ForceUnit> div(Force divisor) {
+  public Per<AngularMomentumUnit, ForceUnit> div(Force divisor) {
     return (Per<AngularMomentumUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
@@ -352,23 +361,23 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularMomentumUnit, ForceUnit> divide(Force divisor) {
+  public Per<AngularMomentumUnit, ForceUnit> divide(Force divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularMomentumUnit, ForceUnit> per(ForceUnit divisorUnit) {
+  public Per<AngularMomentumUnit, ForceUnit> per(ForceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularMomentumUnit, FrequencyUnit> times(Frequency multiplier) {
+  public Mult<AngularMomentumUnit, FrequencyUnit> times(Frequency multiplier) {
     return (Mult<AngularMomentumUnit, FrequencyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularMomentumUnit, FrequencyUnit> div(Frequency divisor) {
+  public Per<AngularMomentumUnit, FrequencyUnit> div(Frequency divisor) {
     return (Per<AngularMomentumUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
@@ -380,23 +389,23 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularMomentumUnit, FrequencyUnit> divide(Frequency divisor) {
+  public Per<AngularMomentumUnit, FrequencyUnit> divide(Frequency divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularMomentumUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
+  public Per<AngularMomentumUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularMomentumUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+  public Mult<AngularMomentumUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
     return (Mult<AngularMomentumUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularMomentumUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
+  public Per<AngularMomentumUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
     return (Per<AngularMomentumUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -408,23 +417,23 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularMomentumUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+  public Per<AngularMomentumUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularMomentumUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
+  public Per<AngularMomentumUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularMomentumUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+  public Mult<AngularMomentumUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
     return (Mult<AngularMomentumUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularMomentumUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
+  public Per<AngularMomentumUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
     return (Per<AngularMomentumUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -436,23 +445,23 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularMomentumUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+  public Per<AngularMomentumUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularMomentumUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
+  public Per<AngularMomentumUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularMomentumUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+  public Mult<AngularMomentumUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
     return (Mult<AngularMomentumUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularMomentumUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
+  public Per<AngularMomentumUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
     return (Per<AngularMomentumUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -464,23 +473,23 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularMomentumUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+  public Per<AngularMomentumUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularMomentumUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
+  public Per<AngularMomentumUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularMomentumUnit, MassUnit> times(Mass multiplier) {
+  public Mult<AngularMomentumUnit, MassUnit> times(Mass multiplier) {
     return (Mult<AngularMomentumUnit, MassUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularMomentumUnit, MassUnit> div(Mass divisor) {
+  public Per<AngularMomentumUnit, MassUnit> div(Mass divisor) {
     return (Per<AngularMomentumUnit, MassUnit>) Measure.super.div(divisor);
   }
 
@@ -492,23 +501,23 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularMomentumUnit, MassUnit> divide(Mass divisor) {
+  public Per<AngularMomentumUnit, MassUnit> divide(Mass divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularMomentumUnit, MassUnit> per(MassUnit divisorUnit) {
+  public Per<AngularMomentumUnit, MassUnit> per(MassUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularMomentumUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+  public Mult<AngularMomentumUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
     return (Mult<AngularMomentumUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularMomentumUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
+  public Per<AngularMomentumUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
     return (Per<AngularMomentumUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
@@ -520,23 +529,23 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularMomentumUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+  public Per<AngularMomentumUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularMomentumUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
+  public Per<AngularMomentumUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularMomentumUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+  public Mult<AngularMomentumUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
     return (Mult<AngularMomentumUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularMomentumUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
+  public Per<AngularMomentumUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
     return (Per<AngularMomentumUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -548,23 +557,23 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularMomentumUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+  public Per<AngularMomentumUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularMomentumUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
+  public Per<AngularMomentumUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<AngularMomentumUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+  public Mult<AngularMomentumUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
     return (Mult<AngularMomentumUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularMomentumUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
+  public Per<AngularMomentumUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
     return (Per<AngularMomentumUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -576,23 +585,23 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularMomentumUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+  public Per<AngularMomentumUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularMomentumUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
+  public Per<AngularMomentumUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<AngularMomentumUnit, PowerUnit> times(Power multiplier) {
+  public Mult<AngularMomentumUnit, PowerUnit> times(Power multiplier) {
     return (Mult<AngularMomentumUnit, PowerUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularMomentumUnit, PowerUnit> div(Power divisor) {
+  public Per<AngularMomentumUnit, PowerUnit> div(Power divisor) {
     return (Per<AngularMomentumUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
@@ -604,23 +613,23 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularMomentumUnit, PowerUnit> divide(Power divisor) {
+  public Per<AngularMomentumUnit, PowerUnit> divide(Power divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularMomentumUnit, PowerUnit> per(PowerUnit divisorUnit) {
+  public Per<AngularMomentumUnit, PowerUnit> per(PowerUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularMomentumUnit, ResistanceUnit> times(Resistance multiplier) {
+  public Mult<AngularMomentumUnit, ResistanceUnit> times(Resistance multiplier) {
     return (Mult<AngularMomentumUnit, ResistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularMomentumUnit, ResistanceUnit> div(Resistance divisor) {
+  public Per<AngularMomentumUnit, ResistanceUnit> div(Resistance divisor) {
     return (Per<AngularMomentumUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -632,23 +641,23 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularMomentumUnit, ResistanceUnit> divide(Resistance divisor) {
+  public Per<AngularMomentumUnit, ResistanceUnit> divide(Resistance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularMomentumUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
+  public Per<AngularMomentumUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularMomentumUnit, TemperatureUnit> times(Temperature multiplier) {
+  public Mult<AngularMomentumUnit, TemperatureUnit> times(Temperature multiplier) {
     return (Mult<AngularMomentumUnit, TemperatureUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularMomentumUnit, TemperatureUnit> div(Temperature divisor) {
+  public Per<AngularMomentumUnit, TemperatureUnit> div(Temperature divisor) {
     return (Per<AngularMomentumUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
@@ -660,23 +669,23 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularMomentumUnit, TemperatureUnit> divide(Temperature divisor) {
+  public Per<AngularMomentumUnit, TemperatureUnit> divide(Temperature divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularMomentumUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
+  public Per<AngularMomentumUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularMomentumUnit, TimeUnit> times(Time multiplier) {
+  public Mult<AngularMomentumUnit, TimeUnit> times(Time multiplier) {
     return (Mult<AngularMomentumUnit, TimeUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Velocity<AngularMomentumUnit> div(Time divisor) {
+  public Velocity<AngularMomentumUnit> div(Time divisor) {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -688,23 +697,23 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Velocity<AngularMomentumUnit> divide(Time divisor) {
+  public Velocity<AngularMomentumUnit> divide(Time divisor) {
     return div(divisor);
   }
 
   @Override
-  default Velocity<AngularMomentumUnit> per(TimeUnit divisorUnit) {
+  public Velocity<AngularMomentumUnit> per(TimeUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularMomentumUnit, TorqueUnit> times(Torque multiplier) {
+  public Mult<AngularMomentumUnit, TorqueUnit> times(Torque multiplier) {
     return (Mult<AngularMomentumUnit, TorqueUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularMomentumUnit, TorqueUnit> div(Torque divisor) {
+  public Per<AngularMomentumUnit, TorqueUnit> div(Torque divisor) {
     return (Per<AngularMomentumUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
@@ -716,23 +725,23 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularMomentumUnit, TorqueUnit> divide(Torque divisor) {
+  public Per<AngularMomentumUnit, TorqueUnit> divide(Torque divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularMomentumUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
+  public Per<AngularMomentumUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularMomentumUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+  public Mult<AngularMomentumUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
     return (Mult<AngularMomentumUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularMomentumUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
+  public Per<AngularMomentumUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
     return (Per<AngularMomentumUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -744,23 +753,23 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularMomentumUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+  public Per<AngularMomentumUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularMomentumUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
+  public Per<AngularMomentumUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularMomentumUnit, VoltageUnit> times(Voltage multiplier) {
+  public Mult<AngularMomentumUnit, VoltageUnit> times(Voltage multiplier) {
     return (Mult<AngularMomentumUnit, VoltageUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularMomentumUnit, VoltageUnit> div(Voltage divisor) {
+  public Per<AngularMomentumUnit, VoltageUnit> div(Voltage divisor) {
     return (Per<AngularMomentumUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
@@ -772,12 +781,12 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularMomentumUnit, VoltageUnit> divide(Voltage divisor) {
+  public Per<AngularMomentumUnit, VoltageUnit> divide(Voltage divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularMomentumUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
+  public Per<AngularMomentumUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularVelocity.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularVelocity.java
index 37b4a28d57..050a28edde 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularVelocity.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularVelocity.java
@@ -10,36 +10,45 @@ import static edu.wpi.first.units.Units.*;
 import edu.wpi.first.units.*;
 
 @SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public interface AngularVelocity extends Measure<AngularVelocityUnit> {
-  static  AngularVelocity ofRelativeUnits(double magnitude, AngularVelocityUnit unit) {
-    return new ImmutableAngularVelocity(magnitude, unit.toBaseUnits(magnitude), unit);
+public record AngularVelocity(double magnitude, double baseUnitMagnitude, AngularVelocityUnit unit) implements Measure<AngularVelocityUnit> {
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link AngularVelocityUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  AngularVelocity ofRelativeUnits(double magnitude, AngularVelocityUnit unit) {
+    return new AngularVelocity(magnitude, unit.toBaseUnits(magnitude), unit);
   }
 
-  static  AngularVelocity ofBaseUnits(double baseUnitMagnitude, AngularVelocityUnit unit) {
-    return new ImmutableAngularVelocity(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link AngularVelocityUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit's base unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  AngularVelocity ofBaseUnits(double baseUnitMagnitude, AngularVelocityUnit unit) {
+    return new AngularVelocity(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
   }
 
   @Override
-  AngularVelocity copy();
+  public AngularVelocityUnit baseUnit() { return (AngularVelocityUnit) unit().getBaseUnit(); }
 
   @Override
-  default MutAngularVelocity mutableCopy() {
-    return new MutAngularVelocity(magnitude(), baseUnitMagnitude(), unit());
-  }
-
-  @Override
-  AngularVelocityUnit unit();
-
-  @Override
-  default AngularVelocityUnit baseUnit() { return (AngularVelocityUnit) unit().getBaseUnit(); }
-
-  @Override
-  default double in(AngularVelocityUnit unit) {
+  public double in(AngularVelocityUnit unit) {
     return unit.fromBaseUnits(baseUnitMagnitude());
   }
 
   @Override
-  default AngularVelocity unaryMinus() {
+  @SuppressWarnings("rawtypes")
+  public boolean equals(Object object) {
+    return object instanceof AngularVelocity m && isEquivalent(m);
+  }
+
+  @Override
+  public AngularVelocity unaryMinus() {
     return (AngularVelocity) unit().ofBaseUnits(0 - baseUnitMagnitude());
   }
 
@@ -51,27 +60,27 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default AngularVelocity negate() {
+  public AngularVelocity negate() {
     return (AngularVelocity) unaryMinus();
   }
 
   @Override
-  default AngularVelocity plus(Measure<? extends AngularVelocityUnit> other) {
+  public AngularVelocity plus(Measure<? extends AngularVelocityUnit> other) {
     return (AngularVelocity) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
   }
 
   @Override
-  default AngularVelocity minus(Measure<? extends AngularVelocityUnit> other) {
+  public AngularVelocity minus(Measure<? extends AngularVelocityUnit> other) {
     return (AngularVelocity) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
   }
 
   @Override
-  default AngularVelocity times(double multiplier) {
+  public AngularVelocity times(double multiplier) {
     return (AngularVelocity) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
   }
 
   @Override
-  default AngularVelocity div(double divisor) {
+  public AngularVelocity div(double divisor) {
     return (AngularVelocity) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
@@ -83,18 +92,18 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default AngularVelocity divide(double divisor) {
+  public AngularVelocity divide(double divisor) {
     return (AngularVelocity) div(divisor);
   }
 
 
   @Override
-  default Mult<AngularVelocityUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+  public Mult<AngularVelocityUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
     return (Mult<AngularVelocityUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularVelocityUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
+  public Per<AngularVelocityUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
     return (Per<AngularVelocityUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -106,23 +115,23 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularVelocityUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+  public Per<AngularVelocityUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularVelocityUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
+  public Per<AngularVelocityUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularVelocityUnit, AngleUnit> times(Angle multiplier) {
+  public Mult<AngularVelocityUnit, AngleUnit> times(Angle multiplier) {
     return (Mult<AngularVelocityUnit, AngleUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularVelocityUnit, AngleUnit> div(Angle divisor) {
+  public Per<AngularVelocityUnit, AngleUnit> div(Angle divisor) {
     return (Per<AngularVelocityUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
@@ -134,23 +143,23 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularVelocityUnit, AngleUnit> divide(Angle divisor) {
+  public Per<AngularVelocityUnit, AngleUnit> divide(Angle divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularVelocityUnit, AngleUnit> per(AngleUnit divisorUnit) {
+  public Per<AngularVelocityUnit, AngleUnit> per(AngleUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularVelocityUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+  public Mult<AngularVelocityUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
     return (Mult<AngularVelocityUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularVelocityUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
+  public Per<AngularVelocityUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
     return (Per<AngularVelocityUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -162,23 +171,23 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularVelocityUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+  public Per<AngularVelocityUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularVelocityUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
+  public Per<AngularVelocityUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularVelocityUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+  public Mult<AngularVelocityUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
     return (Mult<AngularVelocityUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularVelocityUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
+  public Per<AngularVelocityUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
     return (Per<AngularVelocityUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -190,23 +199,23 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularVelocityUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+  public Per<AngularVelocityUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularVelocityUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
+  public Per<AngularVelocityUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularVelocityUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+  public Mult<AngularVelocityUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
     return (Mult<AngularVelocityUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Dimensionless div(AngularVelocity divisor) {
+  public Dimensionless div(AngularVelocity divisor) {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -218,23 +227,23 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Dimensionless divide(AngularVelocity divisor) {
+  public Dimensionless divide(AngularVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Dimensionless per(AngularVelocityUnit divisorUnit) {
+  public Dimensionless per(AngularVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularVelocityUnit, CurrentUnit> times(Current multiplier) {
+  public Mult<AngularVelocityUnit, CurrentUnit> times(Current multiplier) {
     return (Mult<AngularVelocityUnit, CurrentUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularVelocityUnit, CurrentUnit> div(Current divisor) {
+  public Per<AngularVelocityUnit, CurrentUnit> div(Current divisor) {
     return (Per<AngularVelocityUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
@@ -246,17 +255,17 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularVelocityUnit, CurrentUnit> divide(Current divisor) {
+  public Per<AngularVelocityUnit, CurrentUnit> divide(Current divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularVelocityUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
+  public Per<AngularVelocityUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
   @Override
-  default AngularVelocity div(Dimensionless divisor) {
+  public AngularVelocity div(Dimensionless divisor) {
     return (AngularVelocity) RadiansPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -268,23 +277,23 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default AngularVelocity divide(Dimensionless divisor) {
+  public AngularVelocity divide(Dimensionless divisor) {
     return (AngularVelocity) div(divisor);
   }
 
   @Override
-  default AngularVelocity times(Dimensionless multiplier) {
+  public AngularVelocity times(Dimensionless multiplier) {
     return (AngularVelocity) RadiansPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
 
   @Override
-  default Mult<AngularVelocityUnit, DistanceUnit> times(Distance multiplier) {
+  public Mult<AngularVelocityUnit, DistanceUnit> times(Distance multiplier) {
     return (Mult<AngularVelocityUnit, DistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularVelocityUnit, DistanceUnit> div(Distance divisor) {
+  public Per<AngularVelocityUnit, DistanceUnit> div(Distance divisor) {
     return (Per<AngularVelocityUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -296,23 +305,23 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularVelocityUnit, DistanceUnit> divide(Distance divisor) {
+  public Per<AngularVelocityUnit, DistanceUnit> divide(Distance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularVelocityUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
+  public Per<AngularVelocityUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularVelocityUnit, EnergyUnit> times(Energy multiplier) {
+  public Mult<AngularVelocityUnit, EnergyUnit> times(Energy multiplier) {
     return (Mult<AngularVelocityUnit, EnergyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularVelocityUnit, EnergyUnit> div(Energy divisor) {
+  public Per<AngularVelocityUnit, EnergyUnit> div(Energy divisor) {
     return (Per<AngularVelocityUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
@@ -324,23 +333,23 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularVelocityUnit, EnergyUnit> divide(Energy divisor) {
+  public Per<AngularVelocityUnit, EnergyUnit> divide(Energy divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularVelocityUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
+  public Per<AngularVelocityUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularVelocityUnit, ForceUnit> times(Force multiplier) {
+  public Mult<AngularVelocityUnit, ForceUnit> times(Force multiplier) {
     return (Mult<AngularVelocityUnit, ForceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularVelocityUnit, ForceUnit> div(Force divisor) {
+  public Per<AngularVelocityUnit, ForceUnit> div(Force divisor) {
     return (Per<AngularVelocityUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
@@ -352,23 +361,23 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularVelocityUnit, ForceUnit> divide(Force divisor) {
+  public Per<AngularVelocityUnit, ForceUnit> divide(Force divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularVelocityUnit, ForceUnit> per(ForceUnit divisorUnit) {
+  public Per<AngularVelocityUnit, ForceUnit> per(ForceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default AngularAcceleration times(Frequency multiplier) {
+  public AngularAcceleration times(Frequency multiplier) {
     return RadiansPerSecondPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<AngularVelocityUnit, FrequencyUnit> div(Frequency divisor) {
+  public Per<AngularVelocityUnit, FrequencyUnit> div(Frequency divisor) {
     return (Per<AngularVelocityUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
@@ -380,23 +389,23 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularVelocityUnit, FrequencyUnit> divide(Frequency divisor) {
+  public Per<AngularVelocityUnit, FrequencyUnit> divide(Frequency divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularVelocityUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
+  public Per<AngularVelocityUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularVelocityUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+  public Mult<AngularVelocityUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
     return (Mult<AngularVelocityUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularVelocityUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
+  public Per<AngularVelocityUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
     return (Per<AngularVelocityUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -408,23 +417,23 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularVelocityUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+  public Per<AngularVelocityUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularVelocityUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
+  public Per<AngularVelocityUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularVelocityUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+  public Mult<AngularVelocityUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
     return (Mult<AngularVelocityUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularVelocityUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
+  public Per<AngularVelocityUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
     return (Per<AngularVelocityUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -436,23 +445,23 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularVelocityUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+  public Per<AngularVelocityUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularVelocityUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
+  public Per<AngularVelocityUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularVelocityUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+  public Mult<AngularVelocityUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
     return (Mult<AngularVelocityUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularVelocityUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
+  public Per<AngularVelocityUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
     return (Per<AngularVelocityUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -464,23 +473,23 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularVelocityUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+  public Per<AngularVelocityUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularVelocityUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
+  public Per<AngularVelocityUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularVelocityUnit, MassUnit> times(Mass multiplier) {
+  public Mult<AngularVelocityUnit, MassUnit> times(Mass multiplier) {
     return (Mult<AngularVelocityUnit, MassUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularVelocityUnit, MassUnit> div(Mass divisor) {
+  public Per<AngularVelocityUnit, MassUnit> div(Mass divisor) {
     return (Per<AngularVelocityUnit, MassUnit>) Measure.super.div(divisor);
   }
 
@@ -492,23 +501,23 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularVelocityUnit, MassUnit> divide(Mass divisor) {
+  public Per<AngularVelocityUnit, MassUnit> divide(Mass divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularVelocityUnit, MassUnit> per(MassUnit divisorUnit) {
+  public Per<AngularVelocityUnit, MassUnit> per(MassUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularVelocityUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+  public Mult<AngularVelocityUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
     return (Mult<AngularVelocityUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularVelocityUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
+  public Per<AngularVelocityUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
     return (Per<AngularVelocityUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
@@ -520,23 +529,23 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularVelocityUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+  public Per<AngularVelocityUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularVelocityUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
+  public Per<AngularVelocityUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularVelocityUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+  public Mult<AngularVelocityUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
     return (Mult<AngularVelocityUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularVelocityUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
+  public Per<AngularVelocityUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
     return (Per<AngularVelocityUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -548,23 +557,23 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularVelocityUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+  public Per<AngularVelocityUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularVelocityUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
+  public Per<AngularVelocityUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<AngularVelocityUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+  public Mult<AngularVelocityUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
     return (Mult<AngularVelocityUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularVelocityUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
+  public Per<AngularVelocityUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
     return (Per<AngularVelocityUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -576,23 +585,23 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularVelocityUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+  public Per<AngularVelocityUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularVelocityUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
+  public Per<AngularVelocityUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<AngularVelocityUnit, PowerUnit> times(Power multiplier) {
+  public Mult<AngularVelocityUnit, PowerUnit> times(Power multiplier) {
     return (Mult<AngularVelocityUnit, PowerUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularVelocityUnit, PowerUnit> div(Power divisor) {
+  public Per<AngularVelocityUnit, PowerUnit> div(Power divisor) {
     return (Per<AngularVelocityUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
@@ -604,23 +613,23 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularVelocityUnit, PowerUnit> divide(Power divisor) {
+  public Per<AngularVelocityUnit, PowerUnit> divide(Power divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularVelocityUnit, PowerUnit> per(PowerUnit divisorUnit) {
+  public Per<AngularVelocityUnit, PowerUnit> per(PowerUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularVelocityUnit, ResistanceUnit> times(Resistance multiplier) {
+  public Mult<AngularVelocityUnit, ResistanceUnit> times(Resistance multiplier) {
     return (Mult<AngularVelocityUnit, ResistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularVelocityUnit, ResistanceUnit> div(Resistance divisor) {
+  public Per<AngularVelocityUnit, ResistanceUnit> div(Resistance divisor) {
     return (Per<AngularVelocityUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -632,23 +641,23 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularVelocityUnit, ResistanceUnit> divide(Resistance divisor) {
+  public Per<AngularVelocityUnit, ResistanceUnit> divide(Resistance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularVelocityUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
+  public Per<AngularVelocityUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularVelocityUnit, TemperatureUnit> times(Temperature multiplier) {
+  public Mult<AngularVelocityUnit, TemperatureUnit> times(Temperature multiplier) {
     return (Mult<AngularVelocityUnit, TemperatureUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularVelocityUnit, TemperatureUnit> div(Temperature divisor) {
+  public Per<AngularVelocityUnit, TemperatureUnit> div(Temperature divisor) {
     return (Per<AngularVelocityUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
@@ -660,23 +669,23 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularVelocityUnit, TemperatureUnit> divide(Temperature divisor) {
+  public Per<AngularVelocityUnit, TemperatureUnit> divide(Temperature divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularVelocityUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
+  public Per<AngularVelocityUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Angle times(Time multiplier) {
+  public Angle times(Time multiplier) {
     return Radians.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default AngularAcceleration div(Time divisor) {
+  public AngularAcceleration div(Time divisor) {
     return RadiansPerSecondPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -688,23 +697,23 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default AngularAcceleration divide(Time divisor) {
+  public AngularAcceleration divide(Time divisor) {
     return div(divisor);
   }
 
   @Override
-  default AngularAcceleration per(TimeUnit divisorUnit) {
+  public AngularAcceleration per(TimeUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularVelocityUnit, TorqueUnit> times(Torque multiplier) {
+  public Mult<AngularVelocityUnit, TorqueUnit> times(Torque multiplier) {
     return (Mult<AngularVelocityUnit, TorqueUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularVelocityUnit, TorqueUnit> div(Torque divisor) {
+  public Per<AngularVelocityUnit, TorqueUnit> div(Torque divisor) {
     return (Per<AngularVelocityUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
@@ -716,23 +725,23 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularVelocityUnit, TorqueUnit> divide(Torque divisor) {
+  public Per<AngularVelocityUnit, TorqueUnit> divide(Torque divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularVelocityUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
+  public Per<AngularVelocityUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularVelocityUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+  public Mult<AngularVelocityUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
     return (Mult<AngularVelocityUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularVelocityUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
+  public Per<AngularVelocityUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
     return (Per<AngularVelocityUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -744,23 +753,23 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularVelocityUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+  public Per<AngularVelocityUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularVelocityUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
+  public Per<AngularVelocityUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<AngularVelocityUnit, VoltageUnit> times(Voltage multiplier) {
+  public Mult<AngularVelocityUnit, VoltageUnit> times(Voltage multiplier) {
     return (Mult<AngularVelocityUnit, VoltageUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<AngularVelocityUnit, VoltageUnit> div(Voltage divisor) {
+  public Per<AngularVelocityUnit, VoltageUnit> div(Voltage divisor) {
     return (Per<AngularVelocityUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
@@ -772,13 +781,13 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<AngularVelocityUnit, VoltageUnit> divide(Voltage divisor) {
+  public Per<AngularVelocityUnit, VoltageUnit> divide(Voltage divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<AngularVelocityUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
+  public Per<AngularVelocityUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
     return div(divisorUnit.one());
   }
-default Frequency asFrequency() { return Hertz.of(baseUnitMagnitude()); }
+public Frequency asFrequency() { return Hertz.of(baseUnitMagnitude()); }
 }
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Current.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Current.java
index 734272a138..8b64da7aef 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Current.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Current.java
@@ -10,36 +10,45 @@ import static edu.wpi.first.units.Units.*;
 import edu.wpi.first.units.*;
 
 @SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public interface Current extends Measure<CurrentUnit> {
-  static  Current ofRelativeUnits(double magnitude, CurrentUnit unit) {
-    return new ImmutableCurrent(magnitude, unit.toBaseUnits(magnitude), unit);
+public record Current(double magnitude, double baseUnitMagnitude, CurrentUnit unit) implements Measure<CurrentUnit> {
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link CurrentUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  Current ofRelativeUnits(double magnitude, CurrentUnit unit) {
+    return new Current(magnitude, unit.toBaseUnits(magnitude), unit);
   }
 
-  static  Current ofBaseUnits(double baseUnitMagnitude, CurrentUnit unit) {
-    return new ImmutableCurrent(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link CurrentUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit's base unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  Current ofBaseUnits(double baseUnitMagnitude, CurrentUnit unit) {
+    return new Current(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
   }
 
   @Override
-  Current copy();
+  public CurrentUnit baseUnit() { return (CurrentUnit) unit().getBaseUnit(); }
 
   @Override
-  default MutCurrent mutableCopy() {
-    return new MutCurrent(magnitude(), baseUnitMagnitude(), unit());
-  }
-
-  @Override
-  CurrentUnit unit();
-
-  @Override
-  default CurrentUnit baseUnit() { return (CurrentUnit) unit().getBaseUnit(); }
-
-  @Override
-  default double in(CurrentUnit unit) {
+  public double in(CurrentUnit unit) {
     return unit.fromBaseUnits(baseUnitMagnitude());
   }
 
   @Override
-  default Current unaryMinus() {
+  @SuppressWarnings("rawtypes")
+  public boolean equals(Object object) {
+    return object instanceof Current m && isEquivalent(m);
+  }
+
+  @Override
+  public Current unaryMinus() {
     return (Current) unit().ofBaseUnits(0 - baseUnitMagnitude());
   }
 
@@ -51,27 +60,27 @@ public interface Current extends Measure<CurrentUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Current negate() {
+  public Current negate() {
     return (Current) unaryMinus();
   }
 
   @Override
-  default Current plus(Measure<? extends CurrentUnit> other) {
+  public Current plus(Measure<? extends CurrentUnit> other) {
     return (Current) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
   }
 
   @Override
-  default Current minus(Measure<? extends CurrentUnit> other) {
+  public Current minus(Measure<? extends CurrentUnit> other) {
     return (Current) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
   }
 
   @Override
-  default Current times(double multiplier) {
+  public Current times(double multiplier) {
     return (Current) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
   }
 
   @Override
-  default Current div(double divisor) {
+  public Current div(double divisor) {
     return (Current) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
@@ -83,18 +92,18 @@ public interface Current extends Measure<CurrentUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Current divide(double divisor) {
+  public Current divide(double divisor) {
     return (Current) div(divisor);
   }
 
 
   @Override
-  default Mult<CurrentUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+  public Mult<CurrentUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
     return (Mult<CurrentUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<CurrentUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
+  public Per<CurrentUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
     return (Per<CurrentUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -106,23 +115,23 @@ public interface Current extends Measure<CurrentUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<CurrentUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+  public Per<CurrentUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<CurrentUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
+  public Per<CurrentUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<CurrentUnit, AngleUnit> times(Angle multiplier) {
+  public Mult<CurrentUnit, AngleUnit> times(Angle multiplier) {
     return (Mult<CurrentUnit, AngleUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<CurrentUnit, AngleUnit> div(Angle divisor) {
+  public Per<CurrentUnit, AngleUnit> div(Angle divisor) {
     return (Per<CurrentUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
@@ -134,23 +143,23 @@ public interface Current extends Measure<CurrentUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<CurrentUnit, AngleUnit> divide(Angle divisor) {
+  public Per<CurrentUnit, AngleUnit> divide(Angle divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<CurrentUnit, AngleUnit> per(AngleUnit divisorUnit) {
+  public Per<CurrentUnit, AngleUnit> per(AngleUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<CurrentUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+  public Mult<CurrentUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
     return (Mult<CurrentUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<CurrentUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
+  public Per<CurrentUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
     return (Per<CurrentUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -162,23 +171,23 @@ public interface Current extends Measure<CurrentUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<CurrentUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+  public Per<CurrentUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<CurrentUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
+  public Per<CurrentUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<CurrentUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+  public Mult<CurrentUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
     return (Mult<CurrentUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<CurrentUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
+  public Per<CurrentUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
     return (Per<CurrentUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -190,23 +199,23 @@ public interface Current extends Measure<CurrentUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<CurrentUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+  public Per<CurrentUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<CurrentUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
+  public Per<CurrentUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<CurrentUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+  public Mult<CurrentUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
     return (Mult<CurrentUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<CurrentUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
+  public Per<CurrentUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
     return (Per<CurrentUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -218,23 +227,23 @@ public interface Current extends Measure<CurrentUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<CurrentUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+  public Per<CurrentUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<CurrentUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
+  public Per<CurrentUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<CurrentUnit, CurrentUnit> times(Current multiplier) {
+  public Mult<CurrentUnit, CurrentUnit> times(Current multiplier) {
     return (Mult<CurrentUnit, CurrentUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Dimensionless div(Current divisor) {
+  public Dimensionless div(Current divisor) {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -246,17 +255,17 @@ public interface Current extends Measure<CurrentUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Dimensionless divide(Current divisor) {
+  public Dimensionless divide(Current divisor) {
     return div(divisor);
   }
 
   @Override
-  default Dimensionless per(CurrentUnit divisorUnit) {
+  public Dimensionless per(CurrentUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
   @Override
-  default Current div(Dimensionless divisor) {
+  public Current div(Dimensionless divisor) {
     return (Current) Amps.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -268,23 +277,23 @@ public interface Current extends Measure<CurrentUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Current divide(Dimensionless divisor) {
+  public Current divide(Dimensionless divisor) {
     return (Current) div(divisor);
   }
 
   @Override
-  default Current times(Dimensionless multiplier) {
+  public Current times(Dimensionless multiplier) {
     return (Current) Amps.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
 
   @Override
-  default Mult<CurrentUnit, DistanceUnit> times(Distance multiplier) {
+  public Mult<CurrentUnit, DistanceUnit> times(Distance multiplier) {
     return (Mult<CurrentUnit, DistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<CurrentUnit, DistanceUnit> div(Distance divisor) {
+  public Per<CurrentUnit, DistanceUnit> div(Distance divisor) {
     return (Per<CurrentUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -296,23 +305,23 @@ public interface Current extends Measure<CurrentUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<CurrentUnit, DistanceUnit> divide(Distance divisor) {
+  public Per<CurrentUnit, DistanceUnit> divide(Distance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<CurrentUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
+  public Per<CurrentUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<CurrentUnit, EnergyUnit> times(Energy multiplier) {
+  public Mult<CurrentUnit, EnergyUnit> times(Energy multiplier) {
     return (Mult<CurrentUnit, EnergyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<CurrentUnit, EnergyUnit> div(Energy divisor) {
+  public Per<CurrentUnit, EnergyUnit> div(Energy divisor) {
     return (Per<CurrentUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
@@ -324,23 +333,23 @@ public interface Current extends Measure<CurrentUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<CurrentUnit, EnergyUnit> divide(Energy divisor) {
+  public Per<CurrentUnit, EnergyUnit> divide(Energy divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<CurrentUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
+  public Per<CurrentUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<CurrentUnit, ForceUnit> times(Force multiplier) {
+  public Mult<CurrentUnit, ForceUnit> times(Force multiplier) {
     return (Mult<CurrentUnit, ForceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<CurrentUnit, ForceUnit> div(Force divisor) {
+  public Per<CurrentUnit, ForceUnit> div(Force divisor) {
     return (Per<CurrentUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
@@ -352,23 +361,23 @@ public interface Current extends Measure<CurrentUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<CurrentUnit, ForceUnit> divide(Force divisor) {
+  public Per<CurrentUnit, ForceUnit> divide(Force divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<CurrentUnit, ForceUnit> per(ForceUnit divisorUnit) {
+  public Per<CurrentUnit, ForceUnit> per(ForceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<CurrentUnit, FrequencyUnit> times(Frequency multiplier) {
+  public Mult<CurrentUnit, FrequencyUnit> times(Frequency multiplier) {
     return (Mult<CurrentUnit, FrequencyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<CurrentUnit, FrequencyUnit> div(Frequency divisor) {
+  public Per<CurrentUnit, FrequencyUnit> div(Frequency divisor) {
     return (Per<CurrentUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
@@ -380,23 +389,23 @@ public interface Current extends Measure<CurrentUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<CurrentUnit, FrequencyUnit> divide(Frequency divisor) {
+  public Per<CurrentUnit, FrequencyUnit> divide(Frequency divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<CurrentUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
+  public Per<CurrentUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<CurrentUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+  public Mult<CurrentUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
     return (Mult<CurrentUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<CurrentUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
+  public Per<CurrentUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
     return (Per<CurrentUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -408,23 +417,23 @@ public interface Current extends Measure<CurrentUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<CurrentUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+  public Per<CurrentUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<CurrentUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
+  public Per<CurrentUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<CurrentUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+  public Mult<CurrentUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
     return (Mult<CurrentUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<CurrentUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
+  public Per<CurrentUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
     return (Per<CurrentUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -436,23 +445,23 @@ public interface Current extends Measure<CurrentUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<CurrentUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+  public Per<CurrentUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<CurrentUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
+  public Per<CurrentUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<CurrentUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+  public Mult<CurrentUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
     return (Mult<CurrentUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<CurrentUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
+  public Per<CurrentUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
     return (Per<CurrentUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -464,23 +473,23 @@ public interface Current extends Measure<CurrentUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<CurrentUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+  public Per<CurrentUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<CurrentUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
+  public Per<CurrentUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<CurrentUnit, MassUnit> times(Mass multiplier) {
+  public Mult<CurrentUnit, MassUnit> times(Mass multiplier) {
     return (Mult<CurrentUnit, MassUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<CurrentUnit, MassUnit> div(Mass divisor) {
+  public Per<CurrentUnit, MassUnit> div(Mass divisor) {
     return (Per<CurrentUnit, MassUnit>) Measure.super.div(divisor);
   }
 
@@ -492,23 +501,23 @@ public interface Current extends Measure<CurrentUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<CurrentUnit, MassUnit> divide(Mass divisor) {
+  public Per<CurrentUnit, MassUnit> divide(Mass divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<CurrentUnit, MassUnit> per(MassUnit divisorUnit) {
+  public Per<CurrentUnit, MassUnit> per(MassUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<CurrentUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+  public Mult<CurrentUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
     return (Mult<CurrentUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<CurrentUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
+  public Per<CurrentUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
     return (Per<CurrentUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
@@ -520,23 +529,23 @@ public interface Current extends Measure<CurrentUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<CurrentUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+  public Per<CurrentUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<CurrentUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
+  public Per<CurrentUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<CurrentUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+  public Mult<CurrentUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
     return (Mult<CurrentUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<CurrentUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
+  public Per<CurrentUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
     return (Per<CurrentUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -548,23 +557,23 @@ public interface Current extends Measure<CurrentUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<CurrentUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+  public Per<CurrentUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<CurrentUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
+  public Per<CurrentUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<CurrentUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+  public Mult<CurrentUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
     return (Mult<CurrentUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<CurrentUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
+  public Per<CurrentUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
     return (Per<CurrentUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -576,23 +585,23 @@ public interface Current extends Measure<CurrentUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<CurrentUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+  public Per<CurrentUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<CurrentUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
+  public Per<CurrentUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<CurrentUnit, PowerUnit> times(Power multiplier) {
+  public Mult<CurrentUnit, PowerUnit> times(Power multiplier) {
     return (Mult<CurrentUnit, PowerUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<CurrentUnit, PowerUnit> div(Power divisor) {
+  public Per<CurrentUnit, PowerUnit> div(Power divisor) {
     return (Per<CurrentUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
@@ -604,23 +613,23 @@ public interface Current extends Measure<CurrentUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<CurrentUnit, PowerUnit> divide(Power divisor) {
+  public Per<CurrentUnit, PowerUnit> divide(Power divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<CurrentUnit, PowerUnit> per(PowerUnit divisorUnit) {
+  public Per<CurrentUnit, PowerUnit> per(PowerUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Voltage times(Resistance multiplier) {
+  public Voltage times(Resistance multiplier) {
     return Volts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<CurrentUnit, ResistanceUnit> div(Resistance divisor) {
+  public Per<CurrentUnit, ResistanceUnit> div(Resistance divisor) {
     return (Per<CurrentUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -632,23 +641,23 @@ public interface Current extends Measure<CurrentUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<CurrentUnit, ResistanceUnit> divide(Resistance divisor) {
+  public Per<CurrentUnit, ResistanceUnit> divide(Resistance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<CurrentUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
+  public Per<CurrentUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<CurrentUnit, TemperatureUnit> times(Temperature multiplier) {
+  public Mult<CurrentUnit, TemperatureUnit> times(Temperature multiplier) {
     return (Mult<CurrentUnit, TemperatureUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<CurrentUnit, TemperatureUnit> div(Temperature divisor) {
+  public Per<CurrentUnit, TemperatureUnit> div(Temperature divisor) {
     return (Per<CurrentUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
@@ -660,23 +669,23 @@ public interface Current extends Measure<CurrentUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<CurrentUnit, TemperatureUnit> divide(Temperature divisor) {
+  public Per<CurrentUnit, TemperatureUnit> divide(Temperature divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<CurrentUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
+  public Per<CurrentUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<CurrentUnit, TimeUnit> times(Time multiplier) {
+  public Mult<CurrentUnit, TimeUnit> times(Time multiplier) {
     return (Mult<CurrentUnit, TimeUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Velocity<CurrentUnit> div(Time divisor) {
+  public Velocity<CurrentUnit> div(Time divisor) {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -688,23 +697,23 @@ public interface Current extends Measure<CurrentUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Velocity<CurrentUnit> divide(Time divisor) {
+  public Velocity<CurrentUnit> divide(Time divisor) {
     return div(divisor);
   }
 
   @Override
-  default Velocity<CurrentUnit> per(TimeUnit divisorUnit) {
+  public Velocity<CurrentUnit> per(TimeUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<CurrentUnit, TorqueUnit> times(Torque multiplier) {
+  public Mult<CurrentUnit, TorqueUnit> times(Torque multiplier) {
     return (Mult<CurrentUnit, TorqueUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<CurrentUnit, TorqueUnit> div(Torque divisor) {
+  public Per<CurrentUnit, TorqueUnit> div(Torque divisor) {
     return (Per<CurrentUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
@@ -716,23 +725,23 @@ public interface Current extends Measure<CurrentUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<CurrentUnit, TorqueUnit> divide(Torque divisor) {
+  public Per<CurrentUnit, TorqueUnit> divide(Torque divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<CurrentUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
+  public Per<CurrentUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<CurrentUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+  public Mult<CurrentUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
     return (Mult<CurrentUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<CurrentUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
+  public Per<CurrentUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
     return (Per<CurrentUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -744,23 +753,23 @@ public interface Current extends Measure<CurrentUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<CurrentUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+  public Per<CurrentUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<CurrentUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
+  public Per<CurrentUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Power times(Voltage multiplier) {
+  public Power times(Voltage multiplier) {
     return Watts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<CurrentUnit, VoltageUnit> div(Voltage divisor) {
+  public Per<CurrentUnit, VoltageUnit> div(Voltage divisor) {
     return (Per<CurrentUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
@@ -772,12 +781,12 @@ public interface Current extends Measure<CurrentUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<CurrentUnit, VoltageUnit> divide(Voltage divisor) {
+  public Per<CurrentUnit, VoltageUnit> divide(Voltage divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<CurrentUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
+  public Per<CurrentUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Dimensionless.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Dimensionless.java
index 4447c270ee..7cfe940dd5 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Dimensionless.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Dimensionless.java
@@ -10,36 +10,45 @@ import static edu.wpi.first.units.Units.*;
 import edu.wpi.first.units.*;
 
 @SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public interface Dimensionless extends Measure<DimensionlessUnit> {
-  static  Dimensionless ofRelativeUnits(double magnitude, DimensionlessUnit unit) {
-    return new ImmutableDimensionless(magnitude, unit.toBaseUnits(magnitude), unit);
+public record Dimensionless(double magnitude, double baseUnitMagnitude, DimensionlessUnit unit) implements Measure<DimensionlessUnit> {
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link DimensionlessUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  Dimensionless ofRelativeUnits(double magnitude, DimensionlessUnit unit) {
+    return new Dimensionless(magnitude, unit.toBaseUnits(magnitude), unit);
   }
 
-  static  Dimensionless ofBaseUnits(double baseUnitMagnitude, DimensionlessUnit unit) {
-    return new ImmutableDimensionless(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link DimensionlessUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit's base unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  Dimensionless ofBaseUnits(double baseUnitMagnitude, DimensionlessUnit unit) {
+    return new Dimensionless(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
   }
 
   @Override
-  Dimensionless copy();
+  public DimensionlessUnit baseUnit() { return (DimensionlessUnit) unit().getBaseUnit(); }
 
   @Override
-  default MutDimensionless mutableCopy() {
-    return new MutDimensionless(magnitude(), baseUnitMagnitude(), unit());
-  }
-
-  @Override
-  DimensionlessUnit unit();
-
-  @Override
-  default DimensionlessUnit baseUnit() { return (DimensionlessUnit) unit().getBaseUnit(); }
-
-  @Override
-  default double in(DimensionlessUnit unit) {
+  public double in(DimensionlessUnit unit) {
     return unit.fromBaseUnits(baseUnitMagnitude());
   }
 
   @Override
-  default Dimensionless unaryMinus() {
+  @SuppressWarnings("rawtypes")
+  public boolean equals(Object object) {
+    return object instanceof Dimensionless m && isEquivalent(m);
+  }
+
+  @Override
+  public Dimensionless unaryMinus() {
     return (Dimensionless) unit().ofBaseUnits(0 - baseUnitMagnitude());
   }
 
@@ -51,27 +60,27 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Dimensionless negate() {
+  public Dimensionless negate() {
     return (Dimensionless) unaryMinus();
   }
 
   @Override
-  default Dimensionless plus(Measure<? extends DimensionlessUnit> other) {
+  public Dimensionless plus(Measure<? extends DimensionlessUnit> other) {
     return (Dimensionless) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
   }
 
   @Override
-  default Dimensionless minus(Measure<? extends DimensionlessUnit> other) {
+  public Dimensionless minus(Measure<? extends DimensionlessUnit> other) {
     return (Dimensionless) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
   }
 
   @Override
-  default Dimensionless times(double multiplier) {
+  public Dimensionless times(double multiplier) {
     return (Dimensionless) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
   }
 
   @Override
-  default Dimensionless div(double divisor) {
+  public Dimensionless div(double divisor) {
     return (Dimensionless) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
@@ -83,18 +92,18 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Dimensionless divide(double divisor) {
+  public Dimensionless divide(double divisor) {
     return (Dimensionless) div(divisor);
   }
 
 
   @Override
-  default Mult<DimensionlessUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+  public Mult<DimensionlessUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
     return (Mult<DimensionlessUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<DimensionlessUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
+  public Per<DimensionlessUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
     return (Per<DimensionlessUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -106,23 +115,23 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DimensionlessUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+  public Per<DimensionlessUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DimensionlessUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
+  public Per<DimensionlessUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Angle times(Angle multiplier) {
+  public Angle times(Angle multiplier) {
     return Radians.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<DimensionlessUnit, AngleUnit> div(Angle divisor) {
+  public Per<DimensionlessUnit, AngleUnit> div(Angle divisor) {
     return (Per<DimensionlessUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
@@ -134,23 +143,23 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DimensionlessUnit, AngleUnit> divide(Angle divisor) {
+  public Per<DimensionlessUnit, AngleUnit> divide(Angle divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DimensionlessUnit, AngleUnit> per(AngleUnit divisorUnit) {
+  public Per<DimensionlessUnit, AngleUnit> per(AngleUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default AngularAcceleration times(AngularAcceleration multiplier) {
+  public AngularAcceleration times(AngularAcceleration multiplier) {
     return RadiansPerSecondPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<DimensionlessUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
+  public Per<DimensionlessUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
     return (Per<DimensionlessUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -162,23 +171,23 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DimensionlessUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+  public Per<DimensionlessUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DimensionlessUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
+  public Per<DimensionlessUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default AngularMomentum times(AngularMomentum multiplier) {
+  public AngularMomentum times(AngularMomentum multiplier) {
     return KilogramMetersSquaredPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<DimensionlessUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
+  public Per<DimensionlessUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
     return (Per<DimensionlessUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -190,23 +199,23 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DimensionlessUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+  public Per<DimensionlessUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DimensionlessUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
+  public Per<DimensionlessUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default AngularVelocity times(AngularVelocity multiplier) {
+  public AngularVelocity times(AngularVelocity multiplier) {
     return RadiansPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<DimensionlessUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
+  public Per<DimensionlessUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
     return (Per<DimensionlessUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -218,23 +227,23 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DimensionlessUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+  public Per<DimensionlessUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DimensionlessUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
+  public Per<DimensionlessUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Current times(Current multiplier) {
+  public Current times(Current multiplier) {
     return Amps.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<DimensionlessUnit, CurrentUnit> div(Current divisor) {
+  public Per<DimensionlessUnit, CurrentUnit> div(Current divisor) {
     return (Per<DimensionlessUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
@@ -246,17 +255,17 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DimensionlessUnit, CurrentUnit> divide(Current divisor) {
+  public Per<DimensionlessUnit, CurrentUnit> divide(Current divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DimensionlessUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
+  public Per<DimensionlessUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
   @Override
-  default Dimensionless div(Dimensionless divisor) {
+  public Dimensionless div(Dimensionless divisor) {
     return (Dimensionless) Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -268,23 +277,23 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Dimensionless divide(Dimensionless divisor) {
+  public Dimensionless divide(Dimensionless divisor) {
     return (Dimensionless) div(divisor);
   }
 
   @Override
-  default Dimensionless times(Dimensionless multiplier) {
+  public Dimensionless times(Dimensionless multiplier) {
     return (Dimensionless) Value.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
 
   @Override
-  default Distance times(Distance multiplier) {
+  public Distance times(Distance multiplier) {
     return Meters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<DimensionlessUnit, DistanceUnit> div(Distance divisor) {
+  public Per<DimensionlessUnit, DistanceUnit> div(Distance divisor) {
     return (Per<DimensionlessUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -296,23 +305,23 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DimensionlessUnit, DistanceUnit> divide(Distance divisor) {
+  public Per<DimensionlessUnit, DistanceUnit> divide(Distance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DimensionlessUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
+  public Per<DimensionlessUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Energy times(Energy multiplier) {
+  public Energy times(Energy multiplier) {
     return Joules.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<DimensionlessUnit, EnergyUnit> div(Energy divisor) {
+  public Per<DimensionlessUnit, EnergyUnit> div(Energy divisor) {
     return (Per<DimensionlessUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
@@ -324,23 +333,23 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DimensionlessUnit, EnergyUnit> divide(Energy divisor) {
+  public Per<DimensionlessUnit, EnergyUnit> divide(Energy divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DimensionlessUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
+  public Per<DimensionlessUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Force times(Force multiplier) {
+  public Force times(Force multiplier) {
     return Newtons.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<DimensionlessUnit, ForceUnit> div(Force divisor) {
+  public Per<DimensionlessUnit, ForceUnit> div(Force divisor) {
     return (Per<DimensionlessUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
@@ -352,23 +361,23 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DimensionlessUnit, ForceUnit> divide(Force divisor) {
+  public Per<DimensionlessUnit, ForceUnit> divide(Force divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DimensionlessUnit, ForceUnit> per(ForceUnit divisorUnit) {
+  public Per<DimensionlessUnit, ForceUnit> per(ForceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Frequency times(Frequency multiplier) {
+  public Frequency times(Frequency multiplier) {
     return Hertz.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<DimensionlessUnit, FrequencyUnit> div(Frequency divisor) {
+  public Per<DimensionlessUnit, FrequencyUnit> div(Frequency divisor) {
     return (Per<DimensionlessUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
@@ -380,23 +389,23 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DimensionlessUnit, FrequencyUnit> divide(Frequency divisor) {
+  public Per<DimensionlessUnit, FrequencyUnit> divide(Frequency divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DimensionlessUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
+  public Per<DimensionlessUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default LinearAcceleration times(LinearAcceleration multiplier) {
+  public LinearAcceleration times(LinearAcceleration multiplier) {
     return MetersPerSecondPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<DimensionlessUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
+  public Per<DimensionlessUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
     return (Per<DimensionlessUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -408,23 +417,23 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DimensionlessUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+  public Per<DimensionlessUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DimensionlessUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
+  public Per<DimensionlessUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default LinearMomentum times(LinearMomentum multiplier) {
+  public LinearMomentum times(LinearMomentum multiplier) {
     return KilogramMetersPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<DimensionlessUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
+  public Per<DimensionlessUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
     return (Per<DimensionlessUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -436,23 +445,23 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DimensionlessUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+  public Per<DimensionlessUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DimensionlessUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
+  public Per<DimensionlessUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default LinearVelocity times(LinearVelocity multiplier) {
+  public LinearVelocity times(LinearVelocity multiplier) {
     return MetersPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<DimensionlessUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
+  public Per<DimensionlessUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
     return (Per<DimensionlessUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -464,23 +473,23 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DimensionlessUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+  public Per<DimensionlessUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DimensionlessUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
+  public Per<DimensionlessUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mass times(Mass multiplier) {
+  public Mass times(Mass multiplier) {
     return Kilograms.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<DimensionlessUnit, MassUnit> div(Mass divisor) {
+  public Per<DimensionlessUnit, MassUnit> div(Mass divisor) {
     return (Per<DimensionlessUnit, MassUnit>) Measure.super.div(divisor);
   }
 
@@ -492,23 +501,23 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DimensionlessUnit, MassUnit> divide(Mass divisor) {
+  public Per<DimensionlessUnit, MassUnit> divide(Mass divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DimensionlessUnit, MassUnit> per(MassUnit divisorUnit) {
+  public Per<DimensionlessUnit, MassUnit> per(MassUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default MomentOfInertia times(MomentOfInertia multiplier) {
+  public MomentOfInertia times(MomentOfInertia multiplier) {
     return KilogramSquareMeters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<DimensionlessUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
+  public Per<DimensionlessUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
     return (Per<DimensionlessUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
@@ -520,23 +529,23 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DimensionlessUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+  public Per<DimensionlessUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DimensionlessUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
+  public Per<DimensionlessUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<DimensionlessUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+  public Mult<DimensionlessUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
     return (Mult<DimensionlessUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<DimensionlessUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
+  public Per<DimensionlessUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
     return (Per<DimensionlessUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -548,23 +557,23 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DimensionlessUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+  public Per<DimensionlessUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DimensionlessUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
+  public Per<DimensionlessUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<DimensionlessUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+  public Mult<DimensionlessUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
     return (Mult<DimensionlessUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<DimensionlessUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
+  public Per<DimensionlessUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
     return (Per<DimensionlessUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -576,23 +585,23 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DimensionlessUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+  public Per<DimensionlessUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DimensionlessUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
+  public Per<DimensionlessUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Power times(Power multiplier) {
+  public Power times(Power multiplier) {
     return Watts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<DimensionlessUnit, PowerUnit> div(Power divisor) {
+  public Per<DimensionlessUnit, PowerUnit> div(Power divisor) {
     return (Per<DimensionlessUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
@@ -604,23 +613,23 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DimensionlessUnit, PowerUnit> divide(Power divisor) {
+  public Per<DimensionlessUnit, PowerUnit> divide(Power divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DimensionlessUnit, PowerUnit> per(PowerUnit divisorUnit) {
+  public Per<DimensionlessUnit, PowerUnit> per(PowerUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Resistance times(Resistance multiplier) {
+  public Resistance times(Resistance multiplier) {
     return Ohms.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<DimensionlessUnit, ResistanceUnit> div(Resistance divisor) {
+  public Per<DimensionlessUnit, ResistanceUnit> div(Resistance divisor) {
     return (Per<DimensionlessUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -632,23 +641,23 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DimensionlessUnit, ResistanceUnit> divide(Resistance divisor) {
+  public Per<DimensionlessUnit, ResistanceUnit> divide(Resistance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DimensionlessUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
+  public Per<DimensionlessUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Temperature times(Temperature multiplier) {
+  public Temperature times(Temperature multiplier) {
     return Kelvin.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<DimensionlessUnit, TemperatureUnit> div(Temperature divisor) {
+  public Per<DimensionlessUnit, TemperatureUnit> div(Temperature divisor) {
     return (Per<DimensionlessUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
@@ -660,23 +669,23 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DimensionlessUnit, TemperatureUnit> divide(Temperature divisor) {
+  public Per<DimensionlessUnit, TemperatureUnit> divide(Temperature divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DimensionlessUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
+  public Per<DimensionlessUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Time times(Time multiplier) {
+  public Time times(Time multiplier) {
     return Seconds.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Frequency div(Time divisor) {
+  public Frequency div(Time divisor) {
     return Hertz.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -688,23 +697,23 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Frequency divide(Time divisor) {
+  public Frequency divide(Time divisor) {
     return div(divisor);
   }
 
   @Override
-  default Frequency per(TimeUnit divisorUnit) {
+  public Frequency per(TimeUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Torque times(Torque multiplier) {
+  public Torque times(Torque multiplier) {
     return NewtonMeters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<DimensionlessUnit, TorqueUnit> div(Torque divisor) {
+  public Per<DimensionlessUnit, TorqueUnit> div(Torque divisor) {
     return (Per<DimensionlessUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
@@ -716,23 +725,23 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DimensionlessUnit, TorqueUnit> divide(Torque divisor) {
+  public Per<DimensionlessUnit, TorqueUnit> divide(Torque divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DimensionlessUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
+  public Per<DimensionlessUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<DimensionlessUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+  public Mult<DimensionlessUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
     return (Mult<DimensionlessUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<DimensionlessUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
+  public Per<DimensionlessUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
     return (Per<DimensionlessUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -744,23 +753,23 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DimensionlessUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+  public Per<DimensionlessUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DimensionlessUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
+  public Per<DimensionlessUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Voltage times(Voltage multiplier) {
+  public Voltage times(Voltage multiplier) {
     return Volts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<DimensionlessUnit, VoltageUnit> div(Voltage divisor) {
+  public Per<DimensionlessUnit, VoltageUnit> div(Voltage divisor) {
     return (Per<DimensionlessUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
@@ -772,12 +781,12 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DimensionlessUnit, VoltageUnit> divide(Voltage divisor) {
+  public Per<DimensionlessUnit, VoltageUnit> divide(Voltage divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DimensionlessUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
+  public Per<DimensionlessUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Distance.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Distance.java
index e0f53a620e..3b044a463d 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Distance.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Distance.java
@@ -10,36 +10,45 @@ import static edu.wpi.first.units.Units.*;
 import edu.wpi.first.units.*;
 
 @SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public interface Distance extends Measure<DistanceUnit> {
-  static  Distance ofRelativeUnits(double magnitude, DistanceUnit unit) {
-    return new ImmutableDistance(magnitude, unit.toBaseUnits(magnitude), unit);
+public record Distance(double magnitude, double baseUnitMagnitude, DistanceUnit unit) implements Measure<DistanceUnit> {
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link DistanceUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  Distance ofRelativeUnits(double magnitude, DistanceUnit unit) {
+    return new Distance(magnitude, unit.toBaseUnits(magnitude), unit);
   }
 
-  static  Distance ofBaseUnits(double baseUnitMagnitude, DistanceUnit unit) {
-    return new ImmutableDistance(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link DistanceUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit's base unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  Distance ofBaseUnits(double baseUnitMagnitude, DistanceUnit unit) {
+    return new Distance(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
   }
 
   @Override
-  Distance copy();
+  public DistanceUnit baseUnit() { return (DistanceUnit) unit().getBaseUnit(); }
 
   @Override
-  default MutDistance mutableCopy() {
-    return new MutDistance(magnitude(), baseUnitMagnitude(), unit());
-  }
-
-  @Override
-  DistanceUnit unit();
-
-  @Override
-  default DistanceUnit baseUnit() { return (DistanceUnit) unit().getBaseUnit(); }
-
-  @Override
-  default double in(DistanceUnit unit) {
+  public double in(DistanceUnit unit) {
     return unit.fromBaseUnits(baseUnitMagnitude());
   }
 
   @Override
-  default Distance unaryMinus() {
+  @SuppressWarnings("rawtypes")
+  public boolean equals(Object object) {
+    return object instanceof Distance m && isEquivalent(m);
+  }
+
+  @Override
+  public Distance unaryMinus() {
     return (Distance) unit().ofBaseUnits(0 - baseUnitMagnitude());
   }
 
@@ -51,27 +60,27 @@ public interface Distance extends Measure<DistanceUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Distance negate() {
+  public Distance negate() {
     return (Distance) unaryMinus();
   }
 
   @Override
-  default Distance plus(Measure<? extends DistanceUnit> other) {
+  public Distance plus(Measure<? extends DistanceUnit> other) {
     return (Distance) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
   }
 
   @Override
-  default Distance minus(Measure<? extends DistanceUnit> other) {
+  public Distance minus(Measure<? extends DistanceUnit> other) {
     return (Distance) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
   }
 
   @Override
-  default Distance times(double multiplier) {
+  public Distance times(double multiplier) {
     return (Distance) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
   }
 
   @Override
-  default Distance div(double divisor) {
+  public Distance div(double divisor) {
     return (Distance) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
@@ -83,18 +92,18 @@ public interface Distance extends Measure<DistanceUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Distance divide(double divisor) {
+  public Distance divide(double divisor) {
     return (Distance) div(divisor);
   }
 
 
   @Override
-  default Mult<DistanceUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+  public Mult<DistanceUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
     return (Mult<DistanceUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<DistanceUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
+  public Per<DistanceUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
     return (Per<DistanceUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -106,23 +115,23 @@ public interface Distance extends Measure<DistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DistanceUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+  public Per<DistanceUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DistanceUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
+  public Per<DistanceUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<DistanceUnit, AngleUnit> times(Angle multiplier) {
+  public Mult<DistanceUnit, AngleUnit> times(Angle multiplier) {
     return (Mult<DistanceUnit, AngleUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<DistanceUnit, AngleUnit> div(Angle divisor) {
+  public Per<DistanceUnit, AngleUnit> div(Angle divisor) {
     return (Per<DistanceUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
@@ -134,23 +143,23 @@ public interface Distance extends Measure<DistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DistanceUnit, AngleUnit> divide(Angle divisor) {
+  public Per<DistanceUnit, AngleUnit> divide(Angle divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DistanceUnit, AngleUnit> per(AngleUnit divisorUnit) {
+  public Per<DistanceUnit, AngleUnit> per(AngleUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<DistanceUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+  public Mult<DistanceUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
     return (Mult<DistanceUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<DistanceUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
+  public Per<DistanceUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
     return (Per<DistanceUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -162,23 +171,23 @@ public interface Distance extends Measure<DistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DistanceUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+  public Per<DistanceUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DistanceUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
+  public Per<DistanceUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<DistanceUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+  public Mult<DistanceUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
     return (Mult<DistanceUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<DistanceUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
+  public Per<DistanceUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
     return (Per<DistanceUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -190,23 +199,23 @@ public interface Distance extends Measure<DistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DistanceUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+  public Per<DistanceUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DistanceUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
+  public Per<DistanceUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<DistanceUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+  public Mult<DistanceUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
     return (Mult<DistanceUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<DistanceUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
+  public Per<DistanceUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
     return (Per<DistanceUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -218,23 +227,23 @@ public interface Distance extends Measure<DistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DistanceUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+  public Per<DistanceUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DistanceUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
+  public Per<DistanceUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<DistanceUnit, CurrentUnit> times(Current multiplier) {
+  public Mult<DistanceUnit, CurrentUnit> times(Current multiplier) {
     return (Mult<DistanceUnit, CurrentUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<DistanceUnit, CurrentUnit> div(Current divisor) {
+  public Per<DistanceUnit, CurrentUnit> div(Current divisor) {
     return (Per<DistanceUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
@@ -246,17 +255,17 @@ public interface Distance extends Measure<DistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DistanceUnit, CurrentUnit> divide(Current divisor) {
+  public Per<DistanceUnit, CurrentUnit> divide(Current divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DistanceUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
+  public Per<DistanceUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
   @Override
-  default Distance div(Dimensionless divisor) {
+  public Distance div(Dimensionless divisor) {
     return (Distance) Meters.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -268,23 +277,23 @@ public interface Distance extends Measure<DistanceUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Distance divide(Dimensionless divisor) {
+  public Distance divide(Dimensionless divisor) {
     return (Distance) div(divisor);
   }
 
   @Override
-  default Distance times(Dimensionless multiplier) {
+  public Distance times(Dimensionless multiplier) {
     return (Distance) Meters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
 
   @Override
-  default Mult<DistanceUnit, DistanceUnit> times(Distance multiplier) {
+  public Mult<DistanceUnit, DistanceUnit> times(Distance multiplier) {
     return (Mult<DistanceUnit, DistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Dimensionless div(Distance divisor) {
+  public Dimensionless div(Distance divisor) {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -296,23 +305,23 @@ public interface Distance extends Measure<DistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Dimensionless divide(Distance divisor) {
+  public Dimensionless divide(Distance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Dimensionless per(DistanceUnit divisorUnit) {
+  public Dimensionless per(DistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<DistanceUnit, EnergyUnit> times(Energy multiplier) {
+  public Mult<DistanceUnit, EnergyUnit> times(Energy multiplier) {
     return (Mult<DistanceUnit, EnergyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<DistanceUnit, EnergyUnit> div(Energy divisor) {
+  public Per<DistanceUnit, EnergyUnit> div(Energy divisor) {
     return (Per<DistanceUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
@@ -324,23 +333,23 @@ public interface Distance extends Measure<DistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DistanceUnit, EnergyUnit> divide(Energy divisor) {
+  public Per<DistanceUnit, EnergyUnit> divide(Energy divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DistanceUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
+  public Per<DistanceUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Torque times(Force multiplier) {
+  public Torque times(Force multiplier) {
     return NewtonMeters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<DistanceUnit, ForceUnit> div(Force divisor) {
+  public Per<DistanceUnit, ForceUnit> div(Force divisor) {
     return (Per<DistanceUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
@@ -352,23 +361,23 @@ public interface Distance extends Measure<DistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DistanceUnit, ForceUnit> divide(Force divisor) {
+  public Per<DistanceUnit, ForceUnit> divide(Force divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DistanceUnit, ForceUnit> per(ForceUnit divisorUnit) {
+  public Per<DistanceUnit, ForceUnit> per(ForceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default LinearVelocity times(Frequency multiplier) {
+  public LinearVelocity times(Frequency multiplier) {
     return MetersPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<DistanceUnit, FrequencyUnit> div(Frequency divisor) {
+  public Per<DistanceUnit, FrequencyUnit> div(Frequency divisor) {
     return (Per<DistanceUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
@@ -380,23 +389,23 @@ public interface Distance extends Measure<DistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DistanceUnit, FrequencyUnit> divide(Frequency divisor) {
+  public Per<DistanceUnit, FrequencyUnit> divide(Frequency divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DistanceUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
+  public Per<DistanceUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<DistanceUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+  public Mult<DistanceUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
     return (Mult<DistanceUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<DistanceUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
+  public Per<DistanceUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
     return (Per<DistanceUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -408,23 +417,23 @@ public interface Distance extends Measure<DistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DistanceUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+  public Per<DistanceUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DistanceUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
+  public Per<DistanceUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<DistanceUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+  public Mult<DistanceUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
     return (Mult<DistanceUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<DistanceUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
+  public Per<DistanceUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
     return (Per<DistanceUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -436,23 +445,23 @@ public interface Distance extends Measure<DistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DistanceUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+  public Per<DistanceUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DistanceUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
+  public Per<DistanceUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<DistanceUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+  public Mult<DistanceUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
     return (Mult<DistanceUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Time div(LinearVelocity divisor) {
+  public Time div(LinearVelocity divisor) {
     return Seconds.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -464,23 +473,23 @@ public interface Distance extends Measure<DistanceUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Time divide(LinearVelocity divisor) {
+  public Time divide(LinearVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Time per(LinearVelocityUnit divisorUnit) {
+  public Time per(LinearVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<DistanceUnit, MassUnit> times(Mass multiplier) {
+  public Mult<DistanceUnit, MassUnit> times(Mass multiplier) {
     return (Mult<DistanceUnit, MassUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<DistanceUnit, MassUnit> div(Mass divisor) {
+  public Per<DistanceUnit, MassUnit> div(Mass divisor) {
     return (Per<DistanceUnit, MassUnit>) Measure.super.div(divisor);
   }
 
@@ -492,23 +501,23 @@ public interface Distance extends Measure<DistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DistanceUnit, MassUnit> divide(Mass divisor) {
+  public Per<DistanceUnit, MassUnit> divide(Mass divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DistanceUnit, MassUnit> per(MassUnit divisorUnit) {
+  public Per<DistanceUnit, MassUnit> per(MassUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<DistanceUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+  public Mult<DistanceUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
     return (Mult<DistanceUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<DistanceUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
+  public Per<DistanceUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
     return (Per<DistanceUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
@@ -520,23 +529,23 @@ public interface Distance extends Measure<DistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DistanceUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+  public Per<DistanceUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DistanceUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
+  public Per<DistanceUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<DistanceUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+  public Mult<DistanceUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
     return (Mult<DistanceUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<DistanceUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
+  public Per<DistanceUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
     return (Per<DistanceUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -548,23 +557,23 @@ public interface Distance extends Measure<DistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DistanceUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+  public Per<DistanceUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DistanceUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
+  public Per<DistanceUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<DistanceUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+  public Mult<DistanceUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
     return (Mult<DistanceUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<DistanceUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
+  public Per<DistanceUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
     return (Per<DistanceUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -576,23 +585,23 @@ public interface Distance extends Measure<DistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DistanceUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+  public Per<DistanceUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DistanceUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
+  public Per<DistanceUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<DistanceUnit, PowerUnit> times(Power multiplier) {
+  public Mult<DistanceUnit, PowerUnit> times(Power multiplier) {
     return (Mult<DistanceUnit, PowerUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<DistanceUnit, PowerUnit> div(Power divisor) {
+  public Per<DistanceUnit, PowerUnit> div(Power divisor) {
     return (Per<DistanceUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
@@ -604,23 +613,23 @@ public interface Distance extends Measure<DistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DistanceUnit, PowerUnit> divide(Power divisor) {
+  public Per<DistanceUnit, PowerUnit> divide(Power divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DistanceUnit, PowerUnit> per(PowerUnit divisorUnit) {
+  public Per<DistanceUnit, PowerUnit> per(PowerUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<DistanceUnit, ResistanceUnit> times(Resistance multiplier) {
+  public Mult<DistanceUnit, ResistanceUnit> times(Resistance multiplier) {
     return (Mult<DistanceUnit, ResistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<DistanceUnit, ResistanceUnit> div(Resistance divisor) {
+  public Per<DistanceUnit, ResistanceUnit> div(Resistance divisor) {
     return (Per<DistanceUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -632,23 +641,23 @@ public interface Distance extends Measure<DistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DistanceUnit, ResistanceUnit> divide(Resistance divisor) {
+  public Per<DistanceUnit, ResistanceUnit> divide(Resistance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DistanceUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
+  public Per<DistanceUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<DistanceUnit, TemperatureUnit> times(Temperature multiplier) {
+  public Mult<DistanceUnit, TemperatureUnit> times(Temperature multiplier) {
     return (Mult<DistanceUnit, TemperatureUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<DistanceUnit, TemperatureUnit> div(Temperature divisor) {
+  public Per<DistanceUnit, TemperatureUnit> div(Temperature divisor) {
     return (Per<DistanceUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
@@ -660,23 +669,23 @@ public interface Distance extends Measure<DistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DistanceUnit, TemperatureUnit> divide(Temperature divisor) {
+  public Per<DistanceUnit, TemperatureUnit> divide(Temperature divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DistanceUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
+  public Per<DistanceUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<DistanceUnit, TimeUnit> times(Time multiplier) {
+  public Mult<DistanceUnit, TimeUnit> times(Time multiplier) {
     return (Mult<DistanceUnit, TimeUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default LinearVelocity div(Time divisor) {
+  public LinearVelocity div(Time divisor) {
     return MetersPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -688,23 +697,23 @@ public interface Distance extends Measure<DistanceUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default LinearVelocity divide(Time divisor) {
+  public LinearVelocity divide(Time divisor) {
     return div(divisor);
   }
 
   @Override
-  default LinearVelocity per(TimeUnit divisorUnit) {
+  public LinearVelocity per(TimeUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<DistanceUnit, TorqueUnit> times(Torque multiplier) {
+  public Mult<DistanceUnit, TorqueUnit> times(Torque multiplier) {
     return (Mult<DistanceUnit, TorqueUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<DistanceUnit, TorqueUnit> div(Torque divisor) {
+  public Per<DistanceUnit, TorqueUnit> div(Torque divisor) {
     return (Per<DistanceUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
@@ -716,23 +725,23 @@ public interface Distance extends Measure<DistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DistanceUnit, TorqueUnit> divide(Torque divisor) {
+  public Per<DistanceUnit, TorqueUnit> divide(Torque divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DistanceUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
+  public Per<DistanceUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<DistanceUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+  public Mult<DistanceUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
     return (Mult<DistanceUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<DistanceUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
+  public Per<DistanceUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
     return (Per<DistanceUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -744,23 +753,23 @@ public interface Distance extends Measure<DistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DistanceUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+  public Per<DistanceUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DistanceUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
+  public Per<DistanceUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<DistanceUnit, VoltageUnit> times(Voltage multiplier) {
+  public Mult<DistanceUnit, VoltageUnit> times(Voltage multiplier) {
     return (Mult<DistanceUnit, VoltageUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<DistanceUnit, VoltageUnit> div(Voltage divisor) {
+  public Per<DistanceUnit, VoltageUnit> div(Voltage divisor) {
     return (Per<DistanceUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
@@ -772,12 +781,12 @@ public interface Distance extends Measure<DistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<DistanceUnit, VoltageUnit> divide(Voltage divisor) {
+  public Per<DistanceUnit, VoltageUnit> divide(Voltage divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<DistanceUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
+  public Per<DistanceUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Energy.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Energy.java
index a98f55d5a8..aa5515d77b 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Energy.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Energy.java
@@ -10,36 +10,45 @@ import static edu.wpi.first.units.Units.*;
 import edu.wpi.first.units.*;
 
 @SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public interface Energy extends Measure<EnergyUnit> {
-  static  Energy ofRelativeUnits(double magnitude, EnergyUnit unit) {
-    return new ImmutableEnergy(magnitude, unit.toBaseUnits(magnitude), unit);
+public record Energy(double magnitude, double baseUnitMagnitude, EnergyUnit unit) implements Measure<EnergyUnit> {
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link EnergyUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  Energy ofRelativeUnits(double magnitude, EnergyUnit unit) {
+    return new Energy(magnitude, unit.toBaseUnits(magnitude), unit);
   }
 
-  static  Energy ofBaseUnits(double baseUnitMagnitude, EnergyUnit unit) {
-    return new ImmutableEnergy(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link EnergyUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit's base unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  Energy ofBaseUnits(double baseUnitMagnitude, EnergyUnit unit) {
+    return new Energy(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
   }
 
   @Override
-  Energy copy();
+  public EnergyUnit baseUnit() { return (EnergyUnit) unit().getBaseUnit(); }
 
   @Override
-  default MutEnergy mutableCopy() {
-    return new MutEnergy(magnitude(), baseUnitMagnitude(), unit());
-  }
-
-  @Override
-  EnergyUnit unit();
-
-  @Override
-  default EnergyUnit baseUnit() { return (EnergyUnit) unit().getBaseUnit(); }
-
-  @Override
-  default double in(EnergyUnit unit) {
+  public double in(EnergyUnit unit) {
     return unit.fromBaseUnits(baseUnitMagnitude());
   }
 
   @Override
-  default Energy unaryMinus() {
+  @SuppressWarnings("rawtypes")
+  public boolean equals(Object object) {
+    return object instanceof Energy m && isEquivalent(m);
+  }
+
+  @Override
+  public Energy unaryMinus() {
     return (Energy) unit().ofBaseUnits(0 - baseUnitMagnitude());
   }
 
@@ -51,27 +60,27 @@ public interface Energy extends Measure<EnergyUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Energy negate() {
+  public Energy negate() {
     return (Energy) unaryMinus();
   }
 
   @Override
-  default Energy plus(Measure<? extends EnergyUnit> other) {
+  public Energy plus(Measure<? extends EnergyUnit> other) {
     return (Energy) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
   }
 
   @Override
-  default Energy minus(Measure<? extends EnergyUnit> other) {
+  public Energy minus(Measure<? extends EnergyUnit> other) {
     return (Energy) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
   }
 
   @Override
-  default Energy times(double multiplier) {
+  public Energy times(double multiplier) {
     return (Energy) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
   }
 
   @Override
-  default Energy div(double divisor) {
+  public Energy div(double divisor) {
     return (Energy) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
@@ -83,18 +92,18 @@ public interface Energy extends Measure<EnergyUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Energy divide(double divisor) {
+  public Energy divide(double divisor) {
     return (Energy) div(divisor);
   }
 
 
   @Override
-  default Mult<EnergyUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+  public Mult<EnergyUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
     return (Mult<EnergyUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<EnergyUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
+  public Per<EnergyUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
     return (Per<EnergyUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -106,23 +115,23 @@ public interface Energy extends Measure<EnergyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<EnergyUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+  public Per<EnergyUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<EnergyUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
+  public Per<EnergyUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<EnergyUnit, AngleUnit> times(Angle multiplier) {
+  public Mult<EnergyUnit, AngleUnit> times(Angle multiplier) {
     return (Mult<EnergyUnit, AngleUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<EnergyUnit, AngleUnit> div(Angle divisor) {
+  public Per<EnergyUnit, AngleUnit> div(Angle divisor) {
     return (Per<EnergyUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
@@ -134,23 +143,23 @@ public interface Energy extends Measure<EnergyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<EnergyUnit, AngleUnit> divide(Angle divisor) {
+  public Per<EnergyUnit, AngleUnit> divide(Angle divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<EnergyUnit, AngleUnit> per(AngleUnit divisorUnit) {
+  public Per<EnergyUnit, AngleUnit> per(AngleUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<EnergyUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+  public Mult<EnergyUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
     return (Mult<EnergyUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<EnergyUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
+  public Per<EnergyUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
     return (Per<EnergyUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -162,23 +171,23 @@ public interface Energy extends Measure<EnergyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<EnergyUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+  public Per<EnergyUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<EnergyUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
+  public Per<EnergyUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<EnergyUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+  public Mult<EnergyUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
     return (Mult<EnergyUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<EnergyUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
+  public Per<EnergyUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
     return (Per<EnergyUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -190,23 +199,23 @@ public interface Energy extends Measure<EnergyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<EnergyUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+  public Per<EnergyUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<EnergyUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
+  public Per<EnergyUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<EnergyUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+  public Mult<EnergyUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
     return (Mult<EnergyUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<EnergyUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
+  public Per<EnergyUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
     return (Per<EnergyUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -218,23 +227,23 @@ public interface Energy extends Measure<EnergyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<EnergyUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+  public Per<EnergyUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<EnergyUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
+  public Per<EnergyUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<EnergyUnit, CurrentUnit> times(Current multiplier) {
+  public Mult<EnergyUnit, CurrentUnit> times(Current multiplier) {
     return (Mult<EnergyUnit, CurrentUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<EnergyUnit, CurrentUnit> div(Current divisor) {
+  public Per<EnergyUnit, CurrentUnit> div(Current divisor) {
     return (Per<EnergyUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
@@ -246,17 +255,17 @@ public interface Energy extends Measure<EnergyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<EnergyUnit, CurrentUnit> divide(Current divisor) {
+  public Per<EnergyUnit, CurrentUnit> divide(Current divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<EnergyUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
+  public Per<EnergyUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
   @Override
-  default Energy div(Dimensionless divisor) {
+  public Energy div(Dimensionless divisor) {
     return (Energy) Joules.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -268,23 +277,23 @@ public interface Energy extends Measure<EnergyUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Energy divide(Dimensionless divisor) {
+  public Energy divide(Dimensionless divisor) {
     return (Energy) div(divisor);
   }
 
   @Override
-  default Energy times(Dimensionless multiplier) {
+  public Energy times(Dimensionless multiplier) {
     return (Energy) Joules.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
 
   @Override
-  default Mult<EnergyUnit, DistanceUnit> times(Distance multiplier) {
+  public Mult<EnergyUnit, DistanceUnit> times(Distance multiplier) {
     return (Mult<EnergyUnit, DistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<EnergyUnit, DistanceUnit> div(Distance divisor) {
+  public Per<EnergyUnit, DistanceUnit> div(Distance divisor) {
     return (Per<EnergyUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -296,23 +305,23 @@ public interface Energy extends Measure<EnergyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<EnergyUnit, DistanceUnit> divide(Distance divisor) {
+  public Per<EnergyUnit, DistanceUnit> divide(Distance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<EnergyUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
+  public Per<EnergyUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<EnergyUnit, EnergyUnit> times(Energy multiplier) {
+  public Mult<EnergyUnit, EnergyUnit> times(Energy multiplier) {
     return (Mult<EnergyUnit, EnergyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Dimensionless div(Energy divisor) {
+  public Dimensionless div(Energy divisor) {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -324,23 +333,23 @@ public interface Energy extends Measure<EnergyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Dimensionless divide(Energy divisor) {
+  public Dimensionless divide(Energy divisor) {
     return div(divisor);
   }
 
   @Override
-  default Dimensionless per(EnergyUnit divisorUnit) {
+  public Dimensionless per(EnergyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<EnergyUnit, ForceUnit> times(Force multiplier) {
+  public Mult<EnergyUnit, ForceUnit> times(Force multiplier) {
     return (Mult<EnergyUnit, ForceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<EnergyUnit, ForceUnit> div(Force divisor) {
+  public Per<EnergyUnit, ForceUnit> div(Force divisor) {
     return (Per<EnergyUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
@@ -352,23 +361,23 @@ public interface Energy extends Measure<EnergyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<EnergyUnit, ForceUnit> divide(Force divisor) {
+  public Per<EnergyUnit, ForceUnit> divide(Force divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<EnergyUnit, ForceUnit> per(ForceUnit divisorUnit) {
+  public Per<EnergyUnit, ForceUnit> per(ForceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Power times(Frequency multiplier) {
+  public Power times(Frequency multiplier) {
     return Watts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<EnergyUnit, FrequencyUnit> div(Frequency divisor) {
+  public Per<EnergyUnit, FrequencyUnit> div(Frequency divisor) {
     return (Per<EnergyUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
@@ -380,23 +389,23 @@ public interface Energy extends Measure<EnergyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<EnergyUnit, FrequencyUnit> divide(Frequency divisor) {
+  public Per<EnergyUnit, FrequencyUnit> divide(Frequency divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<EnergyUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
+  public Per<EnergyUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<EnergyUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+  public Mult<EnergyUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
     return (Mult<EnergyUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<EnergyUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
+  public Per<EnergyUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
     return (Per<EnergyUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -408,23 +417,23 @@ public interface Energy extends Measure<EnergyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<EnergyUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+  public Per<EnergyUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<EnergyUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
+  public Per<EnergyUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<EnergyUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+  public Mult<EnergyUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
     return (Mult<EnergyUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<EnergyUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
+  public Per<EnergyUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
     return (Per<EnergyUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -436,23 +445,23 @@ public interface Energy extends Measure<EnergyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<EnergyUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+  public Per<EnergyUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<EnergyUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
+  public Per<EnergyUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<EnergyUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+  public Mult<EnergyUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
     return (Mult<EnergyUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<EnergyUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
+  public Per<EnergyUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
     return (Per<EnergyUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -464,23 +473,23 @@ public interface Energy extends Measure<EnergyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<EnergyUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+  public Per<EnergyUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<EnergyUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
+  public Per<EnergyUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<EnergyUnit, MassUnit> times(Mass multiplier) {
+  public Mult<EnergyUnit, MassUnit> times(Mass multiplier) {
     return (Mult<EnergyUnit, MassUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<EnergyUnit, MassUnit> div(Mass divisor) {
+  public Per<EnergyUnit, MassUnit> div(Mass divisor) {
     return (Per<EnergyUnit, MassUnit>) Measure.super.div(divisor);
   }
 
@@ -492,23 +501,23 @@ public interface Energy extends Measure<EnergyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<EnergyUnit, MassUnit> divide(Mass divisor) {
+  public Per<EnergyUnit, MassUnit> divide(Mass divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<EnergyUnit, MassUnit> per(MassUnit divisorUnit) {
+  public Per<EnergyUnit, MassUnit> per(MassUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<EnergyUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+  public Mult<EnergyUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
     return (Mult<EnergyUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<EnergyUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
+  public Per<EnergyUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
     return (Per<EnergyUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
@@ -520,23 +529,23 @@ public interface Energy extends Measure<EnergyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<EnergyUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+  public Per<EnergyUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<EnergyUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
+  public Per<EnergyUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<EnergyUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+  public Mult<EnergyUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
     return (Mult<EnergyUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<EnergyUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
+  public Per<EnergyUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
     return (Per<EnergyUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -548,23 +557,23 @@ public interface Energy extends Measure<EnergyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<EnergyUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+  public Per<EnergyUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<EnergyUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
+  public Per<EnergyUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<EnergyUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+  public Mult<EnergyUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
     return (Mult<EnergyUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<EnergyUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
+  public Per<EnergyUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
     return (Per<EnergyUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -576,23 +585,23 @@ public interface Energy extends Measure<EnergyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<EnergyUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+  public Per<EnergyUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<EnergyUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
+  public Per<EnergyUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<EnergyUnit, PowerUnit> times(Power multiplier) {
+  public Mult<EnergyUnit, PowerUnit> times(Power multiplier) {
     return (Mult<EnergyUnit, PowerUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<EnergyUnit, PowerUnit> div(Power divisor) {
+  public Per<EnergyUnit, PowerUnit> div(Power divisor) {
     return (Per<EnergyUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
@@ -604,23 +613,23 @@ public interface Energy extends Measure<EnergyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<EnergyUnit, PowerUnit> divide(Power divisor) {
+  public Per<EnergyUnit, PowerUnit> divide(Power divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<EnergyUnit, PowerUnit> per(PowerUnit divisorUnit) {
+  public Per<EnergyUnit, PowerUnit> per(PowerUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<EnergyUnit, ResistanceUnit> times(Resistance multiplier) {
+  public Mult<EnergyUnit, ResistanceUnit> times(Resistance multiplier) {
     return (Mult<EnergyUnit, ResistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<EnergyUnit, ResistanceUnit> div(Resistance divisor) {
+  public Per<EnergyUnit, ResistanceUnit> div(Resistance divisor) {
     return (Per<EnergyUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -632,23 +641,23 @@ public interface Energy extends Measure<EnergyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<EnergyUnit, ResistanceUnit> divide(Resistance divisor) {
+  public Per<EnergyUnit, ResistanceUnit> divide(Resistance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<EnergyUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
+  public Per<EnergyUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<EnergyUnit, TemperatureUnit> times(Temperature multiplier) {
+  public Mult<EnergyUnit, TemperatureUnit> times(Temperature multiplier) {
     return (Mult<EnergyUnit, TemperatureUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<EnergyUnit, TemperatureUnit> div(Temperature divisor) {
+  public Per<EnergyUnit, TemperatureUnit> div(Temperature divisor) {
     return (Per<EnergyUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
@@ -660,23 +669,23 @@ public interface Energy extends Measure<EnergyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<EnergyUnit, TemperatureUnit> divide(Temperature divisor) {
+  public Per<EnergyUnit, TemperatureUnit> divide(Temperature divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<EnergyUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
+  public Per<EnergyUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<EnergyUnit, TimeUnit> times(Time multiplier) {
+  public Mult<EnergyUnit, TimeUnit> times(Time multiplier) {
     return (Mult<EnergyUnit, TimeUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Power div(Time divisor) {
+  public Power div(Time divisor) {
     return Watts.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -688,23 +697,23 @@ public interface Energy extends Measure<EnergyUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Power divide(Time divisor) {
+  public Power divide(Time divisor) {
     return div(divisor);
   }
 
   @Override
-  default Power per(TimeUnit divisorUnit) {
+  public Power per(TimeUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<EnergyUnit, TorqueUnit> times(Torque multiplier) {
+  public Mult<EnergyUnit, TorqueUnit> times(Torque multiplier) {
     return (Mult<EnergyUnit, TorqueUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<EnergyUnit, TorqueUnit> div(Torque divisor) {
+  public Per<EnergyUnit, TorqueUnit> div(Torque divisor) {
     return (Per<EnergyUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
@@ -716,23 +725,23 @@ public interface Energy extends Measure<EnergyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<EnergyUnit, TorqueUnit> divide(Torque divisor) {
+  public Per<EnergyUnit, TorqueUnit> divide(Torque divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<EnergyUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
+  public Per<EnergyUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<EnergyUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+  public Mult<EnergyUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
     return (Mult<EnergyUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<EnergyUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
+  public Per<EnergyUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
     return (Per<EnergyUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -744,23 +753,23 @@ public interface Energy extends Measure<EnergyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<EnergyUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+  public Per<EnergyUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<EnergyUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
+  public Per<EnergyUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<EnergyUnit, VoltageUnit> times(Voltage multiplier) {
+  public Mult<EnergyUnit, VoltageUnit> times(Voltage multiplier) {
     return (Mult<EnergyUnit, VoltageUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<EnergyUnit, VoltageUnit> div(Voltage divisor) {
+  public Per<EnergyUnit, VoltageUnit> div(Voltage divisor) {
     return (Per<EnergyUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
@@ -772,12 +781,12 @@ public interface Energy extends Measure<EnergyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<EnergyUnit, VoltageUnit> divide(Voltage divisor) {
+  public Per<EnergyUnit, VoltageUnit> divide(Voltage divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<EnergyUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
+  public Per<EnergyUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Force.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Force.java
index 0233742892..962296c1c9 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Force.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Force.java
@@ -10,36 +10,45 @@ import static edu.wpi.first.units.Units.*;
 import edu.wpi.first.units.*;
 
 @SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public interface Force extends Measure<ForceUnit> {
-  static  Force ofRelativeUnits(double magnitude, ForceUnit unit) {
-    return new ImmutableForce(magnitude, unit.toBaseUnits(magnitude), unit);
+public record Force(double magnitude, double baseUnitMagnitude, ForceUnit unit) implements Measure<ForceUnit> {
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link ForceUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  Force ofRelativeUnits(double magnitude, ForceUnit unit) {
+    return new Force(magnitude, unit.toBaseUnits(magnitude), unit);
   }
 
-  static  Force ofBaseUnits(double baseUnitMagnitude, ForceUnit unit) {
-    return new ImmutableForce(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link ForceUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit's base unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  Force ofBaseUnits(double baseUnitMagnitude, ForceUnit unit) {
+    return new Force(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
   }
 
   @Override
-  Force copy();
+  public ForceUnit baseUnit() { return (ForceUnit) unit().getBaseUnit(); }
 
   @Override
-  default MutForce mutableCopy() {
-    return new MutForce(magnitude(), baseUnitMagnitude(), unit());
-  }
-
-  @Override
-  ForceUnit unit();
-
-  @Override
-  default ForceUnit baseUnit() { return (ForceUnit) unit().getBaseUnit(); }
-
-  @Override
-  default double in(ForceUnit unit) {
+  public double in(ForceUnit unit) {
     return unit.fromBaseUnits(baseUnitMagnitude());
   }
 
   @Override
-  default Force unaryMinus() {
+  @SuppressWarnings("rawtypes")
+  public boolean equals(Object object) {
+    return object instanceof Force m && isEquivalent(m);
+  }
+
+  @Override
+  public Force unaryMinus() {
     return (Force) unit().ofBaseUnits(0 - baseUnitMagnitude());
   }
 
@@ -51,27 +60,27 @@ public interface Force extends Measure<ForceUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Force negate() {
+  public Force negate() {
     return (Force) unaryMinus();
   }
 
   @Override
-  default Force plus(Measure<? extends ForceUnit> other) {
+  public Force plus(Measure<? extends ForceUnit> other) {
     return (Force) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
   }
 
   @Override
-  default Force minus(Measure<? extends ForceUnit> other) {
+  public Force minus(Measure<? extends ForceUnit> other) {
     return (Force) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
   }
 
   @Override
-  default Force times(double multiplier) {
+  public Force times(double multiplier) {
     return (Force) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
   }
 
   @Override
-  default Force div(double divisor) {
+  public Force div(double divisor) {
     return (Force) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
@@ -83,18 +92,18 @@ public interface Force extends Measure<ForceUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Force divide(double divisor) {
+  public Force divide(double divisor) {
     return (Force) div(divisor);
   }
 
 
   @Override
-  default Mult<ForceUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+  public Mult<ForceUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
     return (Mult<ForceUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ForceUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
+  public Per<ForceUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
     return (Per<ForceUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -106,23 +115,23 @@ public interface Force extends Measure<ForceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ForceUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+  public Per<ForceUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ForceUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
+  public Per<ForceUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ForceUnit, AngleUnit> times(Angle multiplier) {
+  public Mult<ForceUnit, AngleUnit> times(Angle multiplier) {
     return (Mult<ForceUnit, AngleUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ForceUnit, AngleUnit> div(Angle divisor) {
+  public Per<ForceUnit, AngleUnit> div(Angle divisor) {
     return (Per<ForceUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
@@ -134,23 +143,23 @@ public interface Force extends Measure<ForceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ForceUnit, AngleUnit> divide(Angle divisor) {
+  public Per<ForceUnit, AngleUnit> divide(Angle divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ForceUnit, AngleUnit> per(AngleUnit divisorUnit) {
+  public Per<ForceUnit, AngleUnit> per(AngleUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ForceUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+  public Mult<ForceUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
     return (Mult<ForceUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ForceUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
+  public Per<ForceUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
     return (Per<ForceUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -162,23 +171,23 @@ public interface Force extends Measure<ForceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ForceUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+  public Per<ForceUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ForceUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
+  public Per<ForceUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ForceUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+  public Mult<ForceUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
     return (Mult<ForceUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ForceUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
+  public Per<ForceUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
     return (Per<ForceUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -190,23 +199,23 @@ public interface Force extends Measure<ForceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ForceUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+  public Per<ForceUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ForceUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
+  public Per<ForceUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ForceUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+  public Mult<ForceUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
     return (Mult<ForceUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ForceUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
+  public Per<ForceUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
     return (Per<ForceUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -218,23 +227,23 @@ public interface Force extends Measure<ForceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ForceUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+  public Per<ForceUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ForceUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
+  public Per<ForceUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ForceUnit, CurrentUnit> times(Current multiplier) {
+  public Mult<ForceUnit, CurrentUnit> times(Current multiplier) {
     return (Mult<ForceUnit, CurrentUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ForceUnit, CurrentUnit> div(Current divisor) {
+  public Per<ForceUnit, CurrentUnit> div(Current divisor) {
     return (Per<ForceUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
@@ -246,17 +255,17 @@ public interface Force extends Measure<ForceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ForceUnit, CurrentUnit> divide(Current divisor) {
+  public Per<ForceUnit, CurrentUnit> divide(Current divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ForceUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
+  public Per<ForceUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
   @Override
-  default Force div(Dimensionless divisor) {
+  public Force div(Dimensionless divisor) {
     return (Force) Newtons.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -268,23 +277,23 @@ public interface Force extends Measure<ForceUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Force divide(Dimensionless divisor) {
+  public Force divide(Dimensionless divisor) {
     return (Force) div(divisor);
   }
 
   @Override
-  default Force times(Dimensionless multiplier) {
+  public Force times(Dimensionless multiplier) {
     return (Force) Newtons.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
 
   @Override
-  default Energy times(Distance multiplier) {
+  public Energy times(Distance multiplier) {
     return Joules.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<ForceUnit, DistanceUnit> div(Distance divisor) {
+  public Per<ForceUnit, DistanceUnit> div(Distance divisor) {
     return (Per<ForceUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -296,23 +305,23 @@ public interface Force extends Measure<ForceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ForceUnit, DistanceUnit> divide(Distance divisor) {
+  public Per<ForceUnit, DistanceUnit> divide(Distance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ForceUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
+  public Per<ForceUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ForceUnit, EnergyUnit> times(Energy multiplier) {
+  public Mult<ForceUnit, EnergyUnit> times(Energy multiplier) {
     return (Mult<ForceUnit, EnergyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ForceUnit, EnergyUnit> div(Energy divisor) {
+  public Per<ForceUnit, EnergyUnit> div(Energy divisor) {
     return (Per<ForceUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
@@ -324,23 +333,23 @@ public interface Force extends Measure<ForceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ForceUnit, EnergyUnit> divide(Energy divisor) {
+  public Per<ForceUnit, EnergyUnit> divide(Energy divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ForceUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
+  public Per<ForceUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ForceUnit, ForceUnit> times(Force multiplier) {
+  public Mult<ForceUnit, ForceUnit> times(Force multiplier) {
     return (Mult<ForceUnit, ForceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Dimensionless div(Force divisor) {
+  public Dimensionless div(Force divisor) {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -352,23 +361,23 @@ public interface Force extends Measure<ForceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Dimensionless divide(Force divisor) {
+  public Dimensionless divide(Force divisor) {
     return div(divisor);
   }
 
   @Override
-  default Dimensionless per(ForceUnit divisorUnit) {
+  public Dimensionless per(ForceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ForceUnit, FrequencyUnit> times(Frequency multiplier) {
+  public Mult<ForceUnit, FrequencyUnit> times(Frequency multiplier) {
     return (Mult<ForceUnit, FrequencyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ForceUnit, FrequencyUnit> div(Frequency divisor) {
+  public Per<ForceUnit, FrequencyUnit> div(Frequency divisor) {
     return (Per<ForceUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
@@ -380,23 +389,23 @@ public interface Force extends Measure<ForceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ForceUnit, FrequencyUnit> divide(Frequency divisor) {
+  public Per<ForceUnit, FrequencyUnit> divide(Frequency divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ForceUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
+  public Per<ForceUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ForceUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+  public Mult<ForceUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
     return (Mult<ForceUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Mass div(LinearAcceleration divisor) {
+  public Mass div(LinearAcceleration divisor) {
     return Kilograms.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -408,23 +417,23 @@ public interface Force extends Measure<ForceUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Mass divide(LinearAcceleration divisor) {
+  public Mass divide(LinearAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Mass per(LinearAccelerationUnit divisorUnit) {
+  public Mass per(LinearAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ForceUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+  public Mult<ForceUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
     return (Mult<ForceUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ForceUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
+  public Per<ForceUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
     return (Per<ForceUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -436,23 +445,23 @@ public interface Force extends Measure<ForceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ForceUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+  public Per<ForceUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ForceUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
+  public Per<ForceUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ForceUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+  public Mult<ForceUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
     return (Mult<ForceUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ForceUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
+  public Per<ForceUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
     return (Per<ForceUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -464,23 +473,23 @@ public interface Force extends Measure<ForceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ForceUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+  public Per<ForceUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ForceUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
+  public Per<ForceUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ForceUnit, MassUnit> times(Mass multiplier) {
+  public Mult<ForceUnit, MassUnit> times(Mass multiplier) {
     return (Mult<ForceUnit, MassUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default LinearAcceleration div(Mass divisor) {
+  public LinearAcceleration div(Mass divisor) {
     return MetersPerSecondPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -492,23 +501,23 @@ public interface Force extends Measure<ForceUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default LinearAcceleration divide(Mass divisor) {
+  public LinearAcceleration divide(Mass divisor) {
     return div(divisor);
   }
 
   @Override
-  default LinearAcceleration per(MassUnit divisorUnit) {
+  public LinearAcceleration per(MassUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ForceUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+  public Mult<ForceUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
     return (Mult<ForceUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ForceUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
+  public Per<ForceUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
     return (Per<ForceUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
@@ -520,23 +529,23 @@ public interface Force extends Measure<ForceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ForceUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+  public Per<ForceUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ForceUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
+  public Per<ForceUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ForceUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+  public Mult<ForceUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
     return (Mult<ForceUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ForceUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
+  public Per<ForceUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
     return (Per<ForceUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -548,23 +557,23 @@ public interface Force extends Measure<ForceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ForceUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+  public Per<ForceUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ForceUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
+  public Per<ForceUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<ForceUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+  public Mult<ForceUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
     return (Mult<ForceUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ForceUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
+  public Per<ForceUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
     return (Per<ForceUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -576,23 +585,23 @@ public interface Force extends Measure<ForceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ForceUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+  public Per<ForceUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ForceUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
+  public Per<ForceUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<ForceUnit, PowerUnit> times(Power multiplier) {
+  public Mult<ForceUnit, PowerUnit> times(Power multiplier) {
     return (Mult<ForceUnit, PowerUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ForceUnit, PowerUnit> div(Power divisor) {
+  public Per<ForceUnit, PowerUnit> div(Power divisor) {
     return (Per<ForceUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
@@ -604,23 +613,23 @@ public interface Force extends Measure<ForceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ForceUnit, PowerUnit> divide(Power divisor) {
+  public Per<ForceUnit, PowerUnit> divide(Power divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ForceUnit, PowerUnit> per(PowerUnit divisorUnit) {
+  public Per<ForceUnit, PowerUnit> per(PowerUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ForceUnit, ResistanceUnit> times(Resistance multiplier) {
+  public Mult<ForceUnit, ResistanceUnit> times(Resistance multiplier) {
     return (Mult<ForceUnit, ResistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ForceUnit, ResistanceUnit> div(Resistance divisor) {
+  public Per<ForceUnit, ResistanceUnit> div(Resistance divisor) {
     return (Per<ForceUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -632,23 +641,23 @@ public interface Force extends Measure<ForceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ForceUnit, ResistanceUnit> divide(Resistance divisor) {
+  public Per<ForceUnit, ResistanceUnit> divide(Resistance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ForceUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
+  public Per<ForceUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ForceUnit, TemperatureUnit> times(Temperature multiplier) {
+  public Mult<ForceUnit, TemperatureUnit> times(Temperature multiplier) {
     return (Mult<ForceUnit, TemperatureUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ForceUnit, TemperatureUnit> div(Temperature divisor) {
+  public Per<ForceUnit, TemperatureUnit> div(Temperature divisor) {
     return (Per<ForceUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
@@ -660,23 +669,23 @@ public interface Force extends Measure<ForceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ForceUnit, TemperatureUnit> divide(Temperature divisor) {
+  public Per<ForceUnit, TemperatureUnit> divide(Temperature divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ForceUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
+  public Per<ForceUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ForceUnit, TimeUnit> times(Time multiplier) {
+  public Mult<ForceUnit, TimeUnit> times(Time multiplier) {
     return (Mult<ForceUnit, TimeUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Velocity<ForceUnit> div(Time divisor) {
+  public Velocity<ForceUnit> div(Time divisor) {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -688,23 +697,23 @@ public interface Force extends Measure<ForceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Velocity<ForceUnit> divide(Time divisor) {
+  public Velocity<ForceUnit> divide(Time divisor) {
     return div(divisor);
   }
 
   @Override
-  default Velocity<ForceUnit> per(TimeUnit divisorUnit) {
+  public Velocity<ForceUnit> per(TimeUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ForceUnit, TorqueUnit> times(Torque multiplier) {
+  public Mult<ForceUnit, TorqueUnit> times(Torque multiplier) {
     return (Mult<ForceUnit, TorqueUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ForceUnit, TorqueUnit> div(Torque divisor) {
+  public Per<ForceUnit, TorqueUnit> div(Torque divisor) {
     return (Per<ForceUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
@@ -716,23 +725,23 @@ public interface Force extends Measure<ForceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ForceUnit, TorqueUnit> divide(Torque divisor) {
+  public Per<ForceUnit, TorqueUnit> divide(Torque divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ForceUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
+  public Per<ForceUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ForceUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+  public Mult<ForceUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
     return (Mult<ForceUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ForceUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
+  public Per<ForceUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
     return (Per<ForceUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -744,23 +753,23 @@ public interface Force extends Measure<ForceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ForceUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+  public Per<ForceUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ForceUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
+  public Per<ForceUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ForceUnit, VoltageUnit> times(Voltage multiplier) {
+  public Mult<ForceUnit, VoltageUnit> times(Voltage multiplier) {
     return (Mult<ForceUnit, VoltageUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ForceUnit, VoltageUnit> div(Voltage divisor) {
+  public Per<ForceUnit, VoltageUnit> div(Voltage divisor) {
     return (Per<ForceUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
@@ -772,12 +781,12 @@ public interface Force extends Measure<ForceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ForceUnit, VoltageUnit> divide(Voltage divisor) {
+  public Per<ForceUnit, VoltageUnit> divide(Voltage divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ForceUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
+  public Per<ForceUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Frequency.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Frequency.java
index d18973a84d..336ccab0fb 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Frequency.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Frequency.java
@@ -10,36 +10,45 @@ import static edu.wpi.first.units.Units.*;
 import edu.wpi.first.units.*;
 
 @SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public interface Frequency extends Measure<FrequencyUnit> {
-  static  Frequency ofRelativeUnits(double magnitude, FrequencyUnit unit) {
-    return new ImmutableFrequency(magnitude, unit.toBaseUnits(magnitude), unit);
+public record Frequency(double magnitude, double baseUnitMagnitude, FrequencyUnit unit) implements Measure<FrequencyUnit> {
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link FrequencyUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  Frequency ofRelativeUnits(double magnitude, FrequencyUnit unit) {
+    return new Frequency(magnitude, unit.toBaseUnits(magnitude), unit);
   }
 
-  static  Frequency ofBaseUnits(double baseUnitMagnitude, FrequencyUnit unit) {
-    return new ImmutableFrequency(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link FrequencyUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit's base unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  Frequency ofBaseUnits(double baseUnitMagnitude, FrequencyUnit unit) {
+    return new Frequency(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
   }
 
   @Override
-  Frequency copy();
+  public FrequencyUnit baseUnit() { return (FrequencyUnit) unit().getBaseUnit(); }
 
   @Override
-  default MutFrequency mutableCopy() {
-    return new MutFrequency(magnitude(), baseUnitMagnitude(), unit());
-  }
-
-  @Override
-  FrequencyUnit unit();
-
-  @Override
-  default FrequencyUnit baseUnit() { return (FrequencyUnit) unit().getBaseUnit(); }
-
-  @Override
-  default double in(FrequencyUnit unit) {
+  public double in(FrequencyUnit unit) {
     return unit.fromBaseUnits(baseUnitMagnitude());
   }
 
   @Override
-  default Frequency unaryMinus() {
+  @SuppressWarnings("rawtypes")
+  public boolean equals(Object object) {
+    return object instanceof Frequency m && isEquivalent(m);
+  }
+
+  @Override
+  public Frequency unaryMinus() {
     return (Frequency) unit().ofBaseUnits(0 - baseUnitMagnitude());
   }
 
@@ -51,27 +60,27 @@ public interface Frequency extends Measure<FrequencyUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Frequency negate() {
+  public Frequency negate() {
     return (Frequency) unaryMinus();
   }
 
   @Override
-  default Frequency plus(Measure<? extends FrequencyUnit> other) {
+  public Frequency plus(Measure<? extends FrequencyUnit> other) {
     return (Frequency) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
   }
 
   @Override
-  default Frequency minus(Measure<? extends FrequencyUnit> other) {
+  public Frequency minus(Measure<? extends FrequencyUnit> other) {
     return (Frequency) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
   }
 
   @Override
-  default Frequency times(double multiplier) {
+  public Frequency times(double multiplier) {
     return (Frequency) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
   }
 
   @Override
-  default Frequency div(double divisor) {
+  public Frequency div(double divisor) {
     return (Frequency) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
@@ -83,18 +92,18 @@ public interface Frequency extends Measure<FrequencyUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Frequency divide(double divisor) {
+  public Frequency divide(double divisor) {
     return (Frequency) div(divisor);
   }
 
 
   @Override
-  default Mult<FrequencyUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+  public Mult<FrequencyUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
     return (Mult<FrequencyUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<FrequencyUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
+  public Per<FrequencyUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
     return (Per<FrequencyUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -106,23 +115,23 @@ public interface Frequency extends Measure<FrequencyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<FrequencyUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+  public Per<FrequencyUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<FrequencyUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
+  public Per<FrequencyUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default AngularVelocity times(Angle multiplier) {
+  public AngularVelocity times(Angle multiplier) {
     return RadiansPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<FrequencyUnit, AngleUnit> div(Angle divisor) {
+  public Per<FrequencyUnit, AngleUnit> div(Angle divisor) {
     return (Per<FrequencyUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
@@ -134,23 +143,23 @@ public interface Frequency extends Measure<FrequencyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<FrequencyUnit, AngleUnit> divide(Angle divisor) {
+  public Per<FrequencyUnit, AngleUnit> divide(Angle divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<FrequencyUnit, AngleUnit> per(AngleUnit divisorUnit) {
+  public Per<FrequencyUnit, AngleUnit> per(AngleUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<FrequencyUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+  public Mult<FrequencyUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
     return (Mult<FrequencyUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<FrequencyUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
+  public Per<FrequencyUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
     return (Per<FrequencyUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -162,23 +171,23 @@ public interface Frequency extends Measure<FrequencyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<FrequencyUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+  public Per<FrequencyUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<FrequencyUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
+  public Per<FrequencyUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<FrequencyUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+  public Mult<FrequencyUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
     return (Mult<FrequencyUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<FrequencyUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
+  public Per<FrequencyUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
     return (Per<FrequencyUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -190,23 +199,23 @@ public interface Frequency extends Measure<FrequencyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<FrequencyUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+  public Per<FrequencyUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<FrequencyUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
+  public Per<FrequencyUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default AngularAcceleration times(AngularVelocity multiplier) {
+  public AngularAcceleration times(AngularVelocity multiplier) {
     return RadiansPerSecondPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<FrequencyUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
+  public Per<FrequencyUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
     return (Per<FrequencyUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -218,23 +227,23 @@ public interface Frequency extends Measure<FrequencyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<FrequencyUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+  public Per<FrequencyUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<FrequencyUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
+  public Per<FrequencyUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<FrequencyUnit, CurrentUnit> times(Current multiplier) {
+  public Mult<FrequencyUnit, CurrentUnit> times(Current multiplier) {
     return (Mult<FrequencyUnit, CurrentUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<FrequencyUnit, CurrentUnit> div(Current divisor) {
+  public Per<FrequencyUnit, CurrentUnit> div(Current divisor) {
     return (Per<FrequencyUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
@@ -246,17 +255,17 @@ public interface Frequency extends Measure<FrequencyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<FrequencyUnit, CurrentUnit> divide(Current divisor) {
+  public Per<FrequencyUnit, CurrentUnit> divide(Current divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<FrequencyUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
+  public Per<FrequencyUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
   @Override
-  default Frequency div(Dimensionless divisor) {
+  public Frequency div(Dimensionless divisor) {
     return (Frequency) Hertz.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -268,23 +277,23 @@ public interface Frequency extends Measure<FrequencyUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Frequency divide(Dimensionless divisor) {
+  public Frequency divide(Dimensionless divisor) {
     return (Frequency) div(divisor);
   }
 
   @Override
-  default Frequency times(Dimensionless multiplier) {
+  public Frequency times(Dimensionless multiplier) {
     return (Frequency) Hertz.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
 
   @Override
-  default LinearVelocity times(Distance multiplier) {
+  public LinearVelocity times(Distance multiplier) {
     return MetersPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<FrequencyUnit, DistanceUnit> div(Distance divisor) {
+  public Per<FrequencyUnit, DistanceUnit> div(Distance divisor) {
     return (Per<FrequencyUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -296,23 +305,23 @@ public interface Frequency extends Measure<FrequencyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<FrequencyUnit, DistanceUnit> divide(Distance divisor) {
+  public Per<FrequencyUnit, DistanceUnit> divide(Distance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<FrequencyUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
+  public Per<FrequencyUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<FrequencyUnit, EnergyUnit> times(Energy multiplier) {
+  public Mult<FrequencyUnit, EnergyUnit> times(Energy multiplier) {
     return (Mult<FrequencyUnit, EnergyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<FrequencyUnit, EnergyUnit> div(Energy divisor) {
+  public Per<FrequencyUnit, EnergyUnit> div(Energy divisor) {
     return (Per<FrequencyUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
@@ -324,23 +333,23 @@ public interface Frequency extends Measure<FrequencyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<FrequencyUnit, EnergyUnit> divide(Energy divisor) {
+  public Per<FrequencyUnit, EnergyUnit> divide(Energy divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<FrequencyUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
+  public Per<FrequencyUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<FrequencyUnit, ForceUnit> times(Force multiplier) {
+  public Mult<FrequencyUnit, ForceUnit> times(Force multiplier) {
     return (Mult<FrequencyUnit, ForceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<FrequencyUnit, ForceUnit> div(Force divisor) {
+  public Per<FrequencyUnit, ForceUnit> div(Force divisor) {
     return (Per<FrequencyUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
@@ -352,23 +361,23 @@ public interface Frequency extends Measure<FrequencyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<FrequencyUnit, ForceUnit> divide(Force divisor) {
+  public Per<FrequencyUnit, ForceUnit> divide(Force divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<FrequencyUnit, ForceUnit> per(ForceUnit divisorUnit) {
+  public Per<FrequencyUnit, ForceUnit> per(ForceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<FrequencyUnit, FrequencyUnit> times(Frequency multiplier) {
+  public Mult<FrequencyUnit, FrequencyUnit> times(Frequency multiplier) {
     return (Mult<FrequencyUnit, FrequencyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Dimensionless div(Frequency divisor) {
+  public Dimensionless div(Frequency divisor) {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -380,23 +389,23 @@ public interface Frequency extends Measure<FrequencyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Dimensionless divide(Frequency divisor) {
+  public Dimensionless divide(Frequency divisor) {
     return div(divisor);
   }
 
   @Override
-  default Dimensionless per(FrequencyUnit divisorUnit) {
+  public Dimensionless per(FrequencyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<FrequencyUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+  public Mult<FrequencyUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
     return (Mult<FrequencyUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<FrequencyUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
+  public Per<FrequencyUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
     return (Per<FrequencyUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -408,23 +417,23 @@ public interface Frequency extends Measure<FrequencyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<FrequencyUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+  public Per<FrequencyUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<FrequencyUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
+  public Per<FrequencyUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<FrequencyUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+  public Mult<FrequencyUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
     return (Mult<FrequencyUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<FrequencyUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
+  public Per<FrequencyUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
     return (Per<FrequencyUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -436,23 +445,23 @@ public interface Frequency extends Measure<FrequencyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<FrequencyUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+  public Per<FrequencyUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<FrequencyUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
+  public Per<FrequencyUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default LinearAcceleration times(LinearVelocity multiplier) {
+  public LinearAcceleration times(LinearVelocity multiplier) {
     return MetersPerSecondPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<FrequencyUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
+  public Per<FrequencyUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
     return (Per<FrequencyUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -464,23 +473,23 @@ public interface Frequency extends Measure<FrequencyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<FrequencyUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+  public Per<FrequencyUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<FrequencyUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
+  public Per<FrequencyUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<FrequencyUnit, MassUnit> times(Mass multiplier) {
+  public Mult<FrequencyUnit, MassUnit> times(Mass multiplier) {
     return (Mult<FrequencyUnit, MassUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<FrequencyUnit, MassUnit> div(Mass divisor) {
+  public Per<FrequencyUnit, MassUnit> div(Mass divisor) {
     return (Per<FrequencyUnit, MassUnit>) Measure.super.div(divisor);
   }
 
@@ -492,23 +501,23 @@ public interface Frequency extends Measure<FrequencyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<FrequencyUnit, MassUnit> divide(Mass divisor) {
+  public Per<FrequencyUnit, MassUnit> divide(Mass divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<FrequencyUnit, MassUnit> per(MassUnit divisorUnit) {
+  public Per<FrequencyUnit, MassUnit> per(MassUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<FrequencyUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+  public Mult<FrequencyUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
     return (Mult<FrequencyUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<FrequencyUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
+  public Per<FrequencyUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
     return (Per<FrequencyUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
@@ -520,23 +529,23 @@ public interface Frequency extends Measure<FrequencyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<FrequencyUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+  public Per<FrequencyUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<FrequencyUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
+  public Per<FrequencyUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<FrequencyUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+  public Mult<FrequencyUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
     return (Mult<FrequencyUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<FrequencyUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
+  public Per<FrequencyUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
     return (Per<FrequencyUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -548,23 +557,23 @@ public interface Frequency extends Measure<FrequencyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<FrequencyUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+  public Per<FrequencyUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<FrequencyUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
+  public Per<FrequencyUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<FrequencyUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+  public Mult<FrequencyUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
     return (Mult<FrequencyUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<FrequencyUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
+  public Per<FrequencyUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
     return (Per<FrequencyUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -576,23 +585,23 @@ public interface Frequency extends Measure<FrequencyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<FrequencyUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+  public Per<FrequencyUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<FrequencyUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
+  public Per<FrequencyUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<FrequencyUnit, PowerUnit> times(Power multiplier) {
+  public Mult<FrequencyUnit, PowerUnit> times(Power multiplier) {
     return (Mult<FrequencyUnit, PowerUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<FrequencyUnit, PowerUnit> div(Power divisor) {
+  public Per<FrequencyUnit, PowerUnit> div(Power divisor) {
     return (Per<FrequencyUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
@@ -604,23 +613,23 @@ public interface Frequency extends Measure<FrequencyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<FrequencyUnit, PowerUnit> divide(Power divisor) {
+  public Per<FrequencyUnit, PowerUnit> divide(Power divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<FrequencyUnit, PowerUnit> per(PowerUnit divisorUnit) {
+  public Per<FrequencyUnit, PowerUnit> per(PowerUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<FrequencyUnit, ResistanceUnit> times(Resistance multiplier) {
+  public Mult<FrequencyUnit, ResistanceUnit> times(Resistance multiplier) {
     return (Mult<FrequencyUnit, ResistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<FrequencyUnit, ResistanceUnit> div(Resistance divisor) {
+  public Per<FrequencyUnit, ResistanceUnit> div(Resistance divisor) {
     return (Per<FrequencyUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -632,23 +641,23 @@ public interface Frequency extends Measure<FrequencyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<FrequencyUnit, ResistanceUnit> divide(Resistance divisor) {
+  public Per<FrequencyUnit, ResistanceUnit> divide(Resistance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<FrequencyUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
+  public Per<FrequencyUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<FrequencyUnit, TemperatureUnit> times(Temperature multiplier) {
+  public Mult<FrequencyUnit, TemperatureUnit> times(Temperature multiplier) {
     return (Mult<FrequencyUnit, TemperatureUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<FrequencyUnit, TemperatureUnit> div(Temperature divisor) {
+  public Per<FrequencyUnit, TemperatureUnit> div(Temperature divisor) {
     return (Per<FrequencyUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
@@ -660,23 +669,23 @@ public interface Frequency extends Measure<FrequencyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<FrequencyUnit, TemperatureUnit> divide(Temperature divisor) {
+  public Per<FrequencyUnit, TemperatureUnit> divide(Temperature divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<FrequencyUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
+  public Per<FrequencyUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Dimensionless times(Time multiplier) {
+  public Dimensionless times(Time multiplier) {
     return Value.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Velocity<FrequencyUnit> div(Time divisor) {
+  public Velocity<FrequencyUnit> div(Time divisor) {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -688,23 +697,23 @@ public interface Frequency extends Measure<FrequencyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Velocity<FrequencyUnit> divide(Time divisor) {
+  public Velocity<FrequencyUnit> divide(Time divisor) {
     return div(divisor);
   }
 
   @Override
-  default Velocity<FrequencyUnit> per(TimeUnit divisorUnit) {
+  public Velocity<FrequencyUnit> per(TimeUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<FrequencyUnit, TorqueUnit> times(Torque multiplier) {
+  public Mult<FrequencyUnit, TorqueUnit> times(Torque multiplier) {
     return (Mult<FrequencyUnit, TorqueUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<FrequencyUnit, TorqueUnit> div(Torque divisor) {
+  public Per<FrequencyUnit, TorqueUnit> div(Torque divisor) {
     return (Per<FrequencyUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
@@ -716,23 +725,23 @@ public interface Frequency extends Measure<FrequencyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<FrequencyUnit, TorqueUnit> divide(Torque divisor) {
+  public Per<FrequencyUnit, TorqueUnit> divide(Torque divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<FrequencyUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
+  public Per<FrequencyUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<FrequencyUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+  public Mult<FrequencyUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
     return (Mult<FrequencyUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<FrequencyUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
+  public Per<FrequencyUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
     return (Per<FrequencyUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -744,23 +753,23 @@ public interface Frequency extends Measure<FrequencyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<FrequencyUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+  public Per<FrequencyUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<FrequencyUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
+  public Per<FrequencyUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<FrequencyUnit, VoltageUnit> times(Voltage multiplier) {
+  public Mult<FrequencyUnit, VoltageUnit> times(Voltage multiplier) {
     return (Mult<FrequencyUnit, VoltageUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<FrequencyUnit, VoltageUnit> div(Voltage divisor) {
+  public Per<FrequencyUnit, VoltageUnit> div(Voltage divisor) {
     return (Per<FrequencyUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
@@ -772,14 +781,14 @@ public interface Frequency extends Measure<FrequencyUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<FrequencyUnit, VoltageUnit> divide(Voltage divisor) {
+  public Per<FrequencyUnit, VoltageUnit> divide(Voltage divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<FrequencyUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
+  public Per<FrequencyUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 /** Converts this frequency to the time period between cycles. */
-default Time asPeriod() { return Seconds.of(1 / baseUnitMagnitude()); }
+public Time asPeriod() { return Seconds.of(1 / baseUnitMagnitude()); }
 }
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAcceleration.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAcceleration.java
deleted file mode 100644
index ab6f0449bf..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAcceleration.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public record ImmutableAcceleration<D extends Unit>(double magnitude, double baseUnitMagnitude, AccelerationUnit<D> unit) implements Acceleration<D> {
-  @Override
-  public Acceleration<D> copy() {
-    return this;
-  }
-
-  @Override
-  public String toString() {
-    return toShortString();
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    return o instanceof Measure<?> m && isEquivalent(m);
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAngle.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAngle.java
deleted file mode 100644
index 352e19ea38..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAngle.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public record ImmutableAngle(double magnitude, double baseUnitMagnitude, AngleUnit unit) implements Angle {
-  @Override
-  public Angle copy() {
-    return this;
-  }
-
-  @Override
-  public String toString() {
-    return toShortString();
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    return o instanceof Measure<?> m && isEquivalent(m);
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAngularAcceleration.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAngularAcceleration.java
deleted file mode 100644
index 0c417e08c6..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAngularAcceleration.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public record ImmutableAngularAcceleration(double magnitude, double baseUnitMagnitude, AngularAccelerationUnit unit) implements AngularAcceleration {
-  @Override
-  public AngularAcceleration copy() {
-    return this;
-  }
-
-  @Override
-  public String toString() {
-    return toShortString();
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    return o instanceof Measure<?> m && isEquivalent(m);
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAngularMomentum.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAngularMomentum.java
deleted file mode 100644
index 7d00dd669e..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAngularMomentum.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public record ImmutableAngularMomentum(double magnitude, double baseUnitMagnitude, AngularMomentumUnit unit) implements AngularMomentum {
-  @Override
-  public AngularMomentum copy() {
-    return this;
-  }
-
-  @Override
-  public String toString() {
-    return toShortString();
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    return o instanceof Measure<?> m && isEquivalent(m);
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAngularVelocity.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAngularVelocity.java
deleted file mode 100644
index c692a116d5..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAngularVelocity.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public record ImmutableAngularVelocity(double magnitude, double baseUnitMagnitude, AngularVelocityUnit unit) implements AngularVelocity {
-  @Override
-  public AngularVelocity copy() {
-    return this;
-  }
-
-  @Override
-  public String toString() {
-    return toShortString();
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    return o instanceof Measure<?> m && isEquivalent(m);
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableCurrent.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableCurrent.java
deleted file mode 100644
index 8710f57efe..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableCurrent.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public record ImmutableCurrent(double magnitude, double baseUnitMagnitude, CurrentUnit unit) implements Current {
-  @Override
-  public Current copy() {
-    return this;
-  }
-
-  @Override
-  public String toString() {
-    return toShortString();
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    return o instanceof Measure<?> m && isEquivalent(m);
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableDimensionless.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableDimensionless.java
deleted file mode 100644
index 455bd2b402..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableDimensionless.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public record ImmutableDimensionless(double magnitude, double baseUnitMagnitude, DimensionlessUnit unit) implements Dimensionless {
-  @Override
-  public Dimensionless copy() {
-    return this;
-  }
-
-  @Override
-  public String toString() {
-    return toShortString();
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    return o instanceof Measure<?> m && isEquivalent(m);
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableDistance.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableDistance.java
deleted file mode 100644
index f919782236..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableDistance.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public record ImmutableDistance(double magnitude, double baseUnitMagnitude, DistanceUnit unit) implements Distance {
-  @Override
-  public Distance copy() {
-    return this;
-  }
-
-  @Override
-  public String toString() {
-    return toShortString();
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    return o instanceof Measure<?> m && isEquivalent(m);
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableEnergy.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableEnergy.java
deleted file mode 100644
index 7e443075b0..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableEnergy.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public record ImmutableEnergy(double magnitude, double baseUnitMagnitude, EnergyUnit unit) implements Energy {
-  @Override
-  public Energy copy() {
-    return this;
-  }
-
-  @Override
-  public String toString() {
-    return toShortString();
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    return o instanceof Measure<?> m && isEquivalent(m);
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableForce.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableForce.java
deleted file mode 100644
index 14f11ec7a1..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableForce.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public record ImmutableForce(double magnitude, double baseUnitMagnitude, ForceUnit unit) implements Force {
-  @Override
-  public Force copy() {
-    return this;
-  }
-
-  @Override
-  public String toString() {
-    return toShortString();
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    return o instanceof Measure<?> m && isEquivalent(m);
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableFrequency.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableFrequency.java
deleted file mode 100644
index f9084ed569..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableFrequency.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public record ImmutableFrequency(double magnitude, double baseUnitMagnitude, FrequencyUnit unit) implements Frequency {
-  @Override
-  public Frequency copy() {
-    return this;
-  }
-
-  @Override
-  public String toString() {
-    return toShortString();
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    return o instanceof Measure<?> m && isEquivalent(m);
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableLinearAcceleration.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableLinearAcceleration.java
deleted file mode 100644
index 3212588d05..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableLinearAcceleration.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public record ImmutableLinearAcceleration(double magnitude, double baseUnitMagnitude, LinearAccelerationUnit unit) implements LinearAcceleration {
-  @Override
-  public LinearAcceleration copy() {
-    return this;
-  }
-
-  @Override
-  public String toString() {
-    return toShortString();
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    return o instanceof Measure<?> m && isEquivalent(m);
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableLinearMomentum.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableLinearMomentum.java
deleted file mode 100644
index 0d7afd654b..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableLinearMomentum.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public record ImmutableLinearMomentum(double magnitude, double baseUnitMagnitude, LinearMomentumUnit unit) implements LinearMomentum {
-  @Override
-  public LinearMomentum copy() {
-    return this;
-  }
-
-  @Override
-  public String toString() {
-    return toShortString();
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    return o instanceof Measure<?> m && isEquivalent(m);
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableLinearVelocity.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableLinearVelocity.java
deleted file mode 100644
index 7373307d39..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableLinearVelocity.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public record ImmutableLinearVelocity(double magnitude, double baseUnitMagnitude, LinearVelocityUnit unit) implements LinearVelocity {
-  @Override
-  public LinearVelocity copy() {
-    return this;
-  }
-
-  @Override
-  public String toString() {
-    return toShortString();
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    return o instanceof Measure<?> m && isEquivalent(m);
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableMass.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableMass.java
deleted file mode 100644
index c74ad2711a..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableMass.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public record ImmutableMass(double magnitude, double baseUnitMagnitude, MassUnit unit) implements Mass {
-  @Override
-  public Mass copy() {
-    return this;
-  }
-
-  @Override
-  public String toString() {
-    return toShortString();
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    return o instanceof Measure<?> m && isEquivalent(m);
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableMomentOfInertia.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableMomentOfInertia.java
deleted file mode 100644
index ea903c7652..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableMomentOfInertia.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public record ImmutableMomentOfInertia(double magnitude, double baseUnitMagnitude, MomentOfInertiaUnit unit) implements MomentOfInertia {
-  @Override
-  public MomentOfInertia copy() {
-    return this;
-  }
-
-  @Override
-  public String toString() {
-    return toShortString();
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    return o instanceof Measure<?> m && isEquivalent(m);
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableMult.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableMult.java
deleted file mode 100644
index fc69825ee4..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableMult.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public record ImmutableMult<A extends Unit, B extends Unit>(double magnitude, double baseUnitMagnitude, MultUnit<A, B> unit) implements Mult<A, B> {
-  @Override
-  public Mult<A, B> copy() {
-    return this;
-  }
-
-  @Override
-  public String toString() {
-    return toShortString();
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    return o instanceof Measure<?> m && isEquivalent(m);
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutablePer.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutablePer.java
deleted file mode 100644
index 3d9ad1fe14..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutablePer.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public record ImmutablePer<Dividend extends Unit, Divisor extends Unit>(double magnitude, double baseUnitMagnitude, PerUnit<Dividend, Divisor> unit) implements Per<Dividend, Divisor> {
-  @Override
-  public Per<Dividend, Divisor> copy() {
-    return this;
-  }
-
-  @Override
-  public String toString() {
-    return toShortString();
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    return o instanceof Measure<?> m && isEquivalent(m);
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutablePower.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutablePower.java
deleted file mode 100644
index 0c7ffc0d95..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutablePower.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public record ImmutablePower(double magnitude, double baseUnitMagnitude, PowerUnit unit) implements Power {
-  @Override
-  public Power copy() {
-    return this;
-  }
-
-  @Override
-  public String toString() {
-    return toShortString();
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    return o instanceof Measure<?> m && isEquivalent(m);
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableResistance.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableResistance.java
deleted file mode 100644
index 34b780e7d3..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableResistance.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public record ImmutableResistance(double magnitude, double baseUnitMagnitude, ResistanceUnit unit) implements Resistance {
-  @Override
-  public Resistance copy() {
-    return this;
-  }
-
-  @Override
-  public String toString() {
-    return toShortString();
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    return o instanceof Measure<?> m && isEquivalent(m);
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableTemperature.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableTemperature.java
deleted file mode 100644
index e035d80922..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableTemperature.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public record ImmutableTemperature(double magnitude, double baseUnitMagnitude, TemperatureUnit unit) implements Temperature {
-  @Override
-  public Temperature copy() {
-    return this;
-  }
-
-  @Override
-  public String toString() {
-    return toShortString();
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    return o instanceof Measure<?> m && isEquivalent(m);
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableTime.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableTime.java
deleted file mode 100644
index 1230d92028..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableTime.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public record ImmutableTime(double magnitude, double baseUnitMagnitude, TimeUnit unit) implements Time {
-  @Override
-  public Time copy() {
-    return this;
-  }
-
-  @Override
-  public String toString() {
-    return toShortString();
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    return o instanceof Measure<?> m && isEquivalent(m);
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableTorque.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableTorque.java
deleted file mode 100644
index 7c756e75dc..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableTorque.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public record ImmutableTorque(double magnitude, double baseUnitMagnitude, TorqueUnit unit) implements Torque {
-  @Override
-  public Torque copy() {
-    return this;
-  }
-
-  @Override
-  public String toString() {
-    return toShortString();
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    return o instanceof Measure<?> m && isEquivalent(m);
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableVelocity.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableVelocity.java
deleted file mode 100644
index 89256f9d05..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableVelocity.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public record ImmutableVelocity<D extends Unit>(double magnitude, double baseUnitMagnitude, VelocityUnit<D> unit) implements Velocity<D> {
-  @Override
-  public Velocity<D> copy() {
-    return this;
-  }
-
-  @Override
-  public String toString() {
-    return toShortString();
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    return o instanceof Measure<?> m && isEquivalent(m);
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableVoltage.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableVoltage.java
deleted file mode 100644
index ca5dfebbf3..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableVoltage.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public record ImmutableVoltage(double magnitude, double baseUnitMagnitude, VoltageUnit unit) implements Voltage {
-  @Override
-  public Voltage copy() {
-    return this;
-  }
-
-  @Override
-  public String toString() {
-    return toShortString();
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    return o instanceof Measure<?> m && isEquivalent(m);
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearAcceleration.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearAcceleration.java
index 875ef937b1..e4589cd159 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearAcceleration.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearAcceleration.java
@@ -10,36 +10,45 @@ import static edu.wpi.first.units.Units.*;
 import edu.wpi.first.units.*;
 
 @SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
-  static  LinearAcceleration ofRelativeUnits(double magnitude, LinearAccelerationUnit unit) {
-    return new ImmutableLinearAcceleration(magnitude, unit.toBaseUnits(magnitude), unit);
+public record LinearAcceleration(double magnitude, double baseUnitMagnitude, LinearAccelerationUnit unit) implements Measure<LinearAccelerationUnit> {
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link LinearAccelerationUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  LinearAcceleration ofRelativeUnits(double magnitude, LinearAccelerationUnit unit) {
+    return new LinearAcceleration(magnitude, unit.toBaseUnits(magnitude), unit);
   }
 
-  static  LinearAcceleration ofBaseUnits(double baseUnitMagnitude, LinearAccelerationUnit unit) {
-    return new ImmutableLinearAcceleration(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link LinearAccelerationUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit's base unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  LinearAcceleration ofBaseUnits(double baseUnitMagnitude, LinearAccelerationUnit unit) {
+    return new LinearAcceleration(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
   }
 
   @Override
-  LinearAcceleration copy();
+  public LinearAccelerationUnit baseUnit() { return (LinearAccelerationUnit) unit().getBaseUnit(); }
 
   @Override
-  default MutLinearAcceleration mutableCopy() {
-    return new MutLinearAcceleration(magnitude(), baseUnitMagnitude(), unit());
-  }
-
-  @Override
-  LinearAccelerationUnit unit();
-
-  @Override
-  default LinearAccelerationUnit baseUnit() { return (LinearAccelerationUnit) unit().getBaseUnit(); }
-
-  @Override
-  default double in(LinearAccelerationUnit unit) {
+  public double in(LinearAccelerationUnit unit) {
     return unit.fromBaseUnits(baseUnitMagnitude());
   }
 
   @Override
-  default LinearAcceleration unaryMinus() {
+  @SuppressWarnings("rawtypes")
+  public boolean equals(Object object) {
+    return object instanceof LinearAcceleration m && isEquivalent(m);
+  }
+
+  @Override
+  public LinearAcceleration unaryMinus() {
     return (LinearAcceleration) unit().ofBaseUnits(0 - baseUnitMagnitude());
   }
 
@@ -51,27 +60,27 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default LinearAcceleration negate() {
+  public LinearAcceleration negate() {
     return (LinearAcceleration) unaryMinus();
   }
 
   @Override
-  default LinearAcceleration plus(Measure<? extends LinearAccelerationUnit> other) {
+  public LinearAcceleration plus(Measure<? extends LinearAccelerationUnit> other) {
     return (LinearAcceleration) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
   }
 
   @Override
-  default LinearAcceleration minus(Measure<? extends LinearAccelerationUnit> other) {
+  public LinearAcceleration minus(Measure<? extends LinearAccelerationUnit> other) {
     return (LinearAcceleration) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
   }
 
   @Override
-  default LinearAcceleration times(double multiplier) {
+  public LinearAcceleration times(double multiplier) {
     return (LinearAcceleration) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
   }
 
   @Override
-  default LinearAcceleration div(double divisor) {
+  public LinearAcceleration div(double divisor) {
     return (LinearAcceleration) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
@@ -83,18 +92,18 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default LinearAcceleration divide(double divisor) {
+  public LinearAcceleration divide(double divisor) {
     return (LinearAcceleration) div(divisor);
   }
 
 
   @Override
-  default Mult<LinearAccelerationUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+  public Mult<LinearAccelerationUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
     return (Mult<LinearAccelerationUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
+  public Per<LinearAccelerationUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
     return (Per<LinearAccelerationUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -106,23 +115,23 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearAccelerationUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+  public Per<LinearAccelerationUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
+  public Per<LinearAccelerationUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearAccelerationUnit, AngleUnit> times(Angle multiplier) {
+  public Mult<LinearAccelerationUnit, AngleUnit> times(Angle multiplier) {
     return (Mult<LinearAccelerationUnit, AngleUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, AngleUnit> div(Angle divisor) {
+  public Per<LinearAccelerationUnit, AngleUnit> div(Angle divisor) {
     return (Per<LinearAccelerationUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
@@ -134,23 +143,23 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearAccelerationUnit, AngleUnit> divide(Angle divisor) {
+  public Per<LinearAccelerationUnit, AngleUnit> divide(Angle divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, AngleUnit> per(AngleUnit divisorUnit) {
+  public Per<LinearAccelerationUnit, AngleUnit> per(AngleUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearAccelerationUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+  public Mult<LinearAccelerationUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
     return (Mult<LinearAccelerationUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
+  public Per<LinearAccelerationUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
     return (Per<LinearAccelerationUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -162,23 +171,23 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearAccelerationUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+  public Per<LinearAccelerationUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
+  public Per<LinearAccelerationUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearAccelerationUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+  public Mult<LinearAccelerationUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
     return (Mult<LinearAccelerationUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
+  public Per<LinearAccelerationUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
     return (Per<LinearAccelerationUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -190,23 +199,23 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearAccelerationUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+  public Per<LinearAccelerationUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
+  public Per<LinearAccelerationUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearAccelerationUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+  public Mult<LinearAccelerationUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
     return (Mult<LinearAccelerationUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
+  public Per<LinearAccelerationUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
     return (Per<LinearAccelerationUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -218,23 +227,23 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearAccelerationUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+  public Per<LinearAccelerationUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
+  public Per<LinearAccelerationUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearAccelerationUnit, CurrentUnit> times(Current multiplier) {
+  public Mult<LinearAccelerationUnit, CurrentUnit> times(Current multiplier) {
     return (Mult<LinearAccelerationUnit, CurrentUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, CurrentUnit> div(Current divisor) {
+  public Per<LinearAccelerationUnit, CurrentUnit> div(Current divisor) {
     return (Per<LinearAccelerationUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
@@ -246,17 +255,17 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearAccelerationUnit, CurrentUnit> divide(Current divisor) {
+  public Per<LinearAccelerationUnit, CurrentUnit> divide(Current divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
+  public Per<LinearAccelerationUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
   @Override
-  default LinearAcceleration div(Dimensionless divisor) {
+  public LinearAcceleration div(Dimensionless divisor) {
     return (LinearAcceleration) MetersPerSecondPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -268,23 +277,23 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default LinearAcceleration divide(Dimensionless divisor) {
+  public LinearAcceleration divide(Dimensionless divisor) {
     return (LinearAcceleration) div(divisor);
   }
 
   @Override
-  default LinearAcceleration times(Dimensionless multiplier) {
+  public LinearAcceleration times(Dimensionless multiplier) {
     return (LinearAcceleration) MetersPerSecondPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
 
   @Override
-  default Mult<LinearAccelerationUnit, DistanceUnit> times(Distance multiplier) {
+  public Mult<LinearAccelerationUnit, DistanceUnit> times(Distance multiplier) {
     return (Mult<LinearAccelerationUnit, DistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, DistanceUnit> div(Distance divisor) {
+  public Per<LinearAccelerationUnit, DistanceUnit> div(Distance divisor) {
     return (Per<LinearAccelerationUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -296,23 +305,23 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearAccelerationUnit, DistanceUnit> divide(Distance divisor) {
+  public Per<LinearAccelerationUnit, DistanceUnit> divide(Distance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
+  public Per<LinearAccelerationUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearAccelerationUnit, EnergyUnit> times(Energy multiplier) {
+  public Mult<LinearAccelerationUnit, EnergyUnit> times(Energy multiplier) {
     return (Mult<LinearAccelerationUnit, EnergyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, EnergyUnit> div(Energy divisor) {
+  public Per<LinearAccelerationUnit, EnergyUnit> div(Energy divisor) {
     return (Per<LinearAccelerationUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
@@ -324,23 +333,23 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearAccelerationUnit, EnergyUnit> divide(Energy divisor) {
+  public Per<LinearAccelerationUnit, EnergyUnit> divide(Energy divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
+  public Per<LinearAccelerationUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearAccelerationUnit, ForceUnit> times(Force multiplier) {
+  public Mult<LinearAccelerationUnit, ForceUnit> times(Force multiplier) {
     return (Mult<LinearAccelerationUnit, ForceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, ForceUnit> div(Force divisor) {
+  public Per<LinearAccelerationUnit, ForceUnit> div(Force divisor) {
     return (Per<LinearAccelerationUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
@@ -352,23 +361,23 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearAccelerationUnit, ForceUnit> divide(Force divisor) {
+  public Per<LinearAccelerationUnit, ForceUnit> divide(Force divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, ForceUnit> per(ForceUnit divisorUnit) {
+  public Per<LinearAccelerationUnit, ForceUnit> per(ForceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearAccelerationUnit, FrequencyUnit> times(Frequency multiplier) {
+  public Mult<LinearAccelerationUnit, FrequencyUnit> times(Frequency multiplier) {
     return (Mult<LinearAccelerationUnit, FrequencyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default LinearVelocity div(Frequency divisor) {
+  public LinearVelocity div(Frequency divisor) {
     return MetersPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -380,23 +389,23 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default LinearVelocity divide(Frequency divisor) {
+  public LinearVelocity divide(Frequency divisor) {
     return div(divisor);
   }
 
   @Override
-  default LinearVelocity per(FrequencyUnit divisorUnit) {
+  public LinearVelocity per(FrequencyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearAccelerationUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+  public Mult<LinearAccelerationUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
     return (Mult<LinearAccelerationUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Dimensionless div(LinearAcceleration divisor) {
+  public Dimensionless div(LinearAcceleration divisor) {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -408,23 +417,23 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Dimensionless divide(LinearAcceleration divisor) {
+  public Dimensionless divide(LinearAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Dimensionless per(LinearAccelerationUnit divisorUnit) {
+  public Dimensionless per(LinearAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearAccelerationUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+  public Mult<LinearAccelerationUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
     return (Mult<LinearAccelerationUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
+  public Per<LinearAccelerationUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
     return (Per<LinearAccelerationUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -436,23 +445,23 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearAccelerationUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+  public Per<LinearAccelerationUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
+  public Per<LinearAccelerationUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearAccelerationUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+  public Mult<LinearAccelerationUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
     return (Mult<LinearAccelerationUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
+  public Per<LinearAccelerationUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
     return (Per<LinearAccelerationUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -464,23 +473,23 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearAccelerationUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+  public Per<LinearAccelerationUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
+  public Per<LinearAccelerationUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearAccelerationUnit, MassUnit> times(Mass multiplier) {
+  public Mult<LinearAccelerationUnit, MassUnit> times(Mass multiplier) {
     return (Mult<LinearAccelerationUnit, MassUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, MassUnit> div(Mass divisor) {
+  public Per<LinearAccelerationUnit, MassUnit> div(Mass divisor) {
     return (Per<LinearAccelerationUnit, MassUnit>) Measure.super.div(divisor);
   }
 
@@ -492,23 +501,23 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearAccelerationUnit, MassUnit> divide(Mass divisor) {
+  public Per<LinearAccelerationUnit, MassUnit> divide(Mass divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, MassUnit> per(MassUnit divisorUnit) {
+  public Per<LinearAccelerationUnit, MassUnit> per(MassUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearAccelerationUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+  public Mult<LinearAccelerationUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
     return (Mult<LinearAccelerationUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
+  public Per<LinearAccelerationUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
     return (Per<LinearAccelerationUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
@@ -520,23 +529,23 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearAccelerationUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+  public Per<LinearAccelerationUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
+  public Per<LinearAccelerationUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearAccelerationUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+  public Mult<LinearAccelerationUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
     return (Mult<LinearAccelerationUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
+  public Per<LinearAccelerationUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
     return (Per<LinearAccelerationUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -548,23 +557,23 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearAccelerationUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+  public Per<LinearAccelerationUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
+  public Per<LinearAccelerationUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<LinearAccelerationUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+  public Mult<LinearAccelerationUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
     return (Mult<LinearAccelerationUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
+  public Per<LinearAccelerationUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
     return (Per<LinearAccelerationUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -576,23 +585,23 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearAccelerationUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+  public Per<LinearAccelerationUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
+  public Per<LinearAccelerationUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<LinearAccelerationUnit, PowerUnit> times(Power multiplier) {
+  public Mult<LinearAccelerationUnit, PowerUnit> times(Power multiplier) {
     return (Mult<LinearAccelerationUnit, PowerUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, PowerUnit> div(Power divisor) {
+  public Per<LinearAccelerationUnit, PowerUnit> div(Power divisor) {
     return (Per<LinearAccelerationUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
@@ -604,23 +613,23 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearAccelerationUnit, PowerUnit> divide(Power divisor) {
+  public Per<LinearAccelerationUnit, PowerUnit> divide(Power divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, PowerUnit> per(PowerUnit divisorUnit) {
+  public Per<LinearAccelerationUnit, PowerUnit> per(PowerUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearAccelerationUnit, ResistanceUnit> times(Resistance multiplier) {
+  public Mult<LinearAccelerationUnit, ResistanceUnit> times(Resistance multiplier) {
     return (Mult<LinearAccelerationUnit, ResistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, ResistanceUnit> div(Resistance divisor) {
+  public Per<LinearAccelerationUnit, ResistanceUnit> div(Resistance divisor) {
     return (Per<LinearAccelerationUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -632,23 +641,23 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearAccelerationUnit, ResistanceUnit> divide(Resistance divisor) {
+  public Per<LinearAccelerationUnit, ResistanceUnit> divide(Resistance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
+  public Per<LinearAccelerationUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearAccelerationUnit, TemperatureUnit> times(Temperature multiplier) {
+  public Mult<LinearAccelerationUnit, TemperatureUnit> times(Temperature multiplier) {
     return (Mult<LinearAccelerationUnit, TemperatureUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, TemperatureUnit> div(Temperature divisor) {
+  public Per<LinearAccelerationUnit, TemperatureUnit> div(Temperature divisor) {
     return (Per<LinearAccelerationUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
@@ -660,23 +669,23 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearAccelerationUnit, TemperatureUnit> divide(Temperature divisor) {
+  public Per<LinearAccelerationUnit, TemperatureUnit> divide(Temperature divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
+  public Per<LinearAccelerationUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default LinearVelocity times(Time multiplier) {
+  public LinearVelocity times(Time multiplier) {
     return MetersPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Velocity<LinearAccelerationUnit> div(Time divisor) {
+  public Velocity<LinearAccelerationUnit> div(Time divisor) {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -688,23 +697,23 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Velocity<LinearAccelerationUnit> divide(Time divisor) {
+  public Velocity<LinearAccelerationUnit> divide(Time divisor) {
     return div(divisor);
   }
 
   @Override
-  default Velocity<LinearAccelerationUnit> per(TimeUnit divisorUnit) {
+  public Velocity<LinearAccelerationUnit> per(TimeUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearAccelerationUnit, TorqueUnit> times(Torque multiplier) {
+  public Mult<LinearAccelerationUnit, TorqueUnit> times(Torque multiplier) {
     return (Mult<LinearAccelerationUnit, TorqueUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, TorqueUnit> div(Torque divisor) {
+  public Per<LinearAccelerationUnit, TorqueUnit> div(Torque divisor) {
     return (Per<LinearAccelerationUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
@@ -716,23 +725,23 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearAccelerationUnit, TorqueUnit> divide(Torque divisor) {
+  public Per<LinearAccelerationUnit, TorqueUnit> divide(Torque divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
+  public Per<LinearAccelerationUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearAccelerationUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+  public Mult<LinearAccelerationUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
     return (Mult<LinearAccelerationUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
+  public Per<LinearAccelerationUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
     return (Per<LinearAccelerationUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -744,23 +753,23 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearAccelerationUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+  public Per<LinearAccelerationUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
+  public Per<LinearAccelerationUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearAccelerationUnit, VoltageUnit> times(Voltage multiplier) {
+  public Mult<LinearAccelerationUnit, VoltageUnit> times(Voltage multiplier) {
     return (Mult<LinearAccelerationUnit, VoltageUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, VoltageUnit> div(Voltage divisor) {
+  public Per<LinearAccelerationUnit, VoltageUnit> div(Voltage divisor) {
     return (Per<LinearAccelerationUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
@@ -772,12 +781,12 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearAccelerationUnit, VoltageUnit> divide(Voltage divisor) {
+  public Per<LinearAccelerationUnit, VoltageUnit> divide(Voltage divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearAccelerationUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
+  public Per<LinearAccelerationUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearMomentum.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearMomentum.java
index c1bf6d7f11..9edfd7b3aa 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearMomentum.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearMomentum.java
@@ -10,36 +10,45 @@ import static edu.wpi.first.units.Units.*;
 import edu.wpi.first.units.*;
 
 @SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public interface LinearMomentum extends Measure<LinearMomentumUnit> {
-  static  LinearMomentum ofRelativeUnits(double magnitude, LinearMomentumUnit unit) {
-    return new ImmutableLinearMomentum(magnitude, unit.toBaseUnits(magnitude), unit);
+public record LinearMomentum(double magnitude, double baseUnitMagnitude, LinearMomentumUnit unit) implements Measure<LinearMomentumUnit> {
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link LinearMomentumUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  LinearMomentum ofRelativeUnits(double magnitude, LinearMomentumUnit unit) {
+    return new LinearMomentum(magnitude, unit.toBaseUnits(magnitude), unit);
   }
 
-  static  LinearMomentum ofBaseUnits(double baseUnitMagnitude, LinearMomentumUnit unit) {
-    return new ImmutableLinearMomentum(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link LinearMomentumUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit's base unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  LinearMomentum ofBaseUnits(double baseUnitMagnitude, LinearMomentumUnit unit) {
+    return new LinearMomentum(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
   }
 
   @Override
-  LinearMomentum copy();
+  public LinearMomentumUnit baseUnit() { return (LinearMomentumUnit) unit().getBaseUnit(); }
 
   @Override
-  default MutLinearMomentum mutableCopy() {
-    return new MutLinearMomentum(magnitude(), baseUnitMagnitude(), unit());
-  }
-
-  @Override
-  LinearMomentumUnit unit();
-
-  @Override
-  default LinearMomentumUnit baseUnit() { return (LinearMomentumUnit) unit().getBaseUnit(); }
-
-  @Override
-  default double in(LinearMomentumUnit unit) {
+  public double in(LinearMomentumUnit unit) {
     return unit.fromBaseUnits(baseUnitMagnitude());
   }
 
   @Override
-  default LinearMomentum unaryMinus() {
+  @SuppressWarnings("rawtypes")
+  public boolean equals(Object object) {
+    return object instanceof LinearMomentum m && isEquivalent(m);
+  }
+
+  @Override
+  public LinearMomentum unaryMinus() {
     return (LinearMomentum) unit().ofBaseUnits(0 - baseUnitMagnitude());
   }
 
@@ -51,27 +60,27 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default LinearMomentum negate() {
+  public LinearMomentum negate() {
     return (LinearMomentum) unaryMinus();
   }
 
   @Override
-  default LinearMomentum plus(Measure<? extends LinearMomentumUnit> other) {
+  public LinearMomentum plus(Measure<? extends LinearMomentumUnit> other) {
     return (LinearMomentum) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
   }
 
   @Override
-  default LinearMomentum minus(Measure<? extends LinearMomentumUnit> other) {
+  public LinearMomentum minus(Measure<? extends LinearMomentumUnit> other) {
     return (LinearMomentum) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
   }
 
   @Override
-  default LinearMomentum times(double multiplier) {
+  public LinearMomentum times(double multiplier) {
     return (LinearMomentum) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
   }
 
   @Override
-  default LinearMomentum div(double divisor) {
+  public LinearMomentum div(double divisor) {
     return (LinearMomentum) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
@@ -83,18 +92,18 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default LinearMomentum divide(double divisor) {
+  public LinearMomentum divide(double divisor) {
     return (LinearMomentum) div(divisor);
   }
 
 
   @Override
-  default Mult<LinearMomentumUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+  public Mult<LinearMomentumUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
     return (Mult<LinearMomentumUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearMomentumUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
+  public Per<LinearMomentumUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
     return (Per<LinearMomentumUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -106,23 +115,23 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearMomentumUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+  public Per<LinearMomentumUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearMomentumUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
+  public Per<LinearMomentumUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearMomentumUnit, AngleUnit> times(Angle multiplier) {
+  public Mult<LinearMomentumUnit, AngleUnit> times(Angle multiplier) {
     return (Mult<LinearMomentumUnit, AngleUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearMomentumUnit, AngleUnit> div(Angle divisor) {
+  public Per<LinearMomentumUnit, AngleUnit> div(Angle divisor) {
     return (Per<LinearMomentumUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
@@ -134,23 +143,23 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearMomentumUnit, AngleUnit> divide(Angle divisor) {
+  public Per<LinearMomentumUnit, AngleUnit> divide(Angle divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearMomentumUnit, AngleUnit> per(AngleUnit divisorUnit) {
+  public Per<LinearMomentumUnit, AngleUnit> per(AngleUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearMomentumUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+  public Mult<LinearMomentumUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
     return (Mult<LinearMomentumUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearMomentumUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
+  public Per<LinearMomentumUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
     return (Per<LinearMomentumUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -162,23 +171,23 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearMomentumUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+  public Per<LinearMomentumUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearMomentumUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
+  public Per<LinearMomentumUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearMomentumUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+  public Mult<LinearMomentumUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
     return (Mult<LinearMomentumUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearMomentumUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
+  public Per<LinearMomentumUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
     return (Per<LinearMomentumUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -190,23 +199,23 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearMomentumUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+  public Per<LinearMomentumUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearMomentumUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
+  public Per<LinearMomentumUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearMomentumUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+  public Mult<LinearMomentumUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
     return (Mult<LinearMomentumUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearMomentumUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
+  public Per<LinearMomentumUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
     return (Per<LinearMomentumUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -218,23 +227,23 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearMomentumUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+  public Per<LinearMomentumUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearMomentumUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
+  public Per<LinearMomentumUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearMomentumUnit, CurrentUnit> times(Current multiplier) {
+  public Mult<LinearMomentumUnit, CurrentUnit> times(Current multiplier) {
     return (Mult<LinearMomentumUnit, CurrentUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearMomentumUnit, CurrentUnit> div(Current divisor) {
+  public Per<LinearMomentumUnit, CurrentUnit> div(Current divisor) {
     return (Per<LinearMomentumUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
@@ -246,17 +255,17 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearMomentumUnit, CurrentUnit> divide(Current divisor) {
+  public Per<LinearMomentumUnit, CurrentUnit> divide(Current divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearMomentumUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
+  public Per<LinearMomentumUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
   @Override
-  default LinearMomentum div(Dimensionless divisor) {
+  public LinearMomentum div(Dimensionless divisor) {
     return (LinearMomentum) KilogramMetersPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -268,23 +277,23 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default LinearMomentum divide(Dimensionless divisor) {
+  public LinearMomentum divide(Dimensionless divisor) {
     return (LinearMomentum) div(divisor);
   }
 
   @Override
-  default LinearMomentum times(Dimensionless multiplier) {
+  public LinearMomentum times(Dimensionless multiplier) {
     return (LinearMomentum) KilogramMetersPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
 
   @Override
-  default Mult<LinearMomentumUnit, DistanceUnit> times(Distance multiplier) {
+  public Mult<LinearMomentumUnit, DistanceUnit> times(Distance multiplier) {
     return (Mult<LinearMomentumUnit, DistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearMomentumUnit, DistanceUnit> div(Distance divisor) {
+  public Per<LinearMomentumUnit, DistanceUnit> div(Distance divisor) {
     return (Per<LinearMomentumUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -296,23 +305,23 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearMomentumUnit, DistanceUnit> divide(Distance divisor) {
+  public Per<LinearMomentumUnit, DistanceUnit> divide(Distance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearMomentumUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
+  public Per<LinearMomentumUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearMomentumUnit, EnergyUnit> times(Energy multiplier) {
+  public Mult<LinearMomentumUnit, EnergyUnit> times(Energy multiplier) {
     return (Mult<LinearMomentumUnit, EnergyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearMomentumUnit, EnergyUnit> div(Energy divisor) {
+  public Per<LinearMomentumUnit, EnergyUnit> div(Energy divisor) {
     return (Per<LinearMomentumUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
@@ -324,23 +333,23 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearMomentumUnit, EnergyUnit> divide(Energy divisor) {
+  public Per<LinearMomentumUnit, EnergyUnit> divide(Energy divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearMomentumUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
+  public Per<LinearMomentumUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearMomentumUnit, ForceUnit> times(Force multiplier) {
+  public Mult<LinearMomentumUnit, ForceUnit> times(Force multiplier) {
     return (Mult<LinearMomentumUnit, ForceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearMomentumUnit, ForceUnit> div(Force divisor) {
+  public Per<LinearMomentumUnit, ForceUnit> div(Force divisor) {
     return (Per<LinearMomentumUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
@@ -352,23 +361,23 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearMomentumUnit, ForceUnit> divide(Force divisor) {
+  public Per<LinearMomentumUnit, ForceUnit> divide(Force divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearMomentumUnit, ForceUnit> per(ForceUnit divisorUnit) {
+  public Per<LinearMomentumUnit, ForceUnit> per(ForceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Force times(Frequency multiplier) {
+  public Force times(Frequency multiplier) {
     return Newtons.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<LinearMomentumUnit, FrequencyUnit> div(Frequency divisor) {
+  public Per<LinearMomentumUnit, FrequencyUnit> div(Frequency divisor) {
     return (Per<LinearMomentumUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
@@ -380,23 +389,23 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearMomentumUnit, FrequencyUnit> divide(Frequency divisor) {
+  public Per<LinearMomentumUnit, FrequencyUnit> divide(Frequency divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearMomentumUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
+  public Per<LinearMomentumUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearMomentumUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+  public Mult<LinearMomentumUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
     return (Mult<LinearMomentumUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearMomentumUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
+  public Per<LinearMomentumUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
     return (Per<LinearMomentumUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -408,23 +417,23 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearMomentumUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+  public Per<LinearMomentumUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearMomentumUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
+  public Per<LinearMomentumUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearMomentumUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+  public Mult<LinearMomentumUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
     return (Mult<LinearMomentumUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Dimensionless div(LinearMomentum divisor) {
+  public Dimensionless div(LinearMomentum divisor) {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -436,23 +445,23 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Dimensionless divide(LinearMomentum divisor) {
+  public Dimensionless divide(LinearMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Dimensionless per(LinearMomentumUnit divisorUnit) {
+  public Dimensionless per(LinearMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearMomentumUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+  public Mult<LinearMomentumUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
     return (Mult<LinearMomentumUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Mass div(LinearVelocity divisor) {
+  public Mass div(LinearVelocity divisor) {
     return Kilograms.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -464,23 +473,23 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Mass divide(LinearVelocity divisor) {
+  public Mass divide(LinearVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Mass per(LinearVelocityUnit divisorUnit) {
+  public Mass per(LinearVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearMomentumUnit, MassUnit> times(Mass multiplier) {
+  public Mult<LinearMomentumUnit, MassUnit> times(Mass multiplier) {
     return (Mult<LinearMomentumUnit, MassUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default LinearVelocity div(Mass divisor) {
+  public LinearVelocity div(Mass divisor) {
     return MetersPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -492,23 +501,23 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default LinearVelocity divide(Mass divisor) {
+  public LinearVelocity divide(Mass divisor) {
     return div(divisor);
   }
 
   @Override
-  default LinearVelocity per(MassUnit divisorUnit) {
+  public LinearVelocity per(MassUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearMomentumUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+  public Mult<LinearMomentumUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
     return (Mult<LinearMomentumUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearMomentumUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
+  public Per<LinearMomentumUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
     return (Per<LinearMomentumUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
@@ -520,23 +529,23 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearMomentumUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+  public Per<LinearMomentumUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearMomentumUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
+  public Per<LinearMomentumUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearMomentumUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+  public Mult<LinearMomentumUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
     return (Mult<LinearMomentumUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearMomentumUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
+  public Per<LinearMomentumUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
     return (Per<LinearMomentumUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -548,23 +557,23 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearMomentumUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+  public Per<LinearMomentumUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearMomentumUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
+  public Per<LinearMomentumUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<LinearMomentumUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+  public Mult<LinearMomentumUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
     return (Mult<LinearMomentumUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearMomentumUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
+  public Per<LinearMomentumUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
     return (Per<LinearMomentumUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -576,23 +585,23 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearMomentumUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+  public Per<LinearMomentumUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearMomentumUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
+  public Per<LinearMomentumUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<LinearMomentumUnit, PowerUnit> times(Power multiplier) {
+  public Mult<LinearMomentumUnit, PowerUnit> times(Power multiplier) {
     return (Mult<LinearMomentumUnit, PowerUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearMomentumUnit, PowerUnit> div(Power divisor) {
+  public Per<LinearMomentumUnit, PowerUnit> div(Power divisor) {
     return (Per<LinearMomentumUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
@@ -604,23 +613,23 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearMomentumUnit, PowerUnit> divide(Power divisor) {
+  public Per<LinearMomentumUnit, PowerUnit> divide(Power divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearMomentumUnit, PowerUnit> per(PowerUnit divisorUnit) {
+  public Per<LinearMomentumUnit, PowerUnit> per(PowerUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearMomentumUnit, ResistanceUnit> times(Resistance multiplier) {
+  public Mult<LinearMomentumUnit, ResistanceUnit> times(Resistance multiplier) {
     return (Mult<LinearMomentumUnit, ResistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearMomentumUnit, ResistanceUnit> div(Resistance divisor) {
+  public Per<LinearMomentumUnit, ResistanceUnit> div(Resistance divisor) {
     return (Per<LinearMomentumUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -632,23 +641,23 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearMomentumUnit, ResistanceUnit> divide(Resistance divisor) {
+  public Per<LinearMomentumUnit, ResistanceUnit> divide(Resistance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearMomentumUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
+  public Per<LinearMomentumUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearMomentumUnit, TemperatureUnit> times(Temperature multiplier) {
+  public Mult<LinearMomentumUnit, TemperatureUnit> times(Temperature multiplier) {
     return (Mult<LinearMomentumUnit, TemperatureUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearMomentumUnit, TemperatureUnit> div(Temperature divisor) {
+  public Per<LinearMomentumUnit, TemperatureUnit> div(Temperature divisor) {
     return (Per<LinearMomentumUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
@@ -660,23 +669,23 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearMomentumUnit, TemperatureUnit> divide(Temperature divisor) {
+  public Per<LinearMomentumUnit, TemperatureUnit> divide(Temperature divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearMomentumUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
+  public Per<LinearMomentumUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearMomentumUnit, TimeUnit> times(Time multiplier) {
+  public Mult<LinearMomentumUnit, TimeUnit> times(Time multiplier) {
     return (Mult<LinearMomentumUnit, TimeUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Force div(Time divisor) {
+  public Force div(Time divisor) {
     return Newtons.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -688,23 +697,23 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Force divide(Time divisor) {
+  public Force divide(Time divisor) {
     return div(divisor);
   }
 
   @Override
-  default Force per(TimeUnit divisorUnit) {
+  public Force per(TimeUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearMomentumUnit, TorqueUnit> times(Torque multiplier) {
+  public Mult<LinearMomentumUnit, TorqueUnit> times(Torque multiplier) {
     return (Mult<LinearMomentumUnit, TorqueUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearMomentumUnit, TorqueUnit> div(Torque divisor) {
+  public Per<LinearMomentumUnit, TorqueUnit> div(Torque divisor) {
     return (Per<LinearMomentumUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
@@ -716,23 +725,23 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearMomentumUnit, TorqueUnit> divide(Torque divisor) {
+  public Per<LinearMomentumUnit, TorqueUnit> divide(Torque divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearMomentumUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
+  public Per<LinearMomentumUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearMomentumUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+  public Mult<LinearMomentumUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
     return (Mult<LinearMomentumUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearMomentumUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
+  public Per<LinearMomentumUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
     return (Per<LinearMomentumUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -744,23 +753,23 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearMomentumUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+  public Per<LinearMomentumUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearMomentumUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
+  public Per<LinearMomentumUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearMomentumUnit, VoltageUnit> times(Voltage multiplier) {
+  public Mult<LinearMomentumUnit, VoltageUnit> times(Voltage multiplier) {
     return (Mult<LinearMomentumUnit, VoltageUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearMomentumUnit, VoltageUnit> div(Voltage divisor) {
+  public Per<LinearMomentumUnit, VoltageUnit> div(Voltage divisor) {
     return (Per<LinearMomentumUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
@@ -772,12 +781,12 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearMomentumUnit, VoltageUnit> divide(Voltage divisor) {
+  public Per<LinearMomentumUnit, VoltageUnit> divide(Voltage divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearMomentumUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
+  public Per<LinearMomentumUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearVelocity.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearVelocity.java
index 7ed8cc1e5f..22ccf2c295 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearVelocity.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearVelocity.java
@@ -10,36 +10,45 @@ import static edu.wpi.first.units.Units.*;
 import edu.wpi.first.units.*;
 
 @SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public interface LinearVelocity extends Measure<LinearVelocityUnit> {
-  static  LinearVelocity ofRelativeUnits(double magnitude, LinearVelocityUnit unit) {
-    return new ImmutableLinearVelocity(magnitude, unit.toBaseUnits(magnitude), unit);
+public record LinearVelocity(double magnitude, double baseUnitMagnitude, LinearVelocityUnit unit) implements Measure<LinearVelocityUnit> {
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link LinearVelocityUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  LinearVelocity ofRelativeUnits(double magnitude, LinearVelocityUnit unit) {
+    return new LinearVelocity(magnitude, unit.toBaseUnits(magnitude), unit);
   }
 
-  static  LinearVelocity ofBaseUnits(double baseUnitMagnitude, LinearVelocityUnit unit) {
-    return new ImmutableLinearVelocity(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link LinearVelocityUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit's base unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  LinearVelocity ofBaseUnits(double baseUnitMagnitude, LinearVelocityUnit unit) {
+    return new LinearVelocity(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
   }
 
   @Override
-  LinearVelocity copy();
+  public LinearVelocityUnit baseUnit() { return (LinearVelocityUnit) unit().getBaseUnit(); }
 
   @Override
-  default MutLinearVelocity mutableCopy() {
-    return new MutLinearVelocity(magnitude(), baseUnitMagnitude(), unit());
-  }
-
-  @Override
-  LinearVelocityUnit unit();
-
-  @Override
-  default LinearVelocityUnit baseUnit() { return (LinearVelocityUnit) unit().getBaseUnit(); }
-
-  @Override
-  default double in(LinearVelocityUnit unit) {
+  public double in(LinearVelocityUnit unit) {
     return unit.fromBaseUnits(baseUnitMagnitude());
   }
 
   @Override
-  default LinearVelocity unaryMinus() {
+  @SuppressWarnings("rawtypes")
+  public boolean equals(Object object) {
+    return object instanceof LinearVelocity m && isEquivalent(m);
+  }
+
+  @Override
+  public LinearVelocity unaryMinus() {
     return (LinearVelocity) unit().ofBaseUnits(0 - baseUnitMagnitude());
   }
 
@@ -51,27 +60,27 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default LinearVelocity negate() {
+  public LinearVelocity negate() {
     return (LinearVelocity) unaryMinus();
   }
 
   @Override
-  default LinearVelocity plus(Measure<? extends LinearVelocityUnit> other) {
+  public LinearVelocity plus(Measure<? extends LinearVelocityUnit> other) {
     return (LinearVelocity) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
   }
 
   @Override
-  default LinearVelocity minus(Measure<? extends LinearVelocityUnit> other) {
+  public LinearVelocity minus(Measure<? extends LinearVelocityUnit> other) {
     return (LinearVelocity) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
   }
 
   @Override
-  default LinearVelocity times(double multiplier) {
+  public LinearVelocity times(double multiplier) {
     return (LinearVelocity) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
   }
 
   @Override
-  default LinearVelocity div(double divisor) {
+  public LinearVelocity div(double divisor) {
     return (LinearVelocity) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
@@ -83,18 +92,18 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default LinearVelocity divide(double divisor) {
+  public LinearVelocity divide(double divisor) {
     return (LinearVelocity) div(divisor);
   }
 
 
   @Override
-  default Mult<LinearVelocityUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+  public Mult<LinearVelocityUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
     return (Mult<LinearVelocityUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearVelocityUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
+  public Per<LinearVelocityUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
     return (Per<LinearVelocityUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -106,23 +115,23 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearVelocityUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+  public Per<LinearVelocityUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearVelocityUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
+  public Per<LinearVelocityUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearVelocityUnit, AngleUnit> times(Angle multiplier) {
+  public Mult<LinearVelocityUnit, AngleUnit> times(Angle multiplier) {
     return (Mult<LinearVelocityUnit, AngleUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearVelocityUnit, AngleUnit> div(Angle divisor) {
+  public Per<LinearVelocityUnit, AngleUnit> div(Angle divisor) {
     return (Per<LinearVelocityUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
@@ -134,23 +143,23 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearVelocityUnit, AngleUnit> divide(Angle divisor) {
+  public Per<LinearVelocityUnit, AngleUnit> divide(Angle divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearVelocityUnit, AngleUnit> per(AngleUnit divisorUnit) {
+  public Per<LinearVelocityUnit, AngleUnit> per(AngleUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearVelocityUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+  public Mult<LinearVelocityUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
     return (Mult<LinearVelocityUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearVelocityUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
+  public Per<LinearVelocityUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
     return (Per<LinearVelocityUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -162,23 +171,23 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearVelocityUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+  public Per<LinearVelocityUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearVelocityUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
+  public Per<LinearVelocityUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearVelocityUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+  public Mult<LinearVelocityUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
     return (Mult<LinearVelocityUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearVelocityUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
+  public Per<LinearVelocityUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
     return (Per<LinearVelocityUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -190,23 +199,23 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearVelocityUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+  public Per<LinearVelocityUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearVelocityUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
+  public Per<LinearVelocityUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearVelocityUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+  public Mult<LinearVelocityUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
     return (Mult<LinearVelocityUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearVelocityUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
+  public Per<LinearVelocityUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
     return (Per<LinearVelocityUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -218,23 +227,23 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearVelocityUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+  public Per<LinearVelocityUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearVelocityUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
+  public Per<LinearVelocityUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearVelocityUnit, CurrentUnit> times(Current multiplier) {
+  public Mult<LinearVelocityUnit, CurrentUnit> times(Current multiplier) {
     return (Mult<LinearVelocityUnit, CurrentUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearVelocityUnit, CurrentUnit> div(Current divisor) {
+  public Per<LinearVelocityUnit, CurrentUnit> div(Current divisor) {
     return (Per<LinearVelocityUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
@@ -246,17 +255,17 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearVelocityUnit, CurrentUnit> divide(Current divisor) {
+  public Per<LinearVelocityUnit, CurrentUnit> divide(Current divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearVelocityUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
+  public Per<LinearVelocityUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
   @Override
-  default LinearVelocity div(Dimensionless divisor) {
+  public LinearVelocity div(Dimensionless divisor) {
     return (LinearVelocity) MetersPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -268,23 +277,23 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default LinearVelocity divide(Dimensionless divisor) {
+  public LinearVelocity divide(Dimensionless divisor) {
     return (LinearVelocity) div(divisor);
   }
 
   @Override
-  default LinearVelocity times(Dimensionless multiplier) {
+  public LinearVelocity times(Dimensionless multiplier) {
     return (LinearVelocity) MetersPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
 
   @Override
-  default Mult<LinearVelocityUnit, DistanceUnit> times(Distance multiplier) {
+  public Mult<LinearVelocityUnit, DistanceUnit> times(Distance multiplier) {
     return (Mult<LinearVelocityUnit, DistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearVelocityUnit, DistanceUnit> div(Distance divisor) {
+  public Per<LinearVelocityUnit, DistanceUnit> div(Distance divisor) {
     return (Per<LinearVelocityUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -296,23 +305,23 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearVelocityUnit, DistanceUnit> divide(Distance divisor) {
+  public Per<LinearVelocityUnit, DistanceUnit> divide(Distance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearVelocityUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
+  public Per<LinearVelocityUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearVelocityUnit, EnergyUnit> times(Energy multiplier) {
+  public Mult<LinearVelocityUnit, EnergyUnit> times(Energy multiplier) {
     return (Mult<LinearVelocityUnit, EnergyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearVelocityUnit, EnergyUnit> div(Energy divisor) {
+  public Per<LinearVelocityUnit, EnergyUnit> div(Energy divisor) {
     return (Per<LinearVelocityUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
@@ -324,23 +333,23 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearVelocityUnit, EnergyUnit> divide(Energy divisor) {
+  public Per<LinearVelocityUnit, EnergyUnit> divide(Energy divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearVelocityUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
+  public Per<LinearVelocityUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearVelocityUnit, ForceUnit> times(Force multiplier) {
+  public Mult<LinearVelocityUnit, ForceUnit> times(Force multiplier) {
     return (Mult<LinearVelocityUnit, ForceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearVelocityUnit, ForceUnit> div(Force divisor) {
+  public Per<LinearVelocityUnit, ForceUnit> div(Force divisor) {
     return (Per<LinearVelocityUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
@@ -352,23 +361,23 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearVelocityUnit, ForceUnit> divide(Force divisor) {
+  public Per<LinearVelocityUnit, ForceUnit> divide(Force divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearVelocityUnit, ForceUnit> per(ForceUnit divisorUnit) {
+  public Per<LinearVelocityUnit, ForceUnit> per(ForceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default LinearAcceleration times(Frequency multiplier) {
+  public LinearAcceleration times(Frequency multiplier) {
     return MetersPerSecondPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<LinearVelocityUnit, FrequencyUnit> div(Frequency divisor) {
+  public Per<LinearVelocityUnit, FrequencyUnit> div(Frequency divisor) {
     return (Per<LinearVelocityUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
@@ -380,23 +389,23 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearVelocityUnit, FrequencyUnit> divide(Frequency divisor) {
+  public Per<LinearVelocityUnit, FrequencyUnit> divide(Frequency divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearVelocityUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
+  public Per<LinearVelocityUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearVelocityUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+  public Mult<LinearVelocityUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
     return (Mult<LinearVelocityUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearVelocityUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
+  public Per<LinearVelocityUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
     return (Per<LinearVelocityUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -408,23 +417,23 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearVelocityUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+  public Per<LinearVelocityUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearVelocityUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
+  public Per<LinearVelocityUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearVelocityUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+  public Mult<LinearVelocityUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
     return (Mult<LinearVelocityUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearVelocityUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
+  public Per<LinearVelocityUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
     return (Per<LinearVelocityUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -436,23 +445,23 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearVelocityUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+  public Per<LinearVelocityUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearVelocityUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
+  public Per<LinearVelocityUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearVelocityUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+  public Mult<LinearVelocityUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
     return (Mult<LinearVelocityUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Dimensionless div(LinearVelocity divisor) {
+  public Dimensionless div(LinearVelocity divisor) {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -464,23 +473,23 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Dimensionless divide(LinearVelocity divisor) {
+  public Dimensionless divide(LinearVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Dimensionless per(LinearVelocityUnit divisorUnit) {
+  public Dimensionless per(LinearVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearVelocityUnit, MassUnit> times(Mass multiplier) {
+  public Mult<LinearVelocityUnit, MassUnit> times(Mass multiplier) {
     return (Mult<LinearVelocityUnit, MassUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearVelocityUnit, MassUnit> div(Mass divisor) {
+  public Per<LinearVelocityUnit, MassUnit> div(Mass divisor) {
     return (Per<LinearVelocityUnit, MassUnit>) Measure.super.div(divisor);
   }
 
@@ -492,23 +501,23 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearVelocityUnit, MassUnit> divide(Mass divisor) {
+  public Per<LinearVelocityUnit, MassUnit> divide(Mass divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearVelocityUnit, MassUnit> per(MassUnit divisorUnit) {
+  public Per<LinearVelocityUnit, MassUnit> per(MassUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearVelocityUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+  public Mult<LinearVelocityUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
     return (Mult<LinearVelocityUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearVelocityUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
+  public Per<LinearVelocityUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
     return (Per<LinearVelocityUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
@@ -520,23 +529,23 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearVelocityUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+  public Per<LinearVelocityUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearVelocityUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
+  public Per<LinearVelocityUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearVelocityUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+  public Mult<LinearVelocityUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
     return (Mult<LinearVelocityUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearVelocityUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
+  public Per<LinearVelocityUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
     return (Per<LinearVelocityUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -548,23 +557,23 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearVelocityUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+  public Per<LinearVelocityUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearVelocityUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
+  public Per<LinearVelocityUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<LinearVelocityUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+  public Mult<LinearVelocityUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
     return (Mult<LinearVelocityUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearVelocityUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
+  public Per<LinearVelocityUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
     return (Per<LinearVelocityUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -576,23 +585,23 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearVelocityUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+  public Per<LinearVelocityUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearVelocityUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
+  public Per<LinearVelocityUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<LinearVelocityUnit, PowerUnit> times(Power multiplier) {
+  public Mult<LinearVelocityUnit, PowerUnit> times(Power multiplier) {
     return (Mult<LinearVelocityUnit, PowerUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearVelocityUnit, PowerUnit> div(Power divisor) {
+  public Per<LinearVelocityUnit, PowerUnit> div(Power divisor) {
     return (Per<LinearVelocityUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
@@ -604,23 +613,23 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearVelocityUnit, PowerUnit> divide(Power divisor) {
+  public Per<LinearVelocityUnit, PowerUnit> divide(Power divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearVelocityUnit, PowerUnit> per(PowerUnit divisorUnit) {
+  public Per<LinearVelocityUnit, PowerUnit> per(PowerUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearVelocityUnit, ResistanceUnit> times(Resistance multiplier) {
+  public Mult<LinearVelocityUnit, ResistanceUnit> times(Resistance multiplier) {
     return (Mult<LinearVelocityUnit, ResistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearVelocityUnit, ResistanceUnit> div(Resistance divisor) {
+  public Per<LinearVelocityUnit, ResistanceUnit> div(Resistance divisor) {
     return (Per<LinearVelocityUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -632,23 +641,23 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearVelocityUnit, ResistanceUnit> divide(Resistance divisor) {
+  public Per<LinearVelocityUnit, ResistanceUnit> divide(Resistance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearVelocityUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
+  public Per<LinearVelocityUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearVelocityUnit, TemperatureUnit> times(Temperature multiplier) {
+  public Mult<LinearVelocityUnit, TemperatureUnit> times(Temperature multiplier) {
     return (Mult<LinearVelocityUnit, TemperatureUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearVelocityUnit, TemperatureUnit> div(Temperature divisor) {
+  public Per<LinearVelocityUnit, TemperatureUnit> div(Temperature divisor) {
     return (Per<LinearVelocityUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
@@ -660,23 +669,23 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearVelocityUnit, TemperatureUnit> divide(Temperature divisor) {
+  public Per<LinearVelocityUnit, TemperatureUnit> divide(Temperature divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearVelocityUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
+  public Per<LinearVelocityUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Distance times(Time multiplier) {
+  public Distance times(Time multiplier) {
     return Meters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default LinearAcceleration div(Time divisor) {
+  public LinearAcceleration div(Time divisor) {
     return MetersPerSecondPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -688,23 +697,23 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default LinearAcceleration divide(Time divisor) {
+  public LinearAcceleration divide(Time divisor) {
     return div(divisor);
   }
 
   @Override
-  default LinearAcceleration per(TimeUnit divisorUnit) {
+  public LinearAcceleration per(TimeUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearVelocityUnit, TorqueUnit> times(Torque multiplier) {
+  public Mult<LinearVelocityUnit, TorqueUnit> times(Torque multiplier) {
     return (Mult<LinearVelocityUnit, TorqueUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearVelocityUnit, TorqueUnit> div(Torque divisor) {
+  public Per<LinearVelocityUnit, TorqueUnit> div(Torque divisor) {
     return (Per<LinearVelocityUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
@@ -716,23 +725,23 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearVelocityUnit, TorqueUnit> divide(Torque divisor) {
+  public Per<LinearVelocityUnit, TorqueUnit> divide(Torque divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearVelocityUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
+  public Per<LinearVelocityUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearVelocityUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+  public Mult<LinearVelocityUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
     return (Mult<LinearVelocityUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearVelocityUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
+  public Per<LinearVelocityUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
     return (Per<LinearVelocityUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -744,23 +753,23 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearVelocityUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+  public Per<LinearVelocityUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearVelocityUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
+  public Per<LinearVelocityUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<LinearVelocityUnit, VoltageUnit> times(Voltage multiplier) {
+  public Mult<LinearVelocityUnit, VoltageUnit> times(Voltage multiplier) {
     return (Mult<LinearVelocityUnit, VoltageUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<LinearVelocityUnit, VoltageUnit> div(Voltage divisor) {
+  public Per<LinearVelocityUnit, VoltageUnit> div(Voltage divisor) {
     return (Per<LinearVelocityUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
@@ -772,12 +781,12 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<LinearVelocityUnit, VoltageUnit> divide(Voltage divisor) {
+  public Per<LinearVelocityUnit, VoltageUnit> divide(Voltage divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<LinearVelocityUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
+  public Per<LinearVelocityUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mass.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mass.java
index 507977df5c..b21a119ae8 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mass.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mass.java
@@ -10,36 +10,45 @@ import static edu.wpi.first.units.Units.*;
 import edu.wpi.first.units.*;
 
 @SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public interface Mass extends Measure<MassUnit> {
-  static  Mass ofRelativeUnits(double magnitude, MassUnit unit) {
-    return new ImmutableMass(magnitude, unit.toBaseUnits(magnitude), unit);
+public record Mass(double magnitude, double baseUnitMagnitude, MassUnit unit) implements Measure<MassUnit> {
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link MassUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  Mass ofRelativeUnits(double magnitude, MassUnit unit) {
+    return new Mass(magnitude, unit.toBaseUnits(magnitude), unit);
   }
 
-  static  Mass ofBaseUnits(double baseUnitMagnitude, MassUnit unit) {
-    return new ImmutableMass(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link MassUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit's base unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  Mass ofBaseUnits(double baseUnitMagnitude, MassUnit unit) {
+    return new Mass(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
   }
 
   @Override
-  Mass copy();
+  public MassUnit baseUnit() { return (MassUnit) unit().getBaseUnit(); }
 
   @Override
-  default MutMass mutableCopy() {
-    return new MutMass(magnitude(), baseUnitMagnitude(), unit());
-  }
-
-  @Override
-  MassUnit unit();
-
-  @Override
-  default MassUnit baseUnit() { return (MassUnit) unit().getBaseUnit(); }
-
-  @Override
-  default double in(MassUnit unit) {
+  public double in(MassUnit unit) {
     return unit.fromBaseUnits(baseUnitMagnitude());
   }
 
   @Override
-  default Mass unaryMinus() {
+  @SuppressWarnings("rawtypes")
+  public boolean equals(Object object) {
+    return object instanceof Mass m && isEquivalent(m);
+  }
+
+  @Override
+  public Mass unaryMinus() {
     return (Mass) unit().ofBaseUnits(0 - baseUnitMagnitude());
   }
 
@@ -51,27 +60,27 @@ public interface Mass extends Measure<MassUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Mass negate() {
+  public Mass negate() {
     return (Mass) unaryMinus();
   }
 
   @Override
-  default Mass plus(Measure<? extends MassUnit> other) {
+  public Mass plus(Measure<? extends MassUnit> other) {
     return (Mass) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
   }
 
   @Override
-  default Mass minus(Measure<? extends MassUnit> other) {
+  public Mass minus(Measure<? extends MassUnit> other) {
     return (Mass) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
   }
 
   @Override
-  default Mass times(double multiplier) {
+  public Mass times(double multiplier) {
     return (Mass) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
   }
 
   @Override
-  default Mass div(double divisor) {
+  public Mass div(double divisor) {
     return (Mass) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
@@ -83,18 +92,18 @@ public interface Mass extends Measure<MassUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Mass divide(double divisor) {
+  public Mass divide(double divisor) {
     return (Mass) div(divisor);
   }
 
 
   @Override
-  default Mult<MassUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+  public Mult<MassUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
     return (Mult<MassUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MassUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
+  public Per<MassUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
     return (Per<MassUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -106,23 +115,23 @@ public interface Mass extends Measure<MassUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MassUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+  public Per<MassUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MassUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
+  public Per<MassUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MassUnit, AngleUnit> times(Angle multiplier) {
+  public Mult<MassUnit, AngleUnit> times(Angle multiplier) {
     return (Mult<MassUnit, AngleUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MassUnit, AngleUnit> div(Angle divisor) {
+  public Per<MassUnit, AngleUnit> div(Angle divisor) {
     return (Per<MassUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
@@ -134,23 +143,23 @@ public interface Mass extends Measure<MassUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MassUnit, AngleUnit> divide(Angle divisor) {
+  public Per<MassUnit, AngleUnit> divide(Angle divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MassUnit, AngleUnit> per(AngleUnit divisorUnit) {
+  public Per<MassUnit, AngleUnit> per(AngleUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MassUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+  public Mult<MassUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
     return (Mult<MassUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MassUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
+  public Per<MassUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
     return (Per<MassUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -162,23 +171,23 @@ public interface Mass extends Measure<MassUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MassUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+  public Per<MassUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MassUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
+  public Per<MassUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MassUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+  public Mult<MassUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
     return (Mult<MassUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MassUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
+  public Per<MassUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
     return (Per<MassUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -190,23 +199,23 @@ public interface Mass extends Measure<MassUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MassUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+  public Per<MassUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MassUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
+  public Per<MassUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MassUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+  public Mult<MassUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
     return (Mult<MassUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MassUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
+  public Per<MassUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
     return (Per<MassUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -218,23 +227,23 @@ public interface Mass extends Measure<MassUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MassUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+  public Per<MassUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MassUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
+  public Per<MassUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MassUnit, CurrentUnit> times(Current multiplier) {
+  public Mult<MassUnit, CurrentUnit> times(Current multiplier) {
     return (Mult<MassUnit, CurrentUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MassUnit, CurrentUnit> div(Current divisor) {
+  public Per<MassUnit, CurrentUnit> div(Current divisor) {
     return (Per<MassUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
@@ -246,17 +255,17 @@ public interface Mass extends Measure<MassUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MassUnit, CurrentUnit> divide(Current divisor) {
+  public Per<MassUnit, CurrentUnit> divide(Current divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MassUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
+  public Per<MassUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
   @Override
-  default Mass div(Dimensionless divisor) {
+  public Mass div(Dimensionless divisor) {
     return (Mass) Kilograms.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -268,23 +277,23 @@ public interface Mass extends Measure<MassUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Mass divide(Dimensionless divisor) {
+  public Mass divide(Dimensionless divisor) {
     return (Mass) div(divisor);
   }
 
   @Override
-  default Mass times(Dimensionless multiplier) {
+  public Mass times(Dimensionless multiplier) {
     return (Mass) Kilograms.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
 
   @Override
-  default Mult<MassUnit, DistanceUnit> times(Distance multiplier) {
+  public Mult<MassUnit, DistanceUnit> times(Distance multiplier) {
     return (Mult<MassUnit, DistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MassUnit, DistanceUnit> div(Distance divisor) {
+  public Per<MassUnit, DistanceUnit> div(Distance divisor) {
     return (Per<MassUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -296,23 +305,23 @@ public interface Mass extends Measure<MassUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MassUnit, DistanceUnit> divide(Distance divisor) {
+  public Per<MassUnit, DistanceUnit> divide(Distance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MassUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
+  public Per<MassUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MassUnit, EnergyUnit> times(Energy multiplier) {
+  public Mult<MassUnit, EnergyUnit> times(Energy multiplier) {
     return (Mult<MassUnit, EnergyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MassUnit, EnergyUnit> div(Energy divisor) {
+  public Per<MassUnit, EnergyUnit> div(Energy divisor) {
     return (Per<MassUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
@@ -324,23 +333,23 @@ public interface Mass extends Measure<MassUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MassUnit, EnergyUnit> divide(Energy divisor) {
+  public Per<MassUnit, EnergyUnit> divide(Energy divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MassUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
+  public Per<MassUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MassUnit, ForceUnit> times(Force multiplier) {
+  public Mult<MassUnit, ForceUnit> times(Force multiplier) {
     return (Mult<MassUnit, ForceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MassUnit, ForceUnit> div(Force divisor) {
+  public Per<MassUnit, ForceUnit> div(Force divisor) {
     return (Per<MassUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
@@ -352,23 +361,23 @@ public interface Mass extends Measure<MassUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MassUnit, ForceUnit> divide(Force divisor) {
+  public Per<MassUnit, ForceUnit> divide(Force divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MassUnit, ForceUnit> per(ForceUnit divisorUnit) {
+  public Per<MassUnit, ForceUnit> per(ForceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MassUnit, FrequencyUnit> times(Frequency multiplier) {
+  public Mult<MassUnit, FrequencyUnit> times(Frequency multiplier) {
     return (Mult<MassUnit, FrequencyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MassUnit, FrequencyUnit> div(Frequency divisor) {
+  public Per<MassUnit, FrequencyUnit> div(Frequency divisor) {
     return (Per<MassUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
@@ -380,23 +389,23 @@ public interface Mass extends Measure<MassUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MassUnit, FrequencyUnit> divide(Frequency divisor) {
+  public Per<MassUnit, FrequencyUnit> divide(Frequency divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MassUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
+  public Per<MassUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Force times(LinearAcceleration multiplier) {
+  public Force times(LinearAcceleration multiplier) {
     return Newtons.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<MassUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
+  public Per<MassUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
     return (Per<MassUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -408,23 +417,23 @@ public interface Mass extends Measure<MassUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MassUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+  public Per<MassUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MassUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
+  public Per<MassUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MassUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+  public Mult<MassUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
     return (Mult<MassUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MassUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
+  public Per<MassUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
     return (Per<MassUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -436,23 +445,23 @@ public interface Mass extends Measure<MassUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MassUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+  public Per<MassUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MassUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
+  public Per<MassUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MassUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+  public Mult<MassUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
     return (Mult<MassUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MassUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
+  public Per<MassUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
     return (Per<MassUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -464,23 +473,23 @@ public interface Mass extends Measure<MassUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MassUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+  public Per<MassUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MassUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
+  public Per<MassUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MassUnit, MassUnit> times(Mass multiplier) {
+  public Mult<MassUnit, MassUnit> times(Mass multiplier) {
     return (Mult<MassUnit, MassUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Dimensionless div(Mass divisor) {
+  public Dimensionless div(Mass divisor) {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -492,23 +501,23 @@ public interface Mass extends Measure<MassUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Dimensionless divide(Mass divisor) {
+  public Dimensionless divide(Mass divisor) {
     return div(divisor);
   }
 
   @Override
-  default Dimensionless per(MassUnit divisorUnit) {
+  public Dimensionless per(MassUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MassUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+  public Mult<MassUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
     return (Mult<MassUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MassUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
+  public Per<MassUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
     return (Per<MassUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
@@ -520,23 +529,23 @@ public interface Mass extends Measure<MassUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MassUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+  public Per<MassUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MassUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
+  public Per<MassUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MassUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+  public Mult<MassUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
     return (Mult<MassUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MassUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
+  public Per<MassUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
     return (Per<MassUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -548,23 +557,23 @@ public interface Mass extends Measure<MassUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MassUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+  public Per<MassUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MassUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
+  public Per<MassUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<MassUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+  public Mult<MassUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
     return (Mult<MassUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MassUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
+  public Per<MassUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
     return (Per<MassUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -576,23 +585,23 @@ public interface Mass extends Measure<MassUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MassUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+  public Per<MassUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MassUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
+  public Per<MassUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<MassUnit, PowerUnit> times(Power multiplier) {
+  public Mult<MassUnit, PowerUnit> times(Power multiplier) {
     return (Mult<MassUnit, PowerUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MassUnit, PowerUnit> div(Power divisor) {
+  public Per<MassUnit, PowerUnit> div(Power divisor) {
     return (Per<MassUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
@@ -604,23 +613,23 @@ public interface Mass extends Measure<MassUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MassUnit, PowerUnit> divide(Power divisor) {
+  public Per<MassUnit, PowerUnit> divide(Power divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MassUnit, PowerUnit> per(PowerUnit divisorUnit) {
+  public Per<MassUnit, PowerUnit> per(PowerUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MassUnit, ResistanceUnit> times(Resistance multiplier) {
+  public Mult<MassUnit, ResistanceUnit> times(Resistance multiplier) {
     return (Mult<MassUnit, ResistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MassUnit, ResistanceUnit> div(Resistance divisor) {
+  public Per<MassUnit, ResistanceUnit> div(Resistance divisor) {
     return (Per<MassUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -632,23 +641,23 @@ public interface Mass extends Measure<MassUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MassUnit, ResistanceUnit> divide(Resistance divisor) {
+  public Per<MassUnit, ResistanceUnit> divide(Resistance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MassUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
+  public Per<MassUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MassUnit, TemperatureUnit> times(Temperature multiplier) {
+  public Mult<MassUnit, TemperatureUnit> times(Temperature multiplier) {
     return (Mult<MassUnit, TemperatureUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MassUnit, TemperatureUnit> div(Temperature divisor) {
+  public Per<MassUnit, TemperatureUnit> div(Temperature divisor) {
     return (Per<MassUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
@@ -660,23 +669,23 @@ public interface Mass extends Measure<MassUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MassUnit, TemperatureUnit> divide(Temperature divisor) {
+  public Per<MassUnit, TemperatureUnit> divide(Temperature divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MassUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
+  public Per<MassUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MassUnit, TimeUnit> times(Time multiplier) {
+  public Mult<MassUnit, TimeUnit> times(Time multiplier) {
     return (Mult<MassUnit, TimeUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Velocity<MassUnit> div(Time divisor) {
+  public Velocity<MassUnit> div(Time divisor) {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -688,23 +697,23 @@ public interface Mass extends Measure<MassUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Velocity<MassUnit> divide(Time divisor) {
+  public Velocity<MassUnit> divide(Time divisor) {
     return div(divisor);
   }
 
   @Override
-  default Velocity<MassUnit> per(TimeUnit divisorUnit) {
+  public Velocity<MassUnit> per(TimeUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MassUnit, TorqueUnit> times(Torque multiplier) {
+  public Mult<MassUnit, TorqueUnit> times(Torque multiplier) {
     return (Mult<MassUnit, TorqueUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MassUnit, TorqueUnit> div(Torque divisor) {
+  public Per<MassUnit, TorqueUnit> div(Torque divisor) {
     return (Per<MassUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
@@ -716,23 +725,23 @@ public interface Mass extends Measure<MassUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MassUnit, TorqueUnit> divide(Torque divisor) {
+  public Per<MassUnit, TorqueUnit> divide(Torque divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MassUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
+  public Per<MassUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MassUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+  public Mult<MassUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
     return (Mult<MassUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MassUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
+  public Per<MassUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
     return (Per<MassUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -744,23 +753,23 @@ public interface Mass extends Measure<MassUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MassUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+  public Per<MassUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MassUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
+  public Per<MassUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MassUnit, VoltageUnit> times(Voltage multiplier) {
+  public Mult<MassUnit, VoltageUnit> times(Voltage multiplier) {
     return (Mult<MassUnit, VoltageUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MassUnit, VoltageUnit> div(Voltage divisor) {
+  public Per<MassUnit, VoltageUnit> div(Voltage divisor) {
     return (Per<MassUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
@@ -772,12 +781,12 @@ public interface Mass extends Measure<MassUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MassUnit, VoltageUnit> divide(Voltage divisor) {
+  public Per<MassUnit, VoltageUnit> divide(Voltage divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MassUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
+  public Per<MassUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MomentOfInertia.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MomentOfInertia.java
index 21f04fbeb7..06aa4b636e 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MomentOfInertia.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MomentOfInertia.java
@@ -10,36 +10,45 @@ import static edu.wpi.first.units.Units.*;
 import edu.wpi.first.units.*;
 
 @SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
-  static  MomentOfInertia ofRelativeUnits(double magnitude, MomentOfInertiaUnit unit) {
-    return new ImmutableMomentOfInertia(magnitude, unit.toBaseUnits(magnitude), unit);
+public record MomentOfInertia(double magnitude, double baseUnitMagnitude, MomentOfInertiaUnit unit) implements Measure<MomentOfInertiaUnit> {
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link MomentOfInertiaUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  MomentOfInertia ofRelativeUnits(double magnitude, MomentOfInertiaUnit unit) {
+    return new MomentOfInertia(magnitude, unit.toBaseUnits(magnitude), unit);
   }
 
-  static  MomentOfInertia ofBaseUnits(double baseUnitMagnitude, MomentOfInertiaUnit unit) {
-    return new ImmutableMomentOfInertia(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link MomentOfInertiaUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit's base unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  MomentOfInertia ofBaseUnits(double baseUnitMagnitude, MomentOfInertiaUnit unit) {
+    return new MomentOfInertia(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
   }
 
   @Override
-  MomentOfInertia copy();
+  public MomentOfInertiaUnit baseUnit() { return (MomentOfInertiaUnit) unit().getBaseUnit(); }
 
   @Override
-  default MutMomentOfInertia mutableCopy() {
-    return new MutMomentOfInertia(magnitude(), baseUnitMagnitude(), unit());
-  }
-
-  @Override
-  MomentOfInertiaUnit unit();
-
-  @Override
-  default MomentOfInertiaUnit baseUnit() { return (MomentOfInertiaUnit) unit().getBaseUnit(); }
-
-  @Override
-  default double in(MomentOfInertiaUnit unit) {
+  public double in(MomentOfInertiaUnit unit) {
     return unit.fromBaseUnits(baseUnitMagnitude());
   }
 
   @Override
-  default MomentOfInertia unaryMinus() {
+  @SuppressWarnings("rawtypes")
+  public boolean equals(Object object) {
+    return object instanceof MomentOfInertia m && isEquivalent(m);
+  }
+
+  @Override
+  public MomentOfInertia unaryMinus() {
     return (MomentOfInertia) unit().ofBaseUnits(0 - baseUnitMagnitude());
   }
 
@@ -51,27 +60,27 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default MomentOfInertia negate() {
+  public MomentOfInertia negate() {
     return (MomentOfInertia) unaryMinus();
   }
 
   @Override
-  default MomentOfInertia plus(Measure<? extends MomentOfInertiaUnit> other) {
+  public MomentOfInertia plus(Measure<? extends MomentOfInertiaUnit> other) {
     return (MomentOfInertia) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
   }
 
   @Override
-  default MomentOfInertia minus(Measure<? extends MomentOfInertiaUnit> other) {
+  public MomentOfInertia minus(Measure<? extends MomentOfInertiaUnit> other) {
     return (MomentOfInertia) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
   }
 
   @Override
-  default MomentOfInertia times(double multiplier) {
+  public MomentOfInertia times(double multiplier) {
     return (MomentOfInertia) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
   }
 
   @Override
-  default MomentOfInertia div(double divisor) {
+  public MomentOfInertia div(double divisor) {
     return (MomentOfInertia) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
@@ -83,18 +92,18 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default MomentOfInertia divide(double divisor) {
+  public MomentOfInertia divide(double divisor) {
     return (MomentOfInertia) div(divisor);
   }
 
 
   @Override
-  default Mult<MomentOfInertiaUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+  public Mult<MomentOfInertiaUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
     return (Mult<MomentOfInertiaUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
+  public Per<MomentOfInertiaUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
     return (Per<MomentOfInertiaUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -106,23 +115,23 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MomentOfInertiaUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+  public Per<MomentOfInertiaUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
+  public Per<MomentOfInertiaUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MomentOfInertiaUnit, AngleUnit> times(Angle multiplier) {
+  public Mult<MomentOfInertiaUnit, AngleUnit> times(Angle multiplier) {
     return (Mult<MomentOfInertiaUnit, AngleUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, AngleUnit> div(Angle divisor) {
+  public Per<MomentOfInertiaUnit, AngleUnit> div(Angle divisor) {
     return (Per<MomentOfInertiaUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
@@ -134,23 +143,23 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MomentOfInertiaUnit, AngleUnit> divide(Angle divisor) {
+  public Per<MomentOfInertiaUnit, AngleUnit> divide(Angle divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, AngleUnit> per(AngleUnit divisorUnit) {
+  public Per<MomentOfInertiaUnit, AngleUnit> per(AngleUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MomentOfInertiaUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+  public Mult<MomentOfInertiaUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
     return (Mult<MomentOfInertiaUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
+  public Per<MomentOfInertiaUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
     return (Per<MomentOfInertiaUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -162,23 +171,23 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MomentOfInertiaUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+  public Per<MomentOfInertiaUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
+  public Per<MomentOfInertiaUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MomentOfInertiaUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+  public Mult<MomentOfInertiaUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
     return (Mult<MomentOfInertiaUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
+  public Per<MomentOfInertiaUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
     return (Per<MomentOfInertiaUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -190,23 +199,23 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MomentOfInertiaUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+  public Per<MomentOfInertiaUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
+  public Per<MomentOfInertiaUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default AngularMomentum times(AngularVelocity multiplier) {
+  public AngularMomentum times(AngularVelocity multiplier) {
     return KilogramMetersSquaredPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
+  public Per<MomentOfInertiaUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
     return (Per<MomentOfInertiaUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -218,23 +227,23 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MomentOfInertiaUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+  public Per<MomentOfInertiaUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
+  public Per<MomentOfInertiaUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MomentOfInertiaUnit, CurrentUnit> times(Current multiplier) {
+  public Mult<MomentOfInertiaUnit, CurrentUnit> times(Current multiplier) {
     return (Mult<MomentOfInertiaUnit, CurrentUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, CurrentUnit> div(Current divisor) {
+  public Per<MomentOfInertiaUnit, CurrentUnit> div(Current divisor) {
     return (Per<MomentOfInertiaUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
@@ -246,17 +255,17 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MomentOfInertiaUnit, CurrentUnit> divide(Current divisor) {
+  public Per<MomentOfInertiaUnit, CurrentUnit> divide(Current divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
+  public Per<MomentOfInertiaUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
   @Override
-  default MomentOfInertia div(Dimensionless divisor) {
+  public MomentOfInertia div(Dimensionless divisor) {
     return (MomentOfInertia) KilogramSquareMeters.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -268,23 +277,23 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default MomentOfInertia divide(Dimensionless divisor) {
+  public MomentOfInertia divide(Dimensionless divisor) {
     return (MomentOfInertia) div(divisor);
   }
 
   @Override
-  default MomentOfInertia times(Dimensionless multiplier) {
+  public MomentOfInertia times(Dimensionless multiplier) {
     return (MomentOfInertia) KilogramSquareMeters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
 
   @Override
-  default Mult<MomentOfInertiaUnit, DistanceUnit> times(Distance multiplier) {
+  public Mult<MomentOfInertiaUnit, DistanceUnit> times(Distance multiplier) {
     return (Mult<MomentOfInertiaUnit, DistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, DistanceUnit> div(Distance divisor) {
+  public Per<MomentOfInertiaUnit, DistanceUnit> div(Distance divisor) {
     return (Per<MomentOfInertiaUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -296,23 +305,23 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MomentOfInertiaUnit, DistanceUnit> divide(Distance divisor) {
+  public Per<MomentOfInertiaUnit, DistanceUnit> divide(Distance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
+  public Per<MomentOfInertiaUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MomentOfInertiaUnit, EnergyUnit> times(Energy multiplier) {
+  public Mult<MomentOfInertiaUnit, EnergyUnit> times(Energy multiplier) {
     return (Mult<MomentOfInertiaUnit, EnergyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, EnergyUnit> div(Energy divisor) {
+  public Per<MomentOfInertiaUnit, EnergyUnit> div(Energy divisor) {
     return (Per<MomentOfInertiaUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
@@ -324,23 +333,23 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MomentOfInertiaUnit, EnergyUnit> divide(Energy divisor) {
+  public Per<MomentOfInertiaUnit, EnergyUnit> divide(Energy divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
+  public Per<MomentOfInertiaUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MomentOfInertiaUnit, ForceUnit> times(Force multiplier) {
+  public Mult<MomentOfInertiaUnit, ForceUnit> times(Force multiplier) {
     return (Mult<MomentOfInertiaUnit, ForceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, ForceUnit> div(Force divisor) {
+  public Per<MomentOfInertiaUnit, ForceUnit> div(Force divisor) {
     return (Per<MomentOfInertiaUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
@@ -352,23 +361,23 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MomentOfInertiaUnit, ForceUnit> divide(Force divisor) {
+  public Per<MomentOfInertiaUnit, ForceUnit> divide(Force divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, ForceUnit> per(ForceUnit divisorUnit) {
+  public Per<MomentOfInertiaUnit, ForceUnit> per(ForceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MomentOfInertiaUnit, FrequencyUnit> times(Frequency multiplier) {
+  public Mult<MomentOfInertiaUnit, FrequencyUnit> times(Frequency multiplier) {
     return (Mult<MomentOfInertiaUnit, FrequencyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, FrequencyUnit> div(Frequency divisor) {
+  public Per<MomentOfInertiaUnit, FrequencyUnit> div(Frequency divisor) {
     return (Per<MomentOfInertiaUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
@@ -380,23 +389,23 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MomentOfInertiaUnit, FrequencyUnit> divide(Frequency divisor) {
+  public Per<MomentOfInertiaUnit, FrequencyUnit> divide(Frequency divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
+  public Per<MomentOfInertiaUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MomentOfInertiaUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+  public Mult<MomentOfInertiaUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
     return (Mult<MomentOfInertiaUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
+  public Per<MomentOfInertiaUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
     return (Per<MomentOfInertiaUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -408,23 +417,23 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MomentOfInertiaUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+  public Per<MomentOfInertiaUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
+  public Per<MomentOfInertiaUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MomentOfInertiaUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+  public Mult<MomentOfInertiaUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
     return (Mult<MomentOfInertiaUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
+  public Per<MomentOfInertiaUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
     return (Per<MomentOfInertiaUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -436,23 +445,23 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MomentOfInertiaUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+  public Per<MomentOfInertiaUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
+  public Per<MomentOfInertiaUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MomentOfInertiaUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+  public Mult<MomentOfInertiaUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
     return (Mult<MomentOfInertiaUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
+  public Per<MomentOfInertiaUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
     return (Per<MomentOfInertiaUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -464,23 +473,23 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MomentOfInertiaUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+  public Per<MomentOfInertiaUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
+  public Per<MomentOfInertiaUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MomentOfInertiaUnit, MassUnit> times(Mass multiplier) {
+  public Mult<MomentOfInertiaUnit, MassUnit> times(Mass multiplier) {
     return (Mult<MomentOfInertiaUnit, MassUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, MassUnit> div(Mass divisor) {
+  public Per<MomentOfInertiaUnit, MassUnit> div(Mass divisor) {
     return (Per<MomentOfInertiaUnit, MassUnit>) Measure.super.div(divisor);
   }
 
@@ -492,23 +501,23 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MomentOfInertiaUnit, MassUnit> divide(Mass divisor) {
+  public Per<MomentOfInertiaUnit, MassUnit> divide(Mass divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, MassUnit> per(MassUnit divisorUnit) {
+  public Per<MomentOfInertiaUnit, MassUnit> per(MassUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MomentOfInertiaUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+  public Mult<MomentOfInertiaUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
     return (Mult<MomentOfInertiaUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Dimensionless div(MomentOfInertia divisor) {
+  public Dimensionless div(MomentOfInertia divisor) {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -520,23 +529,23 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Dimensionless divide(MomentOfInertia divisor) {
+  public Dimensionless divide(MomentOfInertia divisor) {
     return div(divisor);
   }
 
   @Override
-  default Dimensionless per(MomentOfInertiaUnit divisorUnit) {
+  public Dimensionless per(MomentOfInertiaUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MomentOfInertiaUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+  public Mult<MomentOfInertiaUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
     return (Mult<MomentOfInertiaUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
+  public Per<MomentOfInertiaUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
     return (Per<MomentOfInertiaUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -548,23 +557,23 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MomentOfInertiaUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+  public Per<MomentOfInertiaUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
+  public Per<MomentOfInertiaUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<MomentOfInertiaUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+  public Mult<MomentOfInertiaUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
     return (Mult<MomentOfInertiaUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
+  public Per<MomentOfInertiaUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
     return (Per<MomentOfInertiaUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -576,23 +585,23 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MomentOfInertiaUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+  public Per<MomentOfInertiaUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
+  public Per<MomentOfInertiaUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<MomentOfInertiaUnit, PowerUnit> times(Power multiplier) {
+  public Mult<MomentOfInertiaUnit, PowerUnit> times(Power multiplier) {
     return (Mult<MomentOfInertiaUnit, PowerUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, PowerUnit> div(Power divisor) {
+  public Per<MomentOfInertiaUnit, PowerUnit> div(Power divisor) {
     return (Per<MomentOfInertiaUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
@@ -604,23 +613,23 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MomentOfInertiaUnit, PowerUnit> divide(Power divisor) {
+  public Per<MomentOfInertiaUnit, PowerUnit> divide(Power divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, PowerUnit> per(PowerUnit divisorUnit) {
+  public Per<MomentOfInertiaUnit, PowerUnit> per(PowerUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MomentOfInertiaUnit, ResistanceUnit> times(Resistance multiplier) {
+  public Mult<MomentOfInertiaUnit, ResistanceUnit> times(Resistance multiplier) {
     return (Mult<MomentOfInertiaUnit, ResistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, ResistanceUnit> div(Resistance divisor) {
+  public Per<MomentOfInertiaUnit, ResistanceUnit> div(Resistance divisor) {
     return (Per<MomentOfInertiaUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -632,23 +641,23 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MomentOfInertiaUnit, ResistanceUnit> divide(Resistance divisor) {
+  public Per<MomentOfInertiaUnit, ResistanceUnit> divide(Resistance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
+  public Per<MomentOfInertiaUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MomentOfInertiaUnit, TemperatureUnit> times(Temperature multiplier) {
+  public Mult<MomentOfInertiaUnit, TemperatureUnit> times(Temperature multiplier) {
     return (Mult<MomentOfInertiaUnit, TemperatureUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, TemperatureUnit> div(Temperature divisor) {
+  public Per<MomentOfInertiaUnit, TemperatureUnit> div(Temperature divisor) {
     return (Per<MomentOfInertiaUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
@@ -660,23 +669,23 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MomentOfInertiaUnit, TemperatureUnit> divide(Temperature divisor) {
+  public Per<MomentOfInertiaUnit, TemperatureUnit> divide(Temperature divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
+  public Per<MomentOfInertiaUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MomentOfInertiaUnit, TimeUnit> times(Time multiplier) {
+  public Mult<MomentOfInertiaUnit, TimeUnit> times(Time multiplier) {
     return (Mult<MomentOfInertiaUnit, TimeUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Velocity<MomentOfInertiaUnit> div(Time divisor) {
+  public Velocity<MomentOfInertiaUnit> div(Time divisor) {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -688,23 +697,23 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Velocity<MomentOfInertiaUnit> divide(Time divisor) {
+  public Velocity<MomentOfInertiaUnit> divide(Time divisor) {
     return div(divisor);
   }
 
   @Override
-  default Velocity<MomentOfInertiaUnit> per(TimeUnit divisorUnit) {
+  public Velocity<MomentOfInertiaUnit> per(TimeUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MomentOfInertiaUnit, TorqueUnit> times(Torque multiplier) {
+  public Mult<MomentOfInertiaUnit, TorqueUnit> times(Torque multiplier) {
     return (Mult<MomentOfInertiaUnit, TorqueUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, TorqueUnit> div(Torque divisor) {
+  public Per<MomentOfInertiaUnit, TorqueUnit> div(Torque divisor) {
     return (Per<MomentOfInertiaUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
@@ -716,23 +725,23 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MomentOfInertiaUnit, TorqueUnit> divide(Torque divisor) {
+  public Per<MomentOfInertiaUnit, TorqueUnit> divide(Torque divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
+  public Per<MomentOfInertiaUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MomentOfInertiaUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+  public Mult<MomentOfInertiaUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
     return (Mult<MomentOfInertiaUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
+  public Per<MomentOfInertiaUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
     return (Per<MomentOfInertiaUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -744,23 +753,23 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MomentOfInertiaUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+  public Per<MomentOfInertiaUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
+  public Per<MomentOfInertiaUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MomentOfInertiaUnit, VoltageUnit> times(Voltage multiplier) {
+  public Mult<MomentOfInertiaUnit, VoltageUnit> times(Voltage multiplier) {
     return (Mult<MomentOfInertiaUnit, VoltageUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, VoltageUnit> div(Voltage divisor) {
+  public Per<MomentOfInertiaUnit, VoltageUnit> div(Voltage divisor) {
     return (Per<MomentOfInertiaUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
@@ -772,12 +781,12 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MomentOfInertiaUnit, VoltageUnit> divide(Voltage divisor) {
+  public Per<MomentOfInertiaUnit, VoltageUnit> divide(Voltage divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MomentOfInertiaUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
+  public Per<MomentOfInertiaUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mult.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mult.java
index 5cee72363d..a9c0eadc87 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mult.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mult.java
@@ -10,36 +10,45 @@ import static edu.wpi.first.units.Units.*;
 import edu.wpi.first.units.*;
 
 @SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A, B>> {
-  static <A extends Unit, B extends Unit> Mult<A, B> ofRelativeUnits(double magnitude, MultUnit<A, B> unit) {
-    return new ImmutableMult<A, B>(magnitude, unit.toBaseUnits(magnitude), unit);
+public record Mult<A extends Unit, B extends Unit>(double magnitude, double baseUnitMagnitude, MultUnit<A, B> unit) implements Measure<MultUnit<A, B>> {
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link MultUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static <A extends Unit, B extends Unit> Mult<A, B> ofRelativeUnits(double magnitude, MultUnit<A, B> unit) {
+    return new Mult<A, B>(magnitude, unit.toBaseUnits(magnitude), unit);
   }
 
-  static <A extends Unit, B extends Unit> Mult<A, B> ofBaseUnits(double baseUnitMagnitude, MultUnit<A, B> unit) {
-    return new ImmutableMult<A, B>(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link MultUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit's base unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static <A extends Unit, B extends Unit> Mult<A, B> ofBaseUnits(double baseUnitMagnitude, MultUnit<A, B> unit) {
+    return new Mult<A, B>(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
   }
 
   @Override
-  Mult<A, B> copy();
+  public MultUnit<A, B> baseUnit() { return (MultUnit<A, B>) unit().getBaseUnit(); }
 
   @Override
-  default MutMult<A, B> mutableCopy() {
-    return new MutMult<A, B>(magnitude(), baseUnitMagnitude(), unit());
-  }
-
-  @Override
-  MultUnit<A, B> unit();
-
-  @Override
-  default MultUnit<A, B> baseUnit() { return (MultUnit<A, B>) unit().getBaseUnit(); }
-
-  @Override
-  default double in(MultUnit<A, B> unit) {
+  public double in(MultUnit<A, B> unit) {
     return unit.fromBaseUnits(baseUnitMagnitude());
   }
 
   @Override
-  default Mult<A, B> unaryMinus() {
+  @SuppressWarnings("rawtypes")
+  public boolean equals(Object object) {
+    return object instanceof Mult m && isEquivalent(m);
+  }
+
+  @Override
+  public Mult<A, B> unaryMinus() {
     return (Mult<A, B>) unit().ofBaseUnits(0 - baseUnitMagnitude());
   }
 
@@ -51,27 +60,27 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Mult<A, B> negate() {
+  public Mult<A, B> negate() {
     return (Mult<A, B>) unaryMinus();
   }
 
   @Override
-  default Mult<A, B> plus(Measure<? extends MultUnit<A, B>> other) {
+  public Mult<A, B> plus(Measure<? extends MultUnit<A, B>> other) {
     return (Mult<A, B>) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
   }
 
   @Override
-  default Mult<A, B> minus(Measure<? extends MultUnit<A, B>> other) {
+  public Mult<A, B> minus(Measure<? extends MultUnit<A, B>> other) {
     return (Mult<A, B>) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
   }
 
   @Override
-  default Mult<A, B> times(double multiplier) {
+  public Mult<A, B> times(double multiplier) {
     return (Mult<A, B>) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
   }
 
   @Override
-  default Mult<A, B> div(double divisor) {
+  public Mult<A, B> div(double divisor) {
     return (Mult<A, B>) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
@@ -83,18 +92,18 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Mult<A, B> divide(double divisor) {
+  public Mult<A, B> divide(double divisor) {
     return (Mult<A, B>) div(divisor);
   }
 
 
   @Override
-  default Mult<MultUnit<A, B>, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+  public Mult<MultUnit<A, B>, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
     return (Mult<MultUnit<A, B>, AccelerationUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MultUnit<A, B>, AccelerationUnit<?>> div(Acceleration<?> divisor) {
+  public Per<MultUnit<A, B>, AccelerationUnit<?>> div(Acceleration<?> divisor) {
     return (Per<MultUnit<A, B>, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -106,23 +115,23 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MultUnit<A, B>, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+  public Per<MultUnit<A, B>, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MultUnit<A, B>, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
+  public Per<MultUnit<A, B>, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MultUnit<A, B>, AngleUnit> times(Angle multiplier) {
+  public Mult<MultUnit<A, B>, AngleUnit> times(Angle multiplier) {
     return (Mult<MultUnit<A, B>, AngleUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MultUnit<A, B>, AngleUnit> div(Angle divisor) {
+  public Per<MultUnit<A, B>, AngleUnit> div(Angle divisor) {
     return (Per<MultUnit<A, B>, AngleUnit>) Measure.super.div(divisor);
   }
 
@@ -134,23 +143,23 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MultUnit<A, B>, AngleUnit> divide(Angle divisor) {
+  public Per<MultUnit<A, B>, AngleUnit> divide(Angle divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MultUnit<A, B>, AngleUnit> per(AngleUnit divisorUnit) {
+  public Per<MultUnit<A, B>, AngleUnit> per(AngleUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MultUnit<A, B>, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+  public Mult<MultUnit<A, B>, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
     return (Mult<MultUnit<A, B>, AngularAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MultUnit<A, B>, AngularAccelerationUnit> div(AngularAcceleration divisor) {
+  public Per<MultUnit<A, B>, AngularAccelerationUnit> div(AngularAcceleration divisor) {
     return (Per<MultUnit<A, B>, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -162,23 +171,23 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MultUnit<A, B>, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+  public Per<MultUnit<A, B>, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MultUnit<A, B>, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
+  public Per<MultUnit<A, B>, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MultUnit<A, B>, AngularMomentumUnit> times(AngularMomentum multiplier) {
+  public Mult<MultUnit<A, B>, AngularMomentumUnit> times(AngularMomentum multiplier) {
     return (Mult<MultUnit<A, B>, AngularMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MultUnit<A, B>, AngularMomentumUnit> div(AngularMomentum divisor) {
+  public Per<MultUnit<A, B>, AngularMomentumUnit> div(AngularMomentum divisor) {
     return (Per<MultUnit<A, B>, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -190,23 +199,23 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MultUnit<A, B>, AngularMomentumUnit> divide(AngularMomentum divisor) {
+  public Per<MultUnit<A, B>, AngularMomentumUnit> divide(AngularMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MultUnit<A, B>, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
+  public Per<MultUnit<A, B>, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MultUnit<A, B>, AngularVelocityUnit> times(AngularVelocity multiplier) {
+  public Mult<MultUnit<A, B>, AngularVelocityUnit> times(AngularVelocity multiplier) {
     return (Mult<MultUnit<A, B>, AngularVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MultUnit<A, B>, AngularVelocityUnit> div(AngularVelocity divisor) {
+  public Per<MultUnit<A, B>, AngularVelocityUnit> div(AngularVelocity divisor) {
     return (Per<MultUnit<A, B>, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -218,23 +227,23 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MultUnit<A, B>, AngularVelocityUnit> divide(AngularVelocity divisor) {
+  public Per<MultUnit<A, B>, AngularVelocityUnit> divide(AngularVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MultUnit<A, B>, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
+  public Per<MultUnit<A, B>, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MultUnit<A, B>, CurrentUnit> times(Current multiplier) {
+  public Mult<MultUnit<A, B>, CurrentUnit> times(Current multiplier) {
     return (Mult<MultUnit<A, B>, CurrentUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MultUnit<A, B>, CurrentUnit> div(Current divisor) {
+  public Per<MultUnit<A, B>, CurrentUnit> div(Current divisor) {
     return (Per<MultUnit<A, B>, CurrentUnit>) Measure.super.div(divisor);
   }
 
@@ -246,17 +255,17 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MultUnit<A, B>, CurrentUnit> divide(Current divisor) {
+  public Per<MultUnit<A, B>, CurrentUnit> divide(Current divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MultUnit<A, B>, CurrentUnit> per(CurrentUnit divisorUnit) {
+  public Per<MultUnit<A, B>, CurrentUnit> per(CurrentUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
   @Override
-  default Mult<A, B> div(Dimensionless divisor) {
+  public Mult<A, B> div(Dimensionless divisor) {
     return (Mult<A, B>) unit().of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -268,23 +277,23 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Mult<A, B> divide(Dimensionless divisor) {
+  public Mult<A, B> divide(Dimensionless divisor) {
     return (Mult<A, B>) div(divisor);
   }
 
   @Override
-  default Mult<A, B> times(Dimensionless multiplier) {
+  public Mult<A, B> times(Dimensionless multiplier) {
     return (Mult<A, B>) unit().of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
 
   @Override
-  default Mult<MultUnit<A, B>, DistanceUnit> times(Distance multiplier) {
+  public Mult<MultUnit<A, B>, DistanceUnit> times(Distance multiplier) {
     return (Mult<MultUnit<A, B>, DistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MultUnit<A, B>, DistanceUnit> div(Distance divisor) {
+  public Per<MultUnit<A, B>, DistanceUnit> div(Distance divisor) {
     return (Per<MultUnit<A, B>, DistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -296,23 +305,23 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MultUnit<A, B>, DistanceUnit> divide(Distance divisor) {
+  public Per<MultUnit<A, B>, DistanceUnit> divide(Distance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MultUnit<A, B>, DistanceUnit> per(DistanceUnit divisorUnit) {
+  public Per<MultUnit<A, B>, DistanceUnit> per(DistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MultUnit<A, B>, EnergyUnit> times(Energy multiplier) {
+  public Mult<MultUnit<A, B>, EnergyUnit> times(Energy multiplier) {
     return (Mult<MultUnit<A, B>, EnergyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MultUnit<A, B>, EnergyUnit> div(Energy divisor) {
+  public Per<MultUnit<A, B>, EnergyUnit> div(Energy divisor) {
     return (Per<MultUnit<A, B>, EnergyUnit>) Measure.super.div(divisor);
   }
 
@@ -324,23 +333,23 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MultUnit<A, B>, EnergyUnit> divide(Energy divisor) {
+  public Per<MultUnit<A, B>, EnergyUnit> divide(Energy divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MultUnit<A, B>, EnergyUnit> per(EnergyUnit divisorUnit) {
+  public Per<MultUnit<A, B>, EnergyUnit> per(EnergyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MultUnit<A, B>, ForceUnit> times(Force multiplier) {
+  public Mult<MultUnit<A, B>, ForceUnit> times(Force multiplier) {
     return (Mult<MultUnit<A, B>, ForceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MultUnit<A, B>, ForceUnit> div(Force divisor) {
+  public Per<MultUnit<A, B>, ForceUnit> div(Force divisor) {
     return (Per<MultUnit<A, B>, ForceUnit>) Measure.super.div(divisor);
   }
 
@@ -352,23 +361,23 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MultUnit<A, B>, ForceUnit> divide(Force divisor) {
+  public Per<MultUnit<A, B>, ForceUnit> divide(Force divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MultUnit<A, B>, ForceUnit> per(ForceUnit divisorUnit) {
+  public Per<MultUnit<A, B>, ForceUnit> per(ForceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MultUnit<A, B>, FrequencyUnit> times(Frequency multiplier) {
+  public Mult<MultUnit<A, B>, FrequencyUnit> times(Frequency multiplier) {
     return (Mult<MultUnit<A, B>, FrequencyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MultUnit<A, B>, FrequencyUnit> div(Frequency divisor) {
+  public Per<MultUnit<A, B>, FrequencyUnit> div(Frequency divisor) {
     return (Per<MultUnit<A, B>, FrequencyUnit>) Measure.super.div(divisor);
   }
 
@@ -380,23 +389,23 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MultUnit<A, B>, FrequencyUnit> divide(Frequency divisor) {
+  public Per<MultUnit<A, B>, FrequencyUnit> divide(Frequency divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MultUnit<A, B>, FrequencyUnit> per(FrequencyUnit divisorUnit) {
+  public Per<MultUnit<A, B>, FrequencyUnit> per(FrequencyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MultUnit<A, B>, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+  public Mult<MultUnit<A, B>, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
     return (Mult<MultUnit<A, B>, LinearAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MultUnit<A, B>, LinearAccelerationUnit> div(LinearAcceleration divisor) {
+  public Per<MultUnit<A, B>, LinearAccelerationUnit> div(LinearAcceleration divisor) {
     return (Per<MultUnit<A, B>, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -408,23 +417,23 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MultUnit<A, B>, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+  public Per<MultUnit<A, B>, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MultUnit<A, B>, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
+  public Per<MultUnit<A, B>, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MultUnit<A, B>, LinearMomentumUnit> times(LinearMomentum multiplier) {
+  public Mult<MultUnit<A, B>, LinearMomentumUnit> times(LinearMomentum multiplier) {
     return (Mult<MultUnit<A, B>, LinearMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MultUnit<A, B>, LinearMomentumUnit> div(LinearMomentum divisor) {
+  public Per<MultUnit<A, B>, LinearMomentumUnit> div(LinearMomentum divisor) {
     return (Per<MultUnit<A, B>, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -436,23 +445,23 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MultUnit<A, B>, LinearMomentumUnit> divide(LinearMomentum divisor) {
+  public Per<MultUnit<A, B>, LinearMomentumUnit> divide(LinearMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MultUnit<A, B>, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
+  public Per<MultUnit<A, B>, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MultUnit<A, B>, LinearVelocityUnit> times(LinearVelocity multiplier) {
+  public Mult<MultUnit<A, B>, LinearVelocityUnit> times(LinearVelocity multiplier) {
     return (Mult<MultUnit<A, B>, LinearVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MultUnit<A, B>, LinearVelocityUnit> div(LinearVelocity divisor) {
+  public Per<MultUnit<A, B>, LinearVelocityUnit> div(LinearVelocity divisor) {
     return (Per<MultUnit<A, B>, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -464,23 +473,23 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MultUnit<A, B>, LinearVelocityUnit> divide(LinearVelocity divisor) {
+  public Per<MultUnit<A, B>, LinearVelocityUnit> divide(LinearVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MultUnit<A, B>, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
+  public Per<MultUnit<A, B>, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MultUnit<A, B>, MassUnit> times(Mass multiplier) {
+  public Mult<MultUnit<A, B>, MassUnit> times(Mass multiplier) {
     return (Mult<MultUnit<A, B>, MassUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MultUnit<A, B>, MassUnit> div(Mass divisor) {
+  public Per<MultUnit<A, B>, MassUnit> div(Mass divisor) {
     return (Per<MultUnit<A, B>, MassUnit>) Measure.super.div(divisor);
   }
 
@@ -492,23 +501,23 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MultUnit<A, B>, MassUnit> divide(Mass divisor) {
+  public Per<MultUnit<A, B>, MassUnit> divide(Mass divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MultUnit<A, B>, MassUnit> per(MassUnit divisorUnit) {
+  public Per<MultUnit<A, B>, MassUnit> per(MassUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MultUnit<A, B>, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+  public Mult<MultUnit<A, B>, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
     return (Mult<MultUnit<A, B>, MomentOfInertiaUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MultUnit<A, B>, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
+  public Per<MultUnit<A, B>, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
     return (Per<MultUnit<A, B>, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
@@ -520,23 +529,23 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MultUnit<A, B>, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+  public Per<MultUnit<A, B>, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MultUnit<A, B>, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
+  public Per<MultUnit<A, B>, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MultUnit<A, B>, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+  public Mult<MultUnit<A, B>, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
     return (Mult<MultUnit<A, B>, MultUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MultUnit<A, B>, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
+  public Per<MultUnit<A, B>, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
     return (Per<MultUnit<A, B>, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -548,23 +557,23 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MultUnit<A, B>, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+  public Per<MultUnit<A, B>, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MultUnit<A, B>, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
+  public Per<MultUnit<A, B>, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<MultUnit<A, B>, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+  public Mult<MultUnit<A, B>, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
     return (Mult<MultUnit<A, B>, PerUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MultUnit<A, B>, PerUnit<?, ?>> div(Per<?, ?> divisor) {
+  public Per<MultUnit<A, B>, PerUnit<?, ?>> div(Per<?, ?> divisor) {
     return (Per<MultUnit<A, B>, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -576,23 +585,23 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MultUnit<A, B>, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+  public Per<MultUnit<A, B>, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MultUnit<A, B>, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
+  public Per<MultUnit<A, B>, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<MultUnit<A, B>, PowerUnit> times(Power multiplier) {
+  public Mult<MultUnit<A, B>, PowerUnit> times(Power multiplier) {
     return (Mult<MultUnit<A, B>, PowerUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MultUnit<A, B>, PowerUnit> div(Power divisor) {
+  public Per<MultUnit<A, B>, PowerUnit> div(Power divisor) {
     return (Per<MultUnit<A, B>, PowerUnit>) Measure.super.div(divisor);
   }
 
@@ -604,23 +613,23 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MultUnit<A, B>, PowerUnit> divide(Power divisor) {
+  public Per<MultUnit<A, B>, PowerUnit> divide(Power divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MultUnit<A, B>, PowerUnit> per(PowerUnit divisorUnit) {
+  public Per<MultUnit<A, B>, PowerUnit> per(PowerUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MultUnit<A, B>, ResistanceUnit> times(Resistance multiplier) {
+  public Mult<MultUnit<A, B>, ResistanceUnit> times(Resistance multiplier) {
     return (Mult<MultUnit<A, B>, ResistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MultUnit<A, B>, ResistanceUnit> div(Resistance divisor) {
+  public Per<MultUnit<A, B>, ResistanceUnit> div(Resistance divisor) {
     return (Per<MultUnit<A, B>, ResistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -632,23 +641,23 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MultUnit<A, B>, ResistanceUnit> divide(Resistance divisor) {
+  public Per<MultUnit<A, B>, ResistanceUnit> divide(Resistance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MultUnit<A, B>, ResistanceUnit> per(ResistanceUnit divisorUnit) {
+  public Per<MultUnit<A, B>, ResistanceUnit> per(ResistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MultUnit<A, B>, TemperatureUnit> times(Temperature multiplier) {
+  public Mult<MultUnit<A, B>, TemperatureUnit> times(Temperature multiplier) {
     return (Mult<MultUnit<A, B>, TemperatureUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MultUnit<A, B>, TemperatureUnit> div(Temperature divisor) {
+  public Per<MultUnit<A, B>, TemperatureUnit> div(Temperature divisor) {
     return (Per<MultUnit<A, B>, TemperatureUnit>) Measure.super.div(divisor);
   }
 
@@ -660,23 +669,23 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MultUnit<A, B>, TemperatureUnit> divide(Temperature divisor) {
+  public Per<MultUnit<A, B>, TemperatureUnit> divide(Temperature divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MultUnit<A, B>, TemperatureUnit> per(TemperatureUnit divisorUnit) {
+  public Per<MultUnit<A, B>, TemperatureUnit> per(TemperatureUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MultUnit<A, B>, TimeUnit> times(Time multiplier) {
+  public Mult<MultUnit<A, B>, TimeUnit> times(Time multiplier) {
     return (Mult<MultUnit<A, B>, TimeUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Velocity<MultUnit<A, B>> div(Time divisor) {
+  public Velocity<MultUnit<A, B>> div(Time divisor) {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -688,23 +697,23 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Velocity<MultUnit<A, B>> divide(Time divisor) {
+  public Velocity<MultUnit<A, B>> divide(Time divisor) {
     return div(divisor);
   }
 
   @Override
-  default Velocity<MultUnit<A, B>> per(TimeUnit divisorUnit) {
+  public Velocity<MultUnit<A, B>> per(TimeUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MultUnit<A, B>, TorqueUnit> times(Torque multiplier) {
+  public Mult<MultUnit<A, B>, TorqueUnit> times(Torque multiplier) {
     return (Mult<MultUnit<A, B>, TorqueUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MultUnit<A, B>, TorqueUnit> div(Torque divisor) {
+  public Per<MultUnit<A, B>, TorqueUnit> div(Torque divisor) {
     return (Per<MultUnit<A, B>, TorqueUnit>) Measure.super.div(divisor);
   }
 
@@ -716,23 +725,23 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MultUnit<A, B>, TorqueUnit> divide(Torque divisor) {
+  public Per<MultUnit<A, B>, TorqueUnit> divide(Torque divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MultUnit<A, B>, TorqueUnit> per(TorqueUnit divisorUnit) {
+  public Per<MultUnit<A, B>, TorqueUnit> per(TorqueUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MultUnit<A, B>, VelocityUnit<?>> times(Velocity<?> multiplier) {
+  public Mult<MultUnit<A, B>, VelocityUnit<?>> times(Velocity<?> multiplier) {
     return (Mult<MultUnit<A, B>, VelocityUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MultUnit<A, B>, VelocityUnit<?>> div(Velocity<?> divisor) {
+  public Per<MultUnit<A, B>, VelocityUnit<?>> div(Velocity<?> divisor) {
     return (Per<MultUnit<A, B>, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -744,23 +753,23 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MultUnit<A, B>, VelocityUnit<?>> divide(Velocity<?> divisor) {
+  public Per<MultUnit<A, B>, VelocityUnit<?>> divide(Velocity<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MultUnit<A, B>, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
+  public Per<MultUnit<A, B>, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<MultUnit<A, B>, VoltageUnit> times(Voltage multiplier) {
+  public Mult<MultUnit<A, B>, VoltageUnit> times(Voltage multiplier) {
     return (Mult<MultUnit<A, B>, VoltageUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<MultUnit<A, B>, VoltageUnit> div(Voltage divisor) {
+  public Per<MultUnit<A, B>, VoltageUnit> div(Voltage divisor) {
     return (Per<MultUnit<A, B>, VoltageUnit>) Measure.super.div(divisor);
   }
 
@@ -772,12 +781,12 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<MultUnit<A, B>, VoltageUnit> divide(Voltage divisor) {
+  public Per<MultUnit<A, B>, VoltageUnit> divide(Voltage divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<MultUnit<A, B>, VoltageUnit> per(VoltageUnit divisorUnit) {
+  public Per<MultUnit<A, B>, VoltageUnit> per(VoltageUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAcceleration.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAcceleration.java
deleted file mode 100644
index ed74009c45..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAcceleration.java
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-import edu.wpi.first.units.mutable.MutableMeasureBase;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public final class MutAcceleration<D extends Unit>
-  extends MutableMeasureBase<AccelerationUnit<D>, Acceleration<D>, MutAcceleration<D>>
-  implements Acceleration<D> {
-  public MutAcceleration(double magnitude, double baseUnitMagnitude, AccelerationUnit<D> unit) {
-    super(magnitude, baseUnitMagnitude, unit);
-  }
-
-  @Override
-  public Acceleration<D> copy() {
-    return new ImmutableAcceleration<D>(magnitude(), baseUnitMagnitude(), unit());
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAngle.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAngle.java
deleted file mode 100644
index ff356e33c2..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAngle.java
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-import edu.wpi.first.units.mutable.MutableMeasureBase;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public final class MutAngle
-  extends MutableMeasureBase<AngleUnit, Angle, MutAngle>
-  implements Angle {
-  public MutAngle(double magnitude, double baseUnitMagnitude, AngleUnit unit) {
-    super(magnitude, baseUnitMagnitude, unit);
-  }
-
-  @Override
-  public Angle copy() {
-    return new ImmutableAngle(magnitude(), baseUnitMagnitude(), unit());
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAngularAcceleration.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAngularAcceleration.java
deleted file mode 100644
index 8d7cecc803..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAngularAcceleration.java
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-import edu.wpi.first.units.mutable.MutableMeasureBase;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public final class MutAngularAcceleration
-  extends MutableMeasureBase<AngularAccelerationUnit, AngularAcceleration, MutAngularAcceleration>
-  implements AngularAcceleration {
-  public MutAngularAcceleration(double magnitude, double baseUnitMagnitude, AngularAccelerationUnit unit) {
-    super(magnitude, baseUnitMagnitude, unit);
-  }
-
-  @Override
-  public AngularAcceleration copy() {
-    return new ImmutableAngularAcceleration(magnitude(), baseUnitMagnitude(), unit());
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAngularMomentum.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAngularMomentum.java
deleted file mode 100644
index c7ee472622..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAngularMomentum.java
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-import edu.wpi.first.units.mutable.MutableMeasureBase;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public final class MutAngularMomentum
-  extends MutableMeasureBase<AngularMomentumUnit, AngularMomentum, MutAngularMomentum>
-  implements AngularMomentum {
-  public MutAngularMomentum(double magnitude, double baseUnitMagnitude, AngularMomentumUnit unit) {
-    super(magnitude, baseUnitMagnitude, unit);
-  }
-
-  @Override
-  public AngularMomentum copy() {
-    return new ImmutableAngularMomentum(magnitude(), baseUnitMagnitude(), unit());
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAngularVelocity.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAngularVelocity.java
deleted file mode 100644
index d4083e179c..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAngularVelocity.java
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-import edu.wpi.first.units.mutable.MutableMeasureBase;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public final class MutAngularVelocity
-  extends MutableMeasureBase<AngularVelocityUnit, AngularVelocity, MutAngularVelocity>
-  implements AngularVelocity {
-  public MutAngularVelocity(double magnitude, double baseUnitMagnitude, AngularVelocityUnit unit) {
-    super(magnitude, baseUnitMagnitude, unit);
-  }
-
-  @Override
-  public AngularVelocity copy() {
-    return new ImmutableAngularVelocity(magnitude(), baseUnitMagnitude(), unit());
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutCurrent.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutCurrent.java
deleted file mode 100644
index 3dab503de2..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutCurrent.java
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-import edu.wpi.first.units.mutable.MutableMeasureBase;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public final class MutCurrent
-  extends MutableMeasureBase<CurrentUnit, Current, MutCurrent>
-  implements Current {
-  public MutCurrent(double magnitude, double baseUnitMagnitude, CurrentUnit unit) {
-    super(magnitude, baseUnitMagnitude, unit);
-  }
-
-  @Override
-  public Current copy() {
-    return new ImmutableCurrent(magnitude(), baseUnitMagnitude(), unit());
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutDimensionless.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutDimensionless.java
deleted file mode 100644
index 13ee3f6e8c..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutDimensionless.java
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-import edu.wpi.first.units.mutable.MutableMeasureBase;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public final class MutDimensionless
-  extends MutableMeasureBase<DimensionlessUnit, Dimensionless, MutDimensionless>
-  implements Dimensionless {
-  public MutDimensionless(double magnitude, double baseUnitMagnitude, DimensionlessUnit unit) {
-    super(magnitude, baseUnitMagnitude, unit);
-  }
-
-  @Override
-  public Dimensionless copy() {
-    return new ImmutableDimensionless(magnitude(), baseUnitMagnitude(), unit());
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutDistance.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutDistance.java
deleted file mode 100644
index 35f1e3faa9..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutDistance.java
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-import edu.wpi.first.units.mutable.MutableMeasureBase;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public final class MutDistance
-  extends MutableMeasureBase<DistanceUnit, Distance, MutDistance>
-  implements Distance {
-  public MutDistance(double magnitude, double baseUnitMagnitude, DistanceUnit unit) {
-    super(magnitude, baseUnitMagnitude, unit);
-  }
-
-  @Override
-  public Distance copy() {
-    return new ImmutableDistance(magnitude(), baseUnitMagnitude(), unit());
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutEnergy.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutEnergy.java
deleted file mode 100644
index bd23cd1e9b..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutEnergy.java
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-import edu.wpi.first.units.mutable.MutableMeasureBase;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public final class MutEnergy
-  extends MutableMeasureBase<EnergyUnit, Energy, MutEnergy>
-  implements Energy {
-  public MutEnergy(double magnitude, double baseUnitMagnitude, EnergyUnit unit) {
-    super(magnitude, baseUnitMagnitude, unit);
-  }
-
-  @Override
-  public Energy copy() {
-    return new ImmutableEnergy(magnitude(), baseUnitMagnitude(), unit());
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutForce.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutForce.java
deleted file mode 100644
index da6c973164..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutForce.java
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-import edu.wpi.first.units.mutable.MutableMeasureBase;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public final class MutForce
-  extends MutableMeasureBase<ForceUnit, Force, MutForce>
-  implements Force {
-  public MutForce(double magnitude, double baseUnitMagnitude, ForceUnit unit) {
-    super(magnitude, baseUnitMagnitude, unit);
-  }
-
-  @Override
-  public Force copy() {
-    return new ImmutableForce(magnitude(), baseUnitMagnitude(), unit());
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutFrequency.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutFrequency.java
deleted file mode 100644
index 091afd130b..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutFrequency.java
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-import edu.wpi.first.units.mutable.MutableMeasureBase;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public final class MutFrequency
-  extends MutableMeasureBase<FrequencyUnit, Frequency, MutFrequency>
-  implements Frequency {
-  public MutFrequency(double magnitude, double baseUnitMagnitude, FrequencyUnit unit) {
-    super(magnitude, baseUnitMagnitude, unit);
-  }
-
-  @Override
-  public Frequency copy() {
-    return new ImmutableFrequency(magnitude(), baseUnitMagnitude(), unit());
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutLinearAcceleration.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutLinearAcceleration.java
deleted file mode 100644
index dd074db5f8..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutLinearAcceleration.java
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-import edu.wpi.first.units.mutable.MutableMeasureBase;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public final class MutLinearAcceleration
-  extends MutableMeasureBase<LinearAccelerationUnit, LinearAcceleration, MutLinearAcceleration>
-  implements LinearAcceleration {
-  public MutLinearAcceleration(double magnitude, double baseUnitMagnitude, LinearAccelerationUnit unit) {
-    super(magnitude, baseUnitMagnitude, unit);
-  }
-
-  @Override
-  public LinearAcceleration copy() {
-    return new ImmutableLinearAcceleration(magnitude(), baseUnitMagnitude(), unit());
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutLinearMomentum.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutLinearMomentum.java
deleted file mode 100644
index da3113c345..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutLinearMomentum.java
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-import edu.wpi.first.units.mutable.MutableMeasureBase;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public final class MutLinearMomentum
-  extends MutableMeasureBase<LinearMomentumUnit, LinearMomentum, MutLinearMomentum>
-  implements LinearMomentum {
-  public MutLinearMomentum(double magnitude, double baseUnitMagnitude, LinearMomentumUnit unit) {
-    super(magnitude, baseUnitMagnitude, unit);
-  }
-
-  @Override
-  public LinearMomentum copy() {
-    return new ImmutableLinearMomentum(magnitude(), baseUnitMagnitude(), unit());
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutLinearVelocity.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutLinearVelocity.java
deleted file mode 100644
index ffd19e3a7e..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutLinearVelocity.java
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-import edu.wpi.first.units.mutable.MutableMeasureBase;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public final class MutLinearVelocity
-  extends MutableMeasureBase<LinearVelocityUnit, LinearVelocity, MutLinearVelocity>
-  implements LinearVelocity {
-  public MutLinearVelocity(double magnitude, double baseUnitMagnitude, LinearVelocityUnit unit) {
-    super(magnitude, baseUnitMagnitude, unit);
-  }
-
-  @Override
-  public LinearVelocity copy() {
-    return new ImmutableLinearVelocity(magnitude(), baseUnitMagnitude(), unit());
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutMass.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutMass.java
deleted file mode 100644
index c1b80c191e..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutMass.java
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-import edu.wpi.first.units.mutable.MutableMeasureBase;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public final class MutMass
-  extends MutableMeasureBase<MassUnit, Mass, MutMass>
-  implements Mass {
-  public MutMass(double magnitude, double baseUnitMagnitude, MassUnit unit) {
-    super(magnitude, baseUnitMagnitude, unit);
-  }
-
-  @Override
-  public Mass copy() {
-    return new ImmutableMass(magnitude(), baseUnitMagnitude(), unit());
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutMomentOfInertia.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutMomentOfInertia.java
deleted file mode 100644
index b6f7481fa5..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutMomentOfInertia.java
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-import edu.wpi.first.units.mutable.MutableMeasureBase;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public final class MutMomentOfInertia
-  extends MutableMeasureBase<MomentOfInertiaUnit, MomentOfInertia, MutMomentOfInertia>
-  implements MomentOfInertia {
-  public MutMomentOfInertia(double magnitude, double baseUnitMagnitude, MomentOfInertiaUnit unit) {
-    super(magnitude, baseUnitMagnitude, unit);
-  }
-
-  @Override
-  public MomentOfInertia copy() {
-    return new ImmutableMomentOfInertia(magnitude(), baseUnitMagnitude(), unit());
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutMult.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutMult.java
deleted file mode 100644
index b743c950fd..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutMult.java
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-import edu.wpi.first.units.mutable.MutableMeasureBase;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public final class MutMult<A extends Unit, B extends Unit>
-  extends MutableMeasureBase<MultUnit<A, B>, Mult<A, B>, MutMult<A, B>>
-  implements Mult<A, B> {
-  public MutMult(double magnitude, double baseUnitMagnitude, MultUnit<A, B> unit) {
-    super(magnitude, baseUnitMagnitude, unit);
-  }
-
-  @Override
-  public Mult<A, B> copy() {
-    return new ImmutableMult<A, B>(magnitude(), baseUnitMagnitude(), unit());
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutPer.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutPer.java
deleted file mode 100644
index 054d87f19b..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutPer.java
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-import edu.wpi.first.units.mutable.MutableMeasureBase;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public final class MutPer<Dividend extends Unit, Divisor extends Unit>
-  extends MutableMeasureBase<PerUnit<Dividend, Divisor>, Per<Dividend, Divisor>, MutPer<Dividend, Divisor>>
-  implements Per<Dividend, Divisor> {
-  public MutPer(double magnitude, double baseUnitMagnitude, PerUnit<Dividend, Divisor> unit) {
-    super(magnitude, baseUnitMagnitude, unit);
-  }
-
-  @Override
-  public Per<Dividend, Divisor> copy() {
-    return new ImmutablePer<Dividend, Divisor>(magnitude(), baseUnitMagnitude(), unit());
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutPower.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutPower.java
deleted file mode 100644
index 7a08663a7d..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutPower.java
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-import edu.wpi.first.units.mutable.MutableMeasureBase;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public final class MutPower
-  extends MutableMeasureBase<PowerUnit, Power, MutPower>
-  implements Power {
-  public MutPower(double magnitude, double baseUnitMagnitude, PowerUnit unit) {
-    super(magnitude, baseUnitMagnitude, unit);
-  }
-
-  @Override
-  public Power copy() {
-    return new ImmutablePower(magnitude(), baseUnitMagnitude(), unit());
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutResistance.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutResistance.java
deleted file mode 100644
index 6acee59f56..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutResistance.java
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-import edu.wpi.first.units.mutable.MutableMeasureBase;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public final class MutResistance
-  extends MutableMeasureBase<ResistanceUnit, Resistance, MutResistance>
-  implements Resistance {
-  public MutResistance(double magnitude, double baseUnitMagnitude, ResistanceUnit unit) {
-    super(magnitude, baseUnitMagnitude, unit);
-  }
-
-  @Override
-  public Resistance copy() {
-    return new ImmutableResistance(magnitude(), baseUnitMagnitude(), unit());
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutTemperature.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutTemperature.java
deleted file mode 100644
index 31ae1fe7b5..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutTemperature.java
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-import edu.wpi.first.units.mutable.MutableMeasureBase;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public final class MutTemperature
-  extends MutableMeasureBase<TemperatureUnit, Temperature, MutTemperature>
-  implements Temperature {
-  public MutTemperature(double magnitude, double baseUnitMagnitude, TemperatureUnit unit) {
-    super(magnitude, baseUnitMagnitude, unit);
-  }
-
-  @Override
-  public Temperature copy() {
-    return new ImmutableTemperature(magnitude(), baseUnitMagnitude(), unit());
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutTime.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutTime.java
deleted file mode 100644
index 4b9b81a745..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutTime.java
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-import edu.wpi.first.units.mutable.MutableMeasureBase;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public final class MutTime
-  extends MutableMeasureBase<TimeUnit, Time, MutTime>
-  implements Time {
-  public MutTime(double magnitude, double baseUnitMagnitude, TimeUnit unit) {
-    super(magnitude, baseUnitMagnitude, unit);
-  }
-
-  @Override
-  public Time copy() {
-    return new ImmutableTime(magnitude(), baseUnitMagnitude(), unit());
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutTorque.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutTorque.java
deleted file mode 100644
index 30f9152329..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutTorque.java
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-import edu.wpi.first.units.mutable.MutableMeasureBase;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public final class MutTorque
-  extends MutableMeasureBase<TorqueUnit, Torque, MutTorque>
-  implements Torque {
-  public MutTorque(double magnitude, double baseUnitMagnitude, TorqueUnit unit) {
-    super(magnitude, baseUnitMagnitude, unit);
-  }
-
-  @Override
-  public Torque copy() {
-    return new ImmutableTorque(magnitude(), baseUnitMagnitude(), unit());
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutVelocity.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutVelocity.java
deleted file mode 100644
index 660cfa9de2..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutVelocity.java
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-import edu.wpi.first.units.mutable.MutableMeasureBase;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public final class MutVelocity<D extends Unit>
-  extends MutableMeasureBase<VelocityUnit<D>, Velocity<D>, MutVelocity<D>>
-  implements Velocity<D> {
-  public MutVelocity(double magnitude, double baseUnitMagnitude, VelocityUnit<D> unit) {
-    super(magnitude, baseUnitMagnitude, unit);
-  }
-
-  @Override
-  public Velocity<D> copy() {
-    return new ImmutableVelocity<D>(magnitude(), baseUnitMagnitude(), unit());
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutVoltage.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutVoltage.java
deleted file mode 100644
index 7002767b9e..0000000000
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutVoltage.java
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-// THIS FILE WAS AUTO-GENERATED BY ./wpiunits/generate_units.py. DO NOT MODIFY
-
-package edu.wpi.first.units.measure;
-
-import static edu.wpi.first.units.Units.*;
-import edu.wpi.first.units.*;
-import edu.wpi.first.units.mutable.MutableMeasureBase;
-
-@SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public final class MutVoltage
-  extends MutableMeasureBase<VoltageUnit, Voltage, MutVoltage>
-  implements Voltage {
-  public MutVoltage(double magnitude, double baseUnitMagnitude, VoltageUnit unit) {
-    super(magnitude, baseUnitMagnitude, unit);
-  }
-
-  @Override
-  public Voltage copy() {
-    return new ImmutableVoltage(magnitude(), baseUnitMagnitude(), unit());
-  }
-}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Per.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Per.java
index 2c1af67794..e99a34a3e6 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Per.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Per.java
@@ -10,36 +10,45 @@ import static edu.wpi.first.units.Units.*;
 import edu.wpi.first.units.*;
 
 @SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measure<PerUnit<Dividend, Divisor>> {
-  static <Dividend extends Unit, Divisor extends Unit> Per<Dividend, Divisor> ofRelativeUnits(double magnitude, PerUnit<Dividend, Divisor> unit) {
-    return new ImmutablePer<Dividend, Divisor>(magnitude, unit.toBaseUnits(magnitude), unit);
+public record Per<Dividend extends Unit, Divisor extends Unit>(double magnitude, double baseUnitMagnitude, PerUnit<Dividend, Divisor> unit) implements Measure<PerUnit<Dividend, Divisor>> {
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link PerUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static <Dividend extends Unit, Divisor extends Unit> Per<Dividend, Divisor> ofRelativeUnits(double magnitude, PerUnit<Dividend, Divisor> unit) {
+    return new Per<Dividend, Divisor>(magnitude, unit.toBaseUnits(magnitude), unit);
   }
 
-  static <Dividend extends Unit, Divisor extends Unit> Per<Dividend, Divisor> ofBaseUnits(double baseUnitMagnitude, PerUnit<Dividend, Divisor> unit) {
-    return new ImmutablePer<Dividend, Divisor>(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link PerUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit's base unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static <Dividend extends Unit, Divisor extends Unit> Per<Dividend, Divisor> ofBaseUnits(double baseUnitMagnitude, PerUnit<Dividend, Divisor> unit) {
+    return new Per<Dividend, Divisor>(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
   }
 
   @Override
-  Per<Dividend, Divisor> copy();
+  public PerUnit<Dividend, Divisor> baseUnit() { return (PerUnit<Dividend, Divisor>) unit().getBaseUnit(); }
 
   @Override
-  default MutPer<Dividend, Divisor> mutableCopy() {
-    return new MutPer<Dividend, Divisor>(magnitude(), baseUnitMagnitude(), unit());
-  }
-
-  @Override
-  PerUnit<Dividend, Divisor> unit();
-
-  @Override
-  default PerUnit<Dividend, Divisor> baseUnit() { return (PerUnit<Dividend, Divisor>) unit().getBaseUnit(); }
-
-  @Override
-  default double in(PerUnit<Dividend, Divisor> unit) {
+  public double in(PerUnit<Dividend, Divisor> unit) {
     return unit.fromBaseUnits(baseUnitMagnitude());
   }
 
   @Override
-  default Per<Dividend, Divisor> unaryMinus() {
+  @SuppressWarnings("rawtypes")
+  public boolean equals(Object object) {
+    return object instanceof Per m && isEquivalent(m);
+  }
+
+  @Override
+  public Per<Dividend, Divisor> unaryMinus() {
     return (Per<Dividend, Divisor>) unit().ofBaseUnits(0 - baseUnitMagnitude());
   }
 
@@ -51,27 +60,27 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Per<Dividend, Divisor> negate() {
+  public Per<Dividend, Divisor> negate() {
     return (Per<Dividend, Divisor>) unaryMinus();
   }
 
   @Override
-  default Per<Dividend, Divisor> plus(Measure<? extends PerUnit<Dividend, Divisor>> other) {
+  public Per<Dividend, Divisor> plus(Measure<? extends PerUnit<Dividend, Divisor>> other) {
     return (Per<Dividend, Divisor>) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
   }
 
   @Override
-  default Per<Dividend, Divisor> minus(Measure<? extends PerUnit<Dividend, Divisor>> other) {
+  public Per<Dividend, Divisor> minus(Measure<? extends PerUnit<Dividend, Divisor>> other) {
     return (Per<Dividend, Divisor>) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
   }
 
   @Override
-  default Per<Dividend, Divisor> times(double multiplier) {
+  public Per<Dividend, Divisor> times(double multiplier) {
     return (Per<Dividend, Divisor>) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
   }
 
   @Override
-  default Per<Dividend, Divisor> div(double divisor) {
+  public Per<Dividend, Divisor> div(double divisor) {
     return (Per<Dividend, Divisor>) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
@@ -83,18 +92,18 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Per<Dividend, Divisor> divide(double divisor) {
+  public Per<Dividend, Divisor> divide(double divisor) {
     return (Per<Dividend, Divisor>) div(divisor);
   }
 
 
   @Override
-  default Mult<PerUnit<Dividend, Divisor>, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+  public Mult<PerUnit<Dividend, Divisor>, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
     return (Mult<PerUnit<Dividend, Divisor>, AccelerationUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, AccelerationUnit<?>> div(Acceleration<?> divisor) {
+  public Per<PerUnit<Dividend, Divisor>, AccelerationUnit<?>> div(Acceleration<?> divisor) {
     return (Per<PerUnit<Dividend, Divisor>, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -106,23 +115,23 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PerUnit<Dividend, Divisor>, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+  public Per<PerUnit<Dividend, Divisor>, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
+  public Per<PerUnit<Dividend, Divisor>, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PerUnit<Dividend, Divisor>, AngleUnit> times(Angle multiplier) {
+  public Mult<PerUnit<Dividend, Divisor>, AngleUnit> times(Angle multiplier) {
     return (Mult<PerUnit<Dividend, Divisor>, AngleUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, AngleUnit> div(Angle divisor) {
+  public Per<PerUnit<Dividend, Divisor>, AngleUnit> div(Angle divisor) {
     return (Per<PerUnit<Dividend, Divisor>, AngleUnit>) Measure.super.div(divisor);
   }
 
@@ -134,23 +143,23 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PerUnit<Dividend, Divisor>, AngleUnit> divide(Angle divisor) {
+  public Per<PerUnit<Dividend, Divisor>, AngleUnit> divide(Angle divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, AngleUnit> per(AngleUnit divisorUnit) {
+  public Per<PerUnit<Dividend, Divisor>, AngleUnit> per(AngleUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PerUnit<Dividend, Divisor>, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+  public Mult<PerUnit<Dividend, Divisor>, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
     return (Mult<PerUnit<Dividend, Divisor>, AngularAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, AngularAccelerationUnit> div(AngularAcceleration divisor) {
+  public Per<PerUnit<Dividend, Divisor>, AngularAccelerationUnit> div(AngularAcceleration divisor) {
     return (Per<PerUnit<Dividend, Divisor>, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -162,23 +171,23 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PerUnit<Dividend, Divisor>, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+  public Per<PerUnit<Dividend, Divisor>, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
+  public Per<PerUnit<Dividend, Divisor>, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PerUnit<Dividend, Divisor>, AngularMomentumUnit> times(AngularMomentum multiplier) {
+  public Mult<PerUnit<Dividend, Divisor>, AngularMomentumUnit> times(AngularMomentum multiplier) {
     return (Mult<PerUnit<Dividend, Divisor>, AngularMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, AngularMomentumUnit> div(AngularMomentum divisor) {
+  public Per<PerUnit<Dividend, Divisor>, AngularMomentumUnit> div(AngularMomentum divisor) {
     return (Per<PerUnit<Dividend, Divisor>, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -190,23 +199,23 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PerUnit<Dividend, Divisor>, AngularMomentumUnit> divide(AngularMomentum divisor) {
+  public Per<PerUnit<Dividend, Divisor>, AngularMomentumUnit> divide(AngularMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
+  public Per<PerUnit<Dividend, Divisor>, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PerUnit<Dividend, Divisor>, AngularVelocityUnit> times(AngularVelocity multiplier) {
+  public Mult<PerUnit<Dividend, Divisor>, AngularVelocityUnit> times(AngularVelocity multiplier) {
     return (Mult<PerUnit<Dividend, Divisor>, AngularVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, AngularVelocityUnit> div(AngularVelocity divisor) {
+  public Per<PerUnit<Dividend, Divisor>, AngularVelocityUnit> div(AngularVelocity divisor) {
     return (Per<PerUnit<Dividend, Divisor>, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -218,23 +227,23 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PerUnit<Dividend, Divisor>, AngularVelocityUnit> divide(AngularVelocity divisor) {
+  public Per<PerUnit<Dividend, Divisor>, AngularVelocityUnit> divide(AngularVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
+  public Per<PerUnit<Dividend, Divisor>, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PerUnit<Dividend, Divisor>, CurrentUnit> times(Current multiplier) {
+  public Mult<PerUnit<Dividend, Divisor>, CurrentUnit> times(Current multiplier) {
     return (Mult<PerUnit<Dividend, Divisor>, CurrentUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, CurrentUnit> div(Current divisor) {
+  public Per<PerUnit<Dividend, Divisor>, CurrentUnit> div(Current divisor) {
     return (Per<PerUnit<Dividend, Divisor>, CurrentUnit>) Measure.super.div(divisor);
   }
 
@@ -246,17 +255,17 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PerUnit<Dividend, Divisor>, CurrentUnit> divide(Current divisor) {
+  public Per<PerUnit<Dividend, Divisor>, CurrentUnit> divide(Current divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, CurrentUnit> per(CurrentUnit divisorUnit) {
+  public Per<PerUnit<Dividend, Divisor>, CurrentUnit> per(CurrentUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
   @Override
-  default Per<Dividend, Divisor> div(Dimensionless divisor) {
+  public Per<Dividend, Divisor> div(Dimensionless divisor) {
     return (Per<Dividend, Divisor>) unit().of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -268,23 +277,23 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Per<Dividend, Divisor> divide(Dimensionless divisor) {
+  public Per<Dividend, Divisor> divide(Dimensionless divisor) {
     return (Per<Dividend, Divisor>) div(divisor);
   }
 
   @Override
-  default Per<Dividend, Divisor> times(Dimensionless multiplier) {
+  public Per<Dividend, Divisor> times(Dimensionless multiplier) {
     return (Per<Dividend, Divisor>) unit().of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
 
   @Override
-  default Mult<PerUnit<Dividend, Divisor>, DistanceUnit> times(Distance multiplier) {
+  public Mult<PerUnit<Dividend, Divisor>, DistanceUnit> times(Distance multiplier) {
     return (Mult<PerUnit<Dividend, Divisor>, DistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, DistanceUnit> div(Distance divisor) {
+  public Per<PerUnit<Dividend, Divisor>, DistanceUnit> div(Distance divisor) {
     return (Per<PerUnit<Dividend, Divisor>, DistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -296,23 +305,23 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PerUnit<Dividend, Divisor>, DistanceUnit> divide(Distance divisor) {
+  public Per<PerUnit<Dividend, Divisor>, DistanceUnit> divide(Distance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, DistanceUnit> per(DistanceUnit divisorUnit) {
+  public Per<PerUnit<Dividend, Divisor>, DistanceUnit> per(DistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PerUnit<Dividend, Divisor>, EnergyUnit> times(Energy multiplier) {
+  public Mult<PerUnit<Dividend, Divisor>, EnergyUnit> times(Energy multiplier) {
     return (Mult<PerUnit<Dividend, Divisor>, EnergyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, EnergyUnit> div(Energy divisor) {
+  public Per<PerUnit<Dividend, Divisor>, EnergyUnit> div(Energy divisor) {
     return (Per<PerUnit<Dividend, Divisor>, EnergyUnit>) Measure.super.div(divisor);
   }
 
@@ -324,23 +333,23 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PerUnit<Dividend, Divisor>, EnergyUnit> divide(Energy divisor) {
+  public Per<PerUnit<Dividend, Divisor>, EnergyUnit> divide(Energy divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, EnergyUnit> per(EnergyUnit divisorUnit) {
+  public Per<PerUnit<Dividend, Divisor>, EnergyUnit> per(EnergyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PerUnit<Dividend, Divisor>, ForceUnit> times(Force multiplier) {
+  public Mult<PerUnit<Dividend, Divisor>, ForceUnit> times(Force multiplier) {
     return (Mult<PerUnit<Dividend, Divisor>, ForceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, ForceUnit> div(Force divisor) {
+  public Per<PerUnit<Dividend, Divisor>, ForceUnit> div(Force divisor) {
     return (Per<PerUnit<Dividend, Divisor>, ForceUnit>) Measure.super.div(divisor);
   }
 
@@ -352,23 +361,23 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PerUnit<Dividend, Divisor>, ForceUnit> divide(Force divisor) {
+  public Per<PerUnit<Dividend, Divisor>, ForceUnit> divide(Force divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, ForceUnit> per(ForceUnit divisorUnit) {
+  public Per<PerUnit<Dividend, Divisor>, ForceUnit> per(ForceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PerUnit<Dividend, Divisor>, FrequencyUnit> times(Frequency multiplier) {
+  public Mult<PerUnit<Dividend, Divisor>, FrequencyUnit> times(Frequency multiplier) {
     return (Mult<PerUnit<Dividend, Divisor>, FrequencyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, FrequencyUnit> div(Frequency divisor) {
+  public Per<PerUnit<Dividend, Divisor>, FrequencyUnit> div(Frequency divisor) {
     return (Per<PerUnit<Dividend, Divisor>, FrequencyUnit>) Measure.super.div(divisor);
   }
 
@@ -380,23 +389,23 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PerUnit<Dividend, Divisor>, FrequencyUnit> divide(Frequency divisor) {
+  public Per<PerUnit<Dividend, Divisor>, FrequencyUnit> divide(Frequency divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, FrequencyUnit> per(FrequencyUnit divisorUnit) {
+  public Per<PerUnit<Dividend, Divisor>, FrequencyUnit> per(FrequencyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PerUnit<Dividend, Divisor>, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+  public Mult<PerUnit<Dividend, Divisor>, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
     return (Mult<PerUnit<Dividend, Divisor>, LinearAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, LinearAccelerationUnit> div(LinearAcceleration divisor) {
+  public Per<PerUnit<Dividend, Divisor>, LinearAccelerationUnit> div(LinearAcceleration divisor) {
     return (Per<PerUnit<Dividend, Divisor>, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -408,23 +417,23 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PerUnit<Dividend, Divisor>, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+  public Per<PerUnit<Dividend, Divisor>, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
+  public Per<PerUnit<Dividend, Divisor>, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PerUnit<Dividend, Divisor>, LinearMomentumUnit> times(LinearMomentum multiplier) {
+  public Mult<PerUnit<Dividend, Divisor>, LinearMomentumUnit> times(LinearMomentum multiplier) {
     return (Mult<PerUnit<Dividend, Divisor>, LinearMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, LinearMomentumUnit> div(LinearMomentum divisor) {
+  public Per<PerUnit<Dividend, Divisor>, LinearMomentumUnit> div(LinearMomentum divisor) {
     return (Per<PerUnit<Dividend, Divisor>, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -436,23 +445,23 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PerUnit<Dividend, Divisor>, LinearMomentumUnit> divide(LinearMomentum divisor) {
+  public Per<PerUnit<Dividend, Divisor>, LinearMomentumUnit> divide(LinearMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
+  public Per<PerUnit<Dividend, Divisor>, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PerUnit<Dividend, Divisor>, LinearVelocityUnit> times(LinearVelocity multiplier) {
+  public Mult<PerUnit<Dividend, Divisor>, LinearVelocityUnit> times(LinearVelocity multiplier) {
     return (Mult<PerUnit<Dividend, Divisor>, LinearVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, LinearVelocityUnit> div(LinearVelocity divisor) {
+  public Per<PerUnit<Dividend, Divisor>, LinearVelocityUnit> div(LinearVelocity divisor) {
     return (Per<PerUnit<Dividend, Divisor>, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -464,23 +473,23 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PerUnit<Dividend, Divisor>, LinearVelocityUnit> divide(LinearVelocity divisor) {
+  public Per<PerUnit<Dividend, Divisor>, LinearVelocityUnit> divide(LinearVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
+  public Per<PerUnit<Dividend, Divisor>, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PerUnit<Dividend, Divisor>, MassUnit> times(Mass multiplier) {
+  public Mult<PerUnit<Dividend, Divisor>, MassUnit> times(Mass multiplier) {
     return (Mult<PerUnit<Dividend, Divisor>, MassUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, MassUnit> div(Mass divisor) {
+  public Per<PerUnit<Dividend, Divisor>, MassUnit> div(Mass divisor) {
     return (Per<PerUnit<Dividend, Divisor>, MassUnit>) Measure.super.div(divisor);
   }
 
@@ -492,23 +501,23 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PerUnit<Dividend, Divisor>, MassUnit> divide(Mass divisor) {
+  public Per<PerUnit<Dividend, Divisor>, MassUnit> divide(Mass divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, MassUnit> per(MassUnit divisorUnit) {
+  public Per<PerUnit<Dividend, Divisor>, MassUnit> per(MassUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PerUnit<Dividend, Divisor>, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+  public Mult<PerUnit<Dividend, Divisor>, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
     return (Mult<PerUnit<Dividend, Divisor>, MomentOfInertiaUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
+  public Per<PerUnit<Dividend, Divisor>, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
     return (Per<PerUnit<Dividend, Divisor>, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
@@ -520,23 +529,23 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PerUnit<Dividend, Divisor>, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+  public Per<PerUnit<Dividend, Divisor>, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
+  public Per<PerUnit<Dividend, Divisor>, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PerUnit<Dividend, Divisor>, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+  public Mult<PerUnit<Dividend, Divisor>, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
     return (Mult<PerUnit<Dividend, Divisor>, MultUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
+  public Per<PerUnit<Dividend, Divisor>, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
     return (Per<PerUnit<Dividend, Divisor>, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -548,23 +557,23 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PerUnit<Dividend, Divisor>, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+  public Per<PerUnit<Dividend, Divisor>, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
+  public Per<PerUnit<Dividend, Divisor>, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<PerUnit<Dividend, Divisor>, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+  public Mult<PerUnit<Dividend, Divisor>, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
     return (Mult<PerUnit<Dividend, Divisor>, PerUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, PerUnit<?, ?>> div(Per<?, ?> divisor) {
+  public Per<PerUnit<Dividend, Divisor>, PerUnit<?, ?>> div(Per<?, ?> divisor) {
     return (Per<PerUnit<Dividend, Divisor>, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -576,23 +585,23 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PerUnit<Dividend, Divisor>, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+  public Per<PerUnit<Dividend, Divisor>, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
+  public Per<PerUnit<Dividend, Divisor>, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<PerUnit<Dividend, Divisor>, PowerUnit> times(Power multiplier) {
+  public Mult<PerUnit<Dividend, Divisor>, PowerUnit> times(Power multiplier) {
     return (Mult<PerUnit<Dividend, Divisor>, PowerUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, PowerUnit> div(Power divisor) {
+  public Per<PerUnit<Dividend, Divisor>, PowerUnit> div(Power divisor) {
     return (Per<PerUnit<Dividend, Divisor>, PowerUnit>) Measure.super.div(divisor);
   }
 
@@ -604,23 +613,23 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PerUnit<Dividend, Divisor>, PowerUnit> divide(Power divisor) {
+  public Per<PerUnit<Dividend, Divisor>, PowerUnit> divide(Power divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, PowerUnit> per(PowerUnit divisorUnit) {
+  public Per<PerUnit<Dividend, Divisor>, PowerUnit> per(PowerUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PerUnit<Dividend, Divisor>, ResistanceUnit> times(Resistance multiplier) {
+  public Mult<PerUnit<Dividend, Divisor>, ResistanceUnit> times(Resistance multiplier) {
     return (Mult<PerUnit<Dividend, Divisor>, ResistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, ResistanceUnit> div(Resistance divisor) {
+  public Per<PerUnit<Dividend, Divisor>, ResistanceUnit> div(Resistance divisor) {
     return (Per<PerUnit<Dividend, Divisor>, ResistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -632,23 +641,23 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PerUnit<Dividend, Divisor>, ResistanceUnit> divide(Resistance divisor) {
+  public Per<PerUnit<Dividend, Divisor>, ResistanceUnit> divide(Resistance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, ResistanceUnit> per(ResistanceUnit divisorUnit) {
+  public Per<PerUnit<Dividend, Divisor>, ResistanceUnit> per(ResistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PerUnit<Dividend, Divisor>, TemperatureUnit> times(Temperature multiplier) {
+  public Mult<PerUnit<Dividend, Divisor>, TemperatureUnit> times(Temperature multiplier) {
     return (Mult<PerUnit<Dividend, Divisor>, TemperatureUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, TemperatureUnit> div(Temperature divisor) {
+  public Per<PerUnit<Dividend, Divisor>, TemperatureUnit> div(Temperature divisor) {
     return (Per<PerUnit<Dividend, Divisor>, TemperatureUnit>) Measure.super.div(divisor);
   }
 
@@ -660,23 +669,23 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PerUnit<Dividend, Divisor>, TemperatureUnit> divide(Temperature divisor) {
+  public Per<PerUnit<Dividend, Divisor>, TemperatureUnit> divide(Temperature divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, TemperatureUnit> per(TemperatureUnit divisorUnit) {
+  public Per<PerUnit<Dividend, Divisor>, TemperatureUnit> per(TemperatureUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PerUnit<Dividend, Divisor>, TimeUnit> times(Time multiplier) {
+  public Mult<PerUnit<Dividend, Divisor>, TimeUnit> times(Time multiplier) {
     return (Mult<PerUnit<Dividend, Divisor>, TimeUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Velocity<PerUnit<Dividend, Divisor>> div(Time divisor) {
+  public Velocity<PerUnit<Dividend, Divisor>> div(Time divisor) {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -688,23 +697,23 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Velocity<PerUnit<Dividend, Divisor>> divide(Time divisor) {
+  public Velocity<PerUnit<Dividend, Divisor>> divide(Time divisor) {
     return div(divisor);
   }
 
   @Override
-  default Velocity<PerUnit<Dividend, Divisor>> per(TimeUnit divisorUnit) {
+  public Velocity<PerUnit<Dividend, Divisor>> per(TimeUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PerUnit<Dividend, Divisor>, TorqueUnit> times(Torque multiplier) {
+  public Mult<PerUnit<Dividend, Divisor>, TorqueUnit> times(Torque multiplier) {
     return (Mult<PerUnit<Dividend, Divisor>, TorqueUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, TorqueUnit> div(Torque divisor) {
+  public Per<PerUnit<Dividend, Divisor>, TorqueUnit> div(Torque divisor) {
     return (Per<PerUnit<Dividend, Divisor>, TorqueUnit>) Measure.super.div(divisor);
   }
 
@@ -716,23 +725,23 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PerUnit<Dividend, Divisor>, TorqueUnit> divide(Torque divisor) {
+  public Per<PerUnit<Dividend, Divisor>, TorqueUnit> divide(Torque divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, TorqueUnit> per(TorqueUnit divisorUnit) {
+  public Per<PerUnit<Dividend, Divisor>, TorqueUnit> per(TorqueUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PerUnit<Dividend, Divisor>, VelocityUnit<?>> times(Velocity<?> multiplier) {
+  public Mult<PerUnit<Dividend, Divisor>, VelocityUnit<?>> times(Velocity<?> multiplier) {
     return (Mult<PerUnit<Dividend, Divisor>, VelocityUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, VelocityUnit<?>> div(Velocity<?> divisor) {
+  public Per<PerUnit<Dividend, Divisor>, VelocityUnit<?>> div(Velocity<?> divisor) {
     return (Per<PerUnit<Dividend, Divisor>, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -744,23 +753,23 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PerUnit<Dividend, Divisor>, VelocityUnit<?>> divide(Velocity<?> divisor) {
+  public Per<PerUnit<Dividend, Divisor>, VelocityUnit<?>> divide(Velocity<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
+  public Per<PerUnit<Dividend, Divisor>, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PerUnit<Dividend, Divisor>, VoltageUnit> times(Voltage multiplier) {
+  public Mult<PerUnit<Dividend, Divisor>, VoltageUnit> times(Voltage multiplier) {
     return (Mult<PerUnit<Dividend, Divisor>, VoltageUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, VoltageUnit> div(Voltage divisor) {
+  public Per<PerUnit<Dividend, Divisor>, VoltageUnit> div(Voltage divisor) {
     return (Per<PerUnit<Dividend, Divisor>, VoltageUnit>) Measure.super.div(divisor);
   }
 
@@ -772,19 +781,19 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PerUnit<Dividend, Divisor>, VoltageUnit> divide(Voltage divisor) {
+  public Per<PerUnit<Dividend, Divisor>, VoltageUnit> divide(Voltage divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PerUnit<Dividend, Divisor>, VoltageUnit> per(VoltageUnit divisorUnit) {
+  public Per<PerUnit<Dividend, Divisor>, VoltageUnit> per(VoltageUnit divisorUnit) {
     return div(divisorUnit.one());
   }
-default Measure<Dividend> timesDivisor(Measure<? extends Divisor> multiplier) {
+public Measure<Dividend> timesDivisor(Measure<? extends Divisor> multiplier) {
   return (Measure<Dividend>) baseUnit().numerator().ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
 }
 
-default Measure<? extends PerUnit<Divisor, Dividend>> reciprocal() {
+public Measure<? extends PerUnit<Divisor, Dividend>> reciprocal() {
   // May return a velocity if Divisor == TimeUnit, so we can't guarantee a "Per" instance
   return baseUnit().reciprocal().ofBaseUnits(1 / baseUnitMagnitude());
 }
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Power.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Power.java
index d94ddcde38..30376d06d5 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Power.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Power.java
@@ -10,36 +10,45 @@ import static edu.wpi.first.units.Units.*;
 import edu.wpi.first.units.*;
 
 @SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public interface Power extends Measure<PowerUnit> {
-  static  Power ofRelativeUnits(double magnitude, PowerUnit unit) {
-    return new ImmutablePower(magnitude, unit.toBaseUnits(magnitude), unit);
+public record Power(double magnitude, double baseUnitMagnitude, PowerUnit unit) implements Measure<PowerUnit> {
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link PowerUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  Power ofRelativeUnits(double magnitude, PowerUnit unit) {
+    return new Power(magnitude, unit.toBaseUnits(magnitude), unit);
   }
 
-  static  Power ofBaseUnits(double baseUnitMagnitude, PowerUnit unit) {
-    return new ImmutablePower(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link PowerUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit's base unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  Power ofBaseUnits(double baseUnitMagnitude, PowerUnit unit) {
+    return new Power(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
   }
 
   @Override
-  Power copy();
+  public PowerUnit baseUnit() { return (PowerUnit) unit().getBaseUnit(); }
 
   @Override
-  default MutPower mutableCopy() {
-    return new MutPower(magnitude(), baseUnitMagnitude(), unit());
-  }
-
-  @Override
-  PowerUnit unit();
-
-  @Override
-  default PowerUnit baseUnit() { return (PowerUnit) unit().getBaseUnit(); }
-
-  @Override
-  default double in(PowerUnit unit) {
+  public double in(PowerUnit unit) {
     return unit.fromBaseUnits(baseUnitMagnitude());
   }
 
   @Override
-  default Power unaryMinus() {
+  @SuppressWarnings("rawtypes")
+  public boolean equals(Object object) {
+    return object instanceof Power m && isEquivalent(m);
+  }
+
+  @Override
+  public Power unaryMinus() {
     return (Power) unit().ofBaseUnits(0 - baseUnitMagnitude());
   }
 
@@ -51,27 +60,27 @@ public interface Power extends Measure<PowerUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Power negate() {
+  public Power negate() {
     return (Power) unaryMinus();
   }
 
   @Override
-  default Power plus(Measure<? extends PowerUnit> other) {
+  public Power plus(Measure<? extends PowerUnit> other) {
     return (Power) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
   }
 
   @Override
-  default Power minus(Measure<? extends PowerUnit> other) {
+  public Power minus(Measure<? extends PowerUnit> other) {
     return (Power) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
   }
 
   @Override
-  default Power times(double multiplier) {
+  public Power times(double multiplier) {
     return (Power) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
   }
 
   @Override
-  default Power div(double divisor) {
+  public Power div(double divisor) {
     return (Power) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
@@ -83,18 +92,18 @@ public interface Power extends Measure<PowerUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Power divide(double divisor) {
+  public Power divide(double divisor) {
     return (Power) div(divisor);
   }
 
 
   @Override
-  default Mult<PowerUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+  public Mult<PowerUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
     return (Mult<PowerUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PowerUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
+  public Per<PowerUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
     return (Per<PowerUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -106,23 +115,23 @@ public interface Power extends Measure<PowerUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PowerUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+  public Per<PowerUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PowerUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
+  public Per<PowerUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PowerUnit, AngleUnit> times(Angle multiplier) {
+  public Mult<PowerUnit, AngleUnit> times(Angle multiplier) {
     return (Mult<PowerUnit, AngleUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PowerUnit, AngleUnit> div(Angle divisor) {
+  public Per<PowerUnit, AngleUnit> div(Angle divisor) {
     return (Per<PowerUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
@@ -134,23 +143,23 @@ public interface Power extends Measure<PowerUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PowerUnit, AngleUnit> divide(Angle divisor) {
+  public Per<PowerUnit, AngleUnit> divide(Angle divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PowerUnit, AngleUnit> per(AngleUnit divisorUnit) {
+  public Per<PowerUnit, AngleUnit> per(AngleUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PowerUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+  public Mult<PowerUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
     return (Mult<PowerUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PowerUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
+  public Per<PowerUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
     return (Per<PowerUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -162,23 +171,23 @@ public interface Power extends Measure<PowerUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PowerUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+  public Per<PowerUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PowerUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
+  public Per<PowerUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PowerUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+  public Mult<PowerUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
     return (Mult<PowerUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PowerUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
+  public Per<PowerUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
     return (Per<PowerUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -190,23 +199,23 @@ public interface Power extends Measure<PowerUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PowerUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+  public Per<PowerUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PowerUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
+  public Per<PowerUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PowerUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+  public Mult<PowerUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
     return (Mult<PowerUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PowerUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
+  public Per<PowerUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
     return (Per<PowerUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -218,23 +227,23 @@ public interface Power extends Measure<PowerUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PowerUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+  public Per<PowerUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PowerUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
+  public Per<PowerUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PowerUnit, CurrentUnit> times(Current multiplier) {
+  public Mult<PowerUnit, CurrentUnit> times(Current multiplier) {
     return (Mult<PowerUnit, CurrentUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Voltage div(Current divisor) {
+  public Voltage div(Current divisor) {
     return Volts.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -246,17 +255,17 @@ public interface Power extends Measure<PowerUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Voltage divide(Current divisor) {
+  public Voltage divide(Current divisor) {
     return div(divisor);
   }
 
   @Override
-  default Voltage per(CurrentUnit divisorUnit) {
+  public Voltage per(CurrentUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
   @Override
-  default Power div(Dimensionless divisor) {
+  public Power div(Dimensionless divisor) {
     return (Power) Watts.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -268,23 +277,23 @@ public interface Power extends Measure<PowerUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Power divide(Dimensionless divisor) {
+  public Power divide(Dimensionless divisor) {
     return (Power) div(divisor);
   }
 
   @Override
-  default Power times(Dimensionless multiplier) {
+  public Power times(Dimensionless multiplier) {
     return (Power) Watts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
 
   @Override
-  default Mult<PowerUnit, DistanceUnit> times(Distance multiplier) {
+  public Mult<PowerUnit, DistanceUnit> times(Distance multiplier) {
     return (Mult<PowerUnit, DistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PowerUnit, DistanceUnit> div(Distance divisor) {
+  public Per<PowerUnit, DistanceUnit> div(Distance divisor) {
     return (Per<PowerUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -296,23 +305,23 @@ public interface Power extends Measure<PowerUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PowerUnit, DistanceUnit> divide(Distance divisor) {
+  public Per<PowerUnit, DistanceUnit> divide(Distance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PowerUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
+  public Per<PowerUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PowerUnit, EnergyUnit> times(Energy multiplier) {
+  public Mult<PowerUnit, EnergyUnit> times(Energy multiplier) {
     return (Mult<PowerUnit, EnergyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Frequency div(Energy divisor) {
+  public Frequency div(Energy divisor) {
     return Hertz.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -324,23 +333,23 @@ public interface Power extends Measure<PowerUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Frequency divide(Energy divisor) {
+  public Frequency divide(Energy divisor) {
     return div(divisor);
   }
 
   @Override
-  default Frequency per(EnergyUnit divisorUnit) {
+  public Frequency per(EnergyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PowerUnit, ForceUnit> times(Force multiplier) {
+  public Mult<PowerUnit, ForceUnit> times(Force multiplier) {
     return (Mult<PowerUnit, ForceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PowerUnit, ForceUnit> div(Force divisor) {
+  public Per<PowerUnit, ForceUnit> div(Force divisor) {
     return (Per<PowerUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
@@ -352,23 +361,23 @@ public interface Power extends Measure<PowerUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PowerUnit, ForceUnit> divide(Force divisor) {
+  public Per<PowerUnit, ForceUnit> divide(Force divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PowerUnit, ForceUnit> per(ForceUnit divisorUnit) {
+  public Per<PowerUnit, ForceUnit> per(ForceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PowerUnit, FrequencyUnit> times(Frequency multiplier) {
+  public Mult<PowerUnit, FrequencyUnit> times(Frequency multiplier) {
     return (Mult<PowerUnit, FrequencyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PowerUnit, FrequencyUnit> div(Frequency divisor) {
+  public Per<PowerUnit, FrequencyUnit> div(Frequency divisor) {
     return (Per<PowerUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
@@ -380,23 +389,23 @@ public interface Power extends Measure<PowerUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PowerUnit, FrequencyUnit> divide(Frequency divisor) {
+  public Per<PowerUnit, FrequencyUnit> divide(Frequency divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PowerUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
+  public Per<PowerUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PowerUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+  public Mult<PowerUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
     return (Mult<PowerUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PowerUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
+  public Per<PowerUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
     return (Per<PowerUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -408,23 +417,23 @@ public interface Power extends Measure<PowerUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PowerUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+  public Per<PowerUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PowerUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
+  public Per<PowerUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PowerUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+  public Mult<PowerUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
     return (Mult<PowerUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PowerUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
+  public Per<PowerUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
     return (Per<PowerUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -436,23 +445,23 @@ public interface Power extends Measure<PowerUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PowerUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+  public Per<PowerUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PowerUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
+  public Per<PowerUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PowerUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+  public Mult<PowerUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
     return (Mult<PowerUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PowerUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
+  public Per<PowerUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
     return (Per<PowerUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -464,23 +473,23 @@ public interface Power extends Measure<PowerUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PowerUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+  public Per<PowerUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PowerUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
+  public Per<PowerUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PowerUnit, MassUnit> times(Mass multiplier) {
+  public Mult<PowerUnit, MassUnit> times(Mass multiplier) {
     return (Mult<PowerUnit, MassUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PowerUnit, MassUnit> div(Mass divisor) {
+  public Per<PowerUnit, MassUnit> div(Mass divisor) {
     return (Per<PowerUnit, MassUnit>) Measure.super.div(divisor);
   }
 
@@ -492,23 +501,23 @@ public interface Power extends Measure<PowerUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PowerUnit, MassUnit> divide(Mass divisor) {
+  public Per<PowerUnit, MassUnit> divide(Mass divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PowerUnit, MassUnit> per(MassUnit divisorUnit) {
+  public Per<PowerUnit, MassUnit> per(MassUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PowerUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+  public Mult<PowerUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
     return (Mult<PowerUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PowerUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
+  public Per<PowerUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
     return (Per<PowerUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
@@ -520,23 +529,23 @@ public interface Power extends Measure<PowerUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PowerUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+  public Per<PowerUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PowerUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
+  public Per<PowerUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PowerUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+  public Mult<PowerUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
     return (Mult<PowerUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PowerUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
+  public Per<PowerUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
     return (Per<PowerUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -548,23 +557,23 @@ public interface Power extends Measure<PowerUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PowerUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+  public Per<PowerUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PowerUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
+  public Per<PowerUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<PowerUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+  public Mult<PowerUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
     return (Mult<PowerUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PowerUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
+  public Per<PowerUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
     return (Per<PowerUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -576,23 +585,23 @@ public interface Power extends Measure<PowerUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PowerUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+  public Per<PowerUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PowerUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
+  public Per<PowerUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<PowerUnit, PowerUnit> times(Power multiplier) {
+  public Mult<PowerUnit, PowerUnit> times(Power multiplier) {
     return (Mult<PowerUnit, PowerUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Dimensionless div(Power divisor) {
+  public Dimensionless div(Power divisor) {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -604,23 +613,23 @@ public interface Power extends Measure<PowerUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Dimensionless divide(Power divisor) {
+  public Dimensionless divide(Power divisor) {
     return div(divisor);
   }
 
   @Override
-  default Dimensionless per(PowerUnit divisorUnit) {
+  public Dimensionless per(PowerUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PowerUnit, ResistanceUnit> times(Resistance multiplier) {
+  public Mult<PowerUnit, ResistanceUnit> times(Resistance multiplier) {
     return (Mult<PowerUnit, ResistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PowerUnit, ResistanceUnit> div(Resistance divisor) {
+  public Per<PowerUnit, ResistanceUnit> div(Resistance divisor) {
     return (Per<PowerUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -632,23 +641,23 @@ public interface Power extends Measure<PowerUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PowerUnit, ResistanceUnit> divide(Resistance divisor) {
+  public Per<PowerUnit, ResistanceUnit> divide(Resistance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PowerUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
+  public Per<PowerUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PowerUnit, TemperatureUnit> times(Temperature multiplier) {
+  public Mult<PowerUnit, TemperatureUnit> times(Temperature multiplier) {
     return (Mult<PowerUnit, TemperatureUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PowerUnit, TemperatureUnit> div(Temperature divisor) {
+  public Per<PowerUnit, TemperatureUnit> div(Temperature divisor) {
     return (Per<PowerUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
@@ -660,23 +669,23 @@ public interface Power extends Measure<PowerUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PowerUnit, TemperatureUnit> divide(Temperature divisor) {
+  public Per<PowerUnit, TemperatureUnit> divide(Temperature divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PowerUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
+  public Per<PowerUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Energy times(Time multiplier) {
+  public Energy times(Time multiplier) {
     return Joules.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Velocity<PowerUnit> div(Time divisor) {
+  public Velocity<PowerUnit> div(Time divisor) {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -688,23 +697,23 @@ public interface Power extends Measure<PowerUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Velocity<PowerUnit> divide(Time divisor) {
+  public Velocity<PowerUnit> divide(Time divisor) {
     return div(divisor);
   }
 
   @Override
-  default Velocity<PowerUnit> per(TimeUnit divisorUnit) {
+  public Velocity<PowerUnit> per(TimeUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PowerUnit, TorqueUnit> times(Torque multiplier) {
+  public Mult<PowerUnit, TorqueUnit> times(Torque multiplier) {
     return (Mult<PowerUnit, TorqueUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PowerUnit, TorqueUnit> div(Torque divisor) {
+  public Per<PowerUnit, TorqueUnit> div(Torque divisor) {
     return (Per<PowerUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
@@ -716,23 +725,23 @@ public interface Power extends Measure<PowerUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PowerUnit, TorqueUnit> divide(Torque divisor) {
+  public Per<PowerUnit, TorqueUnit> divide(Torque divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PowerUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
+  public Per<PowerUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PowerUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+  public Mult<PowerUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
     return (Mult<PowerUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<PowerUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
+  public Per<PowerUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
     return (Per<PowerUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -744,23 +753,23 @@ public interface Power extends Measure<PowerUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<PowerUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+  public Per<PowerUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<PowerUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
+  public Per<PowerUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<PowerUnit, VoltageUnit> times(Voltage multiplier) {
+  public Mult<PowerUnit, VoltageUnit> times(Voltage multiplier) {
     return (Mult<PowerUnit, VoltageUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Current div(Voltage divisor) {
+  public Current div(Voltage divisor) {
     return Amps.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -772,12 +781,12 @@ public interface Power extends Measure<PowerUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Current divide(Voltage divisor) {
+  public Current divide(Voltage divisor) {
     return div(divisor);
   }
 
   @Override
-  default Current per(VoltageUnit divisorUnit) {
+  public Current per(VoltageUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Resistance.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Resistance.java
index 52d15b091a..81bff183c3 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Resistance.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Resistance.java
@@ -10,36 +10,45 @@ import static edu.wpi.first.units.Units.*;
 import edu.wpi.first.units.*;
 
 @SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public interface Resistance extends Measure<ResistanceUnit> {
-  static  Resistance ofRelativeUnits(double magnitude, ResistanceUnit unit) {
-    return new ImmutableResistance(magnitude, unit.toBaseUnits(magnitude), unit);
+public record Resistance(double magnitude, double baseUnitMagnitude, ResistanceUnit unit) implements Measure<ResistanceUnit> {
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link ResistanceUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  Resistance ofRelativeUnits(double magnitude, ResistanceUnit unit) {
+    return new Resistance(magnitude, unit.toBaseUnits(magnitude), unit);
   }
 
-  static  Resistance ofBaseUnits(double baseUnitMagnitude, ResistanceUnit unit) {
-    return new ImmutableResistance(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link ResistanceUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit's base unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  Resistance ofBaseUnits(double baseUnitMagnitude, ResistanceUnit unit) {
+    return new Resistance(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
   }
 
   @Override
-  Resistance copy();
+  public ResistanceUnit baseUnit() { return (ResistanceUnit) unit().getBaseUnit(); }
 
   @Override
-  default MutResistance mutableCopy() {
-    return new MutResistance(magnitude(), baseUnitMagnitude(), unit());
-  }
-
-  @Override
-  ResistanceUnit unit();
-
-  @Override
-  default ResistanceUnit baseUnit() { return (ResistanceUnit) unit().getBaseUnit(); }
-
-  @Override
-  default double in(ResistanceUnit unit) {
+  public double in(ResistanceUnit unit) {
     return unit.fromBaseUnits(baseUnitMagnitude());
   }
 
   @Override
-  default Resistance unaryMinus() {
+  @SuppressWarnings("rawtypes")
+  public boolean equals(Object object) {
+    return object instanceof Resistance m && isEquivalent(m);
+  }
+
+  @Override
+  public Resistance unaryMinus() {
     return (Resistance) unit().ofBaseUnits(0 - baseUnitMagnitude());
   }
 
@@ -51,27 +60,27 @@ public interface Resistance extends Measure<ResistanceUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Resistance negate() {
+  public Resistance negate() {
     return (Resistance) unaryMinus();
   }
 
   @Override
-  default Resistance plus(Measure<? extends ResistanceUnit> other) {
+  public Resistance plus(Measure<? extends ResistanceUnit> other) {
     return (Resistance) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
   }
 
   @Override
-  default Resistance minus(Measure<? extends ResistanceUnit> other) {
+  public Resistance minus(Measure<? extends ResistanceUnit> other) {
     return (Resistance) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
   }
 
   @Override
-  default Resistance times(double multiplier) {
+  public Resistance times(double multiplier) {
     return (Resistance) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
   }
 
   @Override
-  default Resistance div(double divisor) {
+  public Resistance div(double divisor) {
     return (Resistance) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
@@ -83,18 +92,18 @@ public interface Resistance extends Measure<ResistanceUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Resistance divide(double divisor) {
+  public Resistance divide(double divisor) {
     return (Resistance) div(divisor);
   }
 
 
   @Override
-  default Mult<ResistanceUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+  public Mult<ResistanceUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
     return (Mult<ResistanceUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ResistanceUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
+  public Per<ResistanceUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
     return (Per<ResistanceUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -106,23 +115,23 @@ public interface Resistance extends Measure<ResistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ResistanceUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+  public Per<ResistanceUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ResistanceUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
+  public Per<ResistanceUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ResistanceUnit, AngleUnit> times(Angle multiplier) {
+  public Mult<ResistanceUnit, AngleUnit> times(Angle multiplier) {
     return (Mult<ResistanceUnit, AngleUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ResistanceUnit, AngleUnit> div(Angle divisor) {
+  public Per<ResistanceUnit, AngleUnit> div(Angle divisor) {
     return (Per<ResistanceUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
@@ -134,23 +143,23 @@ public interface Resistance extends Measure<ResistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ResistanceUnit, AngleUnit> divide(Angle divisor) {
+  public Per<ResistanceUnit, AngleUnit> divide(Angle divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ResistanceUnit, AngleUnit> per(AngleUnit divisorUnit) {
+  public Per<ResistanceUnit, AngleUnit> per(AngleUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ResistanceUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+  public Mult<ResistanceUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
     return (Mult<ResistanceUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ResistanceUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
+  public Per<ResistanceUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
     return (Per<ResistanceUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -162,23 +171,23 @@ public interface Resistance extends Measure<ResistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ResistanceUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+  public Per<ResistanceUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ResistanceUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
+  public Per<ResistanceUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ResistanceUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+  public Mult<ResistanceUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
     return (Mult<ResistanceUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ResistanceUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
+  public Per<ResistanceUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
     return (Per<ResistanceUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -190,23 +199,23 @@ public interface Resistance extends Measure<ResistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ResistanceUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+  public Per<ResistanceUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ResistanceUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
+  public Per<ResistanceUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ResistanceUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+  public Mult<ResistanceUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
     return (Mult<ResistanceUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ResistanceUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
+  public Per<ResistanceUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
     return (Per<ResistanceUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -218,23 +227,23 @@ public interface Resistance extends Measure<ResistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ResistanceUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+  public Per<ResistanceUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ResistanceUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
+  public Per<ResistanceUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Voltage times(Current multiplier) {
+  public Voltage times(Current multiplier) {
     return Volts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<ResistanceUnit, CurrentUnit> div(Current divisor) {
+  public Per<ResistanceUnit, CurrentUnit> div(Current divisor) {
     return (Per<ResistanceUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
@@ -246,17 +255,17 @@ public interface Resistance extends Measure<ResistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ResistanceUnit, CurrentUnit> divide(Current divisor) {
+  public Per<ResistanceUnit, CurrentUnit> divide(Current divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ResistanceUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
+  public Per<ResistanceUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
   @Override
-  default Resistance div(Dimensionless divisor) {
+  public Resistance div(Dimensionless divisor) {
     return (Resistance) Ohms.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -268,23 +277,23 @@ public interface Resistance extends Measure<ResistanceUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Resistance divide(Dimensionless divisor) {
+  public Resistance divide(Dimensionless divisor) {
     return (Resistance) div(divisor);
   }
 
   @Override
-  default Resistance times(Dimensionless multiplier) {
+  public Resistance times(Dimensionless multiplier) {
     return (Resistance) Ohms.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
 
   @Override
-  default Mult<ResistanceUnit, DistanceUnit> times(Distance multiplier) {
+  public Mult<ResistanceUnit, DistanceUnit> times(Distance multiplier) {
     return (Mult<ResistanceUnit, DistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ResistanceUnit, DistanceUnit> div(Distance divisor) {
+  public Per<ResistanceUnit, DistanceUnit> div(Distance divisor) {
     return (Per<ResistanceUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -296,23 +305,23 @@ public interface Resistance extends Measure<ResistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ResistanceUnit, DistanceUnit> divide(Distance divisor) {
+  public Per<ResistanceUnit, DistanceUnit> divide(Distance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ResistanceUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
+  public Per<ResistanceUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ResistanceUnit, EnergyUnit> times(Energy multiplier) {
+  public Mult<ResistanceUnit, EnergyUnit> times(Energy multiplier) {
     return (Mult<ResistanceUnit, EnergyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ResistanceUnit, EnergyUnit> div(Energy divisor) {
+  public Per<ResistanceUnit, EnergyUnit> div(Energy divisor) {
     return (Per<ResistanceUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
@@ -324,23 +333,23 @@ public interface Resistance extends Measure<ResistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ResistanceUnit, EnergyUnit> divide(Energy divisor) {
+  public Per<ResistanceUnit, EnergyUnit> divide(Energy divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ResistanceUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
+  public Per<ResistanceUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ResistanceUnit, ForceUnit> times(Force multiplier) {
+  public Mult<ResistanceUnit, ForceUnit> times(Force multiplier) {
     return (Mult<ResistanceUnit, ForceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ResistanceUnit, ForceUnit> div(Force divisor) {
+  public Per<ResistanceUnit, ForceUnit> div(Force divisor) {
     return (Per<ResistanceUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
@@ -352,23 +361,23 @@ public interface Resistance extends Measure<ResistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ResistanceUnit, ForceUnit> divide(Force divisor) {
+  public Per<ResistanceUnit, ForceUnit> divide(Force divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ResistanceUnit, ForceUnit> per(ForceUnit divisorUnit) {
+  public Per<ResistanceUnit, ForceUnit> per(ForceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ResistanceUnit, FrequencyUnit> times(Frequency multiplier) {
+  public Mult<ResistanceUnit, FrequencyUnit> times(Frequency multiplier) {
     return (Mult<ResistanceUnit, FrequencyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ResistanceUnit, FrequencyUnit> div(Frequency divisor) {
+  public Per<ResistanceUnit, FrequencyUnit> div(Frequency divisor) {
     return (Per<ResistanceUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
@@ -380,23 +389,23 @@ public interface Resistance extends Measure<ResistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ResistanceUnit, FrequencyUnit> divide(Frequency divisor) {
+  public Per<ResistanceUnit, FrequencyUnit> divide(Frequency divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ResistanceUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
+  public Per<ResistanceUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ResistanceUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+  public Mult<ResistanceUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
     return (Mult<ResistanceUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ResistanceUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
+  public Per<ResistanceUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
     return (Per<ResistanceUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -408,23 +417,23 @@ public interface Resistance extends Measure<ResistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ResistanceUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+  public Per<ResistanceUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ResistanceUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
+  public Per<ResistanceUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ResistanceUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+  public Mult<ResistanceUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
     return (Mult<ResistanceUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ResistanceUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
+  public Per<ResistanceUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
     return (Per<ResistanceUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -436,23 +445,23 @@ public interface Resistance extends Measure<ResistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ResistanceUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+  public Per<ResistanceUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ResistanceUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
+  public Per<ResistanceUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ResistanceUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+  public Mult<ResistanceUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
     return (Mult<ResistanceUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ResistanceUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
+  public Per<ResistanceUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
     return (Per<ResistanceUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -464,23 +473,23 @@ public interface Resistance extends Measure<ResistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ResistanceUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+  public Per<ResistanceUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ResistanceUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
+  public Per<ResistanceUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ResistanceUnit, MassUnit> times(Mass multiplier) {
+  public Mult<ResistanceUnit, MassUnit> times(Mass multiplier) {
     return (Mult<ResistanceUnit, MassUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ResistanceUnit, MassUnit> div(Mass divisor) {
+  public Per<ResistanceUnit, MassUnit> div(Mass divisor) {
     return (Per<ResistanceUnit, MassUnit>) Measure.super.div(divisor);
   }
 
@@ -492,23 +501,23 @@ public interface Resistance extends Measure<ResistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ResistanceUnit, MassUnit> divide(Mass divisor) {
+  public Per<ResistanceUnit, MassUnit> divide(Mass divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ResistanceUnit, MassUnit> per(MassUnit divisorUnit) {
+  public Per<ResistanceUnit, MassUnit> per(MassUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ResistanceUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+  public Mult<ResistanceUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
     return (Mult<ResistanceUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ResistanceUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
+  public Per<ResistanceUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
     return (Per<ResistanceUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
@@ -520,23 +529,23 @@ public interface Resistance extends Measure<ResistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ResistanceUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+  public Per<ResistanceUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ResistanceUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
+  public Per<ResistanceUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ResistanceUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+  public Mult<ResistanceUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
     return (Mult<ResistanceUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ResistanceUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
+  public Per<ResistanceUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
     return (Per<ResistanceUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -548,23 +557,23 @@ public interface Resistance extends Measure<ResistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ResistanceUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+  public Per<ResistanceUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ResistanceUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
+  public Per<ResistanceUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<ResistanceUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+  public Mult<ResistanceUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
     return (Mult<ResistanceUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ResistanceUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
+  public Per<ResistanceUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
     return (Per<ResistanceUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -576,23 +585,23 @@ public interface Resistance extends Measure<ResistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ResistanceUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+  public Per<ResistanceUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ResistanceUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
+  public Per<ResistanceUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<ResistanceUnit, PowerUnit> times(Power multiplier) {
+  public Mult<ResistanceUnit, PowerUnit> times(Power multiplier) {
     return (Mult<ResistanceUnit, PowerUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ResistanceUnit, PowerUnit> div(Power divisor) {
+  public Per<ResistanceUnit, PowerUnit> div(Power divisor) {
     return (Per<ResistanceUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
@@ -604,23 +613,23 @@ public interface Resistance extends Measure<ResistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ResistanceUnit, PowerUnit> divide(Power divisor) {
+  public Per<ResistanceUnit, PowerUnit> divide(Power divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ResistanceUnit, PowerUnit> per(PowerUnit divisorUnit) {
+  public Per<ResistanceUnit, PowerUnit> per(PowerUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ResistanceUnit, ResistanceUnit> times(Resistance multiplier) {
+  public Mult<ResistanceUnit, ResistanceUnit> times(Resistance multiplier) {
     return (Mult<ResistanceUnit, ResistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Dimensionless div(Resistance divisor) {
+  public Dimensionless div(Resistance divisor) {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -632,23 +641,23 @@ public interface Resistance extends Measure<ResistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Dimensionless divide(Resistance divisor) {
+  public Dimensionless divide(Resistance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Dimensionless per(ResistanceUnit divisorUnit) {
+  public Dimensionless per(ResistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ResistanceUnit, TemperatureUnit> times(Temperature multiplier) {
+  public Mult<ResistanceUnit, TemperatureUnit> times(Temperature multiplier) {
     return (Mult<ResistanceUnit, TemperatureUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ResistanceUnit, TemperatureUnit> div(Temperature divisor) {
+  public Per<ResistanceUnit, TemperatureUnit> div(Temperature divisor) {
     return (Per<ResistanceUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
@@ -660,23 +669,23 @@ public interface Resistance extends Measure<ResistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ResistanceUnit, TemperatureUnit> divide(Temperature divisor) {
+  public Per<ResistanceUnit, TemperatureUnit> divide(Temperature divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ResistanceUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
+  public Per<ResistanceUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ResistanceUnit, TimeUnit> times(Time multiplier) {
+  public Mult<ResistanceUnit, TimeUnit> times(Time multiplier) {
     return (Mult<ResistanceUnit, TimeUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Velocity<ResistanceUnit> div(Time divisor) {
+  public Velocity<ResistanceUnit> div(Time divisor) {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -688,23 +697,23 @@ public interface Resistance extends Measure<ResistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Velocity<ResistanceUnit> divide(Time divisor) {
+  public Velocity<ResistanceUnit> divide(Time divisor) {
     return div(divisor);
   }
 
   @Override
-  default Velocity<ResistanceUnit> per(TimeUnit divisorUnit) {
+  public Velocity<ResistanceUnit> per(TimeUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ResistanceUnit, TorqueUnit> times(Torque multiplier) {
+  public Mult<ResistanceUnit, TorqueUnit> times(Torque multiplier) {
     return (Mult<ResistanceUnit, TorqueUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ResistanceUnit, TorqueUnit> div(Torque divisor) {
+  public Per<ResistanceUnit, TorqueUnit> div(Torque divisor) {
     return (Per<ResistanceUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
@@ -716,23 +725,23 @@ public interface Resistance extends Measure<ResistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ResistanceUnit, TorqueUnit> divide(Torque divisor) {
+  public Per<ResistanceUnit, TorqueUnit> divide(Torque divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ResistanceUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
+  public Per<ResistanceUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ResistanceUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+  public Mult<ResistanceUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
     return (Mult<ResistanceUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ResistanceUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
+  public Per<ResistanceUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
     return (Per<ResistanceUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -744,23 +753,23 @@ public interface Resistance extends Measure<ResistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ResistanceUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+  public Per<ResistanceUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ResistanceUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
+  public Per<ResistanceUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<ResistanceUnit, VoltageUnit> times(Voltage multiplier) {
+  public Mult<ResistanceUnit, VoltageUnit> times(Voltage multiplier) {
     return (Mult<ResistanceUnit, VoltageUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<ResistanceUnit, VoltageUnit> div(Voltage divisor) {
+  public Per<ResistanceUnit, VoltageUnit> div(Voltage divisor) {
     return (Per<ResistanceUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
@@ -772,12 +781,12 @@ public interface Resistance extends Measure<ResistanceUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<ResistanceUnit, VoltageUnit> divide(Voltage divisor) {
+  public Per<ResistanceUnit, VoltageUnit> divide(Voltage divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<ResistanceUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
+  public Per<ResistanceUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Temperature.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Temperature.java
index 2d7983b846..a6fc0a5c7b 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Temperature.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Temperature.java
@@ -10,36 +10,45 @@ import static edu.wpi.first.units.Units.*;
 import edu.wpi.first.units.*;
 
 @SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public interface Temperature extends Measure<TemperatureUnit> {
-  static  Temperature ofRelativeUnits(double magnitude, TemperatureUnit unit) {
-    return new ImmutableTemperature(magnitude, unit.toBaseUnits(magnitude), unit);
+public record Temperature(double magnitude, double baseUnitMagnitude, TemperatureUnit unit) implements Measure<TemperatureUnit> {
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link TemperatureUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  Temperature ofRelativeUnits(double magnitude, TemperatureUnit unit) {
+    return new Temperature(magnitude, unit.toBaseUnits(magnitude), unit);
   }
 
-  static  Temperature ofBaseUnits(double baseUnitMagnitude, TemperatureUnit unit) {
-    return new ImmutableTemperature(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link TemperatureUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit's base unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  Temperature ofBaseUnits(double baseUnitMagnitude, TemperatureUnit unit) {
+    return new Temperature(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
   }
 
   @Override
-  Temperature copy();
+  public TemperatureUnit baseUnit() { return (TemperatureUnit) unit().getBaseUnit(); }
 
   @Override
-  default MutTemperature mutableCopy() {
-    return new MutTemperature(magnitude(), baseUnitMagnitude(), unit());
-  }
-
-  @Override
-  TemperatureUnit unit();
-
-  @Override
-  default TemperatureUnit baseUnit() { return (TemperatureUnit) unit().getBaseUnit(); }
-
-  @Override
-  default double in(TemperatureUnit unit) {
+  public double in(TemperatureUnit unit) {
     return unit.fromBaseUnits(baseUnitMagnitude());
   }
 
   @Override
-  default Temperature unaryMinus() {
+  @SuppressWarnings("rawtypes")
+  public boolean equals(Object object) {
+    return object instanceof Temperature m && isEquivalent(m);
+  }
+
+  @Override
+  public Temperature unaryMinus() {
     return (Temperature) unit().ofBaseUnits(0 - baseUnitMagnitude());
   }
 
@@ -51,27 +60,27 @@ public interface Temperature extends Measure<TemperatureUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Temperature negate() {
+  public Temperature negate() {
     return (Temperature) unaryMinus();
   }
 
   @Override
-  default Temperature plus(Measure<? extends TemperatureUnit> other) {
+  public Temperature plus(Measure<? extends TemperatureUnit> other) {
     return (Temperature) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
   }
 
   @Override
-  default Temperature minus(Measure<? extends TemperatureUnit> other) {
+  public Temperature minus(Measure<? extends TemperatureUnit> other) {
     return (Temperature) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
   }
 
   @Override
-  default Temperature times(double multiplier) {
+  public Temperature times(double multiplier) {
     return (Temperature) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
   }
 
   @Override
-  default Temperature div(double divisor) {
+  public Temperature div(double divisor) {
     return (Temperature) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
@@ -83,18 +92,18 @@ public interface Temperature extends Measure<TemperatureUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Temperature divide(double divisor) {
+  public Temperature divide(double divisor) {
     return (Temperature) div(divisor);
   }
 
 
   @Override
-  default Mult<TemperatureUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+  public Mult<TemperatureUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
     return (Mult<TemperatureUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TemperatureUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
+  public Per<TemperatureUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
     return (Per<TemperatureUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -106,23 +115,23 @@ public interface Temperature extends Measure<TemperatureUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TemperatureUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+  public Per<TemperatureUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TemperatureUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
+  public Per<TemperatureUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TemperatureUnit, AngleUnit> times(Angle multiplier) {
+  public Mult<TemperatureUnit, AngleUnit> times(Angle multiplier) {
     return (Mult<TemperatureUnit, AngleUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TemperatureUnit, AngleUnit> div(Angle divisor) {
+  public Per<TemperatureUnit, AngleUnit> div(Angle divisor) {
     return (Per<TemperatureUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
@@ -134,23 +143,23 @@ public interface Temperature extends Measure<TemperatureUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TemperatureUnit, AngleUnit> divide(Angle divisor) {
+  public Per<TemperatureUnit, AngleUnit> divide(Angle divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TemperatureUnit, AngleUnit> per(AngleUnit divisorUnit) {
+  public Per<TemperatureUnit, AngleUnit> per(AngleUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TemperatureUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+  public Mult<TemperatureUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
     return (Mult<TemperatureUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TemperatureUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
+  public Per<TemperatureUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
     return (Per<TemperatureUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -162,23 +171,23 @@ public interface Temperature extends Measure<TemperatureUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TemperatureUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+  public Per<TemperatureUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TemperatureUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
+  public Per<TemperatureUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TemperatureUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+  public Mult<TemperatureUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
     return (Mult<TemperatureUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TemperatureUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
+  public Per<TemperatureUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
     return (Per<TemperatureUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -190,23 +199,23 @@ public interface Temperature extends Measure<TemperatureUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TemperatureUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+  public Per<TemperatureUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TemperatureUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
+  public Per<TemperatureUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TemperatureUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+  public Mult<TemperatureUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
     return (Mult<TemperatureUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TemperatureUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
+  public Per<TemperatureUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
     return (Per<TemperatureUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -218,23 +227,23 @@ public interface Temperature extends Measure<TemperatureUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TemperatureUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+  public Per<TemperatureUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TemperatureUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
+  public Per<TemperatureUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TemperatureUnit, CurrentUnit> times(Current multiplier) {
+  public Mult<TemperatureUnit, CurrentUnit> times(Current multiplier) {
     return (Mult<TemperatureUnit, CurrentUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TemperatureUnit, CurrentUnit> div(Current divisor) {
+  public Per<TemperatureUnit, CurrentUnit> div(Current divisor) {
     return (Per<TemperatureUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
@@ -246,17 +255,17 @@ public interface Temperature extends Measure<TemperatureUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TemperatureUnit, CurrentUnit> divide(Current divisor) {
+  public Per<TemperatureUnit, CurrentUnit> divide(Current divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TemperatureUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
+  public Per<TemperatureUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
   @Override
-  default Temperature div(Dimensionless divisor) {
+  public Temperature div(Dimensionless divisor) {
     return (Temperature) Kelvin.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -268,23 +277,23 @@ public interface Temperature extends Measure<TemperatureUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Temperature divide(Dimensionless divisor) {
+  public Temperature divide(Dimensionless divisor) {
     return (Temperature) div(divisor);
   }
 
   @Override
-  default Temperature times(Dimensionless multiplier) {
+  public Temperature times(Dimensionless multiplier) {
     return (Temperature) Kelvin.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
 
   @Override
-  default Mult<TemperatureUnit, DistanceUnit> times(Distance multiplier) {
+  public Mult<TemperatureUnit, DistanceUnit> times(Distance multiplier) {
     return (Mult<TemperatureUnit, DistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TemperatureUnit, DistanceUnit> div(Distance divisor) {
+  public Per<TemperatureUnit, DistanceUnit> div(Distance divisor) {
     return (Per<TemperatureUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -296,23 +305,23 @@ public interface Temperature extends Measure<TemperatureUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TemperatureUnit, DistanceUnit> divide(Distance divisor) {
+  public Per<TemperatureUnit, DistanceUnit> divide(Distance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TemperatureUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
+  public Per<TemperatureUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TemperatureUnit, EnergyUnit> times(Energy multiplier) {
+  public Mult<TemperatureUnit, EnergyUnit> times(Energy multiplier) {
     return (Mult<TemperatureUnit, EnergyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TemperatureUnit, EnergyUnit> div(Energy divisor) {
+  public Per<TemperatureUnit, EnergyUnit> div(Energy divisor) {
     return (Per<TemperatureUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
@@ -324,23 +333,23 @@ public interface Temperature extends Measure<TemperatureUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TemperatureUnit, EnergyUnit> divide(Energy divisor) {
+  public Per<TemperatureUnit, EnergyUnit> divide(Energy divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TemperatureUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
+  public Per<TemperatureUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TemperatureUnit, ForceUnit> times(Force multiplier) {
+  public Mult<TemperatureUnit, ForceUnit> times(Force multiplier) {
     return (Mult<TemperatureUnit, ForceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TemperatureUnit, ForceUnit> div(Force divisor) {
+  public Per<TemperatureUnit, ForceUnit> div(Force divisor) {
     return (Per<TemperatureUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
@@ -352,23 +361,23 @@ public interface Temperature extends Measure<TemperatureUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TemperatureUnit, ForceUnit> divide(Force divisor) {
+  public Per<TemperatureUnit, ForceUnit> divide(Force divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TemperatureUnit, ForceUnit> per(ForceUnit divisorUnit) {
+  public Per<TemperatureUnit, ForceUnit> per(ForceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TemperatureUnit, FrequencyUnit> times(Frequency multiplier) {
+  public Mult<TemperatureUnit, FrequencyUnit> times(Frequency multiplier) {
     return (Mult<TemperatureUnit, FrequencyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TemperatureUnit, FrequencyUnit> div(Frequency divisor) {
+  public Per<TemperatureUnit, FrequencyUnit> div(Frequency divisor) {
     return (Per<TemperatureUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
@@ -380,23 +389,23 @@ public interface Temperature extends Measure<TemperatureUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TemperatureUnit, FrequencyUnit> divide(Frequency divisor) {
+  public Per<TemperatureUnit, FrequencyUnit> divide(Frequency divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TemperatureUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
+  public Per<TemperatureUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TemperatureUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+  public Mult<TemperatureUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
     return (Mult<TemperatureUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TemperatureUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
+  public Per<TemperatureUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
     return (Per<TemperatureUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -408,23 +417,23 @@ public interface Temperature extends Measure<TemperatureUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TemperatureUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+  public Per<TemperatureUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TemperatureUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
+  public Per<TemperatureUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TemperatureUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+  public Mult<TemperatureUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
     return (Mult<TemperatureUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TemperatureUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
+  public Per<TemperatureUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
     return (Per<TemperatureUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -436,23 +445,23 @@ public interface Temperature extends Measure<TemperatureUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TemperatureUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+  public Per<TemperatureUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TemperatureUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
+  public Per<TemperatureUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TemperatureUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+  public Mult<TemperatureUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
     return (Mult<TemperatureUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TemperatureUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
+  public Per<TemperatureUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
     return (Per<TemperatureUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -464,23 +473,23 @@ public interface Temperature extends Measure<TemperatureUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TemperatureUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+  public Per<TemperatureUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TemperatureUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
+  public Per<TemperatureUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TemperatureUnit, MassUnit> times(Mass multiplier) {
+  public Mult<TemperatureUnit, MassUnit> times(Mass multiplier) {
     return (Mult<TemperatureUnit, MassUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TemperatureUnit, MassUnit> div(Mass divisor) {
+  public Per<TemperatureUnit, MassUnit> div(Mass divisor) {
     return (Per<TemperatureUnit, MassUnit>) Measure.super.div(divisor);
   }
 
@@ -492,23 +501,23 @@ public interface Temperature extends Measure<TemperatureUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TemperatureUnit, MassUnit> divide(Mass divisor) {
+  public Per<TemperatureUnit, MassUnit> divide(Mass divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TemperatureUnit, MassUnit> per(MassUnit divisorUnit) {
+  public Per<TemperatureUnit, MassUnit> per(MassUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TemperatureUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+  public Mult<TemperatureUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
     return (Mult<TemperatureUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TemperatureUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
+  public Per<TemperatureUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
     return (Per<TemperatureUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
@@ -520,23 +529,23 @@ public interface Temperature extends Measure<TemperatureUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TemperatureUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+  public Per<TemperatureUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TemperatureUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
+  public Per<TemperatureUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TemperatureUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+  public Mult<TemperatureUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
     return (Mult<TemperatureUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TemperatureUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
+  public Per<TemperatureUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
     return (Per<TemperatureUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -548,23 +557,23 @@ public interface Temperature extends Measure<TemperatureUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TemperatureUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+  public Per<TemperatureUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TemperatureUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
+  public Per<TemperatureUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<TemperatureUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+  public Mult<TemperatureUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
     return (Mult<TemperatureUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TemperatureUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
+  public Per<TemperatureUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
     return (Per<TemperatureUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -576,23 +585,23 @@ public interface Temperature extends Measure<TemperatureUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TemperatureUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+  public Per<TemperatureUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TemperatureUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
+  public Per<TemperatureUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<TemperatureUnit, PowerUnit> times(Power multiplier) {
+  public Mult<TemperatureUnit, PowerUnit> times(Power multiplier) {
     return (Mult<TemperatureUnit, PowerUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TemperatureUnit, PowerUnit> div(Power divisor) {
+  public Per<TemperatureUnit, PowerUnit> div(Power divisor) {
     return (Per<TemperatureUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
@@ -604,23 +613,23 @@ public interface Temperature extends Measure<TemperatureUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TemperatureUnit, PowerUnit> divide(Power divisor) {
+  public Per<TemperatureUnit, PowerUnit> divide(Power divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TemperatureUnit, PowerUnit> per(PowerUnit divisorUnit) {
+  public Per<TemperatureUnit, PowerUnit> per(PowerUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TemperatureUnit, ResistanceUnit> times(Resistance multiplier) {
+  public Mult<TemperatureUnit, ResistanceUnit> times(Resistance multiplier) {
     return (Mult<TemperatureUnit, ResistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TemperatureUnit, ResistanceUnit> div(Resistance divisor) {
+  public Per<TemperatureUnit, ResistanceUnit> div(Resistance divisor) {
     return (Per<TemperatureUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -632,23 +641,23 @@ public interface Temperature extends Measure<TemperatureUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TemperatureUnit, ResistanceUnit> divide(Resistance divisor) {
+  public Per<TemperatureUnit, ResistanceUnit> divide(Resistance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TemperatureUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
+  public Per<TemperatureUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TemperatureUnit, TemperatureUnit> times(Temperature multiplier) {
+  public Mult<TemperatureUnit, TemperatureUnit> times(Temperature multiplier) {
     return (Mult<TemperatureUnit, TemperatureUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Dimensionless div(Temperature divisor) {
+  public Dimensionless div(Temperature divisor) {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -660,23 +669,23 @@ public interface Temperature extends Measure<TemperatureUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Dimensionless divide(Temperature divisor) {
+  public Dimensionless divide(Temperature divisor) {
     return div(divisor);
   }
 
   @Override
-  default Dimensionless per(TemperatureUnit divisorUnit) {
+  public Dimensionless per(TemperatureUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TemperatureUnit, TimeUnit> times(Time multiplier) {
+  public Mult<TemperatureUnit, TimeUnit> times(Time multiplier) {
     return (Mult<TemperatureUnit, TimeUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Velocity<TemperatureUnit> div(Time divisor) {
+  public Velocity<TemperatureUnit> div(Time divisor) {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -688,23 +697,23 @@ public interface Temperature extends Measure<TemperatureUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Velocity<TemperatureUnit> divide(Time divisor) {
+  public Velocity<TemperatureUnit> divide(Time divisor) {
     return div(divisor);
   }
 
   @Override
-  default Velocity<TemperatureUnit> per(TimeUnit divisorUnit) {
+  public Velocity<TemperatureUnit> per(TimeUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TemperatureUnit, TorqueUnit> times(Torque multiplier) {
+  public Mult<TemperatureUnit, TorqueUnit> times(Torque multiplier) {
     return (Mult<TemperatureUnit, TorqueUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TemperatureUnit, TorqueUnit> div(Torque divisor) {
+  public Per<TemperatureUnit, TorqueUnit> div(Torque divisor) {
     return (Per<TemperatureUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
@@ -716,23 +725,23 @@ public interface Temperature extends Measure<TemperatureUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TemperatureUnit, TorqueUnit> divide(Torque divisor) {
+  public Per<TemperatureUnit, TorqueUnit> divide(Torque divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TemperatureUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
+  public Per<TemperatureUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TemperatureUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+  public Mult<TemperatureUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
     return (Mult<TemperatureUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TemperatureUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
+  public Per<TemperatureUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
     return (Per<TemperatureUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -744,23 +753,23 @@ public interface Temperature extends Measure<TemperatureUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TemperatureUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+  public Per<TemperatureUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TemperatureUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
+  public Per<TemperatureUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TemperatureUnit, VoltageUnit> times(Voltage multiplier) {
+  public Mult<TemperatureUnit, VoltageUnit> times(Voltage multiplier) {
     return (Mult<TemperatureUnit, VoltageUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TemperatureUnit, VoltageUnit> div(Voltage divisor) {
+  public Per<TemperatureUnit, VoltageUnit> div(Voltage divisor) {
     return (Per<TemperatureUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
@@ -772,12 +781,12 @@ public interface Temperature extends Measure<TemperatureUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TemperatureUnit, VoltageUnit> divide(Voltage divisor) {
+  public Per<TemperatureUnit, VoltageUnit> divide(Voltage divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TemperatureUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
+  public Per<TemperatureUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Time.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Time.java
index 4244325a26..2c95f2bf2e 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Time.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Time.java
@@ -10,36 +10,45 @@ import static edu.wpi.first.units.Units.*;
 import edu.wpi.first.units.*;
 
 @SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public interface Time extends Measure<TimeUnit> {
-  static  Time ofRelativeUnits(double magnitude, TimeUnit unit) {
-    return new ImmutableTime(magnitude, unit.toBaseUnits(magnitude), unit);
+public record Time(double magnitude, double baseUnitMagnitude, TimeUnit unit) implements Measure<TimeUnit> {
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link TimeUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  Time ofRelativeUnits(double magnitude, TimeUnit unit) {
+    return new Time(magnitude, unit.toBaseUnits(magnitude), unit);
   }
 
-  static  Time ofBaseUnits(double baseUnitMagnitude, TimeUnit unit) {
-    return new ImmutableTime(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link TimeUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit's base unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  Time ofBaseUnits(double baseUnitMagnitude, TimeUnit unit) {
+    return new Time(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
   }
 
   @Override
-  Time copy();
+  public TimeUnit baseUnit() { return (TimeUnit) unit().getBaseUnit(); }
 
   @Override
-  default MutTime mutableCopy() {
-    return new MutTime(magnitude(), baseUnitMagnitude(), unit());
-  }
-
-  @Override
-  TimeUnit unit();
-
-  @Override
-  default TimeUnit baseUnit() { return (TimeUnit) unit().getBaseUnit(); }
-
-  @Override
-  default double in(TimeUnit unit) {
+  public double in(TimeUnit unit) {
     return unit.fromBaseUnits(baseUnitMagnitude());
   }
 
   @Override
-  default Time unaryMinus() {
+  @SuppressWarnings("rawtypes")
+  public boolean equals(Object object) {
+    return object instanceof Time m && isEquivalent(m);
+  }
+
+  @Override
+  public Time unaryMinus() {
     return (Time) unit().ofBaseUnits(0 - baseUnitMagnitude());
   }
 
@@ -51,27 +60,27 @@ public interface Time extends Measure<TimeUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Time negate() {
+  public Time negate() {
     return (Time) unaryMinus();
   }
 
   @Override
-  default Time plus(Measure<? extends TimeUnit> other) {
+  public Time plus(Measure<? extends TimeUnit> other) {
     return (Time) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
   }
 
   @Override
-  default Time minus(Measure<? extends TimeUnit> other) {
+  public Time minus(Measure<? extends TimeUnit> other) {
     return (Time) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
   }
 
   @Override
-  default Time times(double multiplier) {
+  public Time times(double multiplier) {
     return (Time) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
   }
 
   @Override
-  default Time div(double divisor) {
+  public Time div(double divisor) {
     return (Time) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
@@ -83,18 +92,18 @@ public interface Time extends Measure<TimeUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Time divide(double divisor) {
+  public Time divide(double divisor) {
     return (Time) div(divisor);
   }
 
 
   @Override
-  default Mult<TimeUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+  public Mult<TimeUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
     return (Mult<TimeUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TimeUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
+  public Per<TimeUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
     return (Per<TimeUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -106,23 +115,23 @@ public interface Time extends Measure<TimeUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TimeUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+  public Per<TimeUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TimeUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
+  public Per<TimeUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TimeUnit, AngleUnit> times(Angle multiplier) {
+  public Mult<TimeUnit, AngleUnit> times(Angle multiplier) {
     return (Mult<TimeUnit, AngleUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TimeUnit, AngleUnit> div(Angle divisor) {
+  public Per<TimeUnit, AngleUnit> div(Angle divisor) {
     return (Per<TimeUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
@@ -134,23 +143,23 @@ public interface Time extends Measure<TimeUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TimeUnit, AngleUnit> divide(Angle divisor) {
+  public Per<TimeUnit, AngleUnit> divide(Angle divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TimeUnit, AngleUnit> per(AngleUnit divisorUnit) {
+  public Per<TimeUnit, AngleUnit> per(AngleUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default AngularVelocity times(AngularAcceleration multiplier) {
+  public AngularVelocity times(AngularAcceleration multiplier) {
     return RadiansPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<TimeUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
+  public Per<TimeUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
     return (Per<TimeUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -162,23 +171,23 @@ public interface Time extends Measure<TimeUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TimeUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+  public Per<TimeUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TimeUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
+  public Per<TimeUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TimeUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+  public Mult<TimeUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
     return (Mult<TimeUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TimeUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
+  public Per<TimeUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
     return (Per<TimeUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -190,23 +199,23 @@ public interface Time extends Measure<TimeUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TimeUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+  public Per<TimeUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TimeUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
+  public Per<TimeUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Angle times(AngularVelocity multiplier) {
+  public Angle times(AngularVelocity multiplier) {
     return Radians.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<TimeUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
+  public Per<TimeUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
     return (Per<TimeUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -218,23 +227,23 @@ public interface Time extends Measure<TimeUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TimeUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+  public Per<TimeUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TimeUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
+  public Per<TimeUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TimeUnit, CurrentUnit> times(Current multiplier) {
+  public Mult<TimeUnit, CurrentUnit> times(Current multiplier) {
     return (Mult<TimeUnit, CurrentUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TimeUnit, CurrentUnit> div(Current divisor) {
+  public Per<TimeUnit, CurrentUnit> div(Current divisor) {
     return (Per<TimeUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
@@ -246,17 +255,17 @@ public interface Time extends Measure<TimeUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TimeUnit, CurrentUnit> divide(Current divisor) {
+  public Per<TimeUnit, CurrentUnit> divide(Current divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TimeUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
+  public Per<TimeUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
   @Override
-  default Time div(Dimensionless divisor) {
+  public Time div(Dimensionless divisor) {
     return (Time) Seconds.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -268,23 +277,23 @@ public interface Time extends Measure<TimeUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Time divide(Dimensionless divisor) {
+  public Time divide(Dimensionless divisor) {
     return (Time) div(divisor);
   }
 
   @Override
-  default Time times(Dimensionless multiplier) {
+  public Time times(Dimensionless multiplier) {
     return (Time) Seconds.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
 
   @Override
-  default Mult<TimeUnit, DistanceUnit> times(Distance multiplier) {
+  public Mult<TimeUnit, DistanceUnit> times(Distance multiplier) {
     return (Mult<TimeUnit, DistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TimeUnit, DistanceUnit> div(Distance divisor) {
+  public Per<TimeUnit, DistanceUnit> div(Distance divisor) {
     return (Per<TimeUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -296,23 +305,23 @@ public interface Time extends Measure<TimeUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TimeUnit, DistanceUnit> divide(Distance divisor) {
+  public Per<TimeUnit, DistanceUnit> divide(Distance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TimeUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
+  public Per<TimeUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TimeUnit, EnergyUnit> times(Energy multiplier) {
+  public Mult<TimeUnit, EnergyUnit> times(Energy multiplier) {
     return (Mult<TimeUnit, EnergyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TimeUnit, EnergyUnit> div(Energy divisor) {
+  public Per<TimeUnit, EnergyUnit> div(Energy divisor) {
     return (Per<TimeUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
@@ -324,23 +333,23 @@ public interface Time extends Measure<TimeUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TimeUnit, EnergyUnit> divide(Energy divisor) {
+  public Per<TimeUnit, EnergyUnit> divide(Energy divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TimeUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
+  public Per<TimeUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TimeUnit, ForceUnit> times(Force multiplier) {
+  public Mult<TimeUnit, ForceUnit> times(Force multiplier) {
     return (Mult<TimeUnit, ForceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TimeUnit, ForceUnit> div(Force divisor) {
+  public Per<TimeUnit, ForceUnit> div(Force divisor) {
     return (Per<TimeUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
@@ -352,23 +361,23 @@ public interface Time extends Measure<TimeUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TimeUnit, ForceUnit> divide(Force divisor) {
+  public Per<TimeUnit, ForceUnit> divide(Force divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TimeUnit, ForceUnit> per(ForceUnit divisorUnit) {
+  public Per<TimeUnit, ForceUnit> per(ForceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Dimensionless times(Frequency multiplier) {
+  public Dimensionless times(Frequency multiplier) {
     return Value.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<TimeUnit, FrequencyUnit> div(Frequency divisor) {
+  public Per<TimeUnit, FrequencyUnit> div(Frequency divisor) {
     return (Per<TimeUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
@@ -380,23 +389,23 @@ public interface Time extends Measure<TimeUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TimeUnit, FrequencyUnit> divide(Frequency divisor) {
+  public Per<TimeUnit, FrequencyUnit> divide(Frequency divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TimeUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
+  public Per<TimeUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default LinearVelocity times(LinearAcceleration multiplier) {
+  public LinearVelocity times(LinearAcceleration multiplier) {
     return MetersPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<TimeUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
+  public Per<TimeUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
     return (Per<TimeUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -408,23 +417,23 @@ public interface Time extends Measure<TimeUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TimeUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+  public Per<TimeUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TimeUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
+  public Per<TimeUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TimeUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+  public Mult<TimeUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
     return (Mult<TimeUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TimeUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
+  public Per<TimeUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
     return (Per<TimeUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -436,23 +445,23 @@ public interface Time extends Measure<TimeUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TimeUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+  public Per<TimeUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TimeUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
+  public Per<TimeUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Distance times(LinearVelocity multiplier) {
+  public Distance times(LinearVelocity multiplier) {
     return Meters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Per<TimeUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
+  public Per<TimeUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
     return (Per<TimeUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -464,23 +473,23 @@ public interface Time extends Measure<TimeUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TimeUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+  public Per<TimeUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TimeUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
+  public Per<TimeUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TimeUnit, MassUnit> times(Mass multiplier) {
+  public Mult<TimeUnit, MassUnit> times(Mass multiplier) {
     return (Mult<TimeUnit, MassUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TimeUnit, MassUnit> div(Mass divisor) {
+  public Per<TimeUnit, MassUnit> div(Mass divisor) {
     return (Per<TimeUnit, MassUnit>) Measure.super.div(divisor);
   }
 
@@ -492,23 +501,23 @@ public interface Time extends Measure<TimeUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TimeUnit, MassUnit> divide(Mass divisor) {
+  public Per<TimeUnit, MassUnit> divide(Mass divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TimeUnit, MassUnit> per(MassUnit divisorUnit) {
+  public Per<TimeUnit, MassUnit> per(MassUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TimeUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+  public Mult<TimeUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
     return (Mult<TimeUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TimeUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
+  public Per<TimeUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
     return (Per<TimeUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
@@ -520,23 +529,23 @@ public interface Time extends Measure<TimeUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TimeUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+  public Per<TimeUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TimeUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
+  public Per<TimeUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TimeUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+  public Mult<TimeUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
     return (Mult<TimeUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TimeUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
+  public Per<TimeUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
     return (Per<TimeUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -548,23 +557,23 @@ public interface Time extends Measure<TimeUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TimeUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+  public Per<TimeUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TimeUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
+  public Per<TimeUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<TimeUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+  public Mult<TimeUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
     return (Mult<TimeUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TimeUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
+  public Per<TimeUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
     return (Per<TimeUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -576,23 +585,23 @@ public interface Time extends Measure<TimeUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TimeUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+  public Per<TimeUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TimeUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
+  public Per<TimeUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<TimeUnit, PowerUnit> times(Power multiplier) {
+  public Mult<TimeUnit, PowerUnit> times(Power multiplier) {
     return (Mult<TimeUnit, PowerUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TimeUnit, PowerUnit> div(Power divisor) {
+  public Per<TimeUnit, PowerUnit> div(Power divisor) {
     return (Per<TimeUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
@@ -604,23 +613,23 @@ public interface Time extends Measure<TimeUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TimeUnit, PowerUnit> divide(Power divisor) {
+  public Per<TimeUnit, PowerUnit> divide(Power divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TimeUnit, PowerUnit> per(PowerUnit divisorUnit) {
+  public Per<TimeUnit, PowerUnit> per(PowerUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TimeUnit, ResistanceUnit> times(Resistance multiplier) {
+  public Mult<TimeUnit, ResistanceUnit> times(Resistance multiplier) {
     return (Mult<TimeUnit, ResistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TimeUnit, ResistanceUnit> div(Resistance divisor) {
+  public Per<TimeUnit, ResistanceUnit> div(Resistance divisor) {
     return (Per<TimeUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -632,23 +641,23 @@ public interface Time extends Measure<TimeUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TimeUnit, ResistanceUnit> divide(Resistance divisor) {
+  public Per<TimeUnit, ResistanceUnit> divide(Resistance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TimeUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
+  public Per<TimeUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TimeUnit, TemperatureUnit> times(Temperature multiplier) {
+  public Mult<TimeUnit, TemperatureUnit> times(Temperature multiplier) {
     return (Mult<TimeUnit, TemperatureUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TimeUnit, TemperatureUnit> div(Temperature divisor) {
+  public Per<TimeUnit, TemperatureUnit> div(Temperature divisor) {
     return (Per<TimeUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
@@ -660,23 +669,23 @@ public interface Time extends Measure<TimeUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TimeUnit, TemperatureUnit> divide(Temperature divisor) {
+  public Per<TimeUnit, TemperatureUnit> divide(Temperature divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TimeUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
+  public Per<TimeUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TimeUnit, TimeUnit> times(Time multiplier) {
+  public Mult<TimeUnit, TimeUnit> times(Time multiplier) {
     return (Mult<TimeUnit, TimeUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Dimensionless div(Time divisor) {
+  public Dimensionless div(Time divisor) {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -688,23 +697,23 @@ public interface Time extends Measure<TimeUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Dimensionless divide(Time divisor) {
+  public Dimensionless divide(Time divisor) {
     return div(divisor);
   }
 
   @Override
-  default Dimensionless per(TimeUnit divisorUnit) {
+  public Dimensionless per(TimeUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TimeUnit, TorqueUnit> times(Torque multiplier) {
+  public Mult<TimeUnit, TorqueUnit> times(Torque multiplier) {
     return (Mult<TimeUnit, TorqueUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TimeUnit, TorqueUnit> div(Torque divisor) {
+  public Per<TimeUnit, TorqueUnit> div(Torque divisor) {
     return (Per<TimeUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
@@ -716,23 +725,23 @@ public interface Time extends Measure<TimeUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TimeUnit, TorqueUnit> divide(Torque divisor) {
+  public Per<TimeUnit, TorqueUnit> divide(Torque divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TimeUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
+  public Per<TimeUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TimeUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+  public Mult<TimeUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
     return (Mult<TimeUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TimeUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
+  public Per<TimeUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
     return (Per<TimeUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -744,23 +753,23 @@ public interface Time extends Measure<TimeUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TimeUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+  public Per<TimeUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TimeUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
+  public Per<TimeUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TimeUnit, VoltageUnit> times(Voltage multiplier) {
+  public Mult<TimeUnit, VoltageUnit> times(Voltage multiplier) {
     return (Mult<TimeUnit, VoltageUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TimeUnit, VoltageUnit> div(Voltage divisor) {
+  public Per<TimeUnit, VoltageUnit> div(Voltage divisor) {
     return (Per<TimeUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
@@ -772,13 +781,13 @@ public interface Time extends Measure<TimeUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TimeUnit, VoltageUnit> divide(Voltage divisor) {
+  public Per<TimeUnit, VoltageUnit> divide(Voltage divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TimeUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
+  public Per<TimeUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
     return div(divisorUnit.one());
   }
-default Frequency asFrequency() { return Hertz.of(1 / baseUnitMagnitude()); }
+public Frequency asFrequency() { return Hertz.of(1 / baseUnitMagnitude()); }
 }
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Torque.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Torque.java
index cc7ac69da5..4cf3afb123 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Torque.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Torque.java
@@ -10,36 +10,45 @@ import static edu.wpi.first.units.Units.*;
 import edu.wpi.first.units.*;
 
 @SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public interface Torque extends Measure<TorqueUnit> {
-  static  Torque ofRelativeUnits(double magnitude, TorqueUnit unit) {
-    return new ImmutableTorque(magnitude, unit.toBaseUnits(magnitude), unit);
+public record Torque(double magnitude, double baseUnitMagnitude, TorqueUnit unit) implements Measure<TorqueUnit> {
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link TorqueUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  Torque ofRelativeUnits(double magnitude, TorqueUnit unit) {
+    return new Torque(magnitude, unit.toBaseUnits(magnitude), unit);
   }
 
-  static  Torque ofBaseUnits(double baseUnitMagnitude, TorqueUnit unit) {
-    return new ImmutableTorque(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link TorqueUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit's base unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  Torque ofBaseUnits(double baseUnitMagnitude, TorqueUnit unit) {
+    return new Torque(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
   }
 
   @Override
-  Torque copy();
+  public TorqueUnit baseUnit() { return (TorqueUnit) unit().getBaseUnit(); }
 
   @Override
-  default MutTorque mutableCopy() {
-    return new MutTorque(magnitude(), baseUnitMagnitude(), unit());
-  }
-
-  @Override
-  TorqueUnit unit();
-
-  @Override
-  default TorqueUnit baseUnit() { return (TorqueUnit) unit().getBaseUnit(); }
-
-  @Override
-  default double in(TorqueUnit unit) {
+  public double in(TorqueUnit unit) {
     return unit.fromBaseUnits(baseUnitMagnitude());
   }
 
   @Override
-  default Torque unaryMinus() {
+  @SuppressWarnings("rawtypes")
+  public boolean equals(Object object) {
+    return object instanceof Torque m && isEquivalent(m);
+  }
+
+  @Override
+  public Torque unaryMinus() {
     return (Torque) unit().ofBaseUnits(0 - baseUnitMagnitude());
   }
 
@@ -51,27 +60,27 @@ public interface Torque extends Measure<TorqueUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Torque negate() {
+  public Torque negate() {
     return (Torque) unaryMinus();
   }
 
   @Override
-  default Torque plus(Measure<? extends TorqueUnit> other) {
+  public Torque plus(Measure<? extends TorqueUnit> other) {
     return (Torque) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
   }
 
   @Override
-  default Torque minus(Measure<? extends TorqueUnit> other) {
+  public Torque minus(Measure<? extends TorqueUnit> other) {
     return (Torque) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
   }
 
   @Override
-  default Torque times(double multiplier) {
+  public Torque times(double multiplier) {
     return (Torque) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
   }
 
   @Override
-  default Torque div(double divisor) {
+  public Torque div(double divisor) {
     return (Torque) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
@@ -83,18 +92,18 @@ public interface Torque extends Measure<TorqueUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Torque divide(double divisor) {
+  public Torque divide(double divisor) {
     return (Torque) div(divisor);
   }
 
 
   @Override
-  default Mult<TorqueUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+  public Mult<TorqueUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
     return (Mult<TorqueUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TorqueUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
+  public Per<TorqueUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
     return (Per<TorqueUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -106,23 +115,23 @@ public interface Torque extends Measure<TorqueUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TorqueUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+  public Per<TorqueUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TorqueUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
+  public Per<TorqueUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TorqueUnit, AngleUnit> times(Angle multiplier) {
+  public Mult<TorqueUnit, AngleUnit> times(Angle multiplier) {
     return (Mult<TorqueUnit, AngleUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TorqueUnit, AngleUnit> div(Angle divisor) {
+  public Per<TorqueUnit, AngleUnit> div(Angle divisor) {
     return (Per<TorqueUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
@@ -134,23 +143,23 @@ public interface Torque extends Measure<TorqueUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TorqueUnit, AngleUnit> divide(Angle divisor) {
+  public Per<TorqueUnit, AngleUnit> divide(Angle divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TorqueUnit, AngleUnit> per(AngleUnit divisorUnit) {
+  public Per<TorqueUnit, AngleUnit> per(AngleUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TorqueUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+  public Mult<TorqueUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
     return (Mult<TorqueUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TorqueUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
+  public Per<TorqueUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
     return (Per<TorqueUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -162,23 +171,23 @@ public interface Torque extends Measure<TorqueUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TorqueUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+  public Per<TorqueUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TorqueUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
+  public Per<TorqueUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TorqueUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+  public Mult<TorqueUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
     return (Mult<TorqueUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TorqueUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
+  public Per<TorqueUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
     return (Per<TorqueUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -190,23 +199,23 @@ public interface Torque extends Measure<TorqueUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TorqueUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+  public Per<TorqueUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TorqueUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
+  public Per<TorqueUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TorqueUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+  public Mult<TorqueUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
     return (Mult<TorqueUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TorqueUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
+  public Per<TorqueUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
     return (Per<TorqueUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -218,23 +227,23 @@ public interface Torque extends Measure<TorqueUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TorqueUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+  public Per<TorqueUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TorqueUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
+  public Per<TorqueUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TorqueUnit, CurrentUnit> times(Current multiplier) {
+  public Mult<TorqueUnit, CurrentUnit> times(Current multiplier) {
     return (Mult<TorqueUnit, CurrentUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TorqueUnit, CurrentUnit> div(Current divisor) {
+  public Per<TorqueUnit, CurrentUnit> div(Current divisor) {
     return (Per<TorqueUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
@@ -246,17 +255,17 @@ public interface Torque extends Measure<TorqueUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TorqueUnit, CurrentUnit> divide(Current divisor) {
+  public Per<TorqueUnit, CurrentUnit> divide(Current divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TorqueUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
+  public Per<TorqueUnit, CurrentUnit> per(CurrentUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
   @Override
-  default Torque div(Dimensionless divisor) {
+  public Torque div(Dimensionless divisor) {
     return (Torque) NewtonMeters.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -268,23 +277,23 @@ public interface Torque extends Measure<TorqueUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Torque divide(Dimensionless divisor) {
+  public Torque divide(Dimensionless divisor) {
     return (Torque) div(divisor);
   }
 
   @Override
-  default Torque times(Dimensionless multiplier) {
+  public Torque times(Dimensionless multiplier) {
     return (Torque) NewtonMeters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
 
   @Override
-  default Mult<TorqueUnit, DistanceUnit> times(Distance multiplier) {
+  public Mult<TorqueUnit, DistanceUnit> times(Distance multiplier) {
     return (Mult<TorqueUnit, DistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Force div(Distance divisor) {
+  public Force div(Distance divisor) {
     return Newtons.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -296,23 +305,23 @@ public interface Torque extends Measure<TorqueUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Force divide(Distance divisor) {
+  public Force divide(Distance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Force per(DistanceUnit divisorUnit) {
+  public Force per(DistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TorqueUnit, EnergyUnit> times(Energy multiplier) {
+  public Mult<TorqueUnit, EnergyUnit> times(Energy multiplier) {
     return (Mult<TorqueUnit, EnergyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TorqueUnit, EnergyUnit> div(Energy divisor) {
+  public Per<TorqueUnit, EnergyUnit> div(Energy divisor) {
     return (Per<TorqueUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
@@ -324,23 +333,23 @@ public interface Torque extends Measure<TorqueUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TorqueUnit, EnergyUnit> divide(Energy divisor) {
+  public Per<TorqueUnit, EnergyUnit> divide(Energy divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TorqueUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
+  public Per<TorqueUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TorqueUnit, ForceUnit> times(Force multiplier) {
+  public Mult<TorqueUnit, ForceUnit> times(Force multiplier) {
     return (Mult<TorqueUnit, ForceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Distance div(Force divisor) {
+  public Distance div(Force divisor) {
     return Meters.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -352,23 +361,23 @@ public interface Torque extends Measure<TorqueUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Distance divide(Force divisor) {
+  public Distance divide(Force divisor) {
     return div(divisor);
   }
 
   @Override
-  default Distance per(ForceUnit divisorUnit) {
+  public Distance per(ForceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TorqueUnit, FrequencyUnit> times(Frequency multiplier) {
+  public Mult<TorqueUnit, FrequencyUnit> times(Frequency multiplier) {
     return (Mult<TorqueUnit, FrequencyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TorqueUnit, FrequencyUnit> div(Frequency divisor) {
+  public Per<TorqueUnit, FrequencyUnit> div(Frequency divisor) {
     return (Per<TorqueUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
@@ -380,23 +389,23 @@ public interface Torque extends Measure<TorqueUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TorqueUnit, FrequencyUnit> divide(Frequency divisor) {
+  public Per<TorqueUnit, FrequencyUnit> divide(Frequency divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TorqueUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
+  public Per<TorqueUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TorqueUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+  public Mult<TorqueUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
     return (Mult<TorqueUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TorqueUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
+  public Per<TorqueUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
     return (Per<TorqueUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -408,23 +417,23 @@ public interface Torque extends Measure<TorqueUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TorqueUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+  public Per<TorqueUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TorqueUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
+  public Per<TorqueUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TorqueUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+  public Mult<TorqueUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
     return (Mult<TorqueUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TorqueUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
+  public Per<TorqueUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
     return (Per<TorqueUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -436,23 +445,23 @@ public interface Torque extends Measure<TorqueUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TorqueUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+  public Per<TorqueUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TorqueUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
+  public Per<TorqueUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TorqueUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+  public Mult<TorqueUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
     return (Mult<TorqueUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TorqueUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
+  public Per<TorqueUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
     return (Per<TorqueUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -464,23 +473,23 @@ public interface Torque extends Measure<TorqueUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TorqueUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+  public Per<TorqueUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TorqueUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
+  public Per<TorqueUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TorqueUnit, MassUnit> times(Mass multiplier) {
+  public Mult<TorqueUnit, MassUnit> times(Mass multiplier) {
     return (Mult<TorqueUnit, MassUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TorqueUnit, MassUnit> div(Mass divisor) {
+  public Per<TorqueUnit, MassUnit> div(Mass divisor) {
     return (Per<TorqueUnit, MassUnit>) Measure.super.div(divisor);
   }
 
@@ -492,23 +501,23 @@ public interface Torque extends Measure<TorqueUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TorqueUnit, MassUnit> divide(Mass divisor) {
+  public Per<TorqueUnit, MassUnit> divide(Mass divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TorqueUnit, MassUnit> per(MassUnit divisorUnit) {
+  public Per<TorqueUnit, MassUnit> per(MassUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TorqueUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+  public Mult<TorqueUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
     return (Mult<TorqueUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TorqueUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
+  public Per<TorqueUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
     return (Per<TorqueUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
@@ -520,23 +529,23 @@ public interface Torque extends Measure<TorqueUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TorqueUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+  public Per<TorqueUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TorqueUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
+  public Per<TorqueUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TorqueUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+  public Mult<TorqueUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
     return (Mult<TorqueUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TorqueUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
+  public Per<TorqueUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
     return (Per<TorqueUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -548,23 +557,23 @@ public interface Torque extends Measure<TorqueUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TorqueUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+  public Per<TorqueUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TorqueUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
+  public Per<TorqueUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<TorqueUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+  public Mult<TorqueUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
     return (Mult<TorqueUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TorqueUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
+  public Per<TorqueUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
     return (Per<TorqueUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -576,23 +585,23 @@ public interface Torque extends Measure<TorqueUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TorqueUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+  public Per<TorqueUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TorqueUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
+  public Per<TorqueUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<TorqueUnit, PowerUnit> times(Power multiplier) {
+  public Mult<TorqueUnit, PowerUnit> times(Power multiplier) {
     return (Mult<TorqueUnit, PowerUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TorqueUnit, PowerUnit> div(Power divisor) {
+  public Per<TorqueUnit, PowerUnit> div(Power divisor) {
     return (Per<TorqueUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
@@ -604,23 +613,23 @@ public interface Torque extends Measure<TorqueUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TorqueUnit, PowerUnit> divide(Power divisor) {
+  public Per<TorqueUnit, PowerUnit> divide(Power divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TorqueUnit, PowerUnit> per(PowerUnit divisorUnit) {
+  public Per<TorqueUnit, PowerUnit> per(PowerUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TorqueUnit, ResistanceUnit> times(Resistance multiplier) {
+  public Mult<TorqueUnit, ResistanceUnit> times(Resistance multiplier) {
     return (Mult<TorqueUnit, ResistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TorqueUnit, ResistanceUnit> div(Resistance divisor) {
+  public Per<TorqueUnit, ResistanceUnit> div(Resistance divisor) {
     return (Per<TorqueUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -632,23 +641,23 @@ public interface Torque extends Measure<TorqueUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TorqueUnit, ResistanceUnit> divide(Resistance divisor) {
+  public Per<TorqueUnit, ResistanceUnit> divide(Resistance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TorqueUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
+  public Per<TorqueUnit, ResistanceUnit> per(ResistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TorqueUnit, TemperatureUnit> times(Temperature multiplier) {
+  public Mult<TorqueUnit, TemperatureUnit> times(Temperature multiplier) {
     return (Mult<TorqueUnit, TemperatureUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TorqueUnit, TemperatureUnit> div(Temperature divisor) {
+  public Per<TorqueUnit, TemperatureUnit> div(Temperature divisor) {
     return (Per<TorqueUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
@@ -660,23 +669,23 @@ public interface Torque extends Measure<TorqueUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TorqueUnit, TemperatureUnit> divide(Temperature divisor) {
+  public Per<TorqueUnit, TemperatureUnit> divide(Temperature divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TorqueUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
+  public Per<TorqueUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TorqueUnit, TimeUnit> times(Time multiplier) {
+  public Mult<TorqueUnit, TimeUnit> times(Time multiplier) {
     return (Mult<TorqueUnit, TimeUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Velocity<TorqueUnit> div(Time divisor) {
+  public Velocity<TorqueUnit> div(Time divisor) {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -688,23 +697,23 @@ public interface Torque extends Measure<TorqueUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Velocity<TorqueUnit> divide(Time divisor) {
+  public Velocity<TorqueUnit> divide(Time divisor) {
     return div(divisor);
   }
 
   @Override
-  default Velocity<TorqueUnit> per(TimeUnit divisorUnit) {
+  public Velocity<TorqueUnit> per(TimeUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TorqueUnit, TorqueUnit> times(Torque multiplier) {
+  public Mult<TorqueUnit, TorqueUnit> times(Torque multiplier) {
     return (Mult<TorqueUnit, TorqueUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Dimensionless div(Torque divisor) {
+  public Dimensionless div(Torque divisor) {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -716,23 +725,23 @@ public interface Torque extends Measure<TorqueUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Dimensionless divide(Torque divisor) {
+  public Dimensionless divide(Torque divisor) {
     return div(divisor);
   }
 
   @Override
-  default Dimensionless per(TorqueUnit divisorUnit) {
+  public Dimensionless per(TorqueUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TorqueUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+  public Mult<TorqueUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
     return (Mult<TorqueUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TorqueUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
+  public Per<TorqueUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
     return (Per<TorqueUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -744,23 +753,23 @@ public interface Torque extends Measure<TorqueUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TorqueUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+  public Per<TorqueUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TorqueUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
+  public Per<TorqueUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<TorqueUnit, VoltageUnit> times(Voltage multiplier) {
+  public Mult<TorqueUnit, VoltageUnit> times(Voltage multiplier) {
     return (Mult<TorqueUnit, VoltageUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<TorqueUnit, VoltageUnit> div(Voltage divisor) {
+  public Per<TorqueUnit, VoltageUnit> div(Voltage divisor) {
     return (Per<TorqueUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
@@ -772,12 +781,12 @@ public interface Torque extends Measure<TorqueUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<TorqueUnit, VoltageUnit> divide(Voltage divisor) {
+  public Per<TorqueUnit, VoltageUnit> divide(Voltage divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<TorqueUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
+  public Per<TorqueUnit, VoltageUnit> per(VoltageUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Velocity.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Velocity.java
index ac6df04e1f..f8ef481d53 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Velocity.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Velocity.java
@@ -10,36 +10,45 @@ import static edu.wpi.first.units.Units.*;
 import edu.wpi.first.units.*;
 
 @SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
-  static <D extends Unit> Velocity<D> ofRelativeUnits(double magnitude, VelocityUnit<D> unit) {
-    return new ImmutableVelocity<D>(magnitude, unit.toBaseUnits(magnitude), unit);
+public record Velocity<D extends Unit>(double magnitude, double baseUnitMagnitude, VelocityUnit<D> unit) implements Measure<VelocityUnit<D>> {
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link VelocityUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static <D extends Unit> Velocity<D> ofRelativeUnits(double magnitude, VelocityUnit<D> unit) {
+    return new Velocity<D>(magnitude, unit.toBaseUnits(magnitude), unit);
   }
 
-  static <D extends Unit> Velocity<D> ofBaseUnits(double baseUnitMagnitude, VelocityUnit<D> unit) {
-    return new ImmutableVelocity<D>(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link VelocityUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit's base unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static <D extends Unit> Velocity<D> ofBaseUnits(double baseUnitMagnitude, VelocityUnit<D> unit) {
+    return new Velocity<D>(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
   }
 
   @Override
-  Velocity<D> copy();
+  public VelocityUnit<D> baseUnit() { return (VelocityUnit<D>) unit().getBaseUnit(); }
 
   @Override
-  default MutVelocity<D> mutableCopy() {
-    return new MutVelocity<D>(magnitude(), baseUnitMagnitude(), unit());
-  }
-
-  @Override
-  VelocityUnit<D> unit();
-
-  @Override
-  default VelocityUnit<D> baseUnit() { return (VelocityUnit<D>) unit().getBaseUnit(); }
-
-  @Override
-  default double in(VelocityUnit<D> unit) {
+  public double in(VelocityUnit<D> unit) {
     return unit.fromBaseUnits(baseUnitMagnitude());
   }
 
   @Override
-  default Velocity<D> unaryMinus() {
+  @SuppressWarnings("rawtypes")
+  public boolean equals(Object object) {
+    return object instanceof Velocity m && isEquivalent(m);
+  }
+
+  @Override
+  public Velocity<D> unaryMinus() {
     return (Velocity<D>) unit().ofBaseUnits(0 - baseUnitMagnitude());
   }
 
@@ -51,27 +60,27 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Velocity<D> negate() {
+  public Velocity<D> negate() {
     return (Velocity<D>) unaryMinus();
   }
 
   @Override
-  default Velocity<D> plus(Measure<? extends VelocityUnit<D>> other) {
+  public Velocity<D> plus(Measure<? extends VelocityUnit<D>> other) {
     return (Velocity<D>) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
   }
 
   @Override
-  default Velocity<D> minus(Measure<? extends VelocityUnit<D>> other) {
+  public Velocity<D> minus(Measure<? extends VelocityUnit<D>> other) {
     return (Velocity<D>) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
   }
 
   @Override
-  default Velocity<D> times(double multiplier) {
+  public Velocity<D> times(double multiplier) {
     return (Velocity<D>) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
   }
 
   @Override
-  default Velocity<D> div(double divisor) {
+  public Velocity<D> div(double divisor) {
     return (Velocity<D>) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
@@ -83,18 +92,18 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Velocity<D> divide(double divisor) {
+  public Velocity<D> divide(double divisor) {
     return (Velocity<D>) div(divisor);
   }
 
 
   @Override
-  default Mult<VelocityUnit<D>, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+  public Mult<VelocityUnit<D>, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
     return (Mult<VelocityUnit<D>, AccelerationUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VelocityUnit<D>, AccelerationUnit<?>> div(Acceleration<?> divisor) {
+  public Per<VelocityUnit<D>, AccelerationUnit<?>> div(Acceleration<?> divisor) {
     return (Per<VelocityUnit<D>, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -106,23 +115,23 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VelocityUnit<D>, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+  public Per<VelocityUnit<D>, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VelocityUnit<D>, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
+  public Per<VelocityUnit<D>, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VelocityUnit<D>, AngleUnit> times(Angle multiplier) {
+  public Mult<VelocityUnit<D>, AngleUnit> times(Angle multiplier) {
     return (Mult<VelocityUnit<D>, AngleUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VelocityUnit<D>, AngleUnit> div(Angle divisor) {
+  public Per<VelocityUnit<D>, AngleUnit> div(Angle divisor) {
     return (Per<VelocityUnit<D>, AngleUnit>) Measure.super.div(divisor);
   }
 
@@ -134,23 +143,23 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VelocityUnit<D>, AngleUnit> divide(Angle divisor) {
+  public Per<VelocityUnit<D>, AngleUnit> divide(Angle divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VelocityUnit<D>, AngleUnit> per(AngleUnit divisorUnit) {
+  public Per<VelocityUnit<D>, AngleUnit> per(AngleUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VelocityUnit<D>, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+  public Mult<VelocityUnit<D>, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
     return (Mult<VelocityUnit<D>, AngularAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VelocityUnit<D>, AngularAccelerationUnit> div(AngularAcceleration divisor) {
+  public Per<VelocityUnit<D>, AngularAccelerationUnit> div(AngularAcceleration divisor) {
     return (Per<VelocityUnit<D>, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -162,23 +171,23 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VelocityUnit<D>, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+  public Per<VelocityUnit<D>, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VelocityUnit<D>, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
+  public Per<VelocityUnit<D>, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VelocityUnit<D>, AngularMomentumUnit> times(AngularMomentum multiplier) {
+  public Mult<VelocityUnit<D>, AngularMomentumUnit> times(AngularMomentum multiplier) {
     return (Mult<VelocityUnit<D>, AngularMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VelocityUnit<D>, AngularMomentumUnit> div(AngularMomentum divisor) {
+  public Per<VelocityUnit<D>, AngularMomentumUnit> div(AngularMomentum divisor) {
     return (Per<VelocityUnit<D>, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -190,23 +199,23 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VelocityUnit<D>, AngularMomentumUnit> divide(AngularMomentum divisor) {
+  public Per<VelocityUnit<D>, AngularMomentumUnit> divide(AngularMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VelocityUnit<D>, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
+  public Per<VelocityUnit<D>, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VelocityUnit<D>, AngularVelocityUnit> times(AngularVelocity multiplier) {
+  public Mult<VelocityUnit<D>, AngularVelocityUnit> times(AngularVelocity multiplier) {
     return (Mult<VelocityUnit<D>, AngularVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VelocityUnit<D>, AngularVelocityUnit> div(AngularVelocity divisor) {
+  public Per<VelocityUnit<D>, AngularVelocityUnit> div(AngularVelocity divisor) {
     return (Per<VelocityUnit<D>, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -218,23 +227,23 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VelocityUnit<D>, AngularVelocityUnit> divide(AngularVelocity divisor) {
+  public Per<VelocityUnit<D>, AngularVelocityUnit> divide(AngularVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VelocityUnit<D>, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
+  public Per<VelocityUnit<D>, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VelocityUnit<D>, CurrentUnit> times(Current multiplier) {
+  public Mult<VelocityUnit<D>, CurrentUnit> times(Current multiplier) {
     return (Mult<VelocityUnit<D>, CurrentUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VelocityUnit<D>, CurrentUnit> div(Current divisor) {
+  public Per<VelocityUnit<D>, CurrentUnit> div(Current divisor) {
     return (Per<VelocityUnit<D>, CurrentUnit>) Measure.super.div(divisor);
   }
 
@@ -246,17 +255,17 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VelocityUnit<D>, CurrentUnit> divide(Current divisor) {
+  public Per<VelocityUnit<D>, CurrentUnit> divide(Current divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VelocityUnit<D>, CurrentUnit> per(CurrentUnit divisorUnit) {
+  public Per<VelocityUnit<D>, CurrentUnit> per(CurrentUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
   @Override
-  default Velocity<D> div(Dimensionless divisor) {
+  public Velocity<D> div(Dimensionless divisor) {
     return (Velocity<D>) unit().of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -268,23 +277,23 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Velocity<D> divide(Dimensionless divisor) {
+  public Velocity<D> divide(Dimensionless divisor) {
     return (Velocity<D>) div(divisor);
   }
 
   @Override
-  default Velocity<D> times(Dimensionless multiplier) {
+  public Velocity<D> times(Dimensionless multiplier) {
     return (Velocity<D>) unit().of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
 
   @Override
-  default Mult<VelocityUnit<D>, DistanceUnit> times(Distance multiplier) {
+  public Mult<VelocityUnit<D>, DistanceUnit> times(Distance multiplier) {
     return (Mult<VelocityUnit<D>, DistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VelocityUnit<D>, DistanceUnit> div(Distance divisor) {
+  public Per<VelocityUnit<D>, DistanceUnit> div(Distance divisor) {
     return (Per<VelocityUnit<D>, DistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -296,23 +305,23 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VelocityUnit<D>, DistanceUnit> divide(Distance divisor) {
+  public Per<VelocityUnit<D>, DistanceUnit> divide(Distance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VelocityUnit<D>, DistanceUnit> per(DistanceUnit divisorUnit) {
+  public Per<VelocityUnit<D>, DistanceUnit> per(DistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VelocityUnit<D>, EnergyUnit> times(Energy multiplier) {
+  public Mult<VelocityUnit<D>, EnergyUnit> times(Energy multiplier) {
     return (Mult<VelocityUnit<D>, EnergyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VelocityUnit<D>, EnergyUnit> div(Energy divisor) {
+  public Per<VelocityUnit<D>, EnergyUnit> div(Energy divisor) {
     return (Per<VelocityUnit<D>, EnergyUnit>) Measure.super.div(divisor);
   }
 
@@ -324,23 +333,23 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VelocityUnit<D>, EnergyUnit> divide(Energy divisor) {
+  public Per<VelocityUnit<D>, EnergyUnit> divide(Energy divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VelocityUnit<D>, EnergyUnit> per(EnergyUnit divisorUnit) {
+  public Per<VelocityUnit<D>, EnergyUnit> per(EnergyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VelocityUnit<D>, ForceUnit> times(Force multiplier) {
+  public Mult<VelocityUnit<D>, ForceUnit> times(Force multiplier) {
     return (Mult<VelocityUnit<D>, ForceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VelocityUnit<D>, ForceUnit> div(Force divisor) {
+  public Per<VelocityUnit<D>, ForceUnit> div(Force divisor) {
     return (Per<VelocityUnit<D>, ForceUnit>) Measure.super.div(divisor);
   }
 
@@ -352,23 +361,23 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VelocityUnit<D>, ForceUnit> divide(Force divisor) {
+  public Per<VelocityUnit<D>, ForceUnit> divide(Force divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VelocityUnit<D>, ForceUnit> per(ForceUnit divisorUnit) {
+  public Per<VelocityUnit<D>, ForceUnit> per(ForceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VelocityUnit<D>, FrequencyUnit> times(Frequency multiplier) {
+  public Mult<VelocityUnit<D>, FrequencyUnit> times(Frequency multiplier) {
     return (Mult<VelocityUnit<D>, FrequencyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VelocityUnit<D>, FrequencyUnit> div(Frequency divisor) {
+  public Per<VelocityUnit<D>, FrequencyUnit> div(Frequency divisor) {
     return (Per<VelocityUnit<D>, FrequencyUnit>) Measure.super.div(divisor);
   }
 
@@ -380,23 +389,23 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VelocityUnit<D>, FrequencyUnit> divide(Frequency divisor) {
+  public Per<VelocityUnit<D>, FrequencyUnit> divide(Frequency divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VelocityUnit<D>, FrequencyUnit> per(FrequencyUnit divisorUnit) {
+  public Per<VelocityUnit<D>, FrequencyUnit> per(FrequencyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VelocityUnit<D>, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+  public Mult<VelocityUnit<D>, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
     return (Mult<VelocityUnit<D>, LinearAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VelocityUnit<D>, LinearAccelerationUnit> div(LinearAcceleration divisor) {
+  public Per<VelocityUnit<D>, LinearAccelerationUnit> div(LinearAcceleration divisor) {
     return (Per<VelocityUnit<D>, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -408,23 +417,23 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VelocityUnit<D>, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+  public Per<VelocityUnit<D>, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VelocityUnit<D>, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
+  public Per<VelocityUnit<D>, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VelocityUnit<D>, LinearMomentumUnit> times(LinearMomentum multiplier) {
+  public Mult<VelocityUnit<D>, LinearMomentumUnit> times(LinearMomentum multiplier) {
     return (Mult<VelocityUnit<D>, LinearMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VelocityUnit<D>, LinearMomentumUnit> div(LinearMomentum divisor) {
+  public Per<VelocityUnit<D>, LinearMomentumUnit> div(LinearMomentum divisor) {
     return (Per<VelocityUnit<D>, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -436,23 +445,23 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VelocityUnit<D>, LinearMomentumUnit> divide(LinearMomentum divisor) {
+  public Per<VelocityUnit<D>, LinearMomentumUnit> divide(LinearMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VelocityUnit<D>, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
+  public Per<VelocityUnit<D>, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VelocityUnit<D>, LinearVelocityUnit> times(LinearVelocity multiplier) {
+  public Mult<VelocityUnit<D>, LinearVelocityUnit> times(LinearVelocity multiplier) {
     return (Mult<VelocityUnit<D>, LinearVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VelocityUnit<D>, LinearVelocityUnit> div(LinearVelocity divisor) {
+  public Per<VelocityUnit<D>, LinearVelocityUnit> div(LinearVelocity divisor) {
     return (Per<VelocityUnit<D>, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -464,23 +473,23 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VelocityUnit<D>, LinearVelocityUnit> divide(LinearVelocity divisor) {
+  public Per<VelocityUnit<D>, LinearVelocityUnit> divide(LinearVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VelocityUnit<D>, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
+  public Per<VelocityUnit<D>, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VelocityUnit<D>, MassUnit> times(Mass multiplier) {
+  public Mult<VelocityUnit<D>, MassUnit> times(Mass multiplier) {
     return (Mult<VelocityUnit<D>, MassUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VelocityUnit<D>, MassUnit> div(Mass divisor) {
+  public Per<VelocityUnit<D>, MassUnit> div(Mass divisor) {
     return (Per<VelocityUnit<D>, MassUnit>) Measure.super.div(divisor);
   }
 
@@ -492,23 +501,23 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VelocityUnit<D>, MassUnit> divide(Mass divisor) {
+  public Per<VelocityUnit<D>, MassUnit> divide(Mass divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VelocityUnit<D>, MassUnit> per(MassUnit divisorUnit) {
+  public Per<VelocityUnit<D>, MassUnit> per(MassUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VelocityUnit<D>, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+  public Mult<VelocityUnit<D>, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
     return (Mult<VelocityUnit<D>, MomentOfInertiaUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VelocityUnit<D>, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
+  public Per<VelocityUnit<D>, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
     return (Per<VelocityUnit<D>, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
@@ -520,23 +529,23 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VelocityUnit<D>, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+  public Per<VelocityUnit<D>, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VelocityUnit<D>, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
+  public Per<VelocityUnit<D>, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VelocityUnit<D>, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+  public Mult<VelocityUnit<D>, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
     return (Mult<VelocityUnit<D>, MultUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VelocityUnit<D>, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
+  public Per<VelocityUnit<D>, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
     return (Per<VelocityUnit<D>, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -548,23 +557,23 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VelocityUnit<D>, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+  public Per<VelocityUnit<D>, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VelocityUnit<D>, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
+  public Per<VelocityUnit<D>, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<VelocityUnit<D>, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+  public Mult<VelocityUnit<D>, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
     return (Mult<VelocityUnit<D>, PerUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VelocityUnit<D>, PerUnit<?, ?>> div(Per<?, ?> divisor) {
+  public Per<VelocityUnit<D>, PerUnit<?, ?>> div(Per<?, ?> divisor) {
     return (Per<VelocityUnit<D>, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -576,23 +585,23 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VelocityUnit<D>, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+  public Per<VelocityUnit<D>, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VelocityUnit<D>, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
+  public Per<VelocityUnit<D>, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<VelocityUnit<D>, PowerUnit> times(Power multiplier) {
+  public Mult<VelocityUnit<D>, PowerUnit> times(Power multiplier) {
     return (Mult<VelocityUnit<D>, PowerUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VelocityUnit<D>, PowerUnit> div(Power divisor) {
+  public Per<VelocityUnit<D>, PowerUnit> div(Power divisor) {
     return (Per<VelocityUnit<D>, PowerUnit>) Measure.super.div(divisor);
   }
 
@@ -604,23 +613,23 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VelocityUnit<D>, PowerUnit> divide(Power divisor) {
+  public Per<VelocityUnit<D>, PowerUnit> divide(Power divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VelocityUnit<D>, PowerUnit> per(PowerUnit divisorUnit) {
+  public Per<VelocityUnit<D>, PowerUnit> per(PowerUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VelocityUnit<D>, ResistanceUnit> times(Resistance multiplier) {
+  public Mult<VelocityUnit<D>, ResistanceUnit> times(Resistance multiplier) {
     return (Mult<VelocityUnit<D>, ResistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VelocityUnit<D>, ResistanceUnit> div(Resistance divisor) {
+  public Per<VelocityUnit<D>, ResistanceUnit> div(Resistance divisor) {
     return (Per<VelocityUnit<D>, ResistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -632,23 +641,23 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VelocityUnit<D>, ResistanceUnit> divide(Resistance divisor) {
+  public Per<VelocityUnit<D>, ResistanceUnit> divide(Resistance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VelocityUnit<D>, ResistanceUnit> per(ResistanceUnit divisorUnit) {
+  public Per<VelocityUnit<D>, ResistanceUnit> per(ResistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VelocityUnit<D>, TemperatureUnit> times(Temperature multiplier) {
+  public Mult<VelocityUnit<D>, TemperatureUnit> times(Temperature multiplier) {
     return (Mult<VelocityUnit<D>, TemperatureUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VelocityUnit<D>, TemperatureUnit> div(Temperature divisor) {
+  public Per<VelocityUnit<D>, TemperatureUnit> div(Temperature divisor) {
     return (Per<VelocityUnit<D>, TemperatureUnit>) Measure.super.div(divisor);
   }
 
@@ -660,22 +669,22 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VelocityUnit<D>, TemperatureUnit> divide(Temperature divisor) {
+  public Per<VelocityUnit<D>, TemperatureUnit> divide(Temperature divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VelocityUnit<D>, TemperatureUnit> per(TemperatureUnit divisorUnit) {
+  public Per<VelocityUnit<D>, TemperatureUnit> per(TemperatureUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
   @Override
-  default Measure<D> times(Time multiplier) {
+  public Measure<D> times(Time multiplier) {
     return (Measure<D>) unit().numerator().ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Velocity<VelocityUnit<D>> div(Time divisor) {
+  public Velocity<VelocityUnit<D>> div(Time divisor) {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -687,23 +696,23 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Velocity<VelocityUnit<D>> divide(Time divisor) {
+  public Velocity<VelocityUnit<D>> divide(Time divisor) {
     return div(divisor);
   }
 
   @Override
-  default Velocity<VelocityUnit<D>> per(TimeUnit divisorUnit) {
+  public Velocity<VelocityUnit<D>> per(TimeUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VelocityUnit<D>, TorqueUnit> times(Torque multiplier) {
+  public Mult<VelocityUnit<D>, TorqueUnit> times(Torque multiplier) {
     return (Mult<VelocityUnit<D>, TorqueUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VelocityUnit<D>, TorqueUnit> div(Torque divisor) {
+  public Per<VelocityUnit<D>, TorqueUnit> div(Torque divisor) {
     return (Per<VelocityUnit<D>, TorqueUnit>) Measure.super.div(divisor);
   }
 
@@ -715,23 +724,23 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VelocityUnit<D>, TorqueUnit> divide(Torque divisor) {
+  public Per<VelocityUnit<D>, TorqueUnit> divide(Torque divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VelocityUnit<D>, TorqueUnit> per(TorqueUnit divisorUnit) {
+  public Per<VelocityUnit<D>, TorqueUnit> per(TorqueUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VelocityUnit<D>, VelocityUnit<?>> times(Velocity<?> multiplier) {
+  public Mult<VelocityUnit<D>, VelocityUnit<?>> times(Velocity<?> multiplier) {
     return (Mult<VelocityUnit<D>, VelocityUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VelocityUnit<D>, VelocityUnit<?>> div(Velocity<?> divisor) {
+  public Per<VelocityUnit<D>, VelocityUnit<?>> div(Velocity<?> divisor) {
     return (Per<VelocityUnit<D>, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -743,23 +752,23 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VelocityUnit<D>, VelocityUnit<?>> divide(Velocity<?> divisor) {
+  public Per<VelocityUnit<D>, VelocityUnit<?>> divide(Velocity<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VelocityUnit<D>, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
+  public Per<VelocityUnit<D>, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VelocityUnit<D>, VoltageUnit> times(Voltage multiplier) {
+  public Mult<VelocityUnit<D>, VoltageUnit> times(Voltage multiplier) {
     return (Mult<VelocityUnit<D>, VoltageUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VelocityUnit<D>, VoltageUnit> div(Voltage divisor) {
+  public Per<VelocityUnit<D>, VoltageUnit> div(Voltage divisor) {
     return (Per<VelocityUnit<D>, VoltageUnit>) Measure.super.div(divisor);
   }
 
@@ -771,12 +780,12 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VelocityUnit<D>, VoltageUnit> divide(Voltage divisor) {
+  public Per<VelocityUnit<D>, VoltageUnit> divide(Voltage divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VelocityUnit<D>, VoltageUnit> per(VoltageUnit divisorUnit) {
+  public Per<VelocityUnit<D>, VoltageUnit> per(VoltageUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Voltage.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Voltage.java
index 33404865fd..06ae7b4074 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Voltage.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Voltage.java
@@ -10,36 +10,45 @@ import static edu.wpi.first.units.Units.*;
 import edu.wpi.first.units.*;
 
 @SuppressWarnings({"unchecked", "cast", "checkstyle", "PMD"})
-public interface Voltage extends Measure<VoltageUnit> {
-  static  Voltage ofRelativeUnits(double magnitude, VoltageUnit unit) {
-    return new ImmutableVoltage(magnitude, unit.toBaseUnits(magnitude), unit);
+public record Voltage(double magnitude, double baseUnitMagnitude, VoltageUnit unit) implements Measure<VoltageUnit> {
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link VoltageUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  Voltage ofRelativeUnits(double magnitude, VoltageUnit unit) {
+    return new Voltage(magnitude, unit.toBaseUnits(magnitude), unit);
   }
 
-  static  Voltage ofBaseUnits(double baseUnitMagnitude, VoltageUnit unit) {
-    return new ImmutableVoltage(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  /**
+   * For doing math with measures of a known dimension but an unknown unit. Most users should use
+   * {@link VoltageUnit#of(double)} on a known unit from {@link Units} instead of calling this method.
+   * @param magnitude the magnitude of the measurement in terms of the given unit's base unit
+   * @param unit the unit of the measurement
+   * @return a measurement object
+   */
+  public static  Voltage ofBaseUnits(double baseUnitMagnitude, VoltageUnit unit) {
+    return new Voltage(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
   }
 
   @Override
-  Voltage copy();
+  public VoltageUnit baseUnit() { return (VoltageUnit) unit().getBaseUnit(); }
 
   @Override
-  default MutVoltage mutableCopy() {
-    return new MutVoltage(magnitude(), baseUnitMagnitude(), unit());
-  }
-
-  @Override
-  VoltageUnit unit();
-
-  @Override
-  default VoltageUnit baseUnit() { return (VoltageUnit) unit().getBaseUnit(); }
-
-  @Override
-  default double in(VoltageUnit unit) {
+  public double in(VoltageUnit unit) {
     return unit.fromBaseUnits(baseUnitMagnitude());
   }
 
   @Override
-  default Voltage unaryMinus() {
+  @SuppressWarnings("rawtypes")
+  public boolean equals(Object object) {
+    return object instanceof Voltage m && isEquivalent(m);
+  }
+
+  @Override
+  public Voltage unaryMinus() {
     return (Voltage) unit().ofBaseUnits(0 - baseUnitMagnitude());
   }
 
@@ -51,27 +60,27 @@ public interface Voltage extends Measure<VoltageUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Voltage negate() {
+  public Voltage negate() {
     return (Voltage) unaryMinus();
   }
 
   @Override
-  default Voltage plus(Measure<? extends VoltageUnit> other) {
+  public Voltage plus(Measure<? extends VoltageUnit> other) {
     return (Voltage) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
   }
 
   @Override
-  default Voltage minus(Measure<? extends VoltageUnit> other) {
+  public Voltage minus(Measure<? extends VoltageUnit> other) {
     return (Voltage) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
   }
 
   @Override
-  default Voltage times(double multiplier) {
+  public Voltage times(double multiplier) {
     return (Voltage) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
   }
 
   @Override
-  default Voltage div(double divisor) {
+  public Voltage div(double divisor) {
     return (Voltage) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
@@ -83,18 +92,18 @@ public interface Voltage extends Measure<VoltageUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Voltage divide(double divisor) {
+  public Voltage divide(double divisor) {
     return (Voltage) div(divisor);
   }
 
 
   @Override
-  default Mult<VoltageUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+  public Mult<VoltageUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
     return (Mult<VoltageUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VoltageUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
+  public Per<VoltageUnit, AccelerationUnit<?>> div(Acceleration<?> divisor) {
     return (Per<VoltageUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -106,23 +115,23 @@ public interface Voltage extends Measure<VoltageUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VoltageUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+  public Per<VoltageUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VoltageUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
+  public Per<VoltageUnit, AccelerationUnit<?>> per(AccelerationUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VoltageUnit, AngleUnit> times(Angle multiplier) {
+  public Mult<VoltageUnit, AngleUnit> times(Angle multiplier) {
     return (Mult<VoltageUnit, AngleUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VoltageUnit, AngleUnit> div(Angle divisor) {
+  public Per<VoltageUnit, AngleUnit> div(Angle divisor) {
     return (Per<VoltageUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
@@ -134,23 +143,23 @@ public interface Voltage extends Measure<VoltageUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VoltageUnit, AngleUnit> divide(Angle divisor) {
+  public Per<VoltageUnit, AngleUnit> divide(Angle divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VoltageUnit, AngleUnit> per(AngleUnit divisorUnit) {
+  public Per<VoltageUnit, AngleUnit> per(AngleUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VoltageUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+  public Mult<VoltageUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
     return (Mult<VoltageUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VoltageUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
+  public Per<VoltageUnit, AngularAccelerationUnit> div(AngularAcceleration divisor) {
     return (Per<VoltageUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -162,23 +171,23 @@ public interface Voltage extends Measure<VoltageUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VoltageUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+  public Per<VoltageUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VoltageUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
+  public Per<VoltageUnit, AngularAccelerationUnit> per(AngularAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VoltageUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+  public Mult<VoltageUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
     return (Mult<VoltageUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VoltageUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
+  public Per<VoltageUnit, AngularMomentumUnit> div(AngularMomentum divisor) {
     return (Per<VoltageUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -190,23 +199,23 @@ public interface Voltage extends Measure<VoltageUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VoltageUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+  public Per<VoltageUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VoltageUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
+  public Per<VoltageUnit, AngularMomentumUnit> per(AngularMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VoltageUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+  public Mult<VoltageUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
     return (Mult<VoltageUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VoltageUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
+  public Per<VoltageUnit, AngularVelocityUnit> div(AngularVelocity divisor) {
     return (Per<VoltageUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -218,23 +227,23 @@ public interface Voltage extends Measure<VoltageUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VoltageUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+  public Per<VoltageUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VoltageUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
+  public Per<VoltageUnit, AngularVelocityUnit> per(AngularVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Power times(Current multiplier) {
+  public Power times(Current multiplier) {
     return Watts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
   @Override
-  default Resistance div(Current divisor) {
+  public Resistance div(Current divisor) {
     return Ohms.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -246,17 +255,17 @@ public interface Voltage extends Measure<VoltageUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Resistance divide(Current divisor) {
+  public Resistance divide(Current divisor) {
     return div(divisor);
   }
 
   @Override
-  default Resistance per(CurrentUnit divisorUnit) {
+  public Resistance per(CurrentUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
   @Override
-  default Voltage div(Dimensionless divisor) {
+  public Voltage div(Dimensionless divisor) {
     return (Voltage) Volts.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -268,23 +277,23 @@ public interface Voltage extends Measure<VoltageUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Voltage divide(Dimensionless divisor) {
+  public Voltage divide(Dimensionless divisor) {
     return (Voltage) div(divisor);
   }
 
   @Override
-  default Voltage times(Dimensionless multiplier) {
+  public Voltage times(Dimensionless multiplier) {
     return (Voltage) Volts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
 
   @Override
-  default Mult<VoltageUnit, DistanceUnit> times(Distance multiplier) {
+  public Mult<VoltageUnit, DistanceUnit> times(Distance multiplier) {
     return (Mult<VoltageUnit, DistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VoltageUnit, DistanceUnit> div(Distance divisor) {
+  public Per<VoltageUnit, DistanceUnit> div(Distance divisor) {
     return (Per<VoltageUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
@@ -296,23 +305,23 @@ public interface Voltage extends Measure<VoltageUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VoltageUnit, DistanceUnit> divide(Distance divisor) {
+  public Per<VoltageUnit, DistanceUnit> divide(Distance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VoltageUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
+  public Per<VoltageUnit, DistanceUnit> per(DistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VoltageUnit, EnergyUnit> times(Energy multiplier) {
+  public Mult<VoltageUnit, EnergyUnit> times(Energy multiplier) {
     return (Mult<VoltageUnit, EnergyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VoltageUnit, EnergyUnit> div(Energy divisor) {
+  public Per<VoltageUnit, EnergyUnit> div(Energy divisor) {
     return (Per<VoltageUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
@@ -324,23 +333,23 @@ public interface Voltage extends Measure<VoltageUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VoltageUnit, EnergyUnit> divide(Energy divisor) {
+  public Per<VoltageUnit, EnergyUnit> divide(Energy divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VoltageUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
+  public Per<VoltageUnit, EnergyUnit> per(EnergyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VoltageUnit, ForceUnit> times(Force multiplier) {
+  public Mult<VoltageUnit, ForceUnit> times(Force multiplier) {
     return (Mult<VoltageUnit, ForceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VoltageUnit, ForceUnit> div(Force divisor) {
+  public Per<VoltageUnit, ForceUnit> div(Force divisor) {
     return (Per<VoltageUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
@@ -352,23 +361,23 @@ public interface Voltage extends Measure<VoltageUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VoltageUnit, ForceUnit> divide(Force divisor) {
+  public Per<VoltageUnit, ForceUnit> divide(Force divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VoltageUnit, ForceUnit> per(ForceUnit divisorUnit) {
+  public Per<VoltageUnit, ForceUnit> per(ForceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VoltageUnit, FrequencyUnit> times(Frequency multiplier) {
+  public Mult<VoltageUnit, FrequencyUnit> times(Frequency multiplier) {
     return (Mult<VoltageUnit, FrequencyUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VoltageUnit, FrequencyUnit> div(Frequency divisor) {
+  public Per<VoltageUnit, FrequencyUnit> div(Frequency divisor) {
     return (Per<VoltageUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
@@ -380,23 +389,23 @@ public interface Voltage extends Measure<VoltageUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VoltageUnit, FrequencyUnit> divide(Frequency divisor) {
+  public Per<VoltageUnit, FrequencyUnit> divide(Frequency divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VoltageUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
+  public Per<VoltageUnit, FrequencyUnit> per(FrequencyUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VoltageUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+  public Mult<VoltageUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
     return (Mult<VoltageUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VoltageUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
+  public Per<VoltageUnit, LinearAccelerationUnit> div(LinearAcceleration divisor) {
     return (Per<VoltageUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
@@ -408,23 +417,23 @@ public interface Voltage extends Measure<VoltageUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VoltageUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+  public Per<VoltageUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VoltageUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
+  public Per<VoltageUnit, LinearAccelerationUnit> per(LinearAccelerationUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VoltageUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+  public Mult<VoltageUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
     return (Mult<VoltageUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VoltageUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
+  public Per<VoltageUnit, LinearMomentumUnit> div(LinearMomentum divisor) {
     return (Per<VoltageUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
@@ -436,23 +445,23 @@ public interface Voltage extends Measure<VoltageUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VoltageUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+  public Per<VoltageUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VoltageUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
+  public Per<VoltageUnit, LinearMomentumUnit> per(LinearMomentumUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VoltageUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+  public Mult<VoltageUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
     return (Mult<VoltageUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VoltageUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
+  public Per<VoltageUnit, LinearVelocityUnit> div(LinearVelocity divisor) {
     return (Per<VoltageUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
@@ -464,23 +473,23 @@ public interface Voltage extends Measure<VoltageUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VoltageUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+  public Per<VoltageUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VoltageUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
+  public Per<VoltageUnit, LinearVelocityUnit> per(LinearVelocityUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VoltageUnit, MassUnit> times(Mass multiplier) {
+  public Mult<VoltageUnit, MassUnit> times(Mass multiplier) {
     return (Mult<VoltageUnit, MassUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VoltageUnit, MassUnit> div(Mass divisor) {
+  public Per<VoltageUnit, MassUnit> div(Mass divisor) {
     return (Per<VoltageUnit, MassUnit>) Measure.super.div(divisor);
   }
 
@@ -492,23 +501,23 @@ public interface Voltage extends Measure<VoltageUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VoltageUnit, MassUnit> divide(Mass divisor) {
+  public Per<VoltageUnit, MassUnit> divide(Mass divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VoltageUnit, MassUnit> per(MassUnit divisorUnit) {
+  public Per<VoltageUnit, MassUnit> per(MassUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VoltageUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+  public Mult<VoltageUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
     return (Mult<VoltageUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VoltageUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
+  public Per<VoltageUnit, MomentOfInertiaUnit> div(MomentOfInertia divisor) {
     return (Per<VoltageUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
@@ -520,23 +529,23 @@ public interface Voltage extends Measure<VoltageUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VoltageUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+  public Per<VoltageUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VoltageUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
+  public Per<VoltageUnit, MomentOfInertiaUnit> per(MomentOfInertiaUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VoltageUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+  public Mult<VoltageUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
     return (Mult<VoltageUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VoltageUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
+  public Per<VoltageUnit, MultUnit<?, ?>> div(Mult<?, ?> divisor) {
     return (Per<VoltageUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -548,23 +557,23 @@ public interface Voltage extends Measure<VoltageUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VoltageUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+  public Per<VoltageUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VoltageUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
+  public Per<VoltageUnit, MultUnit<?, ?>> per(MultUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<VoltageUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+  public Mult<VoltageUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
     return (Mult<VoltageUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VoltageUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
+  public Per<VoltageUnit, PerUnit<?, ?>> div(Per<?, ?> divisor) {
     return (Per<VoltageUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
@@ -576,23 +585,23 @@ public interface Voltage extends Measure<VoltageUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VoltageUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+  public Per<VoltageUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VoltageUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
+  public Per<VoltageUnit, PerUnit<?, ?>> per(PerUnit<?, ?> divisorUnit) {
     return div(divisorUnit.ofNative(1));
   }
 
 
   @Override
-  default Mult<VoltageUnit, PowerUnit> times(Power multiplier) {
+  public Mult<VoltageUnit, PowerUnit> times(Power multiplier) {
     return (Mult<VoltageUnit, PowerUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VoltageUnit, PowerUnit> div(Power divisor) {
+  public Per<VoltageUnit, PowerUnit> div(Power divisor) {
     return (Per<VoltageUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
@@ -604,23 +613,23 @@ public interface Voltage extends Measure<VoltageUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VoltageUnit, PowerUnit> divide(Power divisor) {
+  public Per<VoltageUnit, PowerUnit> divide(Power divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VoltageUnit, PowerUnit> per(PowerUnit divisorUnit) {
+  public Per<VoltageUnit, PowerUnit> per(PowerUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VoltageUnit, ResistanceUnit> times(Resistance multiplier) {
+  public Mult<VoltageUnit, ResistanceUnit> times(Resistance multiplier) {
     return (Mult<VoltageUnit, ResistanceUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Current div(Resistance divisor) {
+  public Current div(Resistance divisor) {
     return Amps.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -632,23 +641,23 @@ public interface Voltage extends Measure<VoltageUnit> {
   @Override
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
-  default Current divide(Resistance divisor) {
+  public Current divide(Resistance divisor) {
     return div(divisor);
   }
 
   @Override
-  default Current per(ResistanceUnit divisorUnit) {
+  public Current per(ResistanceUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VoltageUnit, TemperatureUnit> times(Temperature multiplier) {
+  public Mult<VoltageUnit, TemperatureUnit> times(Temperature multiplier) {
     return (Mult<VoltageUnit, TemperatureUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VoltageUnit, TemperatureUnit> div(Temperature divisor) {
+  public Per<VoltageUnit, TemperatureUnit> div(Temperature divisor) {
     return (Per<VoltageUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
@@ -660,23 +669,23 @@ public interface Voltage extends Measure<VoltageUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VoltageUnit, TemperatureUnit> divide(Temperature divisor) {
+  public Per<VoltageUnit, TemperatureUnit> divide(Temperature divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VoltageUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
+  public Per<VoltageUnit, TemperatureUnit> per(TemperatureUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VoltageUnit, TimeUnit> times(Time multiplier) {
+  public Mult<VoltageUnit, TimeUnit> times(Time multiplier) {
     return (Mult<VoltageUnit, TimeUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Velocity<VoltageUnit> div(Time divisor) {
+  public Velocity<VoltageUnit> div(Time divisor) {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -688,23 +697,23 @@ public interface Voltage extends Measure<VoltageUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Velocity<VoltageUnit> divide(Time divisor) {
+  public Velocity<VoltageUnit> divide(Time divisor) {
     return div(divisor);
   }
 
   @Override
-  default Velocity<VoltageUnit> per(TimeUnit divisorUnit) {
+  public Velocity<VoltageUnit> per(TimeUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VoltageUnit, TorqueUnit> times(Torque multiplier) {
+  public Mult<VoltageUnit, TorqueUnit> times(Torque multiplier) {
     return (Mult<VoltageUnit, TorqueUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VoltageUnit, TorqueUnit> div(Torque divisor) {
+  public Per<VoltageUnit, TorqueUnit> div(Torque divisor) {
     return (Per<VoltageUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
@@ -716,23 +725,23 @@ public interface Voltage extends Measure<VoltageUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VoltageUnit, TorqueUnit> divide(Torque divisor) {
+  public Per<VoltageUnit, TorqueUnit> divide(Torque divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VoltageUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
+  public Per<VoltageUnit, TorqueUnit> per(TorqueUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VoltageUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+  public Mult<VoltageUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
     return (Mult<VoltageUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Per<VoltageUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
+  public Per<VoltageUnit, VelocityUnit<?>> div(Velocity<?> divisor) {
     return (Per<VoltageUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
@@ -744,23 +753,23 @@ public interface Voltage extends Measure<VoltageUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Per<VoltageUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+  public Per<VoltageUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
     return div(divisor);
   }
 
   @Override
-  default Per<VoltageUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
+  public Per<VoltageUnit, VelocityUnit<?>> per(VelocityUnit<?> divisorUnit) {
     return div(divisorUnit.one());
   }
 
 
   @Override
-  default Mult<VoltageUnit, VoltageUnit> times(Voltage multiplier) {
+  public Mult<VoltageUnit, VoltageUnit> times(Voltage multiplier) {
     return (Mult<VoltageUnit, VoltageUnit>) Measure.super.times(multiplier);
   }
 
   @Override
-  default Dimensionless div(Voltage divisor) {
+  public Dimensionless div(Voltage divisor) {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
@@ -772,12 +781,12 @@ public interface Voltage extends Measure<VoltageUnit> {
   @Deprecated(since = "2025", forRemoval = true)
   @SuppressWarnings({"deprecation", "removal"})
   @Override
-  default Dimensionless divide(Voltage divisor) {
+  public Dimensionless divide(Voltage divisor) {
     return div(divisor);
   }
 
   @Override
-  default Dimensionless per(VoltageUnit divisorUnit) {
+  public Dimensionless per(VoltageUnit divisorUnit) {
     return div(divisorUnit.one());
   }
 
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/AccelerationUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/AccelerationUnit.java
index 7fe2bc1dd5..dfc953b377 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/AccelerationUnit.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/AccelerationUnit.java
@@ -5,8 +5,6 @@
 package edu.wpi.first.units;
 
 import edu.wpi.first.units.measure.Acceleration;
-import edu.wpi.first.units.measure.ImmutableAcceleration;
-import edu.wpi.first.units.measure.MutAcceleration;
 
 /**
  * A generic unit of acceleration.
@@ -45,12 +43,12 @@ public final class AccelerationUnit<D extends Unit> extends PerUnit<VelocityUnit
 
   @Override
   public Acceleration<D> of(double magnitude) {
-    return new ImmutableAcceleration<>(magnitude, toBaseUnits(magnitude), this);
+    return new Acceleration<>(magnitude, toBaseUnits(magnitude), this);
   }
 
   @Override
   public Acceleration<D> ofBaseUnits(double baseUnitMagnitude) {
-    return new ImmutableAcceleration<>(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+    return new Acceleration<>(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
   }
 
   @Override
@@ -65,11 +63,6 @@ public final class AccelerationUnit<D extends Unit> extends PerUnit<VelocityUnit
     return (Acceleration<D>) (Acceleration) super.one();
   }
 
-  @Override
-  public MutAcceleration<D> mutable(double initialMagnitude) {
-    return new MutAcceleration<>(initialMagnitude, toBaseUnits(initialMagnitude), this);
-  }
-
   @Override
   public VelocityUnit<AccelerationUnit<D>> per(TimeUnit time) {
     return VelocityUnit.combine(this, time);
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/AngleUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/AngleUnit.java
index d89d6d9ad6..e00f4ce7fc 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/AngleUnit.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/AngleUnit.java
@@ -5,7 +5,6 @@
 package edu.wpi.first.units;
 
 import edu.wpi.first.units.measure.Angle;
-import edu.wpi.first.units.measure.MutAngle;
 
 /**
  * Unit of angular dimension.
@@ -49,11 +48,6 @@ public final class AngleUnit extends Unit {
     return Angle.ofBaseUnits(baseUnitMagnitude, this);
   }
 
-  @Override
-  public MutAngle mutable(double initialMagnitude) {
-    return new MutAngle(initialMagnitude, toBaseUnits(initialMagnitude), this);
-  }
-
   @Override
   public AngularVelocityUnit per(TimeUnit period) {
     return AngularVelocityUnit.combine(this, period);
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/AngularAccelerationUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/AngularAccelerationUnit.java
index c818a16662..00aae31033 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/AngularAccelerationUnit.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/AngularAccelerationUnit.java
@@ -5,8 +5,6 @@
 package edu.wpi.first.units;
 
 import edu.wpi.first.units.measure.AngularAcceleration;
-import edu.wpi.first.units.measure.ImmutableAngularAcceleration;
-import edu.wpi.first.units.measure.MutAngularAcceleration;
 
 /** A unit of angular acceleration, such as {@link Units#RadiansPerSecondPerSecond}. */
 public final class AngularAccelerationUnit extends PerUnit<AngularVelocityUnit, TimeUnit> {
@@ -49,13 +47,12 @@ public final class AngularAccelerationUnit extends PerUnit<AngularVelocityUnit,
 
   @Override
   public AngularAcceleration of(double magnitude) {
-    return new ImmutableAngularAcceleration(magnitude, toBaseUnits(magnitude), this);
+    return new AngularAcceleration(magnitude, toBaseUnits(magnitude), this);
   }
 
   @Override
   public AngularAcceleration ofBaseUnits(double baseUnitMagnitude) {
-    return new ImmutableAngularAcceleration(
-        fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+    return new AngularAcceleration(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
   }
 
   @Override
@@ -68,11 +65,6 @@ public final class AngularAccelerationUnit extends PerUnit<AngularVelocityUnit,
     return (AngularAcceleration) super.one();
   }
 
-  @Override
-  public MutAngularAcceleration mutable(double initialMagnitude) {
-    return new MutAngularAcceleration(initialMagnitude, toBaseUnits(initialMagnitude), this);
-  }
-
   @Override
   public VelocityUnit<AngularAccelerationUnit> per(TimeUnit time) {
     return VelocityUnit.combine(this, time);
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/AngularMomentumUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/AngularMomentumUnit.java
index be54a13504..77f3ec6851 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/AngularMomentumUnit.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/AngularMomentumUnit.java
@@ -5,8 +5,6 @@
 package edu.wpi.first.units;
 
 import edu.wpi.first.units.measure.AngularMomentum;
-import edu.wpi.first.units.measure.ImmutableAngularMomentum;
-import edu.wpi.first.units.measure.MutAngularMomentum;
 
 /**
  * A unit of angular momentum, modeled as linear momentum of an object rotating some distance away
@@ -52,12 +50,12 @@ public final class AngularMomentumUnit extends MultUnit<LinearMomentumUnit, Dist
 
   @Override
   public AngularMomentum of(double magnitude) {
-    return new ImmutableAngularMomentum(magnitude, toBaseUnits(magnitude), this);
+    return new AngularMomentum(magnitude, toBaseUnits(magnitude), this);
   }
 
   @Override
   public AngularMomentum ofBaseUnits(double baseUnitMagnitude) {
-    return new ImmutableAngularMomentum(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+    return new AngularMomentum(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
   }
 
   @Override
@@ -70,11 +68,6 @@ public final class AngularMomentumUnit extends MultUnit<LinearMomentumUnit, Dist
     return (AngularMomentum) super.one();
   }
 
-  @Override
-  public MutAngularMomentum mutable(double magnitude) {
-    return new MutAngularMomentum(magnitude, toBaseUnits(magnitude), this);
-  }
-
   @Override
   public VelocityUnit<AngularMomentumUnit> per(TimeUnit time) {
     return VelocityUnit.combine(this, time);
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/AngularVelocityUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/AngularVelocityUnit.java
index 5a2f81b761..6b087abc98 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/AngularVelocityUnit.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/AngularVelocityUnit.java
@@ -5,8 +5,6 @@
 package edu.wpi.first.units;
 
 import edu.wpi.first.units.measure.AngularVelocity;
-import edu.wpi.first.units.measure.ImmutableAngularVelocity;
-import edu.wpi.first.units.measure.MutAngularVelocity;
 
 /** A unit of angular velocity like {@link Units#RadiansPerSecond}. */
 public final class AngularVelocityUnit extends PerUnit<AngleUnit, TimeUnit> {
@@ -49,12 +47,12 @@ public final class AngularVelocityUnit extends PerUnit<AngleUnit, TimeUnit> {
 
   @Override
   public AngularVelocity of(double magnitude) {
-    return new ImmutableAngularVelocity(magnitude, toBaseUnits(magnitude), this);
+    return new AngularVelocity(magnitude, toBaseUnits(magnitude), this);
   }
 
   @Override
   public AngularVelocity ofBaseUnits(double baseUnitMagnitude) {
-    return new ImmutableAngularVelocity(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+    return new AngularVelocity(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
   }
 
   @Override
@@ -67,11 +65,6 @@ public final class AngularVelocityUnit extends PerUnit<AngleUnit, TimeUnit> {
     return (AngularVelocity) super.one();
   }
 
-  @Override
-  public MutAngularVelocity mutable(double initialMagnitude) {
-    return new MutAngularVelocity(initialMagnitude, toBaseUnits(initialMagnitude), this);
-  }
-
   @Override
   public AngularAccelerationUnit per(TimeUnit period) {
     return AngularAccelerationUnit.combine(this, period);
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/CurrentUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/CurrentUnit.java
index e22ab54525..4e51a543d7 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/CurrentUnit.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/CurrentUnit.java
@@ -5,8 +5,6 @@
 package edu.wpi.first.units;
 
 import edu.wpi.first.units.measure.Current;
-import edu.wpi.first.units.measure.ImmutableCurrent;
-import edu.wpi.first.units.measure.MutCurrent;
 
 /**
  * Unit of electric current dimension.
@@ -53,12 +51,12 @@ public final class CurrentUnit extends Unit {
 
   @Override
   public Current of(double magnitude) {
-    return new ImmutableCurrent(magnitude, toBaseUnits(magnitude), this);
+    return new Current(magnitude, toBaseUnits(magnitude), this);
   }
 
   @Override
   public Current ofBaseUnits(double baseUnitMagnitude) {
-    return new ImmutableCurrent(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+    return new Current(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
   }
 
   @Override
@@ -71,11 +69,6 @@ public final class CurrentUnit extends Unit {
     return (Current) super.one();
   }
 
-  @Override
-  public MutCurrent mutable(double initialMagnitude) {
-    return new MutCurrent(initialMagnitude, toBaseUnits(initialMagnitude), this);
-  }
-
   @Override
   public VelocityUnit<CurrentUnit> per(TimeUnit time) {
     return VelocityUnit.combine(this, time);
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/DimensionlessUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/DimensionlessUnit.java
index 186476fb0b..bdf0b650c9 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/DimensionlessUnit.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/DimensionlessUnit.java
@@ -5,8 +5,6 @@
 package edu.wpi.first.units;
 
 import edu.wpi.first.units.measure.Dimensionless;
-import edu.wpi.first.units.measure.ImmutableDimensionless;
-import edu.wpi.first.units.measure.MutDimensionless;
 
 /**
  * A type of unit that corresponds to raw values and not any physical dimension, such as percentage.
@@ -40,12 +38,12 @@ public final class DimensionlessUnit extends Unit {
 
   @Override
   public Dimensionless of(double magnitude) {
-    return new ImmutableDimensionless(magnitude, toBaseUnits(magnitude), this);
+    return new Dimensionless(magnitude, toBaseUnits(magnitude), this);
   }
 
   @Override
   public Dimensionless ofBaseUnits(double baseUnitMagnitude) {
-    return new ImmutableDimensionless(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+    return new Dimensionless(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
   }
 
   @Override
@@ -58,11 +56,6 @@ public final class DimensionlessUnit extends Unit {
     return (Dimensionless) super.one();
   }
 
-  @Override
-  public MutDimensionless mutable(double initialMagnitude) {
-    return new MutDimensionless(initialMagnitude, toBaseUnits(initialMagnitude), this);
-  }
-
   /**
    * Converts a measurement value in terms of another dimensionless unit to this unit.
    *
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/DistanceUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/DistanceUnit.java
index df4c1ffee4..57bd7be1bf 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/DistanceUnit.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/DistanceUnit.java
@@ -5,8 +5,6 @@
 package edu.wpi.first.units;
 
 import edu.wpi.first.units.measure.Distance;
-import edu.wpi.first.units.measure.ImmutableDistance;
-import edu.wpi.first.units.measure.MutDistance;
 
 /**
  * Unit of linear dimension.
@@ -65,12 +63,12 @@ public final class DistanceUnit extends Unit {
 
   @Override
   public Distance of(double magnitude) {
-    return new ImmutableDistance(magnitude, toBaseUnits(magnitude), this);
+    return new Distance(magnitude, toBaseUnits(magnitude), this);
   }
 
   @Override
   public Distance ofBaseUnits(double baseUnitMagnitude) {
-    return new ImmutableDistance(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+    return new Distance(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
   }
 
   @Override
@@ -83,11 +81,6 @@ public final class DistanceUnit extends Unit {
     return (Distance) super.one();
   }
 
-  @Override
-  public MutDistance mutable(double initialMagnitude) {
-    return new MutDistance(initialMagnitude, toBaseUnits(initialMagnitude), this);
-  }
-
   /**
    * Multiplies this distance unit by a unit of force to create a unit of torque.
    *
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/EnergyUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/EnergyUnit.java
index 90a0be81ef..d31bc3cbbf 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/EnergyUnit.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/EnergyUnit.java
@@ -5,8 +5,6 @@
 package edu.wpi.first.units;
 
 import edu.wpi.first.units.measure.Energy;
-import edu.wpi.first.units.measure.ImmutableEnergy;
-import edu.wpi.first.units.measure.MutEnergy;
 
 /**
  * Unit of energy dimension.
@@ -71,12 +69,12 @@ public final class EnergyUnit extends Unit {
 
   @Override
   public Energy of(double magnitude) {
-    return new ImmutableEnergy(magnitude, toBaseUnits(magnitude), this);
+    return new Energy(magnitude, toBaseUnits(magnitude), this);
   }
 
   @Override
   public Energy ofBaseUnits(double baseUnitMagnitude) {
-    return new ImmutableEnergy(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+    return new Energy(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
   }
 
   @Override
@@ -88,9 +86,4 @@ public final class EnergyUnit extends Unit {
   public Energy one() {
     return (Energy) super.one();
   }
-
-  @Override
-  public MutEnergy mutable(double initialMagnitude) {
-    return new MutEnergy(initialMagnitude, toBaseUnits(initialMagnitude), this);
-  }
 }
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/ForceUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/ForceUnit.java
index 9fead01b37..407e0301f7 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/ForceUnit.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/ForceUnit.java
@@ -5,8 +5,6 @@
 package edu.wpi.first.units;
 
 import edu.wpi.first.units.measure.Force;
-import edu.wpi.first.units.measure.ImmutableForce;
-import edu.wpi.first.units.measure.MutForce;
 
 /** A unit of force like {@link Units#Newtons}. */
 public final class ForceUnit extends MultUnit<MassUnit, LinearAccelerationUnit> {
@@ -61,12 +59,12 @@ public final class ForceUnit extends MultUnit<MassUnit, LinearAccelerationUnit>
 
   @Override
   public Force of(double magnitude) {
-    return new ImmutableForce(magnitude, toBaseUnits(magnitude), this);
+    return new Force(magnitude, toBaseUnits(magnitude), this);
   }
 
   @Override
   public Force ofBaseUnits(double baseUnitMagnitude) {
-    return new ImmutableForce(toBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+    return new Force(toBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
   }
 
   @Override
@@ -79,11 +77,6 @@ public final class ForceUnit extends MultUnit<MassUnit, LinearAccelerationUnit>
     return (Force) super.one();
   }
 
-  @Override
-  public MutForce mutable(double initialMagnitude) {
-    return new MutForce(initialMagnitude, toBaseUnits(initialMagnitude), this);
-  }
-
   @Override
   public VelocityUnit<ForceUnit> per(TimeUnit time) {
     return VelocityUnit.combine(this, time);
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/FrequencyUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/FrequencyUnit.java
index b2989fb883..a2f44cec60 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/FrequencyUnit.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/FrequencyUnit.java
@@ -7,8 +7,6 @@ package edu.wpi.first.units;
 import static edu.wpi.first.units.Units.Value;
 
 import edu.wpi.first.units.measure.Frequency;
-import edu.wpi.first.units.measure.ImmutableFrequency;
-import edu.wpi.first.units.measure.MutFrequency;
 
 /** A unit of frequency like {@link edu.wpi.first.units.Units#Hertz}. */
 public final class FrequencyUnit extends PerUnit<DimensionlessUnit, TimeUnit> {
@@ -62,12 +60,12 @@ public final class FrequencyUnit extends PerUnit<DimensionlessUnit, TimeUnit> {
 
   @Override
   public Frequency of(double magnitude) {
-    return new ImmutableFrequency(magnitude, toBaseUnits(magnitude), this);
+    return new Frequency(magnitude, toBaseUnits(magnitude), this);
   }
 
   @Override
   public Frequency ofBaseUnits(double baseUnitMagnitude) {
-    return new ImmutableFrequency(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+    return new Frequency(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
   }
 
   @Override
@@ -80,11 +78,6 @@ public final class FrequencyUnit extends PerUnit<DimensionlessUnit, TimeUnit> {
     return (Frequency) super.one();
   }
 
-  @Override
-  public MutFrequency mutable(double initialMagnitude) {
-    return new MutFrequency(initialMagnitude, toBaseUnits(initialMagnitude), this);
-  }
-
   @Override
   public VelocityUnit<FrequencyUnit> per(TimeUnit time) {
     return VelocityUnit.combine(this, time);
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/ImmutableMeasure.java b/wpiunits/src/main/java/edu/wpi/first/units/ImmutableMeasure.java
index 64005b0987..6d16cdde66 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/ImmutableMeasure.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/ImmutableMeasure.java
@@ -5,7 +5,6 @@
 package edu.wpi.first.units;
 
 import edu.wpi.first.units.measure.Dimensionless;
-import edu.wpi.first.units.mutable.GenericMutableMeasureImpl;
 
 /**
  * A measure holds the magnitude and unit of some dimension, such as distance, time, or speed. An
@@ -45,16 +44,6 @@ public record ImmutableMeasure<U extends Unit>(double magnitude, double baseUnit
     return new ImmutableMeasure<>(relativeMagnitude, unit.toBaseUnits(relativeMagnitude), unit);
   }
 
-  @Override
-  public Measure<U> copy() {
-    return this; // already immutable, no need to allocate a new object
-  }
-
-  @Override
-  public MutableMeasure<U, ?, ?> mutableCopy() {
-    return new GenericMutableMeasureImpl<>(magnitude, baseUnitMagnitude, unit);
-  }
-
   @Override
   public Measure<U> unaryMinus() {
     return ofBaseUnits(0 - baseUnitMagnitude, unit);
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/LinearAccelerationUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/LinearAccelerationUnit.java
index 9756ca6084..343024a3a1 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/LinearAccelerationUnit.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/LinearAccelerationUnit.java
@@ -4,9 +4,7 @@
 
 package edu.wpi.first.units;
 
-import edu.wpi.first.units.measure.ImmutableLinearAcceleration;
 import edu.wpi.first.units.measure.LinearAcceleration;
-import edu.wpi.first.units.measure.MutLinearAcceleration;
 
 /**
  * A unit of linear acceleration like {@link edu.wpi.first.units.Units#MetersPerSecondPerSecond}.
@@ -51,13 +49,12 @@ public final class LinearAccelerationUnit extends PerUnit<LinearVelocityUnit, Ti
 
   @Override
   public LinearAcceleration of(double magnitude) {
-    return new ImmutableLinearAcceleration(magnitude, toBaseUnits(magnitude), this);
+    return new LinearAcceleration(magnitude, toBaseUnits(magnitude), this);
   }
 
   @Override
   public LinearAcceleration ofBaseUnits(double baseUnitMagnitude) {
-    return new ImmutableLinearAcceleration(
-        fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+    return new LinearAcceleration(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
   }
 
   @Override
@@ -70,11 +67,6 @@ public final class LinearAccelerationUnit extends PerUnit<LinearVelocityUnit, Ti
     return (LinearAcceleration) super.one();
   }
 
-  @Override
-  public MutLinearAcceleration mutable(double initialMagnitude) {
-    return new MutLinearAcceleration(initialMagnitude, toBaseUnits(initialMagnitude), this);
-  }
-
   @Override
   public VelocityUnit<LinearAccelerationUnit> per(TimeUnit time) {
     return VelocityUnit.combine(this, time);
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/LinearMomentumUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/LinearMomentumUnit.java
index 489955b3a6..c323204d01 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/LinearMomentumUnit.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/LinearMomentumUnit.java
@@ -4,9 +4,7 @@
 
 package edu.wpi.first.units;
 
-import edu.wpi.first.units.measure.ImmutableLinearMomentum;
 import edu.wpi.first.units.measure.LinearMomentum;
-import edu.wpi.first.units.measure.MutLinearMomentum;
 
 /** A unit of linear momentum like {@link edu.wpi.first.units.Units#KilogramMetersPerSecond}. */
 public final class LinearMomentumUnit extends MultUnit<MassUnit, LinearVelocityUnit> {
@@ -49,12 +47,12 @@ public final class LinearMomentumUnit extends MultUnit<MassUnit, LinearVelocityU
 
   @Override
   public LinearMomentum of(double magnitude) {
-    return new ImmutableLinearMomentum(magnitude, toBaseUnits(magnitude), this);
+    return new LinearMomentum(magnitude, toBaseUnits(magnitude), this);
   }
 
   @Override
   public LinearMomentum ofBaseUnits(double baseUnitMagnitude) {
-    return new ImmutableLinearMomentum(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+    return new LinearMomentum(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
   }
 
   @Override
@@ -67,11 +65,6 @@ public final class LinearMomentumUnit extends MultUnit<MassUnit, LinearVelocityU
     return (LinearMomentum) super.one();
   }
 
-  @Override
-  public MutLinearMomentum mutable(double initialMagnitude) {
-    return new MutLinearMomentum(initialMagnitude, toBaseUnits(initialMagnitude), this);
-  }
-
   @Override
   public VelocityUnit<LinearMomentumUnit> per(TimeUnit time) {
     return VelocityUnit.combine(this, time);
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/LinearVelocityUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/LinearVelocityUnit.java
index ca155ce0cd..24dd61acc2 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/LinearVelocityUnit.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/LinearVelocityUnit.java
@@ -4,9 +4,7 @@
 
 package edu.wpi.first.units;
 
-import edu.wpi.first.units.measure.ImmutableLinearVelocity;
 import edu.wpi.first.units.measure.LinearVelocity;
-import edu.wpi.first.units.measure.MutLinearVelocity;
 
 /** A unit of linear velocity like {@link edu.wpi.first.units.Units#MetersPerSecond}. */
 public final class LinearVelocityUnit extends PerUnit<DistanceUnit, TimeUnit> {
@@ -49,12 +47,12 @@ public final class LinearVelocityUnit extends PerUnit<DistanceUnit, TimeUnit> {
 
   @Override
   public LinearVelocity of(double magnitude) {
-    return new ImmutableLinearVelocity(magnitude, toBaseUnits(magnitude), this);
+    return new LinearVelocity(magnitude, toBaseUnits(magnitude), this);
   }
 
   @Override
   public LinearVelocity ofBaseUnits(double baseUnitMagnitude) {
-    return new ImmutableLinearVelocity(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+    return new LinearVelocity(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
   }
 
   @Override
@@ -67,11 +65,6 @@ public final class LinearVelocityUnit extends PerUnit<DistanceUnit, TimeUnit> {
     return (LinearVelocity) super.one();
   }
 
-  @Override
-  public MutLinearVelocity mutable(double value) {
-    return new MutLinearVelocity(value, toBaseUnits(value), this);
-  }
-
   /**
    * Combines this velocity with a time period of change to form a unit of acceleration.
    *
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/MassUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/MassUnit.java
index dad3fd4148..630c4de5c8 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/MassUnit.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/MassUnit.java
@@ -4,9 +4,7 @@
 
 package edu.wpi.first.units;
 
-import edu.wpi.first.units.measure.ImmutableMass;
 import edu.wpi.first.units.measure.Mass;
-import edu.wpi.first.units.measure.MutMass;
 
 /**
  * Unit of mass dimension.
@@ -39,12 +37,12 @@ public final class MassUnit extends Unit {
 
   @Override
   public Mass of(double magnitude) {
-    return new ImmutableMass(magnitude, toBaseUnits(magnitude), this);
+    return new Mass(magnitude, toBaseUnits(magnitude), this);
   }
 
   @Override
   public Mass ofBaseUnits(double baseUnitMagnitude) {
-    return new ImmutableMass(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+    return new Mass(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
   }
 
   @Override
@@ -57,11 +55,6 @@ public final class MassUnit extends Unit {
     return (Mass) super.one();
   }
 
-  @Override
-  public MutMass mutable(double initialMagnitude) {
-    return new MutMass(initialMagnitude, toBaseUnits(initialMagnitude), this);
-  }
-
   @Override
   public VelocityUnit<MassUnit> per(TimeUnit period) {
     return VelocityUnit.combine(this, period);
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/Measure.java b/wpiunits/src/main/java/edu/wpi/first/units/Measure.java
index 6a436194b7..e805ba20f8 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/Measure.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/Measure.java
@@ -119,22 +119,6 @@ public interface Measure<U extends Unit> extends Comparable<Measure<U>> {
     return Math.copySign(this.in(unit), other.in(unit));
   }
 
-  /**
-   * Returns an immutable copy of this measure. The copy can be used freely and is guaranteed never
-   * to change.
-   *
-   * @return the copied measure
-   */
-  Measure<U> copy();
-
-  /**
-   * Returns a mutable copy of this measure. It will be initialized to the current state of this
-   * measure, but can be changed over time without needing to allocate new measurement objects.
-   *
-   * @return the copied measure
-   */
-  MutableMeasure<U, ?, ?> mutableCopy();
-
   /**
    * Returns a measure equivalent to this one equal to zero minus its current value. For non-linear
    * unit types like temperature, the zero point is treated as the zero value of the base unit (eg
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/MomentOfInertiaUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/MomentOfInertiaUnit.java
index ab92427001..6279ea9a7e 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/MomentOfInertiaUnit.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/MomentOfInertiaUnit.java
@@ -4,9 +4,7 @@
 
 package edu.wpi.first.units;
 
-import edu.wpi.first.units.measure.ImmutableMomentOfInertia;
 import edu.wpi.first.units.measure.MomentOfInertia;
-import edu.wpi.first.units.measure.MutMomentOfInertia;
 
 /**
  * A unit of moment of inertia, like {@link edu.wpi.first.units.Units#KilogramSquareMeters}. Moments
@@ -55,12 +53,12 @@ public final class MomentOfInertiaUnit extends PerUnit<AngularMomentumUnit, Angu
 
   @Override
   public MomentOfInertia of(double magnitude) {
-    return new ImmutableMomentOfInertia(magnitude, toBaseUnits(magnitude), this);
+    return new MomentOfInertia(magnitude, toBaseUnits(magnitude), this);
   }
 
   @Override
   public MomentOfInertia ofBaseUnits(double baseUnitMagnitude) {
-    return new ImmutableMomentOfInertia(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+    return new MomentOfInertia(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
   }
 
   @Override
@@ -73,11 +71,6 @@ public final class MomentOfInertiaUnit extends PerUnit<AngularMomentumUnit, Angu
     return (MomentOfInertia) super.one();
   }
 
-  @Override
-  public MutMomentOfInertia mutable(double initialMagnitude) {
-    return new MutMomentOfInertia(initialMagnitude, toBaseUnits(initialMagnitude), this);
-  }
-
   @Override
   public VelocityUnit<MomentOfInertiaUnit> per(TimeUnit time) {
     return VelocityUnit.combine(this, time);
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/MultUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/MultUnit.java
index 2c6906c717..1ca2f520da 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/MultUnit.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/MultUnit.java
@@ -4,9 +4,7 @@
 
 package edu.wpi.first.units;
 
-import edu.wpi.first.units.measure.ImmutableMult;
 import edu.wpi.first.units.measure.Mult;
-import edu.wpi.first.units.measure.MutMult;
 import java.util.Objects;
 
 /**
@@ -130,7 +128,7 @@ public class MultUnit<A extends Unit, B extends Unit> extends Unit {
    * @see #of(double)
    */
   public final Mult<A, B> ofNative(double magnitude) {
-    return new ImmutableMult<>(magnitude, toBaseUnits(magnitude), this);
+    return new Mult<>(magnitude, toBaseUnits(magnitude), this);
   }
 
   /**
@@ -142,7 +140,7 @@ public class MultUnit<A extends Unit, B extends Unit> extends Unit {
    * @see #ofBaseUnits(double)
    */
   public final Mult<A, B> ofNativeBaseUnits(double baseUnitMagnitude) {
-    return new ImmutableMult<>(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+    return new Mult<>(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
   }
 
   @Override
@@ -157,11 +155,6 @@ public class MultUnit<A extends Unit, B extends Unit> extends Unit {
     return (Measure<? extends MultUnit<A, B>>) super.one();
   }
 
-  @Override
-  public MutableMeasure<? extends MultUnit<A, B>, ?, ?> mutable(double initialMagnitude) {
-    return new MutMult<>(initialMagnitude, toBaseUnits(initialMagnitude), this);
-  }
-
   @Override
   public Unit per(TimeUnit time) {
     return VelocityUnit.combine(this, time);
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/MutableMeasure.java b/wpiunits/src/main/java/edu/wpi/first/units/MutableMeasure.java
deleted file mode 100644
index 672dbe61f0..0000000000
--- a/wpiunits/src/main/java/edu/wpi/first/units/MutableMeasure.java
+++ /dev/null
@@ -1,180 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-package edu.wpi.first.units;
-
-import edu.wpi.first.units.measure.Dimensionless;
-
-/**
- * A mutable measurement can be used to keep a single object allocation and reference whose state is
- * mutated or changed as it is used. This is helpful for optimizing memory usage to keep garbage
- * collection time - and its associated loop overruns - to a minimum.
- *
- * @param <U> The dimension of measurement.
- * @param <Base> The base measure type.
- * @param <MutSelf> The self type. This MUST inherit from the base measure type.
- */
-public interface MutableMeasure<
-        U extends Unit, Base extends Measure<U>, MutSelf extends MutableMeasure<U, Base, MutSelf>>
-    extends Measure<U> {
-  /**
-   * Overwrites the state of this measure with new values.
-   *
-   * @param magnitude the new magnitude in terms of the new unit
-   * @param newUnit the new unit
-   * @return this measure
-   */
-  MutSelf mut_replace(double magnitude, U newUnit);
-
-  /**
-   * Overwrites the state of this measure and replaces it completely with values from the given one.
-   * The magnitude, base unit magnitude, and unit will all be copied. This is functionally the same
-   * as calling {@code other.mutableCopy()}, but copying to a pre-existing mutable measure instead
-   * of instantiating a new one.
-   *
-   * @param other the other measure to copy values from
-   * @return this measure
-   */
-  default MutSelf mut_replace(Base other) {
-    return mut_replace(other.magnitude(), other.unit());
-  }
-
-  @Override
-  Base copy();
-
-  /**
-   * Sets the new magnitude of the measurement. The magnitude must be in terms of the {@link
-   * #unit()}.
-   *
-   * @param magnitude the new magnitude of the measurement
-   * @return this mutable measure
-   */
-  default MutSelf mut_setMagnitude(double magnitude) {
-    return mut_replace(magnitude, unit());
-  }
-
-  /**
-   * Sets the new magnitude of the measurement. The magnitude must be in terms of the base unit of
-   * the current unit.
-   *
-   * @param baseUnitMagnitude the new magnitude of the measurement
-   * @return this mutable measure
-   */
-  default MutSelf mut_setBaseUnitMagnitude(double baseUnitMagnitude) {
-    return mut_replace(unit().fromBaseUnits(baseUnitMagnitude), unit());
-  }
-
-  /**
-   * Increments the current magnitude of the measure by the given value. The value must be in terms
-   * of the current {@link #unit() unit}.
-   *
-   * @param raw the raw value to accumulate by
-   * @return the measure
-   */
-  default MutSelf mut_acc(double raw) {
-    return mut_setBaseUnitMagnitude(magnitude() + raw);
-  }
-
-  /**
-   * Increments the current magnitude of the measure by the amount of the given measure.
-   *
-   * @param other the measure whose value should be added to this one
-   * @return this measure
-   */
-  default MutSelf mut_acc(Base other) {
-    return mut_setMagnitude(magnitude() + unit().fromBaseUnits(other.baseUnitMagnitude()));
-  }
-
-  /**
-   * Adds another measurement to this one. This will mutate the object instead of generating a new
-   * measurement object.
-   *
-   * @param other the measurement to add
-   * @return this measure
-   */
-  default MutSelf mut_plus(Base other) {
-    return mut_acc(other);
-  }
-
-  /**
-   * Adds another measurement to this one. This will mutate the object instead of generating a new
-   * measurement object. This is a denormalized version of {@link #mut_plus(Measure)} to avoid
-   * having to wrap raw numbers in a {@code Measure} object and pay for an object allocation.
-   *
-   * @param magnitude the magnitude of the other measurement.
-   * @param otherUnit the unit of the other measurement
-   * @return this measure
-   */
-  default MutSelf mut_plus(double magnitude, U otherUnit) {
-    return mut_setBaseUnitMagnitude(magnitude() + otherUnit.toBaseUnits(magnitude));
-  }
-
-  /**
-   * Subtracts another measurement to this one. This will mutate the object instead of generating a
-   * new measurement object.
-   *
-   * @param other the measurement to subtract from this one
-   * @return this measure
-   */
-  default MutSelf mut_minus(Base other) {
-    return mut_setBaseUnitMagnitude(baseUnitMagnitude() - other.baseUnitMagnitude());
-  }
-
-  /**
-   * Subtracts another measurement from this one. This will mutate the object instead of generating
-   * a new measurement object. This is a denormalized version of {@link #mut_minus(Measure)} to
-   * avoid having to wrap raw numbers in a {@code Measure} object and pay for an object allocation.
-   *
-   * @param magnitude the magnitude of the other measurement.
-   * @param otherUnit the unit of the other measurement
-   * @return this measure
-   */
-  default MutSelf mut_minus(double magnitude, U otherUnit) {
-    return mut_setBaseUnitMagnitude(baseUnitMagnitude() - otherUnit.toBaseUnits(magnitude));
-  }
-
-  /**
-   * Multiplies this measurement by some constant value. This will mutate the object instead of
-   * generating a new measurement object.
-   *
-   * @param multiplier the multiplier to scale the measurement by
-   * @return this measure
-   */
-  default MutSelf mut_times(double multiplier) {
-    return mut_setBaseUnitMagnitude(baseUnitMagnitude() * multiplier);
-  }
-
-  /**
-   * Multiplies this measurement by some constant value. This will mutate the object instead of
-   * generating a new measurement object.
-   *
-   * @param multiplier the multiplier to scale the measurement by
-   * @return this measure
-   */
-  default MutSelf mut_times(Dimensionless multiplier) {
-    return mut_times(multiplier.baseUnitMagnitude());
-  }
-
-  /**
-   * Divides this measurement by some constant value. This will mutate the object instead of
-   * generating a new measurement object.
-   *
-   * @param divisor the divisor to scale the measurement by
-   * @return this measure
-   */
-  default MutSelf mut_divide(double divisor) {
-    return mut_times(1 / divisor);
-  }
-
-  /**
-   * Divides this measurement by some constant value. This will mutate the object instead of
-   * generating a new measurement object.
-   *
-   * @param divisor the divisor to scale the measurement by
-   * @return this measure
-   */
-  default MutSelf mut_divide(Dimensionless divisor) {
-    return mut_divide(divisor.baseUnitMagnitude());
-  }
-}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/PerUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/PerUnit.java
index 3c7de4ad3c..a52a20f010 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/PerUnit.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/PerUnit.java
@@ -4,8 +4,6 @@
 
 package edu.wpi.first.units;
 
-import edu.wpi.first.units.measure.ImmutablePer;
-import edu.wpi.first.units.measure.MutPer;
 import edu.wpi.first.units.measure.Per;
 import java.util.Objects;
 
@@ -195,7 +193,7 @@ public class PerUnit<N extends Unit, D extends Unit> extends Unit {
    * @see #of(double)
    */
   public final Per<N, D> ofNative(double magnitude) {
-    return new ImmutablePer<>(magnitude, toBaseUnits(magnitude), this);
+    return new Per<>(magnitude, toBaseUnits(magnitude), this);
   }
 
   /**
@@ -207,7 +205,7 @@ public class PerUnit<N extends Unit, D extends Unit> extends Unit {
    * @see #ofBaseUnits(double)
    */
   public final Per<N, D> ofNativeBaseUnits(double baseUnitMagnitude) {
-    return new ImmutablePer<>(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+    return new Per<>(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
   }
 
   @Override
@@ -222,32 +220,6 @@ public class PerUnit<N extends Unit, D extends Unit> extends Unit {
     return (Measure<? extends PerUnit<N, D>>) super.one();
   }
 
-  /**
-   * {@inheritDoc}
-   *
-   * <p>Note: When called on an object of type {@code PerUnit} (and <i>not</i> a subclass!), this
-   * method will always return a {@link edu.wpi.first.units.measure.MutPer} instance.
-   *
-   * @param initialMagnitude the starting magnitude of the measure
-   * @return the ratio measure
-   */
-  @Override
-  public MutableMeasure<? extends PerUnit<N, D>, ?, ?> mutable(double initialMagnitude) {
-    return mutableNative(initialMagnitude);
-  }
-
-  /**
-   * Creates a new mutable measurement of the given magnitude in terms of the ratio unit. This will
-   * always return a {@code Per} object and cannot be overridden by subclasses.
-   *
-   * @param initialMagnitude the starting magnitude of the measure
-   * @return the ratio measure
-   * @see #mutable(double)
-   */
-  public final MutPer<N, D> mutableNative(double initialMagnitude) {
-    return new MutPer<>(initialMagnitude, toBaseUnits(initialMagnitude), this);
-  }
-
   @Override
   public Unit per(TimeUnit time) {
     return VelocityUnit.combine(this, time);
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/PowerUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/PowerUnit.java
index 4129b22177..677e0b20a4 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/PowerUnit.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/PowerUnit.java
@@ -7,8 +7,6 @@ package edu.wpi.first.units;
 import static edu.wpi.first.units.Units.Joules;
 import static edu.wpi.first.units.Units.Seconds;
 
-import edu.wpi.first.units.measure.ImmutablePower;
-import edu.wpi.first.units.measure.MutPower;
 import edu.wpi.first.units.measure.Power;
 
 /**
@@ -112,12 +110,12 @@ public final class PowerUnit extends PerUnit<EnergyUnit, TimeUnit> {
 
   @Override
   public Power of(double magnitude) {
-    return new ImmutablePower(magnitude, toBaseUnits(magnitude), this);
+    return new Power(magnitude, toBaseUnits(magnitude), this);
   }
 
   @Override
   public Power ofBaseUnits(double baseUnitMagnitude) {
-    return new ImmutablePower(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+    return new Power(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
   }
 
   @Override
@@ -130,11 +128,6 @@ public final class PowerUnit extends PerUnit<EnergyUnit, TimeUnit> {
     return (Power) super.one();
   }
 
-  @Override
-  public MutPower mutable(double initialMagnitude) {
-    return new MutPower(initialMagnitude, toBaseUnits(initialMagnitude), this);
-  }
-
   @Override
   public VelocityUnit<PowerUnit> per(TimeUnit time) {
     return VelocityUnit.combine(this, time);
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/ResistanceUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/ResistanceUnit.java
index 0fba48f38c..57ed168952 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/ResistanceUnit.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/ResistanceUnit.java
@@ -4,8 +4,6 @@
 
 package edu.wpi.first.units;
 
-import edu.wpi.first.units.measure.ImmutableResistance;
-import edu.wpi.first.units.measure.MutResistance;
 import edu.wpi.first.units.measure.Resistance;
 
 /**
@@ -57,12 +55,12 @@ public final class ResistanceUnit extends PerUnit<VoltageUnit, CurrentUnit> {
 
   @Override
   public Resistance of(double magnitude) {
-    return new ImmutableResistance(magnitude, toBaseUnits(magnitude), this);
+    return new Resistance(magnitude, toBaseUnits(magnitude), this);
   }
 
   @Override
   public Resistance ofBaseUnits(double baseUnitMagnitude) {
-    return new ImmutableResistance(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+    return new Resistance(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
   }
 
   @Override
@@ -75,11 +73,6 @@ public final class ResistanceUnit extends PerUnit<VoltageUnit, CurrentUnit> {
     return (Resistance) super.one();
   }
 
-  @Override
-  public MutResistance mutable(double initialMagnitude) {
-    return new MutResistance(initialMagnitude, toBaseUnits(initialMagnitude), this);
-  }
-
   /**
    * Creates a ratio unit between this unit and an arbitrary other unit.
    *
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/TemperatureUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/TemperatureUnit.java
index 479c7e847a..de3bec9fb8 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/TemperatureUnit.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/TemperatureUnit.java
@@ -4,8 +4,6 @@
 
 package edu.wpi.first.units;
 
-import edu.wpi.first.units.measure.ImmutableTemperature;
-import edu.wpi.first.units.measure.MutTemperature;
 import edu.wpi.first.units.measure.Temperature;
 
 /**
@@ -34,12 +32,12 @@ public final class TemperatureUnit extends Unit {
 
   @Override
   public Temperature of(double magnitude) {
-    return new ImmutableTemperature(magnitude, toBaseUnits(magnitude), this);
+    return new Temperature(magnitude, toBaseUnits(magnitude), this);
   }
 
   @Override
   public Temperature ofBaseUnits(double baseUnitMagnitude) {
-    return new ImmutableTemperature(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+    return new Temperature(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
   }
 
   @Override
@@ -52,11 +50,6 @@ public final class TemperatureUnit extends Unit {
     return (Temperature) super.one();
   }
 
-  @Override
-  public MutTemperature mutable(double initialMagnitude) {
-    return new MutTemperature(initialMagnitude, toBaseUnits(initialMagnitude), this);
-  }
-
   @Override
   public VelocityUnit<TemperatureUnit> per(TimeUnit period) {
     return VelocityUnit.combine(this, period);
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/TimeUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/TimeUnit.java
index c8afa47098..9029e35148 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/TimeUnit.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/TimeUnit.java
@@ -4,8 +4,6 @@
 
 package edu.wpi.first.units;
 
-import edu.wpi.first.units.measure.ImmutableTime;
-import edu.wpi.first.units.measure.MutTime;
 import edu.wpi.first.units.measure.Time;
 
 /**
@@ -77,12 +75,12 @@ public final class TimeUnit extends Unit {
 
   @Override
   public Time of(double magnitude) {
-    return new ImmutableTime(magnitude, toBaseUnits(magnitude), this);
+    return new Time(magnitude, toBaseUnits(magnitude), this);
   }
 
   @Override
   public Time ofBaseUnits(double baseUnitMagnitude) {
-    return new ImmutableTime(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+    return new Time(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
   }
 
   @Override
@@ -94,9 +92,4 @@ public final class TimeUnit extends Unit {
   public Time one() {
     return (Time) super.one();
   }
-
-  @Override
-  public MutTime mutable(double initialMagnitude) {
-    return new MutTime(initialMagnitude, toBaseUnits(initialMagnitude), this);
-  }
 }
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/TorqueUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/TorqueUnit.java
index 3aeef3b55d..ea7b5ab2f3 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/TorqueUnit.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/TorqueUnit.java
@@ -4,8 +4,6 @@
 
 package edu.wpi.first.units;
 
-import edu.wpi.first.units.measure.ImmutableTorque;
-import edu.wpi.first.units.measure.MutTorque;
 import edu.wpi.first.units.measure.Torque;
 
 /** A unit of torque like {@link edu.wpi.first.units.Units#NewtonMeters}. */
@@ -49,12 +47,12 @@ public final class TorqueUnit extends MultUnit<DistanceUnit, ForceUnit> {
 
   @Override
   public Torque of(double magnitude) {
-    return new ImmutableTorque(magnitude, toBaseUnits(magnitude), this);
+    return new Torque(magnitude, toBaseUnits(magnitude), this);
   }
 
   @Override
   public Torque ofBaseUnits(double baseUnitMagnitude) {
-    return new ImmutableTorque(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+    return new Torque(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
   }
 
   @Override
@@ -67,11 +65,6 @@ public final class TorqueUnit extends MultUnit<DistanceUnit, ForceUnit> {
     return (Torque) super.one();
   }
 
-  @Override
-  public MutTorque mutable(double initialMagnitude) {
-    return new MutTorque(initialMagnitude, toBaseUnits(initialMagnitude), this);
-  }
-
   @Override
   public VelocityUnit<TorqueUnit> per(TimeUnit time) {
     return VelocityUnit.combine(this, time);
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/Unit.java b/wpiunits/src/main/java/edu/wpi/first/units/Unit.java
index 1dfc36f8eb..2b6da66432 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/Unit.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/Unit.java
@@ -85,16 +85,6 @@ public abstract class Unit {
    */
   public abstract Measure<?> ofBaseUnits(double baseUnitMagnitude);
 
-  /**
-   * Creates a new mutable measurement that is initialized to the given magnitude in terms of this
-   * unit. Implementations are <strong>strongly</strong> recommended to sharpen the return type to a
-   * unit-specific measurement implementation.
-   *
-   * @param initialMagnitude the initial magnitude of the mutable measurement
-   * @return the mutable measurement object
-   */
-  public abstract MutableMeasure<?, ?, ?> mutable(double initialMagnitude);
-
   /**
    * Gets a measure of zero magnitude in terms of this unit. The returned object is guaranteed to be
    * of the same type returned by {@link #of(double)}. Subclasses are encouraged to override this
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/VelocityUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/VelocityUnit.java
index 45374cd39c..2792ebe842 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/VelocityUnit.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/VelocityUnit.java
@@ -4,8 +4,6 @@
 
 package edu.wpi.first.units;
 
-import edu.wpi.first.units.measure.ImmutableVelocity;
-import edu.wpi.first.units.measure.MutVelocity;
 import edu.wpi.first.units.measure.Velocity;
 
 /**
@@ -80,12 +78,12 @@ public final class VelocityUnit<D extends Unit> extends PerUnit<D, TimeUnit> {
 
   @Override
   public Velocity<D> of(double magnitude) {
-    return new ImmutableVelocity<>(magnitude, toBaseUnits(magnitude), this);
+    return new Velocity<>(magnitude, toBaseUnits(magnitude), this);
   }
 
   @Override
   public Velocity<D> ofBaseUnits(double baseUnitMagnitude) {
-    return new ImmutableVelocity<>(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+    return new Velocity<>(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
   }
 
   @Override
@@ -100,11 +98,6 @@ public final class VelocityUnit<D extends Unit> extends PerUnit<D, TimeUnit> {
     return (Velocity<D>) super.one();
   }
 
-  @Override
-  public MutableMeasure<VelocityUnit<D>, ?, ?> mutable(double initialMagnitude) {
-    return new MutVelocity<>(initialMagnitude, toBaseUnits(initialMagnitude), this);
-  }
-
   /**
    * Combines this velocity unit with a unit of a period of change to create an acceleration unit.
    *
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/VoltageUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/VoltageUnit.java
index 7506935170..ab768e450f 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/VoltageUnit.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/VoltageUnit.java
@@ -4,8 +4,6 @@
 
 package edu.wpi.first.units;
 
-import edu.wpi.first.units.measure.ImmutableVoltage;
-import edu.wpi.first.units.measure.MutVoltage;
 import edu.wpi.first.units.measure.Voltage;
 
 /**
@@ -53,12 +51,12 @@ public final class VoltageUnit extends Unit {
 
   @Override
   public Voltage of(double magnitude) {
-    return new ImmutableVoltage(magnitude, toBaseUnits(magnitude), this);
+    return new Voltage(magnitude, toBaseUnits(magnitude), this);
   }
 
   @Override
   public Voltage ofBaseUnits(double baseUnitMagnitude) {
-    return new ImmutableVoltage(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+    return new Voltage(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
   }
 
   @Override
@@ -71,11 +69,6 @@ public final class VoltageUnit extends Unit {
     return (Voltage) super.one();
   }
 
-  @Override
-  public MutVoltage mutable(double magnitude) {
-    return new MutVoltage(magnitude, toBaseUnits(magnitude), this);
-  }
-
   @Override
   public VelocityUnit<VoltageUnit> per(TimeUnit period) {
     return VelocityUnit.combine(this, period);
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/mutable/GenericMutableMeasureImpl.java b/wpiunits/src/main/java/edu/wpi/first/units/mutable/GenericMutableMeasureImpl.java
deleted file mode 100644
index c14187c000..0000000000
--- a/wpiunits/src/main/java/edu/wpi/first/units/mutable/GenericMutableMeasureImpl.java
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-package edu.wpi.first.units.mutable;
-
-import edu.wpi.first.units.ImmutableMeasure;
-import edu.wpi.first.units.Measure;
-import edu.wpi.first.units.MutableMeasure;
-import edu.wpi.first.units.Unit;
-import edu.wpi.first.units.measure.Dimensionless;
-
-/**
- * A generic implementation of a mutable measure. This is used in scenarios no unit-specific mutable
- * implementation can be determined.
- *
- * @param <U> the unit of measure
- */
-public final class GenericMutableMeasureImpl<U extends Unit>
-    extends MutableMeasureBase<U, Measure<U>, GenericMutableMeasureImpl<U>> {
-  /**
-   * Initializes the mutable measure with initial conditions. Both relative and base unit magnitudes
-   * are required to avoid unnecessary calculations. It is up to the caller to ensure they are
-   * correct.
-   *
-   * @param initialValue the initial magnitude of the measure, in terms of the unit
-   * @param baseUnitMagnitude the initial magnitude of the measure, in terms of the base unit
-   * @param unit the initial unit of measure
-   */
-  public GenericMutableMeasureImpl(double initialValue, double baseUnitMagnitude, U unit) {
-    super(initialValue, baseUnitMagnitude, unit);
-  }
-
-  @Override
-  public Measure<U> copy() {
-    return ImmutableMeasure.ofBaseUnits(m_baseUnitMagnitude, m_unit);
-  }
-
-  @Override
-  public MutableMeasure<U, ?, ?> mutableCopy() {
-    return new GenericMutableMeasureImpl<>(m_magnitude, m_baseUnitMagnitude, m_unit);
-  }
-
-  @Override
-  public Measure<U> unaryMinus() {
-    return ImmutableMeasure.ofBaseUnits(0 - m_baseUnitMagnitude, m_unit);
-  }
-
-  @Override
-  public Measure<U> plus(Measure<? extends U> other) {
-    return ImmutableMeasure.ofBaseUnits(m_baseUnitMagnitude + other.baseUnitMagnitude(), m_unit);
-  }
-
-  @Override
-  public Measure<U> minus(Measure<? extends U> other) {
-    return ImmutableMeasure.ofBaseUnits(m_baseUnitMagnitude - other.baseUnitMagnitude(), m_unit);
-  }
-
-  @Override
-  public Measure<U> times(double multiplier) {
-    return ImmutableMeasure.ofBaseUnits(m_baseUnitMagnitude * multiplier, m_unit);
-  }
-
-  @Override
-  public Measure<U> times(Dimensionless multiplier) {
-    return ImmutableMeasure.ofBaseUnits(
-        m_baseUnitMagnitude * multiplier.baseUnitMagnitude(), m_unit);
-  }
-
-  @Override
-  public Measure<U> div(double divisor) {
-    return ImmutableMeasure.ofBaseUnits(m_baseUnitMagnitude / divisor, m_unit);
-  }
-
-  @Override
-  public Measure<U> div(Dimensionless divisor) {
-    return ImmutableMeasure.ofBaseUnits(m_baseUnitMagnitude / divisor.baseUnitMagnitude(), m_unit);
-  }
-}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/mutable/MutableMeasureBase.java b/wpiunits/src/main/java/edu/wpi/first/units/mutable/MutableMeasureBase.java
deleted file mode 100644
index 3314e809b2..0000000000
--- a/wpiunits/src/main/java/edu/wpi/first/units/mutable/MutableMeasureBase.java
+++ /dev/null
@@ -1,86 +0,0 @@
-// Copyright (c) FIRST and other WPILib contributors.
-// Open Source Software; you can modify and/or share it under the terms of
-// the WPILib BSD license file in the root directory of this project.
-
-package edu.wpi.first.units.mutable;
-
-import edu.wpi.first.units.Measure;
-import edu.wpi.first.units.MutableMeasure;
-import edu.wpi.first.units.Unit;
-import java.util.Objects;
-
-/**
- * A partial implementation of {@link MutableMeasure} to handle most of the state and Java object-
- * related implementations.
- *
- * @param <U> The dimension of measurement.
- * @param <Base> The base measure type.
- * @param <MutSelf> The self type. This MUST inherit from the base measure type.
- */
-public abstract class MutableMeasureBase<
-        U extends Unit, Base extends Measure<U>, MutSelf extends MutableMeasure<U, Base, MutSelf>>
-    implements Measure<U>, MutableMeasure<U, Base, MutSelf> {
-  /** The magnitude of the measurement, in terms of {@link #m_unit}. */
-  protected double m_magnitude;
-
-  /** The magnitude of the measurement, in terms of {@link #m_unit}'s base unit. */
-  protected double m_baseUnitMagnitude;
-
-  /** The unit of measurement. */
-  protected U m_unit;
-
-  /**
-   * Initializes the mutable measure with initial conditions. Both relative and base unit magnitudes
-   * are required to avoid unnecessary calculations. It is up to the caller to ensure they are
-   * correct.
-   *
-   * @param magnitude the initial magnitude of the measure, in terms of the unit
-   * @param baseUnitMagnitude the initial magnitude of the measure, in terms of the base unit
-   * @param unit the initial unit of measure
-   */
-  protected MutableMeasureBase(double magnitude, double baseUnitMagnitude, U unit) {
-    this.m_magnitude = magnitude;
-    this.m_baseUnitMagnitude = baseUnitMagnitude;
-    this.m_unit = Objects.requireNonNull(unit, "Unit cannot be null");
-  }
-
-  @Override
-  public double magnitude() {
-    return m_magnitude;
-  }
-
-  @Override
-  public double baseUnitMagnitude() {
-    return m_baseUnitMagnitude;
-  }
-
-  @Override
-  public U unit() {
-    return m_unit;
-  }
-
-  @Override
-  public String toString() {
-    return toShortString();
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    return this == o || o instanceof Measure<?> m && isEquivalent(m);
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(m_magnitude, m_baseUnitMagnitude, m_unit);
-  }
-
-  @Override
-  @SuppressWarnings("unchecked")
-  public MutSelf mut_replace(double magnitude, U newUnit) {
-    this.m_unit = Objects.requireNonNull(newUnit, "New unit cannot be null");
-    this.m_magnitude = magnitude;
-    this.m_baseUnitMagnitude = m_unit.toBaseUnits(magnitude);
-
-    return (MutSelf) this;
-  }
-}
diff --git a/wpiunits/src/test/java/edu/wpi/first/units/ExampleUnit.java b/wpiunits/src/test/java/edu/wpi/first/units/ExampleUnit.java
index cc4b272f88..c4e047ff41 100644
--- a/wpiunits/src/test/java/edu/wpi/first/units/ExampleUnit.java
+++ b/wpiunits/src/test/java/edu/wpi/first/units/ExampleUnit.java
@@ -4,8 +4,6 @@
 
 package edu.wpi.first.units;
 
-import edu.wpi.first.units.mutable.GenericMutableMeasureImpl;
-
 class ExampleUnit extends Unit {
   ExampleUnit(double baseUnitEquivalent) {
     this(baseUnitEquivalent, "Example", "ex");
@@ -38,11 +36,6 @@ class ExampleUnit extends Unit {
     return ImmutableMeasure.ofBaseUnits(baseUnitMagnitude, this);
   }
 
-  @Override
-  public MutableMeasure<ExampleUnit, ?, ?> mutable(double initialMagnitude) {
-    return new GenericMutableMeasureImpl<>(initialMagnitude, toBaseUnits(initialMagnitude), this);
-  }
-
   @Override
   public VelocityUnit<ExampleUnit> per(TimeUnit time) {
     return VelocityUnit.combine(this, time);