From a9b885070e2ce9c4226ce0cecaec2f62f442b69e Mon Sep 17 00:00:00 2001
From: Sam Carlberg <sam@slfc.dev>
Date: Sat, 7 Sep 2024 13:59:29 -0400
Subject: [PATCH] [wpiunits] Java units API rewrite (#6958)

Java generics are too limited to do what we need. This refactors generic code previously in Unit and Measure into unit-specific classes that can have unit-safe math operations (notably, times and divide) that can return values in known units instead of a wildcarded Measure<?>.

Unit-specific measure implementations are automatically generated by ./wpiunits/generate_units.py, which generates generic interfaces and mutable and immutable implementations of those interfaces. These make up the bulk of the diff of this PR (approximately 9300 LOC).

This also adds units for angular and linear velocities, accelerations, and momenta; moment of inertia; and torque.
---
 .github/workflows/pregenerate.yml             |   2 +
 docs/build.gradle                             |   5 +-
 .../first/epilogue/EpilogueConfiguration.java |   7 +-
 .../first/epilogue/logging/DataLogger.java    |   2 +-
 styleguide/checkstyle-suppressions.xml        |   2 +
 .../wpi/first/wpilibj2/command/Command.java   |   9 +-
 .../wpi/first/wpilibj2/command/Commands.java  |   5 +-
 .../command/MecanumControllerCommand.java     |  28 +-
 .../wpilibj2/command/RamseteCommand.java      |  16 +-
 .../first/wpilibj2/command/WaitCommand.java   |   9 +-
 .../wpilibj2/command/sysid/SysIdRoutine.java  |  40 +-
 .../command/sysid/SysIdRoutineTest.java       |   5 +-
 .../edu/wpi/first/wpilibj/LEDPattern.java     |  37 +-
 .../edu/wpi/first/wpilibj/TimedRobot.java     |   7 +-
 .../wpilibj/motorcontrol/MotorController.java |  20 +-
 .../first/wpilibj/simulation/FlywheelSim.java |  18 +-
 .../first/wpilibj/sysid/SysIdRoutineLog.java  |  30 +-
 .../edu/wpi/first/wpilibj/LEDPatternTest.java |   2 +-
 .../examples/addressableled/Robot.java        |   5 +-
 .../examples/sysid/subsystems/Drive.java      |  21 +-
 .../examples/sysid/subsystems/Shooter.java    |  21 +-
 .../controller/SimpleMotorFeedforward.java    |  12 +-
 .../edu/wpi/first/math/geometry/Pose2d.java   |   5 +-
 .../wpi/first/math/geometry/Rotation2d.java   |   7 +-
 .../wpi/first/math/geometry/Transform2d.java  |   5 +-
 .../first/math/geometry/Translation2d.java    |   5 +-
 .../first/math/geometry/Translation3d.java    |   5 +-
 .../first/math/kinematics/ChassisSpeeds.java  |  28 +-
 .../DifferentialDriveKinematics.java          |   5 +-
 .../kinematics/DifferentialDriveOdometry.java |  14 +-
 .../DifferentialDriveWheelPositions.java      |   5 +-
 .../DifferentialDriveWheelSpeeds.java         |   9 +-
 .../MecanumDriveWheelPositions.java           |   8 +-
 .../kinematics/MecanumDriveWheelSpeeds.java   |  14 +-
 .../kinematics/SwerveDriveKinematics.java     |  14 +-
 .../math/kinematics/SwerveModulePosition.java |   5 +-
 .../math/kinematics/SwerveModuleState.java    |   6 +-
 .../math/trajectory/TrajectoryConfig.java     |  13 +-
 .../math/trajectory/TrapezoidProfile.java     |  12 +-
 .../SimpleMotorFeedforwardTest.java           |   5 +-
 .../math/kinematics/ChassisSpeedsTest.java    |   2 +-
 .../trajectory/ExponentialProfileTest.java    |   5 +-
 wpiunits/CMakeLists.txt                       |   6 +-
 wpiunits/build.gradle                         |   2 +
 wpiunits/generate_units.py                    | 362 +++++++
 .../main/java/Measure-immutable.java.jinja    |  28 +
 .../main/java/Measure-interface.java.jinja    | 117 +++
 .../main/java/Measure-mutable.java.jinja      |  25 +
 .../wpi/first/units/measure/Acceleration.java | 334 ++++++
 .../edu/wpi/first/units/measure/Angle.java    | 334 ++++++
 .../units/measure/AngularAcceleration.java    | 334 ++++++
 .../first/units/measure/AngularMomentum.java  | 334 ++++++
 .../first/units/measure/AngularVelocity.java  | 334 ++++++
 .../edu/wpi/first/units/measure/Current.java  | 334 ++++++
 .../first/units/measure/Dimensionless.java    | 334 ++++++
 .../edu/wpi/first/units/measure/Distance.java | 334 ++++++
 .../edu/wpi/first/units/measure/Energy.java   | 334 ++++++
 .../edu/wpi/first/units/measure/Force.java    | 334 ++++++
 .../wpi/first/units/measure/Frequency.java    | 335 ++++++
 .../units/measure/ImmutableAcceleration.java  |  28 +
 .../first/units/measure/ImmutableAngle.java   |  28 +
 .../measure/ImmutableAngularAcceleration.java |  28 +
 .../measure/ImmutableAngularMomentum.java     |  28 +
 .../measure/ImmutableAngularVelocity.java     |  28 +
 .../first/units/measure/ImmutableCurrent.java |  28 +
 .../units/measure/ImmutableDimensionless.java |  28 +
 .../units/measure/ImmutableDistance.java      |  28 +
 .../first/units/measure/ImmutableEnergy.java  |  28 +
 .../first/units/measure/ImmutableForce.java   |  28 +
 .../units/measure/ImmutableFrequency.java     |  28 +
 .../measure/ImmutableLinearAcceleration.java  |  28 +
 .../measure/ImmutableLinearMomentum.java      |  28 +
 .../measure/ImmutableLinearVelocity.java      |  28 +
 .../first/units/measure/ImmutableMass.java    |  28 +
 .../measure/ImmutableMomentOfInertia.java     |  28 +
 .../first/units/measure/ImmutableMult.java    |  28 +
 .../wpi/first/units/measure/ImmutablePer.java |  28 +
 .../first/units/measure/ImmutablePower.java   |  28 +
 .../units/measure/ImmutableTemperature.java   |  28 +
 .../first/units/measure/ImmutableTime.java    |  28 +
 .../first/units/measure/ImmutableTorque.java  |  28 +
 .../units/measure/ImmutableVelocity.java      |  28 +
 .../first/units/measure/ImmutableVoltage.java |  28 +
 .../units/measure/LinearAcceleration.java     | 334 ++++++
 .../first/units/measure/LinearMomentum.java   | 334 ++++++
 .../first/units/measure/LinearVelocity.java   | 334 ++++++
 .../edu/wpi/first/units/measure/Mass.java     | 334 ++++++
 .../first/units/measure/MomentOfInertia.java  | 334 ++++++
 .../edu/wpi/first/units/measure/Mult.java     | 334 ++++++
 .../first/units/measure/MutAcceleration.java  |  25 +
 .../edu/wpi/first/units/measure/MutAngle.java |  25 +
 .../units/measure/MutAngularAcceleration.java |  25 +
 .../units/measure/MutAngularMomentum.java     |  25 +
 .../units/measure/MutAngularVelocity.java     |  25 +
 .../wpi/first/units/measure/MutCurrent.java   |  25 +
 .../first/units/measure/MutDimensionless.java |  25 +
 .../wpi/first/units/measure/MutDistance.java  |  25 +
 .../wpi/first/units/measure/MutEnergy.java    |  25 +
 .../edu/wpi/first/units/measure/MutForce.java |  25 +
 .../wpi/first/units/measure/MutFrequency.java |  25 +
 .../units/measure/MutLinearAcceleration.java  |  25 +
 .../units/measure/MutLinearMomentum.java      |  25 +
 .../units/measure/MutLinearVelocity.java      |  25 +
 .../edu/wpi/first/units/measure/MutMass.java  |  25 +
 .../units/measure/MutMomentOfInertia.java     |  25 +
 .../edu/wpi/first/units/measure/MutMult.java  |  25 +
 .../edu/wpi/first/units/measure/MutPer.java   |  25 +
 .../edu/wpi/first/units/measure/MutPower.java |  25 +
 .../first/units/measure/MutTemperature.java   |  25 +
 .../edu/wpi/first/units/measure/MutTime.java  |  25 +
 .../wpi/first/units/measure/MutTorque.java    |  25 +
 .../wpi/first/units/measure/MutVelocity.java  |  25 +
 .../wpi/first/units/measure/MutVoltage.java   |  25 +
 .../java/edu/wpi/first/units/measure/Per.java | 341 +++++++
 .../edu/wpi/first/units/measure/Power.java    | 334 ++++++
 .../wpi/first/units/measure/Temperature.java  | 334 ++++++
 .../edu/wpi/first/units/measure/Time.java     | 334 ++++++
 .../edu/wpi/first/units/measure/Torque.java   | 334 ++++++
 .../edu/wpi/first/units/measure/Velocity.java | 334 ++++++
 .../edu/wpi/first/units/measure/Voltage.java  | 334 ++++++
 .../edu/wpi/first/units/AccelerationUnit.java | 113 +++
 .../main/java/edu/wpi/first/units/Angle.java  |  32 -
 .../java/edu/wpi/first/units/AngleUnit.java   |  93 ++
 .../first/units/AngularAccelerationUnit.java  | 102 ++
 .../wpi/first/units/AngularMomentumUnit.java  | 114 +++
 .../wpi/first/units/AngularVelocityUnit.java  | 101 ++
 .../java/edu/wpi/first/units/BaseUnits.java   |  23 +-
 .../wpi/first/units/CombinatoryUnitCache.java |  60 ++
 .../java/edu/wpi/first/units/Current.java     |  46 -
 .../java/edu/wpi/first/units/CurrentUnit.java | 105 ++
 .../edu/wpi/first/units/Dimensionless.java    |  30 -
 .../wpi/first/units/DimensionlessUnit.java    |  99 ++
 .../java/edu/wpi/first/units/Distance.java    |  29 -
 .../edu/wpi/first/units/DistanceUnit.java     | 102 ++
 .../main/java/edu/wpi/first/units/Energy.java |  29 -
 .../java/edu/wpi/first/units/EnergyUnit.java  |  96 ++
 .../java/edu/wpi/first/units/ForceUnit.java   | 113 +++
 .../edu/wpi/first/units/FrequencyUnit.java    | 114 +++
 .../edu/wpi/first/units/ImmutableMeasure.java |  81 +-
 .../first/units/LinearAccelerationUnit.java   | 125 +++
 .../wpi/first/units/LinearMomentumUnit.java   | 111 ++
 .../wpi/first/units/LinearVelocityUnit.java   | 107 ++
 .../main/java/edu/wpi/first/units/Mass.java   |  30 -
 .../java/edu/wpi/first/units/MassUnit.java    | 112 ++
 .../java/edu/wpi/first/units/Measure.java     | 954 ++++++++++++++++--
 .../wpi/first/units/MomentOfInertiaUnit.java  | 107 ++
 .../main/java/edu/wpi/first/units/Mult.java   | 123 ---
 .../java/edu/wpi/first/units/MultUnit.java    | 229 +++++
 .../edu/wpi/first/units/MutableMeasure.java   | 228 +----
 .../main/java/edu/wpi/first/units/Per.java    | 140 ---
 .../java/edu/wpi/first/units/PerUnit.java     | 287 ++++++
 .../main/java/edu/wpi/first/units/Power.java  |  29 -
 .../java/edu/wpi/first/units/PowerUnit.java   | 164 +++
 .../java/edu/wpi/first/units/Temperature.java |  25 -
 .../edu/wpi/first/units/TemperatureUnit.java  |  86 ++
 .../main/java/edu/wpi/first/units/Time.java   |  29 -
 .../java/edu/wpi/first/units/TimeUnit.java    | 102 ++
 .../java/edu/wpi/first/units/TorqueUnit.java  | 101 ++
 .../main/java/edu/wpi/first/units/Unit.java   | 222 ++--
 .../java/edu/wpi/first/units/UnitBuilder.java |  14 +-
 .../main/java/edu/wpi/first/units/Units.java  | 336 ++++--
 .../java/edu/wpi/first/units/Velocity.java    | 188 ----
 .../edu/wpi/first/units/VelocityUnit.java     | 140 +++
 .../java/edu/wpi/first/units/Voltage.java     |  46 -
 .../java/edu/wpi/first/units/VoltageUnit.java | 105 ++
 .../mutable/GenericMutableMeasureImpl.java    |  79 ++
 .../units/mutable/MutableMeasureBase.java     |  86 ++
 ...{CurrentTest.java => CurrentUnitTest.java} |  14 +-
 ...istanceTest.java => DistanceUnitTest.java} |   8 +-
 .../java/edu/wpi/first/units/EncoderTest.java |  91 --
 .../java/edu/wpi/first/units/ExampleUnit.java |  28 +-
 .../java/edu/wpi/first/units/MeasureTest.java | 241 ++---
 .../{MultTest.java => MultUnitTest.java}      |  10 +-
 .../wpi/first/units/MutableMeasureTest.java   | 133 ---
 .../java/edu/wpi/first/units/PerUnitTest.java |  56 +
 .../java/edu/wpi/first/units/UnitsTest.java   |  39 +-
 ...elocityTest.java => VelocityUnitTest.java} |  19 +-
 ...{VoltageTest.java => VoltageUnitTest.java} |   7 +-
 178 files changed, 14668 insertions(+), 2076 deletions(-)
 create mode 100755 wpiunits/generate_units.py
 create mode 100644 wpiunits/src/generate/main/java/Measure-immutable.java.jinja
 create mode 100644 wpiunits/src/generate/main/java/Measure-interface.java.jinja
 create mode 100644 wpiunits/src/generate/main/java/Measure-mutable.java.jinja
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Acceleration.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Angle.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularAcceleration.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularMomentum.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularVelocity.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Current.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Dimensionless.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Distance.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Energy.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Force.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Frequency.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAcceleration.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAngle.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAngularAcceleration.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAngularMomentum.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAngularVelocity.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableCurrent.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableDimensionless.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableDistance.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableEnergy.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableForce.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableFrequency.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableLinearAcceleration.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableLinearMomentum.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableLinearVelocity.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableMass.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableMomentOfInertia.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableMult.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutablePer.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutablePower.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableTemperature.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableTime.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableTorque.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableVelocity.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableVoltage.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearAcceleration.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearMomentum.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearVelocity.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mass.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MomentOfInertia.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mult.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAcceleration.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAngle.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAngularAcceleration.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAngularMomentum.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAngularVelocity.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutCurrent.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutDimensionless.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutDistance.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutEnergy.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutForce.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutFrequency.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutLinearAcceleration.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutLinearMomentum.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutLinearVelocity.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutMass.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutMomentOfInertia.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutMult.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutPer.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutPower.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutTemperature.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutTime.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutTorque.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutVelocity.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutVoltage.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Per.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Power.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Temperature.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Time.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Torque.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Velocity.java
 create mode 100644 wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Voltage.java
 create mode 100644 wpiunits/src/main/java/edu/wpi/first/units/AccelerationUnit.java
 delete mode 100644 wpiunits/src/main/java/edu/wpi/first/units/Angle.java
 create mode 100644 wpiunits/src/main/java/edu/wpi/first/units/AngleUnit.java
 create mode 100644 wpiunits/src/main/java/edu/wpi/first/units/AngularAccelerationUnit.java
 create mode 100644 wpiunits/src/main/java/edu/wpi/first/units/AngularMomentumUnit.java
 create mode 100644 wpiunits/src/main/java/edu/wpi/first/units/AngularVelocityUnit.java
 create mode 100644 wpiunits/src/main/java/edu/wpi/first/units/CombinatoryUnitCache.java
 delete mode 100644 wpiunits/src/main/java/edu/wpi/first/units/Current.java
 create mode 100644 wpiunits/src/main/java/edu/wpi/first/units/CurrentUnit.java
 delete mode 100644 wpiunits/src/main/java/edu/wpi/first/units/Dimensionless.java
 create mode 100644 wpiunits/src/main/java/edu/wpi/first/units/DimensionlessUnit.java
 delete mode 100644 wpiunits/src/main/java/edu/wpi/first/units/Distance.java
 create mode 100644 wpiunits/src/main/java/edu/wpi/first/units/DistanceUnit.java
 delete mode 100644 wpiunits/src/main/java/edu/wpi/first/units/Energy.java
 create mode 100644 wpiunits/src/main/java/edu/wpi/first/units/EnergyUnit.java
 create mode 100644 wpiunits/src/main/java/edu/wpi/first/units/ForceUnit.java
 create mode 100644 wpiunits/src/main/java/edu/wpi/first/units/FrequencyUnit.java
 create mode 100644 wpiunits/src/main/java/edu/wpi/first/units/LinearAccelerationUnit.java
 create mode 100644 wpiunits/src/main/java/edu/wpi/first/units/LinearMomentumUnit.java
 create mode 100644 wpiunits/src/main/java/edu/wpi/first/units/LinearVelocityUnit.java
 delete mode 100644 wpiunits/src/main/java/edu/wpi/first/units/Mass.java
 create mode 100644 wpiunits/src/main/java/edu/wpi/first/units/MassUnit.java
 create mode 100644 wpiunits/src/main/java/edu/wpi/first/units/MomentOfInertiaUnit.java
 delete mode 100644 wpiunits/src/main/java/edu/wpi/first/units/Mult.java
 create mode 100644 wpiunits/src/main/java/edu/wpi/first/units/MultUnit.java
 delete mode 100644 wpiunits/src/main/java/edu/wpi/first/units/Per.java
 create mode 100644 wpiunits/src/main/java/edu/wpi/first/units/PerUnit.java
 delete mode 100644 wpiunits/src/main/java/edu/wpi/first/units/Power.java
 create mode 100644 wpiunits/src/main/java/edu/wpi/first/units/PowerUnit.java
 delete mode 100644 wpiunits/src/main/java/edu/wpi/first/units/Temperature.java
 create mode 100644 wpiunits/src/main/java/edu/wpi/first/units/TemperatureUnit.java
 delete mode 100644 wpiunits/src/main/java/edu/wpi/first/units/Time.java
 create mode 100644 wpiunits/src/main/java/edu/wpi/first/units/TimeUnit.java
 create mode 100644 wpiunits/src/main/java/edu/wpi/first/units/TorqueUnit.java
 delete mode 100644 wpiunits/src/main/java/edu/wpi/first/units/Velocity.java
 create mode 100644 wpiunits/src/main/java/edu/wpi/first/units/VelocityUnit.java
 delete mode 100644 wpiunits/src/main/java/edu/wpi/first/units/Voltage.java
 create mode 100644 wpiunits/src/main/java/edu/wpi/first/units/VoltageUnit.java
 create mode 100644 wpiunits/src/main/java/edu/wpi/first/units/mutable/GenericMutableMeasureImpl.java
 create mode 100644 wpiunits/src/main/java/edu/wpi/first/units/mutable/MutableMeasureBase.java
 rename wpiunits/src/test/java/edu/wpi/first/units/{CurrentTest.java => CurrentUnitTest.java} (52%)
 rename wpiunits/src/test/java/edu/wpi/first/units/{DistanceTest.java => DistanceUnitTest.java} (83%)
 delete mode 100644 wpiunits/src/test/java/edu/wpi/first/units/EncoderTest.java
 rename wpiunits/src/test/java/edu/wpi/first/units/{MultTest.java => MultUnitTest.java} (80%)
 delete mode 100644 wpiunits/src/test/java/edu/wpi/first/units/MutableMeasureTest.java
 create mode 100644 wpiunits/src/test/java/edu/wpi/first/units/PerUnitTest.java
 rename wpiunits/src/test/java/edu/wpi/first/units/{VelocityTest.java => VelocityUnitTest.java} (72%)
 rename wpiunits/src/test/java/edu/wpi/first/units/{VoltageTest.java => VoltageUnitTest.java} (67%)

diff --git a/.github/workflows/pregenerate.yml b/.github/workflows/pregenerate.yml
index f356b087140..decca974b6c 100644
--- a/.github/workflows/pregenerate.yml
+++ b/.github/workflows/pregenerate.yml
@@ -32,6 +32,8 @@ jobs:
         run: ./ntcore/generate_topics.py
       - name: Run wpimath
         run: ./wpimath/generate_numbers.py && ./wpimath/generate_quickbuf.py --quickbuf_plugin=protoc-gen-quickbuf-1.3.3-linux-x86_64.exe
+      - name: Run wpiunits
+        run: ./wpiunits/generate_units.py
       - name: Run HIDs
         run: ./wpilibj/generate_hids.py && ./wpilibc/generate_hids.py && ./wpilibNewCommands/generate_hids.py
       - name: Run PWM Controllers
diff --git a/docs/build.gradle b/docs/build.gradle
index 526bae0c7bb..4104c6db874 100644
--- a/docs/build.gradle
+++ b/docs/build.gradle
@@ -203,7 +203,10 @@ task generateJavaDocs(type: Javadoc) {
             "-edu.wpi.first.math.system.struct," +
             "-edu.wpi.first.math.system.plant.proto," +
             "-edu.wpi.first.math.system.plant.struct," +
-            "-edu.wpi.first.math.trajectory.proto", true)
+            "-edu.wpi.first.math.trajectory.proto," +
+            // The .measure package contains generated source files for which automatic javadoc
+            // generation is very difficult to do meaningfully.
+            "-edu.wpi.first.units.measure", true)
     options.addBooleanOption("Xdoclint:html,missing,reference,syntax", true)
     options.addBooleanOption('html5', true)
     options.linkSource(true)
diff --git a/epilogue-runtime/src/main/java/edu/wpi/first/epilogue/EpilogueConfiguration.java b/epilogue-runtime/src/main/java/edu/wpi/first/epilogue/EpilogueConfiguration.java
index 868a7cb0bf6..84bdc1fae5d 100644
--- a/epilogue-runtime/src/main/java/edu/wpi/first/epilogue/EpilogueConfiguration.java
+++ b/epilogue-runtime/src/main/java/edu/wpi/first/epilogue/EpilogueConfiguration.java
@@ -9,8 +9,7 @@
 import edu.wpi.first.epilogue.logging.errors.ErrorHandler;
 import edu.wpi.first.epilogue.logging.errors.ErrorPrinter;
 import edu.wpi.first.networktables.NetworkTableInstance;
-import edu.wpi.first.units.Measure;
-import edu.wpi.first.units.Time;
+import edu.wpi.first.units.measure.Time;
 
 /**
  * A configuration object to be used by the generated {@code Epilogue} class to customize its
@@ -29,13 +28,13 @@ public class EpilogueConfiguration {
    * The period Epilogue will log at. By default this is the period that the robot runs at. This is
    * the field used by bind to configure speed when adding the periodic logging function
    */
-  public Measure<Time> loggingPeriod;
+  public Time loggingPeriod;
 
   /**
    * The offset from the periodic run that Epilogue will log at. By default this will be half of the
    * robots period. This is the field used by bind when adding the periodic logging function
    */
-  public Measure<Time> loggingPeriodOffset;
+  public Time loggingPeriodOffset;
 
   /**
    * The minimum importance level of data to be logged. Defaults to debug, which logs data of all
diff --git a/epilogue-runtime/src/main/java/edu/wpi/first/epilogue/logging/DataLogger.java b/epilogue-runtime/src/main/java/edu/wpi/first/epilogue/logging/DataLogger.java
index a8b6f341682..a804bc5a1ae 100644
--- a/epilogue-runtime/src/main/java/edu/wpi/first/epilogue/logging/DataLogger.java
+++ b/epilogue-runtime/src/main/java/edu/wpi/first/epilogue/logging/DataLogger.java
@@ -211,7 +211,7 @@ default void log(String identifier, Measure<?> value) {
    * @param unit the unit to log the measurement in
    * @param <U> the dimension of the unit
    */
-  default <U extends Unit<U>> void log(String identifier, Measure<U> value, U unit) {
+  default <U extends Unit> void log(String identifier, Measure<U> value, U unit) {
     log(identifier, value.in(unit));
   }
 
diff --git a/styleguide/checkstyle-suppressions.xml b/styleguide/checkstyle-suppressions.xml
index 7644ea0563c..2bfd414d595 100644
--- a/styleguide/checkstyle-suppressions.xml
+++ b/styleguide/checkstyle-suppressions.xml
@@ -14,4 +14,6 @@ suppressions PUBLIC "-//Puppy Crawl//DTD Suppressions 1.1//EN"
     checks="(CustomImportOrder|EmptyLineSeparator|LineLength|JavadocParagraph|MissingJavadocMethod|OverloadMethodsDeclarationOrder|SummaryJavadoc|UnnecessaryParentheses|OperatorWrap|JavadocMethod|JavadocTagContinuationIndentation)" />
   <suppress files="wpilibj[/\\]src[/\\]generated.*"
     checks="MethodName" />
+  <!-- Disable checkstyle for generated unit files -->
+  <suppress files="wpiunits[/\\]src[/\\]generated.*" checks=".*"/>
 </suppressions>
diff --git a/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj2/command/Command.java b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj2/command/Command.java
index 7d71676ce41..a53d792d0e4 100644
--- a/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj2/command/Command.java
+++ b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj2/command/Command.java
@@ -4,11 +4,10 @@
 
 package edu.wpi.first.wpilibj2.command;
 
-import static edu.wpi.first.units.Units.Second;
+import static edu.wpi.first.units.Units.Seconds;
 import static edu.wpi.first.util.ErrorMessages.requireNonNullParam;
 
-import edu.wpi.first.units.Measure;
-import edu.wpi.first.units.Time;
+import edu.wpi.first.units.measure.Time;
 import edu.wpi.first.util.function.BooleanConsumer;
 import edu.wpi.first.util.sendable.Sendable;
 import edu.wpi.first.util.sendable.SendableBuilder;
@@ -179,8 +178,8 @@ public ParallelRaceGroup withTimeout(double seconds) {
    * @param time the timeout duration
    * @return the command with the timeout added
    */
-  public ParallelRaceGroup withTimeout(Measure<Time> time) {
-    return withTimeout(time.in(Second));
+  public ParallelRaceGroup withTimeout(Time time) {
+    return withTimeout(time.in(Seconds));
   }
 
   /**
diff --git a/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj2/command/Commands.java b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj2/command/Commands.java
index 3632c1100ad..c53409a033d 100644
--- a/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj2/command/Commands.java
+++ b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj2/command/Commands.java
@@ -6,8 +6,7 @@
 
 import static edu.wpi.first.util.ErrorMessages.requireNonNullParam;
 
-import edu.wpi.first.units.Measure;
-import edu.wpi.first.units.Time;
+import edu.wpi.first.units.measure.Time;
 import java.util.Map;
 import java.util.Set;
 import java.util.function.BooleanSupplier;
@@ -137,7 +136,7 @@ public static Command waitSeconds(double seconds) {
    * @return the command
    * @see WaitCommand
    */
-  public static Command waitTime(Measure<Time> time) {
+  public static Command waitTime(Time time) {
     return new WaitCommand(time);
   }
 
diff --git a/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj2/command/MecanumControllerCommand.java b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj2/command/MecanumControllerCommand.java
index fa299a51180..bb47e58a370 100644
--- a/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj2/command/MecanumControllerCommand.java
+++ b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj2/command/MecanumControllerCommand.java
@@ -19,9 +19,7 @@
 import edu.wpi.first.math.kinematics.MecanumDriveMotorVoltages;
 import edu.wpi.first.math.kinematics.MecanumDriveWheelSpeeds;
 import edu.wpi.first.math.trajectory.Trajectory;
-import edu.wpi.first.units.Distance;
-import edu.wpi.first.units.MutableMeasure;
-import edu.wpi.first.units.Velocity;
+import edu.wpi.first.units.measure.MutLinearVelocity;
 import edu.wpi.first.wpilibj.Timer;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
@@ -60,22 +58,14 @@ public class MecanumControllerCommand extends Command {
   private final Supplier<MecanumDriveWheelSpeeds> m_currentWheelSpeeds;
   private final Consumer<MecanumDriveMotorVoltages> m_outputDriveVoltages;
   private final Consumer<MecanumDriveWheelSpeeds> m_outputWheelSpeeds;
-  private final MutableMeasure<Velocity<Distance>> m_prevFrontLeftSpeedSetpoint =
-      MutableMeasure.zero(MetersPerSecond);
-  private final MutableMeasure<Velocity<Distance>> m_prevRearLeftSpeedSetpoint =
-      MutableMeasure.zero(MetersPerSecond);
-  private final MutableMeasure<Velocity<Distance>> m_prevFrontRightSpeedSetpoint =
-      MutableMeasure.zero(MetersPerSecond);
-  private final MutableMeasure<Velocity<Distance>> m_prevRearRightSpeedSetpoint =
-      MutableMeasure.zero(MetersPerSecond);
-  private final MutableMeasure<Velocity<Distance>> m_frontLeftSpeedSetpoint =
-      MutableMeasure.zero(MetersPerSecond);
-  private final MutableMeasure<Velocity<Distance>> m_rearLeftSpeedSetpoint =
-      MutableMeasure.zero(MetersPerSecond);
-  private final MutableMeasure<Velocity<Distance>> m_frontRightSpeedSetpoint =
-      MutableMeasure.zero(MetersPerSecond);
-  private final MutableMeasure<Velocity<Distance>> m_rearRightSpeedSetpoint =
-      MutableMeasure.zero(MetersPerSecond);
+  private final MutLinearVelocity m_prevFrontLeftSpeedSetpoint = MetersPerSecond.mutable(0);
+  private final MutLinearVelocity m_prevRearLeftSpeedSetpoint = MetersPerSecond.mutable(0);
+  private final MutLinearVelocity m_prevFrontRightSpeedSetpoint = MetersPerSecond.mutable(0);
+  private final MutLinearVelocity m_prevRearRightSpeedSetpoint = MetersPerSecond.mutable(0);
+  private final MutLinearVelocity m_frontLeftSpeedSetpoint = MetersPerSecond.mutable(0);
+  private final MutLinearVelocity m_rearLeftSpeedSetpoint = MetersPerSecond.mutable(0);
+  private final MutLinearVelocity m_frontRightSpeedSetpoint = MetersPerSecond.mutable(0);
+  private final MutLinearVelocity m_rearRightSpeedSetpoint = MetersPerSecond.mutable(0);
 
   /**
    * Constructs a new MecanumControllerCommand that when executed will follow the provided
diff --git a/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj2/command/RamseteCommand.java b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj2/command/RamseteCommand.java
index bcd2a7929be..533db5b0398 100644
--- a/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj2/command/RamseteCommand.java
+++ b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj2/command/RamseteCommand.java
@@ -16,9 +16,7 @@
 import edu.wpi.first.math.kinematics.DifferentialDriveKinematics;
 import edu.wpi.first.math.kinematics.DifferentialDriveWheelSpeeds;
 import edu.wpi.first.math.trajectory.Trajectory;
-import edu.wpi.first.units.Distance;
-import edu.wpi.first.units.MutableMeasure;
-import edu.wpi.first.units.Velocity;
+import edu.wpi.first.units.measure.MutLinearVelocity;
 import edu.wpi.first.util.sendable.SendableBuilder;
 import edu.wpi.first.wpilibj.Timer;
 import java.util.function.BiConsumer;
@@ -51,14 +49,10 @@ public class RamseteCommand extends Command {
   private final PIDController m_rightController;
   private final BiConsumer<Double, Double> m_output;
   private DifferentialDriveWheelSpeeds m_prevSpeeds = new DifferentialDriveWheelSpeeds();
-  private final MutableMeasure<Velocity<Distance>> m_prevLeftSpeedSetpoint =
-      MutableMeasure.zero(MetersPerSecond);
-  private final MutableMeasure<Velocity<Distance>> m_prevRightSpeedSetpoint =
-      MutableMeasure.zero(MetersPerSecond);
-  private final MutableMeasure<Velocity<Distance>> m_leftSpeedSetpoint =
-      MutableMeasure.zero(MetersPerSecond);
-  private final MutableMeasure<Velocity<Distance>> m_rightSpeedSetpoint =
-      MutableMeasure.zero(MetersPerSecond);
+  private final MutLinearVelocity m_prevLeftSpeedSetpoint = MetersPerSecond.mutable(0);
+  private final MutLinearVelocity m_prevRightSpeedSetpoint = MetersPerSecond.mutable(0);
+  private final MutLinearVelocity m_leftSpeedSetpoint = MetersPerSecond.mutable(0);
+  private final MutLinearVelocity m_rightSpeedSetpoint = MetersPerSecond.mutable(0);
   private double m_prevTime;
 
   /**
diff --git a/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj2/command/WaitCommand.java b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj2/command/WaitCommand.java
index a0851925137..556d134c7e5 100644
--- a/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj2/command/WaitCommand.java
+++ b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj2/command/WaitCommand.java
@@ -4,10 +4,9 @@
 
 package edu.wpi.first.wpilibj2.command;
 
-import static edu.wpi.first.units.Units.Second;
+import static edu.wpi.first.units.Units.Seconds;
 
-import edu.wpi.first.units.Measure;
-import edu.wpi.first.units.Time;
+import edu.wpi.first.units.measure.Time;
 import edu.wpi.first.util.sendable.SendableBuilder;
 import edu.wpi.first.util.sendable.SendableRegistry;
 import edu.wpi.first.wpilibj.Timer;
@@ -39,8 +38,8 @@ public WaitCommand(double seconds) {
    *
    * @param time the time to wait
    */
-  public WaitCommand(Measure<Time> time) {
-    this(time.in(Second));
+  public WaitCommand(Time time) {
+    this(time.in(Seconds));
   }
 
   @Override
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 053a404c779..48c3a37190f 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
@@ -4,17 +4,16 @@
 
 package edu.wpi.first.wpilibj2.command.sysid;
 
-import static edu.wpi.first.units.MutableMeasure.mutable;
 import static edu.wpi.first.units.Units.Second;
 import static edu.wpi.first.units.Units.Seconds;
 import static edu.wpi.first.units.Units.Volts;
 import static java.util.Map.entry;
 
-import edu.wpi.first.units.Measure;
-import edu.wpi.first.units.MutableMeasure;
-import edu.wpi.first.units.Time;
-import edu.wpi.first.units.Velocity;
-import edu.wpi.first.units.Voltage;
+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;
 import edu.wpi.first.wpilibj.Timer;
 import edu.wpi.first.wpilibj.sysid.SysIdRoutineLog;
 import edu.wpi.first.wpilibj2.command.Command;
@@ -43,7 +42,7 @@
 public class SysIdRoutine extends SysIdRoutineLog {
   private final Config m_config;
   private final Mechanism m_mechanism;
-  private final MutableMeasure<Voltage> m_outputVolts = mutable(Volts.of(0));
+  private final MutVoltage m_outputVolts = Volts.mutable(0);
   private final Consumer<State> m_recordState;
 
   /**
@@ -62,13 +61,13 @@ public SysIdRoutine(Config config, Mechanism mechanism) {
   /** Hardware-independent configuration for a SysId test routine. */
   public static class Config {
     /** The voltage ramp rate used for quasistatic test routines. */
-    public final Measure<Velocity<Voltage>> m_rampRate;
+    public final Velocity<VoltageUnit> m_rampRate;
 
     /** The step voltage output used for dynamic test routines. */
-    public final Measure<Voltage> m_stepVoltage;
+    public final Voltage m_stepVoltage;
 
     /** Safety timeout for the test routine commands. */
-    public final Measure<Time> m_timeout;
+    public final Time m_timeout;
 
     /** Optional handle for recording test state in a third-party logging solution. */
     public final Consumer<State> m_recordState;
@@ -87,11 +86,11 @@ public static class Config {
      *     logged in WPILog.
      */
     public Config(
-        Measure<Velocity<Voltage>> rampRate,
-        Measure<Voltage> stepVoltage,
-        Measure<Time> timeout,
+        Velocity<VoltageUnit> rampRate,
+        Voltage stepVoltage,
+        Time timeout,
         Consumer<State> recordState) {
-      m_rampRate = rampRate != null ? rampRate : Volts.of(1).per(Seconds.of(1));
+      m_rampRate = rampRate != null ? rampRate : Volts.of(1).per(Second);
       m_stepVoltage = stepVoltage != null ? stepVoltage : Volts.of(7);
       m_timeout = timeout != null ? timeout : Seconds.of(10);
       m_recordState = recordState;
@@ -107,8 +106,7 @@ public Config(
      * @param timeout Safety timeout for the test routine commands. Defaults to 10 seconds if left
      *     null.
      */
-    public Config(
-        Measure<Velocity<Voltage>> rampRate, Measure<Voltage> stepVoltage, Measure<Time> timeout) {
+    public Config(Velocity<VoltageUnit> rampRate, Voltage stepVoltage, Time timeout) {
       this(rampRate, stepVoltage, timeout, null);
     }
 
@@ -132,7 +130,7 @@ public Config() {
    */
   public static class Mechanism {
     /** Sends the SysId-specified drive signal to the mechanism motors during test routines. */
-    public final Consumer<Measure<Voltage>> m_drive;
+    public final Consumer<? super Voltage> m_drive;
 
     /**
      * Returns measured data (voltages, positions, velocities) of the mechanism motors during test
@@ -163,10 +161,7 @@ public static class Mechanism {
      *     the subsystem if left null.
      */
     public Mechanism(
-        Consumer<Measure<Voltage>> drive,
-        Consumer<SysIdRoutineLog> log,
-        Subsystem subsystem,
-        String name) {
+        Consumer<Voltage> drive, Consumer<SysIdRoutineLog> log, Subsystem subsystem, String name) {
       m_drive = drive;
       m_log = log != null ? log : l -> {};
       m_subsystem = subsystem;
@@ -189,8 +184,7 @@ public Mechanism(
      *     will be appended to the log entry title for the routine's test state, e.g.
      *     "sysid-test-state-subsystem".
      */
-    public Mechanism(
-        Consumer<Measure<Voltage>> drive, Consumer<SysIdRoutineLog> log, Subsystem subsystem) {
+    public Mechanism(Consumer<Voltage> drive, Consumer<SysIdRoutineLog> log, Subsystem subsystem) {
       this(drive, log, subsystem, null);
     }
   }
diff --git a/wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/command/sysid/SysIdRoutineTest.java b/wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/command/sysid/SysIdRoutineTest.java
index 3d885b21bd9..48b0ba89a0b 100644
--- a/wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/command/sysid/SysIdRoutineTest.java
+++ b/wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/command/sysid/SysIdRoutineTest.java
@@ -14,8 +14,7 @@
 import static org.mockito.Mockito.verify;
 
 import edu.wpi.first.hal.HAL;
-import edu.wpi.first.units.Measure;
-import edu.wpi.first.units.Voltage;
+import edu.wpi.first.units.measure.Voltage;
 import edu.wpi.first.wpilibj.simulation.SimHooks;
 import edu.wpi.first.wpilibj.sysid.SysIdRoutineLog;
 import edu.wpi.first.wpilibj2.command.Command;
@@ -28,7 +27,7 @@ class SysIdRoutineTest {
   interface Mechanism extends Subsystem {
     void recordState(SysIdRoutineLog.State state);
 
-    void drive(Measure<Voltage> voltage);
+    void drive(Voltage voltage);
 
     void log(SysIdRoutineLog log);
   }
diff --git a/wpilibj/src/main/java/edu/wpi/first/wpilibj/LEDPattern.java b/wpilibj/src/main/java/edu/wpi/first/wpilibj/LEDPattern.java
index 3d39b502c01..adabe89da83 100644
--- a/wpilibj/src/main/java/edu/wpi/first/wpilibj/LEDPattern.java
+++ b/wpilibj/src/main/java/edu/wpi/first/wpilibj/LEDPattern.java
@@ -10,12 +10,12 @@
 import static edu.wpi.first.units.Units.Value;
 
 import edu.wpi.first.math.MathUtil;
-import edu.wpi.first.units.Dimensionless;
-import edu.wpi.first.units.Distance;
-import edu.wpi.first.units.Measure;
-import edu.wpi.first.units.Time;
-import edu.wpi.first.units.Velocity;
 import edu.wpi.first.units.collections.LongToObjectHashMap;
+import edu.wpi.first.units.measure.Dimensionless;
+import edu.wpi.first.units.measure.Distance;
+import edu.wpi.first.units.measure.Frequency;
+import edu.wpi.first.units.measure.LinearVelocity;
+import edu.wpi.first.units.measure.Time;
 import edu.wpi.first.util.WPIUtilJNI;
 import edu.wpi.first.wpilibj.util.Color;
 import java.util.Map;
@@ -99,9 +99,9 @@ public interface LEDPattern {
    *
    * <p>This method is intentionally designed to use separate objects for reading and writing data.
    * By splitting them up, we can easily modify the behavior of some base pattern to make it {@link
-   * #scrollAtRelativeSpeed(Measure) scroll}, {@link #blink(Measure, Measure) blink}, or {@link
-   * #breathe(Measure) breathe} by intercepting the data writes to transform their behavior to
-   * whatever we like.
+   * #scrollAtRelativeSpeed(Frequency) scroll}, {@link #blink(Time, Time) blink}, or {@link
+   * #breathe(Time) breathe} by intercepting the data writes to transform their behavior to whatever
+   * we like.
    *
    * @param reader data reader for accessing buffer length and current colors
    * @param writer data writer for setting new LED colors on the buffer
@@ -186,8 +186,8 @@ default LEDPattern offsetBy(int offset) {
    *     scroll along the length of LEDs and return back to the starting position
    * @return the scrolling pattern
    */
-  default LEDPattern scrollAtRelativeSpeed(Measure<Velocity<Dimensionless>> velocity) {
-    final double periodMicros = 1 / velocity.in(Value.per(Microsecond));
+  default LEDPattern scrollAtRelativeSpeed(Frequency velocity) {
+    final double periodMicros = velocity.asPeriod().in(Microseconds);
 
     return (reader, writer) -> {
       int bufLen = reader.getLength();
@@ -217,7 +217,7 @@ default LEDPattern scrollAtRelativeSpeed(Measure<Velocity<Dimensionless>> veloci
    *
    * <pre>
    *   // LEDs per meter, a known value taken from the spec sheet of our particular LED strip
-   *   Measure&lt;Distance&gt; LED_SPACING = Meters.of(1.0 / 60);
+   *   Distance LED_SPACING = Meters.of(1.0 / 60);
    *
    *   LEDPattern rainbow = LEDPattern.rainbow();
    *   LEDPattern scrollingRainbow =
@@ -232,8 +232,7 @@ default LEDPattern scrollAtRelativeSpeed(Measure<Velocity<Dimensionless>> veloci
    * @param ledSpacing the distance between adjacent LEDs on the physical LED strip
    * @return the scrolling pattern
    */
-  default LEDPattern scrollAtAbsoluteSpeed(
-      Measure<Velocity<Distance>> velocity, Measure<Distance> ledSpacing) {
+  default LEDPattern scrollAtAbsoluteSpeed(LinearVelocity velocity, Distance ledSpacing) {
     // eg velocity = 10 m/s, spacing = 0.01m
     // meters per micro = 1e-5 m/us
     // micros per LED = 1e-2 m / (1e-5 m/us) = 1e-3 us
@@ -267,7 +266,7 @@ default LEDPattern scrollAtAbsoluteSpeed(
    * @param offTime how long the pattern should be turned off for, per cycle
    * @return the blinking pattern
    */
-  default LEDPattern blink(Measure<Time> onTime, Measure<Time> offTime) {
+  default LEDPattern blink(Time onTime, Time offTime) {
     final long totalTimeMicros = (long) (onTime.in(Microseconds) + offTime.in(Microseconds));
     final long onTimeMicros = (long) onTime.in(Microseconds);
 
@@ -281,13 +280,13 @@ default LEDPattern blink(Measure<Time> onTime, Measure<Time> offTime) {
   }
 
   /**
-   * Like {@link #blink(Measure, Measure) blink(onTime, offTime)}, but where the "off" time is
-   * exactly equal to the "on" time.
+   * Like {@link #blink(Time, Time) blink(onTime, offTime)}, but where the "off" time is exactly
+   * equal to the "on" time.
    *
    * @param onTime how long the pattern should play for (and be turned off for), per cycle
    * @return the blinking pattern
    */
-  default LEDPattern blink(Measure<Time> onTime) {
+  default LEDPattern blink(Time onTime) {
     return blink(onTime, onTime);
   }
 
@@ -316,7 +315,7 @@ default LEDPattern synchronizedBlink(BooleanSupplier signal) {
    * @param period how fast the breathing pattern should complete a single cycle
    * @return the breathing pattern
    */
-  default LEDPattern breathe(Measure<Time> period) {
+  default LEDPattern breathe(Time period) {
     final long periodMicros = (long) period.in(Microseconds);
 
     return (reader, writer) -> {
@@ -444,7 +443,7 @@ default LEDPattern mask(LEDPattern mask) {
    * @param relativeBrightness the multiplier to apply to all channels to modify brightness
    * @return the input pattern, displayed at
    */
-  default LEDPattern atBrightness(Measure<Dimensionless> relativeBrightness) {
+  default LEDPattern atBrightness(Dimensionless relativeBrightness) {
     double multiplier = relativeBrightness.in(Value);
 
     return (reader, writer) -> {
diff --git a/wpilibj/src/main/java/edu/wpi/first/wpilibj/TimedRobot.java b/wpilibj/src/main/java/edu/wpi/first/wpilibj/TimedRobot.java
index 2251d712d9f..7b59f528a6b 100644
--- a/wpilibj/src/main/java/edu/wpi/first/wpilibj/TimedRobot.java
+++ b/wpilibj/src/main/java/edu/wpi/first/wpilibj/TimedRobot.java
@@ -11,8 +11,7 @@
 import edu.wpi.first.hal.FRCNetComm.tResourceType;
 import edu.wpi.first.hal.HAL;
 import edu.wpi.first.hal.NotifierJNI;
-import edu.wpi.first.units.Measure;
-import edu.wpi.first.units.Time;
+import edu.wpi.first.units.measure.Time;
 import java.util.PriorityQueue;
 
 /**
@@ -199,7 +198,7 @@ public final void addPeriodic(Runnable callback, double periodSeconds, double of
    * @param callback The callback to run.
    * @param period The period at which to run the callback.
    */
-  public final void addPeriodic(Runnable callback, Measure<Time> period) {
+  public final void addPeriodic(Runnable callback, Time period) {
     addPeriodic(callback, period.in(Seconds));
   }
 
@@ -214,7 +213,7 @@ public final void addPeriodic(Runnable callback, Measure<Time> period) {
    * @param offset The offset from the common starting time. This is useful for scheduling a
    *     callback in a different timeslot relative to TimedRobot.
    */
-  public final void addPeriodic(Runnable callback, Measure<Time> period, Measure<Time> offset) {
+  public final void addPeriodic(Runnable callback, Time period, Time offset) {
     addPeriodic(callback, period.in(Seconds), offset.in(Seconds));
   }
 }
diff --git a/wpilibj/src/main/java/edu/wpi/first/wpilibj/motorcontrol/MotorController.java b/wpilibj/src/main/java/edu/wpi/first/wpilibj/motorcontrol/MotorController.java
index 4cd50da11d8..7c77f8afac9 100644
--- a/wpilibj/src/main/java/edu/wpi/first/wpilibj/motorcontrol/MotorController.java
+++ b/wpilibj/src/main/java/edu/wpi/first/wpilibj/motorcontrol/MotorController.java
@@ -4,6 +4,9 @@
 
 package edu.wpi.first.wpilibj.motorcontrol;
 
+import static edu.wpi.first.units.Units.Volts;
+
+import edu.wpi.first.units.measure.Voltage;
 import edu.wpi.first.wpilibj.RobotController;
 
 /** Interface for motor controlling devices. */
@@ -24,12 +27,27 @@ public interface MotorController {
    * <p>NOTE: This function *must* be called regularly in order for voltage compensation to work
    * properly - unlike the ordinary set function, it is not "set it and forget it."
    *
-   * @param outputVolts The voltage to output.
+   * @param outputVolts The voltage to output, in Volts.
    */
   default void setVoltage(double outputVolts) {
     set(outputVolts / RobotController.getBatteryVoltage());
   }
 
+  /**
+   * Sets the voltage output of the MotorController. Compensates for the current bus voltage to
+   * ensure that the desired voltage is output even if the battery voltage is below 12V - highly
+   * useful when the voltage outputs are "meaningful" (e.g. they come from a feedforward
+   * calculation).
+   *
+   * <p>NOTE: This function *must* be called regularly in order for voltage compensation to work
+   * properly - unlike the ordinary set function, it is not "set it and forget it."
+   *
+   * @param outputVoltage The voltage to output.
+   */
+  default void setVoltage(Voltage outputVoltage) {
+    setVoltage(outputVoltage.in(Volts));
+  }
+
   /**
    * Common interface for getting the current set speed of a motor controller.
    *
diff --git a/wpilibj/src/main/java/edu/wpi/first/wpilibj/simulation/FlywheelSim.java b/wpilibj/src/main/java/edu/wpi/first/wpilibj/simulation/FlywheelSim.java
index 225543a2b6c..372dec74560 100644
--- a/wpilibj/src/main/java/edu/wpi/first/wpilibj/simulation/FlywheelSim.java
+++ b/wpilibj/src/main/java/edu/wpi/first/wpilibj/simulation/FlywheelSim.java
@@ -13,10 +13,10 @@
 import edu.wpi.first.math.system.plant.DCMotor;
 import edu.wpi.first.math.system.plant.LinearSystemId;
 import edu.wpi.first.math.util.Units;
-import edu.wpi.first.units.Angle;
-import edu.wpi.first.units.Measure;
-import edu.wpi.first.units.MutableMeasure;
-import edu.wpi.first.units.Velocity;
+import edu.wpi.first.units.measure.AngularAcceleration;
+import edu.wpi.first.units.measure.AngularVelocity;
+import edu.wpi.first.units.measure.MutAngularAcceleration;
+import edu.wpi.first.units.measure.MutAngularVelocity;
 import edu.wpi.first.wpilibj.RobotController;
 
 /** Represents a simulated flywheel mechanism. */
@@ -31,12 +31,10 @@ public class FlywheelSim extends LinearSystemSim<N1, N1, N1> {
   private final double m_jKgMetersSquared;
 
   // The angular velocity of the system.
-  private final MutableMeasure<Velocity<Angle>> m_angularVelocity =
-      MutableMeasure.zero(RadiansPerSecond);
+  private final MutAngularVelocity m_angularVelocity = RadiansPerSecond.mutable(0);
 
   // The angular acceleration of the system.
-  private final MutableMeasure<Velocity<Velocity<Angle>>> m_angularAcceleration =
-      MutableMeasure.zero(RadiansPerSecondPerSecond);
+  private final MutAngularAcceleration m_angularAcceleration = RadiansPerSecondPerSecond.mutable(0);
 
   /**
    * Creates a simulated flywheel mechanism.
@@ -133,7 +131,7 @@ public double getAngularVelocityRPM() {
    *
    * @return The flywheel's velocity
    */
-  public Measure<Velocity<Angle>> getAngularVelocity() {
+  public AngularVelocity getAngularVelocity() {
     m_angularVelocity.mut_setMagnitude(getAngularVelocityRadPerSec());
     return m_angularVelocity;
   }
@@ -153,7 +151,7 @@ public double getAngularAccelerationRadPerSecSq() {
    *
    * @return The flywheel's acceleration.
    */
-  public Measure<Velocity<Velocity<Angle>>> getAngularAcceleration() {
+  public AngularAcceleration getAngularAcceleration() {
     m_angularAcceleration.mut_setMagnitude(getAngularAccelerationRadPerSecSq());
     return m_angularAcceleration;
   }
diff --git a/wpilibj/src/main/java/edu/wpi/first/wpilibj/sysid/SysIdRoutineLog.java b/wpilibj/src/main/java/edu/wpi/first/wpilibj/sysid/SysIdRoutineLog.java
index cbc6991fd35..82c9ed9b05f 100644
--- a/wpilibj/src/main/java/edu/wpi/first/wpilibj/sysid/SysIdRoutineLog.java
+++ b/wpilibj/src/main/java/edu/wpi/first/wpilibj/sysid/SysIdRoutineLog.java
@@ -12,12 +12,14 @@
 import static edu.wpi.first.units.Units.Second;
 import static edu.wpi.first.units.Units.Volts;
 
-import edu.wpi.first.units.Angle;
-import edu.wpi.first.units.Current;
-import edu.wpi.first.units.Distance;
-import edu.wpi.first.units.Measure;
-import edu.wpi.first.units.Velocity;
-import edu.wpi.first.units.Voltage;
+import edu.wpi.first.units.measure.Angle;
+import edu.wpi.first.units.measure.AngularAcceleration;
+import edu.wpi.first.units.measure.AngularVelocity;
+import edu.wpi.first.units.measure.Current;
+import edu.wpi.first.units.measure.Distance;
+import edu.wpi.first.units.measure.LinearAcceleration;
+import edu.wpi.first.units.measure.LinearVelocity;
+import edu.wpi.first.units.measure.Voltage;
 import edu.wpi.first.util.datalog.DoubleLogEntry;
 import edu.wpi.first.util.datalog.StringLogEntry;
 import edu.wpi.first.wpilibj.DataLogManager;
@@ -114,7 +116,7 @@ public MotorLog value(String name, double value, String unit) {
      * @param voltage The voltage to record.
      * @return The motor log (for call chaining).
      */
-    public MotorLog voltage(Measure<Voltage> voltage) {
+    public MotorLog voltage(Voltage voltage) {
       return value("voltage", voltage.in(Volts), Volts.name());
     }
 
@@ -124,7 +126,7 @@ public MotorLog voltage(Measure<Voltage> voltage) {
      * @param position The linear position to record.
      * @return The motor log (for call chaining).
      */
-    public MotorLog linearPosition(Measure<Distance> position) {
+    public MotorLog linearPosition(Distance position) {
       return value("position", position.in(Meters), Meters.name());
     }
 
@@ -134,7 +136,7 @@ public MotorLog linearPosition(Measure<Distance> position) {
      * @param position The angular position to record.
      * @return The motor log (for call chaining).
      */
-    public MotorLog angularPosition(Measure<Angle> position) {
+    public MotorLog angularPosition(Angle position) {
       return value("position", position.in(Rotations), Rotations.name());
     }
 
@@ -144,7 +146,7 @@ public MotorLog angularPosition(Measure<Angle> position) {
      * @param velocity The linear velocity to record.
      * @return The motor log (for call chaining).
      */
-    public MotorLog linearVelocity(Measure<Velocity<Distance>> velocity) {
+    public MotorLog linearVelocity(LinearVelocity velocity) {
       return value("velocity", velocity.in(MetersPerSecond), MetersPerSecond.name());
     }
 
@@ -154,7 +156,7 @@ public MotorLog linearVelocity(Measure<Velocity<Distance>> velocity) {
      * @param velocity The angular velocity to record.
      * @return The motor log (for call chaining).
      */
-    public MotorLog angularVelocity(Measure<Velocity<Angle>> velocity) {
+    public MotorLog angularVelocity(AngularVelocity velocity) {
       return value("velocity", velocity.in(RotationsPerSecond), RotationsPerSecond.name());
     }
 
@@ -166,7 +168,7 @@ public MotorLog angularVelocity(Measure<Velocity<Angle>> velocity) {
      * @param acceleration The linear acceleration to record.
      * @return The motor log (for call chaining).
      */
-    public MotorLog linearAcceleration(Measure<Velocity<Velocity<Distance>>> acceleration) {
+    public MotorLog linearAcceleration(LinearAcceleration acceleration) {
       return value(
           "acceleration",
           acceleration.in(MetersPerSecond.per(Second)),
@@ -181,7 +183,7 @@ public MotorLog linearAcceleration(Measure<Velocity<Velocity<Distance>>> acceler
      * @param acceleration The angular acceleration to record.
      * @return The motor log (for call chaining).
      */
-    public MotorLog angularAcceleration(Measure<Velocity<Velocity<Angle>>> acceleration) {
+    public MotorLog angularAcceleration(AngularAcceleration acceleration) {
       return value(
           "acceleration",
           acceleration.in(RotationsPerSecond.per(Second)),
@@ -196,7 +198,7 @@ public MotorLog angularAcceleration(Measure<Velocity<Velocity<Angle>>> accelerat
      * @param current The current to record.
      * @return The motor log (for call chaining).
      */
-    public MotorLog current(Measure<Current> current) {
+    public MotorLog current(Current current) {
       value("current", current.in(Amps), Amps.name());
       return this;
     }
diff --git a/wpilibj/src/test/java/edu/wpi/first/wpilibj/LEDPatternTest.java b/wpilibj/src/test/java/edu/wpi/first/wpilibj/LEDPatternTest.java
index f6d38ed7484..ea4c7681516 100644
--- a/wpilibj/src/test/java/edu/wpi/first/wpilibj/LEDPatternTest.java
+++ b/wpilibj/src/test/java/edu/wpi/first/wpilibj/LEDPatternTest.java
@@ -745,7 +745,7 @@ void progressMaskLayer() {
 
   @Test
   void zeroBrightness() {
-    var pattern = LEDPattern.solid(kRed).atBrightness(Percent.zero());
+    var pattern = LEDPattern.solid(kRed).atBrightness(Percent.of(0));
     var buffer = new AddressableLEDBuffer(1);
     pattern.applyTo(buffer);
 
diff --git a/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/addressableled/Robot.java b/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/addressableled/Robot.java
index 16e5321307a..a698f333925 100644
--- a/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/addressableled/Robot.java
+++ b/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/addressableled/Robot.java
@@ -7,8 +7,7 @@
 import static edu.wpi.first.units.Units.Meters;
 import static edu.wpi.first.units.Units.MetersPerSecond;
 
-import edu.wpi.first.units.Distance;
-import edu.wpi.first.units.Measure;
+import edu.wpi.first.units.measure.Distance;
 import edu.wpi.first.wpilibj.AddressableLED;
 import edu.wpi.first.wpilibj.AddressableLEDBuffer;
 import edu.wpi.first.wpilibj.LEDPattern;
@@ -23,7 +22,7 @@ public class Robot extends TimedRobot {
   private final LEDPattern m_rainbow = LEDPattern.rainbow(255, 128);
 
   // Our LED strip has a density of 120 LEDs per meter
-  private static final Measure<Distance> kLedSpacing = Meters.of(1 / 120.0);
+  private static final Distance kLedSpacing = Meters.of(1 / 120.0);
 
   // Create a new pattern that scrolls the rainbow pattern across the LED strip, moving at a speed
   // of 1 meter per second.
diff --git a/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/sysid/subsystems/Drive.java b/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/sysid/subsystems/Drive.java
index 9cad2950c0d..1981172cc53 100644
--- a/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/sysid/subsystems/Drive.java
+++ b/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/sysid/subsystems/Drive.java
@@ -4,16 +4,13 @@
 
 package edu.wpi.first.wpilibj.examples.sysid.subsystems;
 
-import static edu.wpi.first.units.MutableMeasure.mutable;
 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.Distance;
-import edu.wpi.first.units.Measure;
-import edu.wpi.first.units.MutableMeasure;
-import edu.wpi.first.units.Velocity;
-import edu.wpi.first.units.Voltage;
+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;
@@ -50,11 +47,11 @@ public class Drive extends SubsystemBase {
           DriveConstants.kRightEncoderReversed);
 
   // Mutable holder for unit-safe voltage values, persisted to avoid reallocation.
-  private final MutableMeasure<Voltage> m_appliedVoltage = mutable(Volts.of(0));
+  private final MutVoltage m_appliedVoltage = Volts.mutable(0);
   // Mutable holder for unit-safe linear distance values, persisted to avoid reallocation.
-  private final MutableMeasure<Distance> m_distance = mutable(Meters.of(0));
+  private final MutDistance m_distance = Meters.mutable(0);
   // Mutable holder for unit-safe linear velocity values, persisted to avoid reallocation.
-  private final MutableMeasure<Velocity<Distance>> m_velocity = mutable(MetersPerSecond.of(0));
+  private final MutLinearVelocity m_velocity = MetersPerSecond.mutable(0);
 
   // Create a new SysId routine for characterizing the drive.
   private final SysIdRoutine m_sysIdRoutine =
@@ -63,9 +60,9 @@ public class Drive extends SubsystemBase {
           new SysIdRoutine.Config(),
           new SysIdRoutine.Mechanism(
               // Tell SysId how to plumb the driving voltage to the motors.
-              (Measure<Voltage> volts) -> {
-                m_leftMotor.setVoltage(volts.in(Volts));
-                m_rightMotor.setVoltage(volts.in(Volts));
+              voltage -> {
+                m_leftMotor.setVoltage(voltage);
+                m_rightMotor.setVoltage(voltage);
               },
               // Tell SysId how to record a frame of data for each motor on the mechanism being
               // characterized.
diff --git a/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/sysid/subsystems/Shooter.java b/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/sysid/subsystems/Shooter.java
index 94574424db9..2b62f5c8064 100644
--- a/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/sysid/subsystems/Shooter.java
+++ b/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/sysid/subsystems/Shooter.java
@@ -4,18 +4,17 @@
 
 package edu.wpi.first.wpilibj.examples.sysid.subsystems;
 
-import static edu.wpi.first.units.MutableMeasure.mutable;
+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.Angle;
-import edu.wpi.first.units.Measure;
-import edu.wpi.first.units.MutableMeasure;
-import edu.wpi.first.units.Velocity;
-import edu.wpi.first.units.Voltage;
+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.sysid.Constants.ShooterConstants;
@@ -40,11 +39,11 @@ public class Shooter extends SubsystemBase {
           ShooterConstants.kEncoderReversed);
 
   // Mutable holder for unit-safe voltage values, persisted to avoid reallocation.
-  private final MutableMeasure<Voltage> m_appliedVoltage = mutable(Volts.of(0));
+  private final MutVoltage m_appliedVoltage = Volts.mutable(0);
   // Mutable holder for unit-safe linear distance values, persisted to avoid reallocation.
-  private final MutableMeasure<Angle> m_angle = mutable(Rotations.of(0));
+  private final MutAngle m_angle = Radians.mutable(0);
   // Mutable holder for unit-safe linear velocity values, persisted to avoid reallocation.
-  private final MutableMeasure<Velocity<Angle>> m_velocity = mutable(RotationsPerSecond.of(0));
+  private final MutAngularVelocity m_velocity = RadiansPerSecond.mutable(0);
 
   // Create a new SysId routine for characterizing the shooter.
   private final SysIdRoutine m_sysIdRoutine =
@@ -53,9 +52,7 @@ public class Shooter extends SubsystemBase {
           new SysIdRoutine.Config(),
           new SysIdRoutine.Mechanism(
               // Tell SysId how to plumb the driving voltage to the motor(s).
-              (Measure<Voltage> volts) -> {
-                m_shooterMotor.setVoltage(volts.in(Volts));
-              },
+              m_shooterMotor::setVoltage,
               // Tell SysId how to record a frame of data for each motor on the mechanism being
               // characterized.
               log -> {
diff --git a/wpimath/src/main/java/edu/wpi/first/math/controller/SimpleMotorFeedforward.java b/wpimath/src/main/java/edu/wpi/first/math/controller/SimpleMotorFeedforward.java
index 771d927cb40..eb8fae85594 100644
--- a/wpimath/src/main/java/edu/wpi/first/math/controller/SimpleMotorFeedforward.java
+++ b/wpimath/src/main/java/edu/wpi/first/math/controller/SimpleMotorFeedforward.java
@@ -9,9 +9,10 @@
 import edu.wpi.first.math.controller.proto.SimpleMotorFeedforwardProto;
 import edu.wpi.first.math.controller.struct.SimpleMotorFeedforwardStruct;
 import edu.wpi.first.units.Measure;
+import edu.wpi.first.units.PerUnit;
+import edu.wpi.first.units.TimeUnit;
 import edu.wpi.first.units.Unit;
-import edu.wpi.first.units.Velocity;
-import edu.wpi.first.units.Voltage;
+import edu.wpi.first.units.measure.Voltage;
 import edu.wpi.first.util.protobuf.ProtobufSerializable;
 import edu.wpi.first.util.struct.StructSerializable;
 
@@ -156,7 +157,7 @@ public double calculate(double velocity) {
    * @param setpoint The velocity setpoint.
    * @return The computed feedforward.
    */
-  public <U extends Unit<U>> Measure<Voltage> calculate(Measure<Velocity<U>> setpoint) {
+  public <U extends Unit> Voltage calculate(Measure<? extends PerUnit<U, TimeUnit>> setpoint) {
     return calculate(setpoint, setpoint);
   }
 
@@ -168,8 +169,9 @@ public <U extends Unit<U>> Measure<Voltage> calculate(Measure<Velocity<U>> setpo
    * @param nextVelocity The next velocity setpoint.
    * @return The computed feedforward.
    */
-  public <U extends Unit<U>> Measure<Voltage> calculate(
-      Measure<Velocity<U>> currentVelocity, Measure<Velocity<U>> nextVelocity) {
+  public <U extends Unit> Voltage calculate(
+      Measure<? extends PerUnit<U, TimeUnit>> currentVelocity,
+      Measure<? extends PerUnit<U, TimeUnit>> nextVelocity) {
     if (ka == 0.0) {
       // Given the following discrete feedforward model
       //
diff --git a/wpimath/src/main/java/edu/wpi/first/math/geometry/Pose2d.java b/wpimath/src/main/java/edu/wpi/first/math/geometry/Pose2d.java
index 3a72ee79f72..536f44e9e52 100644
--- a/wpimath/src/main/java/edu/wpi/first/math/geometry/Pose2d.java
+++ b/wpimath/src/main/java/edu/wpi/first/math/geometry/Pose2d.java
@@ -13,8 +13,7 @@
 import edu.wpi.first.math.geometry.proto.Pose2dProto;
 import edu.wpi.first.math.geometry.struct.Pose2dStruct;
 import edu.wpi.first.math.interpolation.Interpolatable;
-import edu.wpi.first.units.Distance;
-import edu.wpi.first.units.Measure;
+import edu.wpi.first.units.measure.Distance;
 import edu.wpi.first.util.protobuf.ProtobufSerializable;
 import edu.wpi.first.util.struct.StructSerializable;
 import java.util.Collections;
@@ -76,7 +75,7 @@ public Pose2d(double x, double y, Rotation2d rotation) {
    * @param y The y component of the translational component of the pose.
    * @param rotation The rotational component of the pose.
    */
-  public Pose2d(Measure<Distance> x, Measure<Distance> y, Rotation2d rotation) {
+  public Pose2d(Distance x, Distance y, Rotation2d rotation) {
     this(x.in(Meters), y.in(Meters), rotation);
   }
 
diff --git a/wpimath/src/main/java/edu/wpi/first/math/geometry/Rotation2d.java b/wpimath/src/main/java/edu/wpi/first/math/geometry/Rotation2d.java
index cbcc3b91555..3eeac17a8f8 100644
--- a/wpimath/src/main/java/edu/wpi/first/math/geometry/Rotation2d.java
+++ b/wpimath/src/main/java/edu/wpi/first/math/geometry/Rotation2d.java
@@ -16,8 +16,7 @@
 import edu.wpi.first.math.geometry.struct.Rotation2dStruct;
 import edu.wpi.first.math.interpolation.Interpolatable;
 import edu.wpi.first.math.util.Units;
-import edu.wpi.first.units.Angle;
-import edu.wpi.first.units.Measure;
+import edu.wpi.first.units.measure.Angle;
 import edu.wpi.first.util.protobuf.ProtobufSerializable;
 import edu.wpi.first.util.struct.StructSerializable;
 import java.util.Objects;
@@ -130,7 +129,7 @@ public Rotation2d(double x, double y) {
    *
    * @param angle The angle of the rotation.
    */
-  public Rotation2d(Measure<Angle> angle) {
+  public Rotation2d(Angle angle) {
     this(angle.in(Radians));
   }
 
@@ -244,7 +243,7 @@ public Rotation2d rotateBy(Rotation2d other) {
    *
    * @return The measure of the Rotation2d.
    */
-  public Measure<Angle> getMeasure() {
+  public Angle getMeasure() {
     return Radians.of(getRadians());
   }
 
diff --git a/wpimath/src/main/java/edu/wpi/first/math/geometry/Transform2d.java b/wpimath/src/main/java/edu/wpi/first/math/geometry/Transform2d.java
index f2bccd80677..4eab093ae46 100644
--- a/wpimath/src/main/java/edu/wpi/first/math/geometry/Transform2d.java
+++ b/wpimath/src/main/java/edu/wpi/first/math/geometry/Transform2d.java
@@ -8,8 +8,7 @@
 
 import edu.wpi.first.math.geometry.proto.Transform2dProto;
 import edu.wpi.first.math.geometry.struct.Transform2dStruct;
-import edu.wpi.first.units.Distance;
-import edu.wpi.first.units.Measure;
+import edu.wpi.first.units.measure.Distance;
 import edu.wpi.first.util.protobuf.ProtobufSerializable;
 import edu.wpi.first.util.struct.StructSerializable;
 import java.util.Objects;
@@ -75,7 +74,7 @@ public Transform2d(double x, double y, Rotation2d rotation) {
    * @param y The y component of the translational component of the transform.
    * @param rotation The rotational component of the transform.
    */
-  public Transform2d(Measure<Distance> x, Measure<Distance> y, Rotation2d rotation) {
+  public Transform2d(Distance x, Distance y, Rotation2d rotation) {
     this(x.in(Meters), y.in(Meters), rotation);
   }
 
diff --git a/wpimath/src/main/java/edu/wpi/first/math/geometry/Translation2d.java b/wpimath/src/main/java/edu/wpi/first/math/geometry/Translation2d.java
index 698421d3b4a..031d88429a5 100644
--- a/wpimath/src/main/java/edu/wpi/first/math/geometry/Translation2d.java
+++ b/wpimath/src/main/java/edu/wpi/first/math/geometry/Translation2d.java
@@ -17,8 +17,7 @@
 import edu.wpi.first.math.geometry.struct.Translation2dStruct;
 import edu.wpi.first.math.interpolation.Interpolatable;
 import edu.wpi.first.math.numbers.N2;
-import edu.wpi.first.units.Distance;
-import edu.wpi.first.units.Measure;
+import edu.wpi.first.units.measure.Distance;
 import edu.wpi.first.util.protobuf.ProtobufSerializable;
 import edu.wpi.first.util.struct.StructSerializable;
 import java.util.Collections;
@@ -84,7 +83,7 @@ public Translation2d(double distance, Rotation2d angle) {
    * @param x The x component of the translation.
    * @param y The y component of the translation.
    */
-  public Translation2d(Measure<Distance> x, Measure<Distance> y) {
+  public Translation2d(Distance x, Distance y) {
     this(x.in(Meters), y.in(Meters));
   }
 
diff --git a/wpimath/src/main/java/edu/wpi/first/math/geometry/Translation3d.java b/wpimath/src/main/java/edu/wpi/first/math/geometry/Translation3d.java
index 3d31784b8be..4ae368b3b65 100644
--- a/wpimath/src/main/java/edu/wpi/first/math/geometry/Translation3d.java
+++ b/wpimath/src/main/java/edu/wpi/first/math/geometry/Translation3d.java
@@ -17,8 +17,7 @@
 import edu.wpi.first.math.geometry.struct.Translation3dStruct;
 import edu.wpi.first.math.interpolation.Interpolatable;
 import edu.wpi.first.math.numbers.N3;
-import edu.wpi.first.units.Distance;
-import edu.wpi.first.units.Measure;
+import edu.wpi.first.units.measure.Distance;
 import edu.wpi.first.util.protobuf.ProtobufSerializable;
 import edu.wpi.first.util.struct.StructSerializable;
 import java.util.Objects;
@@ -89,7 +88,7 @@ public Translation3d(double distance, Rotation3d angle) {
    * @param y The y component of the translation.
    * @param z The z component of the translation.
    */
-  public Translation3d(Measure<Distance> x, Measure<Distance> y, Measure<Distance> z) {
+  public Translation3d(Distance x, Distance y, Distance z) {
     this(x.in(Meters), y.in(Meters), z.in(Meters));
   }
 
diff --git a/wpimath/src/main/java/edu/wpi/first/math/kinematics/ChassisSpeeds.java b/wpimath/src/main/java/edu/wpi/first/math/kinematics/ChassisSpeeds.java
index 44628733e32..4c806a52cb7 100644
--- a/wpimath/src/main/java/edu/wpi/first/math/kinematics/ChassisSpeeds.java
+++ b/wpimath/src/main/java/edu/wpi/first/math/kinematics/ChassisSpeeds.java
@@ -14,11 +14,9 @@
 import edu.wpi.first.math.geometry.Twist2d;
 import edu.wpi.first.math.kinematics.proto.ChassisSpeedsProto;
 import edu.wpi.first.math.kinematics.struct.ChassisSpeedsStruct;
-import edu.wpi.first.units.Angle;
-import edu.wpi.first.units.Distance;
-import edu.wpi.first.units.Measure;
-import edu.wpi.first.units.Time;
-import edu.wpi.first.units.Velocity;
+import edu.wpi.first.units.measure.AngularVelocity;
+import edu.wpi.first.units.measure.LinearVelocity;
+import edu.wpi.first.units.measure.Time;
 import edu.wpi.first.util.protobuf.ProtobufSerializable;
 import edu.wpi.first.util.struct.StructSerializable;
 import java.util.Objects;
@@ -72,10 +70,7 @@ public ChassisSpeeds(
    * @param vy Sideways velocity.
    * @param omega Angular velocity.
    */
-  public ChassisSpeeds(
-      Measure<Velocity<Distance>> vx,
-      Measure<Velocity<Distance>> vy,
-      Measure<Velocity<Angle>> omega) {
+  public ChassisSpeeds(LinearVelocity vx, LinearVelocity vy, AngularVelocity omega) {
     this(vx.in(MetersPerSecond), vy.in(MetersPerSecond), omega.in(RadiansPerSecond));
   }
 
@@ -148,10 +143,7 @@ public static ChassisSpeeds discretize(
    * @return Discretized ChassisSpeeds.
    */
   public static ChassisSpeeds discretize(
-      Measure<Velocity<Distance>> vx,
-      Measure<Velocity<Distance>> vy,
-      Measure<Velocity<Angle>> omega,
-      Measure<Time> dt) {
+      LinearVelocity vx, LinearVelocity vy, AngularVelocity omega, Time dt) {
     return discretize(
         vx.in(MetersPerSecond), vy.in(MetersPerSecond), omega.in(RadiansPerSecond), dt.in(Seconds));
   }
@@ -219,10 +211,7 @@ public static ChassisSpeeds fromFieldRelativeSpeeds(
    * @return ChassisSpeeds object representing the speeds in the robot's frame of reference.
    */
   public static ChassisSpeeds fromFieldRelativeSpeeds(
-      Measure<Velocity<Distance>> vx,
-      Measure<Velocity<Distance>> vy,
-      Measure<Velocity<Angle>> omega,
-      Rotation2d robotAngle) {
+      LinearVelocity vx, LinearVelocity vy, AngularVelocity omega, Rotation2d robotAngle) {
     return fromFieldRelativeSpeeds(
         vx.in(MetersPerSecond), vy.in(MetersPerSecond), omega.in(RadiansPerSecond), robotAngle);
   }
@@ -287,10 +276,7 @@ public static ChassisSpeeds fromRobotRelativeSpeeds(
    * @return ChassisSpeeds object representing the speeds in the field's frame of reference.
    */
   public static ChassisSpeeds fromRobotRelativeSpeeds(
-      Measure<Velocity<Distance>> vx,
-      Measure<Velocity<Distance>> vy,
-      Measure<Velocity<Angle>> omega,
-      Rotation2d robotAngle) {
+      LinearVelocity vx, LinearVelocity vy, AngularVelocity omega, Rotation2d robotAngle) {
     return fromRobotRelativeSpeeds(
         vx.in(MetersPerSecond), vy.in(MetersPerSecond), omega.in(RadiansPerSecond), robotAngle);
   }
diff --git a/wpimath/src/main/java/edu/wpi/first/math/kinematics/DifferentialDriveKinematics.java b/wpimath/src/main/java/edu/wpi/first/math/kinematics/DifferentialDriveKinematics.java
index c8a443904f6..ffa24cd9ba9 100644
--- a/wpimath/src/main/java/edu/wpi/first/math/kinematics/DifferentialDriveKinematics.java
+++ b/wpimath/src/main/java/edu/wpi/first/math/kinematics/DifferentialDriveKinematics.java
@@ -11,8 +11,7 @@
 import edu.wpi.first.math.geometry.Twist2d;
 import edu.wpi.first.math.kinematics.proto.DifferentialDriveKinematicsProto;
 import edu.wpi.first.math.kinematics.struct.DifferentialDriveKinematicsStruct;
-import edu.wpi.first.units.Distance;
-import edu.wpi.first.units.Measure;
+import edu.wpi.first.units.measure.Distance;
 import edu.wpi.first.util.protobuf.ProtobufSerializable;
 import edu.wpi.first.util.struct.StructSerializable;
 
@@ -58,7 +57,7 @@ public DifferentialDriveKinematics(double trackWidthMeters) {
    *     between the left wheels and right wheels. However, the empirical value may be larger than
    *     the physical measured value due to scrubbing effects.
    */
-  public DifferentialDriveKinematics(Measure<Distance> trackWidth) {
+  public DifferentialDriveKinematics(Distance trackWidth) {
     this(trackWidth.in(Meters));
   }
 
diff --git a/wpimath/src/main/java/edu/wpi/first/math/kinematics/DifferentialDriveOdometry.java b/wpimath/src/main/java/edu/wpi/first/math/kinematics/DifferentialDriveOdometry.java
index ad2199e4b98..46fb3950638 100644
--- a/wpimath/src/main/java/edu/wpi/first/math/kinematics/DifferentialDriveOdometry.java
+++ b/wpimath/src/main/java/edu/wpi/first/math/kinematics/DifferentialDriveOdometry.java
@@ -10,8 +10,7 @@
 import edu.wpi.first.math.MathUsageId;
 import edu.wpi.first.math.geometry.Pose2d;
 import edu.wpi.first.math.geometry.Rotation2d;
-import edu.wpi.first.units.Distance;
-import edu.wpi.first.units.Measure;
+import edu.wpi.first.units.measure.Distance;
 
 /**
  * Class for differential drive odometry. Odometry allows you to track the robot's position on the
@@ -55,8 +54,8 @@ public DifferentialDriveOdometry(
    */
   public DifferentialDriveOdometry(
       Rotation2d gyroAngle,
-      Measure<Distance> leftDistance,
-      Measure<Distance> rightDistance,
+      Distance leftDistance,
+      Distance rightDistance,
       Pose2d initialPoseMeters) {
     this(gyroAngle, leftDistance.in(Meters), rightDistance.in(Meters), initialPoseMeters);
   }
@@ -81,7 +80,7 @@ public DifferentialDriveOdometry(
    * @param rightDistance The distance traveled by the right encoder.
    */
   public DifferentialDriveOdometry(
-      Rotation2d gyroAngle, Measure<Distance> leftDistance, Measure<Distance> rightDistance) {
+      Rotation2d gyroAngle, Distance leftDistance, Distance rightDistance) {
     this(gyroAngle, leftDistance, rightDistance, Pose2d.kZero);
   }
 
@@ -119,10 +118,7 @@ public void resetPosition(
    * @param poseMeters The position on the field that your robot is at.
    */
   public void resetPosition(
-      Rotation2d gyroAngle,
-      Measure<Distance> leftDistance,
-      Measure<Distance> rightDistance,
-      Pose2d poseMeters) {
+      Rotation2d gyroAngle, Distance leftDistance, Distance rightDistance, Pose2d poseMeters) {
     resetPosition(gyroAngle, leftDistance.in(Meters), rightDistance.in(Meters), poseMeters);
   }
 
diff --git a/wpimath/src/main/java/edu/wpi/first/math/kinematics/DifferentialDriveWheelPositions.java b/wpimath/src/main/java/edu/wpi/first/math/kinematics/DifferentialDriveWheelPositions.java
index 24f3070847d..b4503e6480f 100644
--- a/wpimath/src/main/java/edu/wpi/first/math/kinematics/DifferentialDriveWheelPositions.java
+++ b/wpimath/src/main/java/edu/wpi/first/math/kinematics/DifferentialDriveWheelPositions.java
@@ -10,8 +10,7 @@
 import edu.wpi.first.math.interpolation.Interpolatable;
 import edu.wpi.first.math.kinematics.proto.DifferentialDriveWheelPositionsProto;
 import edu.wpi.first.math.kinematics.struct.DifferentialDriveWheelPositionsStruct;
-import edu.wpi.first.units.Distance;
-import edu.wpi.first.units.Measure;
+import edu.wpi.first.units.measure.Distance;
 import java.util.Objects;
 
 /** Represents the wheel positions for a differential drive drivetrain. */
@@ -48,7 +47,7 @@ public DifferentialDriveWheelPositions(double leftMeters, double rightMeters) {
    * @param left Distance measured by the left side.
    * @param right Distance measured by the right side.
    */
-  public DifferentialDriveWheelPositions(Measure<Distance> left, Measure<Distance> right) {
+  public DifferentialDriveWheelPositions(Distance left, Distance right) {
     this(left.in(Meters), right.in(Meters));
   }
 
diff --git a/wpimath/src/main/java/edu/wpi/first/math/kinematics/DifferentialDriveWheelSpeeds.java b/wpimath/src/main/java/edu/wpi/first/math/kinematics/DifferentialDriveWheelSpeeds.java
index de188179534..6796fabb1e2 100644
--- a/wpimath/src/main/java/edu/wpi/first/math/kinematics/DifferentialDriveWheelSpeeds.java
+++ b/wpimath/src/main/java/edu/wpi/first/math/kinematics/DifferentialDriveWheelSpeeds.java
@@ -8,9 +8,7 @@
 
 import edu.wpi.first.math.kinematics.proto.DifferentialDriveWheelSpeedsProto;
 import edu.wpi.first.math.kinematics.struct.DifferentialDriveWheelSpeedsStruct;
-import edu.wpi.first.units.Distance;
-import edu.wpi.first.units.Measure;
-import edu.wpi.first.units.Velocity;
+import edu.wpi.first.units.measure.LinearVelocity;
 import edu.wpi.first.util.protobuf.ProtobufSerializable;
 import edu.wpi.first.util.struct.StructSerializable;
 
@@ -50,8 +48,7 @@ public DifferentialDriveWheelSpeeds(double leftMetersPerSecond, double rightMete
    * @param left The left speed.
    * @param right The right speed.
    */
-  public DifferentialDriveWheelSpeeds(
-      Measure<Velocity<Distance>> left, Measure<Velocity<Distance>> right) {
+  public DifferentialDriveWheelSpeeds(LinearVelocity left, LinearVelocity right) {
     this(left.in(MetersPerSecond), right.in(MetersPerSecond));
   }
 
@@ -85,7 +82,7 @@ public void desaturate(double attainableMaxSpeedMetersPerSecond) {
    *
    * @param attainableMaxSpeed The absolute max speed that a wheel can reach.
    */
-  public void desaturate(Measure<Velocity<Distance>> attainableMaxSpeed) {
+  public void desaturate(LinearVelocity attainableMaxSpeed) {
     desaturate(attainableMaxSpeed.in(MetersPerSecond));
   }
 
diff --git a/wpimath/src/main/java/edu/wpi/first/math/kinematics/MecanumDriveWheelPositions.java b/wpimath/src/main/java/edu/wpi/first/math/kinematics/MecanumDriveWheelPositions.java
index 1dc14a82928..284c4d3f859 100644
--- a/wpimath/src/main/java/edu/wpi/first/math/kinematics/MecanumDriveWheelPositions.java
+++ b/wpimath/src/main/java/edu/wpi/first/math/kinematics/MecanumDriveWheelPositions.java
@@ -10,8 +10,7 @@
 import edu.wpi.first.math.interpolation.Interpolatable;
 import edu.wpi.first.math.kinematics.proto.MecanumDriveWheelPositionsProto;
 import edu.wpi.first.math.kinematics.struct.MecanumDriveWheelPositionsStruct;
-import edu.wpi.first.units.Distance;
-import edu.wpi.first.units.Measure;
+import edu.wpi.first.units.measure.Distance;
 import edu.wpi.first.util.protobuf.ProtobufSerializable;
 import edu.wpi.first.util.struct.StructSerializable;
 import java.util.Objects;
@@ -71,10 +70,7 @@ public MecanumDriveWheelPositions(
    * @param rearRight Distance measured by the rear right wheel.
    */
   public MecanumDriveWheelPositions(
-      Measure<Distance> frontLeft,
-      Measure<Distance> frontRight,
-      Measure<Distance> rearLeft,
-      Measure<Distance> rearRight) {
+      Distance frontLeft, Distance frontRight, Distance rearLeft, Distance rearRight) {
     this(frontLeft.in(Meters), frontRight.in(Meters), rearLeft.in(Meters), rearRight.in(Meters));
   }
 
diff --git a/wpimath/src/main/java/edu/wpi/first/math/kinematics/MecanumDriveWheelSpeeds.java b/wpimath/src/main/java/edu/wpi/first/math/kinematics/MecanumDriveWheelSpeeds.java
index 59a34558a1d..4240b9f5397 100644
--- a/wpimath/src/main/java/edu/wpi/first/math/kinematics/MecanumDriveWheelSpeeds.java
+++ b/wpimath/src/main/java/edu/wpi/first/math/kinematics/MecanumDriveWheelSpeeds.java
@@ -8,9 +8,7 @@
 
 import edu.wpi.first.math.kinematics.proto.MecanumDriveWheelSpeedsProto;
 import edu.wpi.first.math.kinematics.struct.MecanumDriveWheelSpeedsStruct;
-import edu.wpi.first.units.Distance;
-import edu.wpi.first.units.Measure;
-import edu.wpi.first.units.Velocity;
+import edu.wpi.first.units.measure.LinearVelocity;
 import edu.wpi.first.util.protobuf.ProtobufSerializable;
 import edu.wpi.first.util.struct.StructSerializable;
 
@@ -65,10 +63,10 @@ public MecanumDriveWheelSpeeds(
    * @param rearRight Speed of the rear right wheel.
    */
   public MecanumDriveWheelSpeeds(
-      Measure<Velocity<Distance>> frontLeft,
-      Measure<Velocity<Distance>> frontRight,
-      Measure<Velocity<Distance>> rearLeft,
-      Measure<Velocity<Distance>> rearRight) {
+      LinearVelocity frontLeft,
+      LinearVelocity frontRight,
+      LinearVelocity rearLeft,
+      LinearVelocity rearRight) {
     this(
         frontLeft.in(MetersPerSecond),
         frontRight.in(MetersPerSecond),
@@ -114,7 +112,7 @@ public void desaturate(double attainableMaxSpeedMetersPerSecond) {
    *
    * @param attainableMaxSpeed The absolute max speed that a wheel can reach.
    */
-  public void desaturate(Measure<Velocity<Distance>> attainableMaxSpeed) {
+  public void desaturate(LinearVelocity attainableMaxSpeed) {
     desaturate(attainableMaxSpeed.in(MetersPerSecond));
   }
 
diff --git a/wpimath/src/main/java/edu/wpi/first/math/kinematics/SwerveDriveKinematics.java b/wpimath/src/main/java/edu/wpi/first/math/kinematics/SwerveDriveKinematics.java
index 99dd85d9873..a5205dcfc74 100644
--- a/wpimath/src/main/java/edu/wpi/first/math/kinematics/SwerveDriveKinematics.java
+++ b/wpimath/src/main/java/edu/wpi/first/math/kinematics/SwerveDriveKinematics.java
@@ -14,10 +14,8 @@
 import edu.wpi.first.math.geometry.Twist2d;
 import edu.wpi.first.math.kinematics.proto.SwerveDriveKinematicsProto;
 import edu.wpi.first.math.kinematics.struct.SwerveDriveKinematicsStruct;
-import edu.wpi.first.units.Angle;
-import edu.wpi.first.units.Distance;
-import edu.wpi.first.units.Measure;
-import edu.wpi.first.units.Velocity;
+import edu.wpi.first.units.measure.AngularVelocity;
+import edu.wpi.first.units.measure.LinearVelocity;
 import edu.wpi.first.util.protobuf.ProtobufSerializable;
 import edu.wpi.first.util.struct.Struct;
 import edu.wpi.first.util.struct.StructSerializable;
@@ -307,7 +305,7 @@ public static void desaturateWheelSpeeds(
    * @param attainableMaxSpeed The absolute max speed that a module can reach.
    */
   public static void desaturateWheelSpeeds(
-      SwerveModuleState[] moduleStates, Measure<Velocity<Distance>> attainableMaxSpeed) {
+      SwerveModuleState[] moduleStates, LinearVelocity attainableMaxSpeed) {
     desaturateWheelSpeeds(moduleStates, attainableMaxSpeed.in(MetersPerSecond));
   }
 
@@ -379,9 +377,9 @@ public static void desaturateWheelSpeeds(
   public static void desaturateWheelSpeeds(
       SwerveModuleState[] moduleStates,
       ChassisSpeeds desiredChassisSpeed,
-      Measure<Velocity<Distance>> attainableMaxModuleSpeed,
-      Measure<Velocity<Distance>> attainableMaxTranslationalSpeed,
-      Measure<Velocity<Angle>> attainableMaxRotationalVelocity) {
+      LinearVelocity attainableMaxModuleSpeed,
+      LinearVelocity attainableMaxTranslationalSpeed,
+      AngularVelocity attainableMaxRotationalVelocity) {
     desaturateWheelSpeeds(
         moduleStates,
         desiredChassisSpeed,
diff --git a/wpimath/src/main/java/edu/wpi/first/math/kinematics/SwerveModulePosition.java b/wpimath/src/main/java/edu/wpi/first/math/kinematics/SwerveModulePosition.java
index 7923a0312b2..a081a702498 100644
--- a/wpimath/src/main/java/edu/wpi/first/math/kinematics/SwerveModulePosition.java
+++ b/wpimath/src/main/java/edu/wpi/first/math/kinematics/SwerveModulePosition.java
@@ -11,8 +11,7 @@
 import edu.wpi.first.math.interpolation.Interpolatable;
 import edu.wpi.first.math.kinematics.proto.SwerveModulePositionProto;
 import edu.wpi.first.math.kinematics.struct.SwerveModulePositionStruct;
-import edu.wpi.first.units.Distance;
-import edu.wpi.first.units.Measure;
+import edu.wpi.first.units.measure.Distance;
 import edu.wpi.first.util.protobuf.ProtobufSerializable;
 import edu.wpi.first.util.struct.StructSerializable;
 import java.util.Objects;
@@ -55,7 +54,7 @@ public SwerveModulePosition(double distanceMeters, Rotation2d angle) {
    * @param distance The distance measured by the wheel of the module.
    * @param angle The angle of the module.
    */
-  public SwerveModulePosition(Measure<Distance> distance, Rotation2d angle) {
+  public SwerveModulePosition(Distance distance, Rotation2d angle) {
     this(distance.in(Meters), angle);
   }
 
diff --git a/wpimath/src/main/java/edu/wpi/first/math/kinematics/SwerveModuleState.java b/wpimath/src/main/java/edu/wpi/first/math/kinematics/SwerveModuleState.java
index 70d52da96dc..8d30494d526 100644
--- a/wpimath/src/main/java/edu/wpi/first/math/kinematics/SwerveModuleState.java
+++ b/wpimath/src/main/java/edu/wpi/first/math/kinematics/SwerveModuleState.java
@@ -9,9 +9,7 @@
 import edu.wpi.first.math.geometry.Rotation2d;
 import edu.wpi.first.math.kinematics.proto.SwerveModuleStateProto;
 import edu.wpi.first.math.kinematics.struct.SwerveModuleStateStruct;
-import edu.wpi.first.units.Distance;
-import edu.wpi.first.units.Measure;
-import edu.wpi.first.units.Velocity;
+import edu.wpi.first.units.measure.LinearVelocity;
 import edu.wpi.first.util.protobuf.ProtobufSerializable;
 import edu.wpi.first.util.struct.StructSerializable;
 import java.util.Objects;
@@ -51,7 +49,7 @@ public SwerveModuleState(double speedMetersPerSecond, Rotation2d angle) {
    * @param speed The speed of the wheel of the module.
    * @param angle The angle of the module.
    */
-  public SwerveModuleState(Measure<Velocity<Distance>> speed, Rotation2d angle) {
+  public SwerveModuleState(LinearVelocity speed, Rotation2d angle) {
     this(speed.in(MetersPerSecond), angle);
   }
 
diff --git a/wpimath/src/main/java/edu/wpi/first/math/trajectory/TrajectoryConfig.java b/wpimath/src/main/java/edu/wpi/first/math/trajectory/TrajectoryConfig.java
index 931efe5aab8..1bcb15f8b56 100644
--- a/wpimath/src/main/java/edu/wpi/first/math/trajectory/TrajectoryConfig.java
+++ b/wpimath/src/main/java/edu/wpi/first/math/trajectory/TrajectoryConfig.java
@@ -14,9 +14,8 @@
 import edu.wpi.first.math.trajectory.constraint.MecanumDriveKinematicsConstraint;
 import edu.wpi.first.math.trajectory.constraint.SwerveDriveKinematicsConstraint;
 import edu.wpi.first.math.trajectory.constraint.TrajectoryConstraint;
-import edu.wpi.first.units.Distance;
-import edu.wpi.first.units.Measure;
-import edu.wpi.first.units.Velocity;
+import edu.wpi.first.units.measure.LinearAcceleration;
+import edu.wpi.first.units.measure.LinearVelocity;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -55,9 +54,7 @@ public TrajectoryConfig(
    * @param maxVelocity The max velocity for the trajectory.
    * @param maxAcceleration The max acceleration for the trajectory.
    */
-  public TrajectoryConfig(
-      Measure<Velocity<Distance>> maxVelocity,
-      Measure<Velocity<Velocity<Distance>>> maxAcceleration) {
+  public TrajectoryConfig(LinearVelocity maxVelocity, LinearAcceleration maxAcceleration) {
     this(maxVelocity.in(MetersPerSecond), maxAcceleration.in(MetersPerSecondPerSecond));
   }
 
@@ -145,7 +142,7 @@ public TrajectoryConfig setStartVelocity(double startVelocityMetersPerSecond) {
    * @param startVelocity The start velocity of the trajectory.
    * @return Instance of the current config object.
    */
-  public TrajectoryConfig setStartVelocity(Measure<Velocity<Distance>> startVelocity) {
+  public TrajectoryConfig setStartVelocity(LinearVelocity startVelocity) {
     return setStartVelocity(startVelocity.in(MetersPerSecond));
   }
 
@@ -175,7 +172,7 @@ public TrajectoryConfig setEndVelocity(double endVelocityMetersPerSecond) {
    * @param endVelocity The end velocity of the trajectory.
    * @return Instance of the current config object.
    */
-  public TrajectoryConfig setEndVelocity(Measure<Velocity<Distance>> endVelocity) {
+  public TrajectoryConfig setEndVelocity(LinearVelocity endVelocity) {
     return setEndVelocity(endVelocity.in(MetersPerSecond));
   }
 
diff --git a/wpimath/src/main/java/edu/wpi/first/math/trajectory/TrapezoidProfile.java b/wpimath/src/main/java/edu/wpi/first/math/trajectory/TrapezoidProfile.java
index 234d725f003..a7ead1bc9c8 100644
--- a/wpimath/src/main/java/edu/wpi/first/math/trajectory/TrapezoidProfile.java
+++ b/wpimath/src/main/java/edu/wpi/first/math/trajectory/TrapezoidProfile.java
@@ -7,8 +7,9 @@
 import edu.wpi.first.math.MathSharedStore;
 import edu.wpi.first.math.MathUsageId;
 import edu.wpi.first.units.Measure;
+import edu.wpi.first.units.PerUnit;
+import edu.wpi.first.units.TimeUnit;
 import edu.wpi.first.units.Unit;
-import edu.wpi.first.units.Velocity;
 import java.util.Objects;
 
 /**
@@ -79,8 +80,10 @@ public Constraints(double maxVelocity, double maxAcceleration) {
      * @param maxVelocity maximum velocity
      * @param maxAcceleration maximum acceleration
      */
-    public <U extends Unit<U>> Constraints(
-        Measure<Velocity<U>> maxVelocity, Measure<Velocity<Velocity<U>>> maxAcceleration) {
+    public <U extends Unit> Constraints(
+        Measure<? extends PerUnit<? extends U, TimeUnit>> maxVelocity,
+        Measure<? extends PerUnit<? extends PerUnit<? extends U, TimeUnit>, TimeUnit>>
+            maxAcceleration) {
       this(maxVelocity.baseUnitMagnitude(), maxAcceleration.baseUnitMagnitude());
     }
   }
@@ -114,7 +117,8 @@ public State(double position, double velocity) {
      * @param position The position at this state.
      * @param velocity The velocity at this state.
      */
-    public <U extends Unit<U>> State(Measure<U> position, Measure<Velocity<U>> velocity) {
+    public <U extends Unit> State(
+        Measure<U> position, Measure<? extends PerUnit<? extends U, TimeUnit>> velocity) {
       this(position.baseUnitMagnitude(), velocity.baseUnitMagnitude());
     }
 
diff --git a/wpimath/src/test/java/edu/wpi/first/math/controller/SimpleMotorFeedforwardTest.java b/wpimath/src/test/java/edu/wpi/first/math/controller/SimpleMotorFeedforwardTest.java
index 0f4edf75d4c..1fd6f58d25f 100644
--- a/wpimath/src/test/java/edu/wpi/first/math/controller/SimpleMotorFeedforwardTest.java
+++ b/wpimath/src/test/java/edu/wpi/first/math/controller/SimpleMotorFeedforwardTest.java
@@ -13,7 +13,6 @@
 import edu.wpi.first.math.Nat;
 import edu.wpi.first.math.VecBuilder;
 import edu.wpi.first.math.numbers.N1;
-import edu.wpi.first.units.MutableMeasure;
 import org.junit.jupiter.api.Test;
 
 class SimpleMotorFeedforwardTest {
@@ -32,8 +31,8 @@ void testCalculate() {
 
     var r = VecBuilder.fill(2.0);
     var nextR = VecBuilder.fill(3.0);
-    var currentVelocity = MutableMeasure.ofBaseUnits(2.0, RadiansPerSecond);
-    var nextVelocity = MutableMeasure.ofBaseUnits(3.0, RadiansPerSecond);
+    var currentVelocity = RadiansPerSecond.mutable(2.0);
+    var nextVelocity = RadiansPerSecond.mutable(3.0);
 
     assertEquals(
         37.52499583432516 + 0.5,
diff --git a/wpimath/src/test/java/edu/wpi/first/math/kinematics/ChassisSpeedsTest.java b/wpimath/src/test/java/edu/wpi/first/math/kinematics/ChassisSpeedsTest.java
index d5d81858cb3..8f7bb6fd123 100644
--- a/wpimath/src/test/java/edu/wpi/first/math/kinematics/ChassisSpeedsTest.java
+++ b/wpimath/src/test/java/edu/wpi/first/math/kinematics/ChassisSpeedsTest.java
@@ -49,7 +49,7 @@ void testDiscretize() {
   @Test
   void testMeasureConstructor() {
     var vx = InchesPerSecond.of(14.52);
-    var vy = InchesPerSecond.zero();
+    var vy = InchesPerSecond.of(0);
     var omega = RPM.of(0.02);
     var speeds = new ChassisSpeeds(vx, vy, omega);
 
diff --git a/wpimath/src/test/java/edu/wpi/first/math/trajectory/ExponentialProfileTest.java b/wpimath/src/test/java/edu/wpi/first/math/trajectory/ExponentialProfileTest.java
index 6a987d47445..80d6abb41cb 100644
--- a/wpimath/src/test/java/edu/wpi/first/math/trajectory/ExponentialProfileTest.java
+++ b/wpimath/src/test/java/edu/wpi/first/math/trajectory/ExponentialProfileTest.java
@@ -11,7 +11,6 @@
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import edu.wpi.first.math.controller.SimpleMotorFeedforward;
-import edu.wpi.first.units.MutableMeasure;
 import java.util.List;
 import org.junit.jupiter.api.Test;
 
@@ -45,8 +44,8 @@ private static void assertNear(
   private static ExponentialProfile.State checkDynamics(
       ExponentialProfile profile, ExponentialProfile.State current, ExponentialProfile.State goal) {
     var next = profile.calculate(kDt, current, goal);
-    var currentVelocity = MutableMeasure.ofBaseUnits(current.velocity, RadiansPerSecond);
-    var nextVelocity = MutableMeasure.ofBaseUnits(next.velocity, RadiansPerSecond);
+    var currentVelocity = RadiansPerSecond.mutable(current.velocity);
+    var nextVelocity = RadiansPerSecond.mutable(next.velocity);
     var signal = feedforward.calculate(currentVelocity, nextVelocity);
 
     assertTrue(Math.abs(signal.magnitude()) < constraints.maxInput + 1e-9);
diff --git a/wpiunits/CMakeLists.txt b/wpiunits/CMakeLists.txt
index 1bfa329089d..df2964a175f 100644
--- a/wpiunits/CMakeLists.txt
+++ b/wpiunits/CMakeLists.txt
@@ -4,7 +4,7 @@ project(wpiunits)
 if(WITH_JAVA)
     include(UseJava)
 
-    file(GLOB_RECURSE JAVA_SOURCES src/main/java/*.java)
+    file(GLOB_RECURSE JAVA_SOURCES src/main/java/*.java src/generated/main/java/*.java)
 
     add_jar(
         wpiunits_jar
@@ -24,7 +24,9 @@ if(WITH_JAVA_SOURCE)
     include(CreateSourceJar)
     add_source_jar(
         wpiunits_src_jar
-        BASE_DIRECTORIES ${CMAKE_CURRENT_SOURCE_DIR}/src/main/java
+        BASE_DIRECTORIES
+            ${CMAKE_CURRENT_SOURCE_DIR}/src/main/java
+            ${CMAKE_CURRENT_SOURCE_DIR}/src/generated/main/java
         OUTPUT_NAME wpiunits-sources
     )
     set_property(TARGET wpiunits_src_jar PROPERTY FOLDER "java")
diff --git a/wpiunits/build.gradle b/wpiunits/build.gradle
index e10033df6af..e6b23385757 100644
--- a/wpiunits/build.gradle
+++ b/wpiunits/build.gradle
@@ -12,3 +12,5 @@ apply from: "${rootDir}/shared/java/javacommon.gradle"
 
 dependencies {
 }
+
+sourceSets.main.java.srcDir "${projectDir}/src/generated/main/java"
diff --git a/wpiunits/generate_units.py b/wpiunits/generate_units.py
new file mode 100755
index 00000000000..2aebf286c22
--- /dev/null
+++ b/wpiunits/generate_units.py
@@ -0,0 +1,362 @@
+#!/usr/bin/env python3
+
+# 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 script generates unit-specific interfaces and mutable and immutable implementations of
+# those interfaces.
+# Generated files will be located in wpiunits/src/generated/main/
+
+import inspect
+import os
+import re
+from jinja2 import Environment, FileSystemLoader
+
+
+def output(outPath, outfn, contents):
+    if not os.path.exists(outPath):
+        os.makedirs(outPath)
+
+    outpathname = f"{outPath}/{outfn}"
+
+    if os.path.exists(outpathname):
+        with open(outpathname, "r") as f:
+            if f.read() == contents:
+                return
+
+    # File either doesn't exist or has different contents
+    with open(outpathname, "w", newline="\n") as f:
+        f.write(contents)
+
+
+# The units for which multiply and divide mathematical operations are defined
+MATH_OPERATION_UNITS = [
+    "Acceleration<?>",
+    "Angle",
+    "AngularAcceleration",
+    "AngularMomentum",
+    "AngularVelocity",
+    "Current",
+    "Dimensionless",
+    "Distance",
+    "Energy",
+    "Force",
+    "Frequency",
+    "LinearAcceleration",
+    "LinearMomentum",
+    "LinearVelocity",
+    "Mass",
+    "MomentOfInertia",
+    "Mult<?, ?>",
+    "Per<?, ?>",
+    "Power",
+    "Temperature",
+    "Time",
+    "Torque",
+    "Velocity<?>",
+    "Voltage",
+]
+
+# Configurations for all generated units
+UNIT_CONFIGURATIONS = {
+    "Acceleration": {
+        "base_unit": "unit()",
+        "generics": {"D": {"extends": "Unit"}},
+        "multiply": {},
+        "divide": {},
+    },
+    "Angle": {
+        "base_unit": "Radians",
+        "multiply": {"Frequency": "AngularVelocity"},
+        "divide": {"Time": "AngularVelocity"},
+    },
+    "AngularAcceleration": {
+        "base_unit": "RadiansPerSecondPerSecond",
+        "multiply": {"Time": "AngularVelocity"},
+        "divide": {"Frequency": "AngularVelocity"},
+    },
+    "AngularMomentum": {
+        "base_unit": "KilogramMetersSquaredPerSecond",
+        "multiply": {},
+        "divide": {"AngularVelocity": "MomentOfInertia"},
+    },
+    "AngularVelocity": {
+        "base_unit": "RadiansPerSecond",
+        "multiply": {"Time": "Angle", "Frequency": "AngularAcceleration"},
+        "divide": {"Time": "AngularAcceleration"},
+        "extra": inspect.cleandoc(
+            """
+          default Frequency asFrequency() { return Hertz.of(baseUnitMagnitude()); }
+        """
+        ),
+    },
+    "Current": {"base_unit": "Amps", "multiply": {"Voltage": "Power"}, "divide": {}},
+    "Dimensionless": {
+        "base_unit": "Value",
+        "multiply": {
+            "Angle": "Angle",
+            "AngularAcceleration": "AngularAcceleration",
+            "AngularMomentum": "AngularMomentum",
+            "AngularVelocity": "AngularVelocity",
+            "Current": "Current",
+            "Dimensionless": "Dimensionless",
+            "Distance": "Distance",
+            "Energy": "Energy",
+            "Force": "Force",
+            "Frequency": "Frequency",
+            "LinearAcceleration": "LinearAcceleration",
+            "LinearMomentum": "LinearMomentum",
+            "LinearVelocity": "LinearVelocity",
+            "Mass": "Mass",
+            "MomentOfInertia": "MomentOfInertia",
+            "Power": "Power",
+            "Temperature": "Temperature",
+            "Time": "Time",
+            "Torque": "Torque",
+            "Voltage": "Voltage",
+        },
+        "divide": {
+            "Time": "Frequency",
+            # TODO:
+            # "AngularVelocity": "Per<TimeUnit, AngleUnit>",
+            # "AngularAcceleration": "Per<TimeUnit, AngularVelocityUnit>",
+            # "LinearVelocity": "Per<TimeUnit, DistanceUnit>",
+            # "LinearAcceleration": "Per<TimeUnit, LinearVelocityUnit>",
+            # "Velocity<?>": "Per<TimeUnit, ?>",
+            # "Acceleration<?>": "Per<TimeUnit, VelocityUnit<?>>
+            # "Per<N, D>": "Per<D, N>"
+        },
+    },
+    "Distance": {
+        "base_unit": "Meters",
+        "multiply": {
+            "Frequency": "LinearVelocity",
+            # Distance x Force = Torque
+            # Force x Distance = Energy
+            "Force": "Torque",
+        },
+        "divide": {"Time": "LinearVelocity", "LinearVelocity": "Time"},
+    },
+    "Energy": {
+        "base_unit": "Joules",
+        "multiply": {"Frequency": "Power"},
+        "divide": {"Time": "Power"},
+    },
+    "Force": {
+        "base_unit": "Newtons",
+        "multiply": {
+            # Distance x Force = Torque
+            # Force x Distance = Energy
+            "Distance": "Energy"
+        },
+        "divide": {"Mass": "LinearAcceleration", "LinearAcceleration": "Mass"},
+    },
+    "Frequency": {
+        "base_unit": "Hertz",
+        "multiply": {
+            "Time": "Dimensionless",
+            "Distance": "LinearVelocity",
+            "LinearVelocity": "LinearAcceleration",
+            "Angle": "AngularVelocity",
+            "AngularVelocity": "AngularAcceleration",
+        },
+        "divide": {},
+        "extra": inspect.cleandoc(
+            """
+          /** Converts this frequency to the time period between cycles. */
+          default Time asPeriod() { return Seconds.of(1 / baseUnitMagnitude()); }
+        """
+        ),
+    },
+    "LinearAcceleration": {
+        "base_unit": "MetersPerSecondPerSecond",
+        "multiply": {"Time": "LinearVelocity"},
+        "divide": {"Frequency": "LinearVelocity"},
+    },
+    "LinearMomentum": {
+        "base_unit": "KilogramMetersPerSecond",
+        "multiply": {"Frequency": "Force"},
+        "divide": {"Mass": "LinearVelocity", "LinearVelocity": "Mass", "Time": "Force"},
+    },
+    "LinearVelocity": {
+        "base_unit": "MetersPerSecond",
+        "multiply": {"Time": "Distance", "Frequency": "LinearAcceleration"},
+        "divide": {"Time": "LinearAcceleration"},
+    },
+    "Mass": {
+        "base_unit": "Kilograms",
+        "multiply": {"LinearAcceleration": "Force"},
+        "divide": {},
+    },
+    "MomentOfInertia": {
+        "base_unit": "KilogramSquareMeters",
+        "multiply": {"AngularVelocity": "AngularMomentum"},
+        "divide": {},
+    },
+    "Mult": {
+        "base_unit": "unit()",
+        "generics": {"A": {"extends": "Unit"}, "B": {"extends": "Unit"}},
+        "multiply": {},
+        "divide": {},
+    },
+    "Per": {
+        "base_unit": "unit()",
+        "generics": {"Dividend": {"extends": "Unit"}, "Divisor": {"extends": "Unit"}},
+        "multiply": {},
+        "divide": {},
+        "extra": inspect.cleandoc(
+            """
+          default Measure<Dividend> timesDivisor(Measure<? extends Divisor> multiplier) {
+            return (Measure<Dividend>) baseUnit().numerator().ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+          }
+
+          default 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());
+          }
+        """
+        ),
+    },
+    "Power": {
+        "base_unit": "Watts",
+        "multiply": {
+            "Time": "Energy",
+        },
+        "divide": {"Voltage": "Current", "Current": "Voltage", "Energy": "Frequency"},
+    },
+    "Temperature": {"base_unit": "Kelvin", "multiply": {}, "divide": {}},
+    "Time": {
+        "base_unit": "Seconds",
+        "multiply": {
+            "Frequency": "Dimensionless",
+            "AngularVelocity": "Angle",
+            "AngularAcceleration": "AngularVelocity",
+            "LinearVelocity": "Distance",
+            "LinearAcceleration": "LinearVelocity",
+            # TODO:
+            # "Acceleration<D>": "Velocity<D>"
+            # "Velocity<D>": "Measure<D>"
+        },
+        "divide": {
+            # Time specifically needs this to be called out so generated methods like
+            # `per(TimeUnit)` or `divide(Time)` will return dimensionless values instead of
+            # `Velocity<TimeUnit>` (i.e. a time per unit time ratio)
+            "Time": "Dimensionless"
+        },
+        "extra": inspect.cleandoc(
+            """
+          default Frequency asFrequency() { return Hertz.of(1 / baseUnitMagnitude()); }
+        """
+        ),
+    },
+    "Torque": {
+        "base_unit": "NewtonMeters",
+        "multiply": {},
+        "divide": {"Distance": "Force", "Force": "Distance"},
+    },
+    "Velocity": {
+        "base_unit": "unit()",
+        "generics": {"D": {"extends": "Unit"}},
+        "multiply": {},
+        "divide": {},
+    },
+    "Voltage": {"base_unit": "Volts", "multiply": {"Current": "Power"}, "divide": {}},
+}
+
+
+def generics_list(measure_name):
+    if "generics" in UNIT_CONFIGURATIONS[measure_name]:
+        args = []
+        for name, config in UNIT_CONFIGURATIONS[measure_name]["generics"].items():
+            if "extends" in config:
+                args.append("{} extends {}".format(name, config["extends"]))
+            elif "super" in config:
+                args.append("{} super {}".format(name, config["super"]))
+            else:
+                args.append(name)
+
+        return "<{}>".format(", ".join(args))
+    else:
+        return ""
+
+
+def generics_usage(measure_name):
+    if "generics" in UNIT_CONFIGURATIONS[measure_name]:
+        args = UNIT_CONFIGURATIONS[measure_name]["generics"].keys()
+
+        return "<{}>".format(", ".join(args))
+    else:
+        return ""
+
+
+def type_decl(measure_name):
+    return measure_name + generics_list(measure_name)
+
+
+def type_usage(measure_name):
+    return measure_name + generics_usage(measure_name)
+
+
+# measure-to-unit
+def mtou(measure_name):
+    if (
+        measure_name in UNIT_CONFIGURATIONS
+        and "generics" in UNIT_CONFIGURATIONS[measure_name]
+    ):
+        return "{}Unit{}".format(measure_name, generics_usage(measure_name))
+    else:
+        regex = re.compile(r"^(.*?)(<.*>)?$")
+        return re.sub(regex, "\\1Unit\\2", measure_name)
+
+
+def main():
+
+    dirname, _ = os.path.split(os.path.abspath(__file__))
+
+    env = Environment(
+        loader=FileSystemLoader(f"{dirname}/src/generate/main/java"),
+        autoescape=False,
+        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")
+    rootPath = f"{dirname}/src/generated/main/java/edu/wpi/first/units"
+
+    helpers = {
+        "type_decl": type_decl,
+        "type_usage": type_usage,
+        "generics_list": generics_list,
+        "generics_usage": generics_usage,
+        "mtou": mtou,
+    }
+
+    for unit_name in UNIT_CONFIGURATIONS:
+        interfaceContents = interfaceTemplate.render(
+            name=unit_name,
+            math_units=MATH_OPERATION_UNITS,
+            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(f"{rootPath}/measure", f"{unit_name}.java", interfaceContents)
+        output(f"{rootPath}/measure", f"Immutable{unit_name}.java", immutableContents)
+        output(f"{rootPath}/measure", f"Mut{unit_name}.java", mutableContents)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/wpiunits/src/generate/main/java/Measure-immutable.java.jinja b/wpiunits/src/generate/main/java/Measure-immutable.java.jinja
new file mode 100644
index 00000000000..526c9509778
--- /dev/null
+++ b/wpiunits/src/generate/main/java/Measure-immutable.java.jinja
@@ -0,0 +1,28 @@
+// 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-interface.java.jinja
new file mode 100644
index 00000000000..83c7025d9f1
--- /dev/null
+++ b/wpiunits/src/generate/main/java/Measure-interface.java.jinja
@@ -0,0 +1,117 @@
+// 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 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);
+  }
+
+  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);
+  }
+
+  @Override
+  {{ helpers['type_usage'](name) }} copy();
+
+  @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) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default {{ helpers['type_usage'](name) }} unaryMinus() {
+    return ({{ helpers['type_usage'](name) }}) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default {{ 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) {
+    return ({{ helpers['type_usage'](name) }}) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default {{ helpers['type_usage'](name) }} times(double multiplier) {
+    return ({{ helpers['type_usage'](name) }}) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default {{ helpers['type_usage'](name) }} divide(double divisor) {
+    return ({{ helpers['type_usage'](name) }}) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default {{ config[name]['divide']['Time'] or "Velocity<{}>".format(helpers['mtou'](name)) }} per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+{% for unit in math_units -%}
+{% if unit == "Dimensionless" %}
+  @Override
+  default {{ helpers['type_usage'](name) }} divide({{ unit }} divisor) {
+    return ({{ helpers['type_usage'](name) }}) {{ config[name]['base_unit'] }}.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default {{ helpers['type_usage'](name) }} times({{ unit }} multiplier) {
+    return ({{ helpers['type_usage'](name) }}) {{ config[name]['base_unit'] }}.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+{% else %}
+{% if unit in config[name]['multiply'] %}
+  @Override
+  default {{ config[name]['multiply'][unit] }} times({{ unit }} multiplier) {
+    return {{ config[config[name]['multiply'][unit]]['base_unit'] }}.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+{% else %}
+  @Override
+  default 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] }} divide({{ unit }} divisor) {
+    return {{ config[config[name]['divide'][unit]]['base_unit'] }}.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+{% elif unit == "Time" %}
+  @Override
+  default Velocity<{{ helpers['mtou'](name) }}> divide({{ unit }} divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+{% elif unit == name %}
+  @Override
+  default Dimensionless divide({{ unit }} divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+{% else %}
+  @Override
+  default Per<{{ helpers['mtou'](name) }}, {{ helpers['mtou'](unit) }}> divide({{ unit }} divisor) {
+    return (Per<{{ helpers['mtou'](name) }}, {{ helpers['mtou'](unit) }}>) Measure.super.divide(divisor);
+  }
+{% endif -%}
+{% endif -%}
+{% endfor -%}
+{{ config[name]['extra'] }}
+}
diff --git a/wpiunits/src/generate/main/java/Measure-mutable.java.jinja b/wpiunits/src/generate/main/java/Measure-mutable.java.jinja
new file mode 100644
index 00000000000..8adf22f74dd
--- /dev/null
+++ b/wpiunits/src/generate/main/java/Measure-mutable.java.jinja
@@ -0,0 +1,25 @@
+// 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
new file mode 100644
index 00000000000..f4ceb282439
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Acceleration.java
@@ -0,0 +1,334 @@
+// 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 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);
+  }
+
+  static <D extends Unit> Acceleration<D> ofBaseUnits(double baseUnitMagnitude, AccelerationUnit<D> unit) {
+    return new ImmutableAcceleration<D>(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Acceleration<D> copy();
+
+  @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) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Acceleration<D> unaryMinus() {
+    return (Acceleration<D>) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default 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) {
+    return (Acceleration<D>) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Acceleration<D> times(double multiplier) {
+    return (Acceleration<D>) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Acceleration<D> divide(double divisor) {
+    return (Acceleration<D>) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<AccelerationUnit<D>> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<AccelerationUnit<D>, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<AccelerationUnit<D>, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, AngleUnit> times(Angle multiplier) {
+    return (Mult<AccelerationUnit<D>, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, AngleUnit> divide(Angle divisor) {
+    return (Per<AccelerationUnit<D>, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<AccelerationUnit<D>, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<AccelerationUnit<D>, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<AccelerationUnit<D>, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<AccelerationUnit<D>, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<AccelerationUnit<D>, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<AccelerationUnit<D>, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, CurrentUnit> times(Current multiplier) {
+    return (Mult<AccelerationUnit<D>, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, CurrentUnit> divide(Current divisor) {
+    return (Per<AccelerationUnit<D>, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Acceleration<D> divide(Dimensionless divisor) {
+    return (Acceleration<D>) unit().of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Acceleration<D> times(Dimensionless multiplier) {
+    return (Acceleration<D>) unit().of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, DistanceUnit> times(Distance multiplier) {
+    return (Mult<AccelerationUnit<D>, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, DistanceUnit> divide(Distance divisor) {
+    return (Per<AccelerationUnit<D>, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, EnergyUnit> times(Energy multiplier) {
+    return (Mult<AccelerationUnit<D>, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, EnergyUnit> divide(Energy divisor) {
+    return (Per<AccelerationUnit<D>, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, ForceUnit> times(Force multiplier) {
+    return (Mult<AccelerationUnit<D>, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, ForceUnit> divide(Force divisor) {
+    return (Per<AccelerationUnit<D>, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<AccelerationUnit<D>, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<AccelerationUnit<D>, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<AccelerationUnit<D>, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<AccelerationUnit<D>, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<AccelerationUnit<D>, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<AccelerationUnit<D>, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<AccelerationUnit<D>, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<AccelerationUnit<D>, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, MassUnit> times(Mass multiplier) {
+    return (Mult<AccelerationUnit<D>, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, MassUnit> divide(Mass divisor) {
+    return (Per<AccelerationUnit<D>, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<AccelerationUnit<D>, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<AccelerationUnit<D>, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<AccelerationUnit<D>, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<AccelerationUnit<D>, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<AccelerationUnit<D>, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<AccelerationUnit<D>, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, PowerUnit> times(Power multiplier) {
+    return (Mult<AccelerationUnit<D>, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, PowerUnit> divide(Power divisor) {
+    return (Per<AccelerationUnit<D>, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<AccelerationUnit<D>, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<AccelerationUnit<D>, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, TimeUnit> times(Time multiplier) {
+    return (Mult<AccelerationUnit<D>, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Velocity<AccelerationUnit<D>> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, TorqueUnit> times(Torque multiplier) {
+    return (Mult<AccelerationUnit<D>, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, TorqueUnit> divide(Torque divisor) {
+    return (Per<AccelerationUnit<D>, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<AccelerationUnit<D>, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<AccelerationUnit<D>, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AccelerationUnit<D>, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<AccelerationUnit<D>, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AccelerationUnit<D>, VoltageUnit> divide(Voltage divisor) {
+    return (Per<AccelerationUnit<D>, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}
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
new file mode 100644
index 00000000000..c182d48f3c1
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Angle.java
@@ -0,0 +1,334 @@
+// 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 interface Angle extends Measure<AngleUnit> {
+  static  Angle ofRelativeUnits(double magnitude, AngleUnit unit) {
+    return new ImmutableAngle(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  Angle ofBaseUnits(double baseUnitMagnitude, AngleUnit unit) {
+    return new ImmutableAngle(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Angle copy();
+
+  @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) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Angle unaryMinus() {
+    return (Angle) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Angle plus(Measure<? extends AngleUnit> other) {
+    return (Angle) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Angle minus(Measure<? extends AngleUnit> other) {
+    return (Angle) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Angle times(double multiplier) {
+    return (Angle) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Angle divide(double divisor) {
+    return (Angle) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default AngularVelocity per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<AngleUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<AngleUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<AngleUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<AngleUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(Angle divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AngleUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<AngleUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<AngleUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<AngleUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<AngleUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<AngleUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<AngleUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<AngleUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<AngleUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Angle divide(Dimensionless divisor) {
+    return (Angle) Radians.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Angle times(Dimensionless multiplier) {
+    return (Angle) Radians.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AngleUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<AngleUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<AngleUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<AngleUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<AngleUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<AngleUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, ForceUnit> divide(Force divisor) {
+    return (Per<AngleUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default AngularVelocity times(Frequency multiplier) {
+    return RadiansPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<AngleUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<AngleUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<AngleUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<AngleUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<AngleUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<AngleUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<AngleUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<AngleUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<AngleUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, MassUnit> divide(Mass divisor) {
+    return (Per<AngleUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<AngleUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<AngleUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<AngleUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<AngleUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<AngleUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<AngleUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<AngleUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, PowerUnit> divide(Power divisor) {
+    return (Per<AngleUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<AngleUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<AngleUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, TimeUnit> times(Time multiplier) {
+    return (Mult<AngleUnit, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default AngularVelocity divide(Time divisor) {
+    return RadiansPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AngleUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<AngleUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<AngleUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<AngleUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<AngleUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngleUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<AngleUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngleUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<AngleUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}
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
new file mode 100644
index 00000000000..44ff1c395b1
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularAcceleration.java
@@ -0,0 +1,334 @@
+// 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 interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
+  static  AngularAcceleration ofRelativeUnits(double magnitude, AngularAccelerationUnit unit) {
+    return new ImmutableAngularAcceleration(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  AngularAcceleration ofBaseUnits(double baseUnitMagnitude, AngularAccelerationUnit unit) {
+    return new ImmutableAngularAcceleration(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  AngularAcceleration copy();
+
+  @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) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularAcceleration unaryMinus() {
+    return (AngularAcceleration) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularAcceleration plus(Measure<? extends AngularAccelerationUnit> other) {
+    return (AngularAcceleration) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularAcceleration minus(Measure<? extends AngularAccelerationUnit> other) {
+    return (AngularAcceleration) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularAcceleration times(double multiplier) {
+    return (AngularAcceleration) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default AngularAcceleration divide(double divisor) {
+    return (AngularAcceleration) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<AngularAccelerationUnit> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<AngularAccelerationUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<AngularAccelerationUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<AngularAccelerationUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<AngularAccelerationUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<AngularAccelerationUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(AngularAcceleration divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<AngularAccelerationUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<AngularAccelerationUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<AngularAccelerationUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<AngularAccelerationUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<AngularAccelerationUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<AngularAccelerationUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default AngularAcceleration divide(Dimensionless divisor) {
+    return (AngularAcceleration) RadiansPerSecondPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularAcceleration times(Dimensionless multiplier) {
+    return (AngularAcceleration) RadiansPerSecondPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<AngularAccelerationUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<AngularAccelerationUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<AngularAccelerationUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<AngularAccelerationUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<AngularAccelerationUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, ForceUnit> divide(Force divisor) {
+    return (Per<AngularAccelerationUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<AngularAccelerationUnit, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default AngularVelocity divide(Frequency divisor) {
+    return RadiansPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<AngularAccelerationUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<AngularAccelerationUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<AngularAccelerationUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<AngularAccelerationUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<AngularAccelerationUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<AngularAccelerationUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<AngularAccelerationUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, MassUnit> divide(Mass divisor) {
+    return (Per<AngularAccelerationUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<AngularAccelerationUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<AngularAccelerationUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<AngularAccelerationUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<AngularAccelerationUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<AngularAccelerationUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<AngularAccelerationUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<AngularAccelerationUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, PowerUnit> divide(Power divisor) {
+    return (Per<AngularAccelerationUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<AngularAccelerationUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<AngularAccelerationUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default AngularVelocity times(Time multiplier) {
+    return RadiansPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Velocity<AngularAccelerationUnit> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<AngularAccelerationUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<AngularAccelerationUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<AngularAccelerationUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<AngularAccelerationUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularAccelerationUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<AngularAccelerationUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularAccelerationUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<AngularAccelerationUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}
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
new file mode 100644
index 00000000000..631ac45cafa
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularMomentum.java
@@ -0,0 +1,334 @@
+// 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 interface AngularMomentum extends Measure<AngularMomentumUnit> {
+  static  AngularMomentum ofRelativeUnits(double magnitude, AngularMomentumUnit unit) {
+    return new ImmutableAngularMomentum(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  AngularMomentum ofBaseUnits(double baseUnitMagnitude, AngularMomentumUnit unit) {
+    return new ImmutableAngularMomentum(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  AngularMomentum copy();
+
+  @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) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularMomentum unaryMinus() {
+    return (AngularMomentum) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularMomentum plus(Measure<? extends AngularMomentumUnit> other) {
+    return (AngularMomentum) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularMomentum minus(Measure<? extends AngularMomentumUnit> other) {
+    return (AngularMomentum) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularMomentum times(double multiplier) {
+    return (AngularMomentum) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default AngularMomentum divide(double divisor) {
+    return (AngularMomentum) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<AngularMomentumUnit> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<AngularMomentumUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<AngularMomentumUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<AngularMomentumUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<AngularMomentumUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<AngularMomentumUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<AngularMomentumUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<AngularMomentumUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(AngularMomentum divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<AngularMomentumUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default MomentOfInertia divide(AngularVelocity divisor) {
+    return KilogramSquareMeters.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<AngularMomentumUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<AngularMomentumUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default AngularMomentum divide(Dimensionless divisor) {
+    return (AngularMomentum) KilogramMetersSquaredPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularMomentum times(Dimensionless multiplier) {
+    return (AngularMomentum) KilogramMetersSquaredPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<AngularMomentumUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<AngularMomentumUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<AngularMomentumUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<AngularMomentumUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<AngularMomentumUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, ForceUnit> divide(Force divisor) {
+    return (Per<AngularMomentumUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<AngularMomentumUnit, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<AngularMomentumUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<AngularMomentumUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<AngularMomentumUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<AngularMomentumUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<AngularMomentumUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<AngularMomentumUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<AngularMomentumUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<AngularMomentumUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, MassUnit> divide(Mass divisor) {
+    return (Per<AngularMomentumUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<AngularMomentumUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<AngularMomentumUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<AngularMomentumUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<AngularMomentumUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<AngularMomentumUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<AngularMomentumUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<AngularMomentumUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, PowerUnit> divide(Power divisor) {
+    return (Per<AngularMomentumUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<AngularMomentumUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<AngularMomentumUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, TimeUnit> times(Time multiplier) {
+    return (Mult<AngularMomentumUnit, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Velocity<AngularMomentumUnit> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<AngularMomentumUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<AngularMomentumUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<AngularMomentumUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<AngularMomentumUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularMomentumUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<AngularMomentumUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularMomentumUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<AngularMomentumUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}
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
new file mode 100644
index 00000000000..5c017c5c8f1
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularVelocity.java
@@ -0,0 +1,334 @@
+// 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 interface AngularVelocity extends Measure<AngularVelocityUnit> {
+  static  AngularVelocity ofRelativeUnits(double magnitude, AngularVelocityUnit unit) {
+    return new ImmutableAngularVelocity(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  AngularVelocity ofBaseUnits(double baseUnitMagnitude, AngularVelocityUnit unit) {
+    return new ImmutableAngularVelocity(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  AngularVelocity copy();
+
+  @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) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularVelocity unaryMinus() {
+    return (AngularVelocity) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularVelocity plus(Measure<? extends AngularVelocityUnit> other) {
+    return (AngularVelocity) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularVelocity minus(Measure<? extends AngularVelocityUnit> other) {
+    return (AngularVelocity) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularVelocity times(double multiplier) {
+    return (AngularVelocity) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default AngularVelocity divide(double divisor) {
+    return (AngularVelocity) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default AngularAcceleration per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<AngularVelocityUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<AngularVelocityUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<AngularVelocityUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<AngularVelocityUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<AngularVelocityUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<AngularVelocityUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<AngularVelocityUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<AngularVelocityUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<AngularVelocityUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(AngularVelocity divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<AngularVelocityUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<AngularVelocityUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default AngularVelocity divide(Dimensionless divisor) {
+    return (AngularVelocity) RadiansPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularVelocity times(Dimensionless multiplier) {
+    return (AngularVelocity) RadiansPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<AngularVelocityUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<AngularVelocityUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<AngularVelocityUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<AngularVelocityUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<AngularVelocityUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, ForceUnit> divide(Force divisor) {
+    return (Per<AngularVelocityUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default AngularAcceleration times(Frequency multiplier) {
+    return RadiansPerSecondPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<AngularVelocityUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<AngularVelocityUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<AngularVelocityUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<AngularVelocityUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<AngularVelocityUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<AngularVelocityUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<AngularVelocityUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<AngularVelocityUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, MassUnit> divide(Mass divisor) {
+    return (Per<AngularVelocityUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<AngularVelocityUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<AngularVelocityUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<AngularVelocityUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<AngularVelocityUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<AngularVelocityUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<AngularVelocityUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<AngularVelocityUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, PowerUnit> divide(Power divisor) {
+    return (Per<AngularVelocityUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<AngularVelocityUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<AngularVelocityUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Angle times(Time multiplier) {
+    return Radians.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default AngularAcceleration divide(Time divisor) {
+    return RadiansPerSecondPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<AngularVelocityUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<AngularVelocityUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<AngularVelocityUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<AngularVelocityUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<AngularVelocityUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<AngularVelocityUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<AngularVelocityUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<AngularVelocityUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+default 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
new file mode 100644
index 00000000000..e7af53dfdac
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Current.java
@@ -0,0 +1,334 @@
+// 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 interface Current extends Measure<CurrentUnit> {
+  static  Current ofRelativeUnits(double magnitude, CurrentUnit unit) {
+    return new ImmutableCurrent(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  Current ofBaseUnits(double baseUnitMagnitude, CurrentUnit unit) {
+    return new ImmutableCurrent(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Current copy();
+
+  @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) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Current unaryMinus() {
+    return (Current) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Current plus(Measure<? extends CurrentUnit> other) {
+    return (Current) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Current minus(Measure<? extends CurrentUnit> other) {
+    return (Current) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Current times(double multiplier) {
+    return (Current) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Current divide(double divisor) {
+    return (Current) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<CurrentUnit> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<CurrentUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<CurrentUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<CurrentUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<CurrentUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<CurrentUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<CurrentUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<CurrentUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<CurrentUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<CurrentUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<CurrentUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<CurrentUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(Current divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Current divide(Dimensionless divisor) {
+    return (Current) Amps.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Current times(Dimensionless multiplier) {
+    return (Current) Amps.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<CurrentUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<CurrentUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<CurrentUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<CurrentUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<CurrentUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, ForceUnit> divide(Force divisor) {
+    return (Per<CurrentUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<CurrentUnit, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<CurrentUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<CurrentUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<CurrentUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<CurrentUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<CurrentUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<CurrentUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<CurrentUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<CurrentUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, MassUnit> divide(Mass divisor) {
+    return (Per<CurrentUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<CurrentUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<CurrentUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<CurrentUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<CurrentUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<CurrentUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<CurrentUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<CurrentUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, PowerUnit> divide(Power divisor) {
+    return (Per<CurrentUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<CurrentUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<CurrentUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, TimeUnit> times(Time multiplier) {
+    return (Mult<CurrentUnit, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Velocity<CurrentUnit> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<CurrentUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<CurrentUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<CurrentUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<CurrentUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<CurrentUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<CurrentUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Power times(Voltage multiplier) {
+    return Watts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<CurrentUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<CurrentUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}
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
new file mode 100644
index 00000000000..942f55d4155
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Dimensionless.java
@@ -0,0 +1,334 @@
+// 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 interface Dimensionless extends Measure<DimensionlessUnit> {
+  static  Dimensionless ofRelativeUnits(double magnitude, DimensionlessUnit unit) {
+    return new ImmutableDimensionless(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  Dimensionless ofBaseUnits(double baseUnitMagnitude, DimensionlessUnit unit) {
+    return new ImmutableDimensionless(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Dimensionless copy();
+
+  @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) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Dimensionless unaryMinus() {
+    return (Dimensionless) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Dimensionless plus(Measure<? extends DimensionlessUnit> other) {
+    return (Dimensionless) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Dimensionless minus(Measure<? extends DimensionlessUnit> other) {
+    return (Dimensionless) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Dimensionless times(double multiplier) {
+    return (Dimensionless) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(double divisor) {
+    return (Dimensionless) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Frequency per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<DimensionlessUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<DimensionlessUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DimensionlessUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<DimensionlessUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Angle times(Angle multiplier) {
+    return Radians.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<DimensionlessUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default AngularAcceleration times(AngularAcceleration multiplier) {
+    return RadiansPerSecondPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<DimensionlessUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default AngularMomentum times(AngularMomentum multiplier) {
+    return KilogramMetersSquaredPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<DimensionlessUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default AngularVelocity times(AngularVelocity multiplier) {
+    return RadiansPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<DimensionlessUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Current times(Current multiplier) {
+    return Amps.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<DimensionlessUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Dimensionless divide(Dimensionless divisor) {
+    return (Dimensionless) Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Dimensionless times(Dimensionless multiplier) {
+    return (Dimensionless) Value.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Distance times(Distance multiplier) {
+    return Meters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<DimensionlessUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Energy times(Energy multiplier) {
+    return Joules.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<DimensionlessUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Force times(Force multiplier) {
+    return Newtons.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, ForceUnit> divide(Force divisor) {
+    return (Per<DimensionlessUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Frequency times(Frequency multiplier) {
+    return Hertz.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<DimensionlessUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default LinearAcceleration times(LinearAcceleration multiplier) {
+    return MetersPerSecondPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<DimensionlessUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default LinearMomentum times(LinearMomentum multiplier) {
+    return KilogramMetersPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<DimensionlessUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default LinearVelocity times(LinearVelocity multiplier) {
+    return MetersPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<DimensionlessUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mass times(Mass multiplier) {
+    return Kilograms.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, MassUnit> divide(Mass divisor) {
+    return (Per<DimensionlessUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default MomentOfInertia times(MomentOfInertia multiplier) {
+    return KilogramSquareMeters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<DimensionlessUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DimensionlessUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<DimensionlessUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DimensionlessUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<DimensionlessUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DimensionlessUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<DimensionlessUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DimensionlessUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<DimensionlessUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Power times(Power multiplier) {
+    return Watts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, PowerUnit> divide(Power divisor) {
+    return (Per<DimensionlessUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Temperature times(Temperature multiplier) {
+    return Kelvin.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<DimensionlessUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Time times(Time multiplier) {
+    return Seconds.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Frequency divide(Time divisor) {
+    return Hertz.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Torque times(Torque multiplier) {
+    return NewtonMeters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<DimensionlessUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DimensionlessUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<DimensionlessUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DimensionlessUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<DimensionlessUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Voltage times(Voltage multiplier) {
+    return Volts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DimensionlessUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<DimensionlessUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}
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
new file mode 100644
index 00000000000..f87106362ef
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Distance.java
@@ -0,0 +1,334 @@
+// 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 interface Distance extends Measure<DistanceUnit> {
+  static  Distance ofRelativeUnits(double magnitude, DistanceUnit unit) {
+    return new ImmutableDistance(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  Distance ofBaseUnits(double baseUnitMagnitude, DistanceUnit unit) {
+    return new ImmutableDistance(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Distance copy();
+
+  @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) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Distance unaryMinus() {
+    return (Distance) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Distance plus(Measure<? extends DistanceUnit> other) {
+    return (Distance) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Distance minus(Measure<? extends DistanceUnit> other) {
+    return (Distance) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Distance times(double multiplier) {
+    return (Distance) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Distance divide(double divisor) {
+    return (Distance) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default LinearVelocity per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<DistanceUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<DistanceUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<DistanceUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<DistanceUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<DistanceUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<DistanceUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<DistanceUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<DistanceUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<DistanceUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<DistanceUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<DistanceUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<DistanceUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Distance divide(Dimensionless divisor) {
+    return (Distance) Meters.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Distance times(Dimensionless multiplier) {
+    return (Distance) Meters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<DistanceUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(Distance divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<DistanceUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<DistanceUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Torque times(Force multiplier) {
+    return NewtonMeters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DistanceUnit, ForceUnit> divide(Force divisor) {
+    return (Per<DistanceUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default LinearVelocity times(Frequency multiplier) {
+    return MetersPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<DistanceUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<DistanceUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<DistanceUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<DistanceUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<DistanceUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<DistanceUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<DistanceUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Time divide(LinearVelocity divisor) {
+    return Seconds.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<DistanceUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, MassUnit> divide(Mass divisor) {
+    return (Per<DistanceUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<DistanceUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<DistanceUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<DistanceUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<DistanceUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<DistanceUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<DistanceUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<DistanceUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, PowerUnit> divide(Power divisor) {
+    return (Per<DistanceUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<DistanceUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<DistanceUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, TimeUnit> times(Time multiplier) {
+    return (Mult<DistanceUnit, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default LinearVelocity divide(Time divisor) {
+    return MetersPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<DistanceUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<DistanceUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<DistanceUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<DistanceUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<DistanceUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<DistanceUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<DistanceUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<DistanceUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}
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
new file mode 100644
index 00000000000..d20f8f19622
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Energy.java
@@ -0,0 +1,334 @@
+// 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 interface Energy extends Measure<EnergyUnit> {
+  static  Energy ofRelativeUnits(double magnitude, EnergyUnit unit) {
+    return new ImmutableEnergy(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  Energy ofBaseUnits(double baseUnitMagnitude, EnergyUnit unit) {
+    return new ImmutableEnergy(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Energy copy();
+
+  @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) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Energy unaryMinus() {
+    return (Energy) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Energy plus(Measure<? extends EnergyUnit> other) {
+    return (Energy) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Energy minus(Measure<? extends EnergyUnit> other) {
+    return (Energy) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Energy times(double multiplier) {
+    return (Energy) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Energy divide(double divisor) {
+    return (Energy) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Power per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<EnergyUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<EnergyUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<EnergyUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<EnergyUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<EnergyUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<EnergyUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<EnergyUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<EnergyUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<EnergyUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<EnergyUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<EnergyUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<EnergyUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Energy divide(Dimensionless divisor) {
+    return (Energy) Joules.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Energy times(Dimensionless multiplier) {
+    return (Energy) Joules.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<EnergyUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<EnergyUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<EnergyUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(Energy divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<EnergyUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, ForceUnit> divide(Force divisor) {
+    return (Per<EnergyUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Power times(Frequency multiplier) {
+    return Watts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<EnergyUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<EnergyUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<EnergyUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<EnergyUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<EnergyUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<EnergyUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<EnergyUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<EnergyUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<EnergyUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, MassUnit> divide(Mass divisor) {
+    return (Per<EnergyUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<EnergyUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<EnergyUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<EnergyUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<EnergyUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<EnergyUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<EnergyUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<EnergyUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, PowerUnit> divide(Power divisor) {
+    return (Per<EnergyUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<EnergyUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<EnergyUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, TimeUnit> times(Time multiplier) {
+    return (Mult<EnergyUnit, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Power divide(Time divisor) {
+    return Watts.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<EnergyUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<EnergyUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<EnergyUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<EnergyUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<EnergyUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<EnergyUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<EnergyUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<EnergyUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}
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
new file mode 100644
index 00000000000..2f69f808b8b
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Force.java
@@ -0,0 +1,334 @@
+// 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 interface Force extends Measure<ForceUnit> {
+  static  Force ofRelativeUnits(double magnitude, ForceUnit unit) {
+    return new ImmutableForce(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  Force ofBaseUnits(double baseUnitMagnitude, ForceUnit unit) {
+    return new ImmutableForce(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Force copy();
+
+  @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) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Force unaryMinus() {
+    return (Force) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Force plus(Measure<? extends ForceUnit> other) {
+    return (Force) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Force minus(Measure<? extends ForceUnit> other) {
+    return (Force) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Force times(double multiplier) {
+    return (Force) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Force divide(double divisor) {
+    return (Force) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<ForceUnit> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<ForceUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<ForceUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<ForceUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<ForceUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<ForceUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<ForceUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<ForceUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<ForceUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<ForceUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<ForceUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<ForceUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<ForceUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<ForceUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Force divide(Dimensionless divisor) {
+    return (Force) Newtons.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Force times(Dimensionless multiplier) {
+    return (Force) Newtons.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Energy times(Distance multiplier) {
+    return Joules.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<ForceUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<ForceUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<ForceUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<ForceUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<ForceUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(Force divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<ForceUnit, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<ForceUnit, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<ForceUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<ForceUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Mass divide(LinearAcceleration divisor) {
+    return Kilograms.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<ForceUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<ForceUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<ForceUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<ForceUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<ForceUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<ForceUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default LinearAcceleration divide(Mass divisor) {
+    return MetersPerSecondPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<ForceUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<ForceUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<ForceUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<ForceUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<ForceUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<ForceUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<ForceUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<ForceUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, PowerUnit> divide(Power divisor) {
+    return (Per<ForceUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<ForceUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<ForceUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, TimeUnit> times(Time multiplier) {
+    return (Mult<ForceUnit, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Velocity<ForceUnit> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<ForceUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<ForceUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<ForceUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<ForceUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<ForceUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<ForceUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<ForceUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<ForceUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<ForceUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}
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
new file mode 100644
index 00000000000..ebce2a9a31c
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Frequency.java
@@ -0,0 +1,335 @@
+// 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 interface Frequency extends Measure<FrequencyUnit> {
+  static  Frequency ofRelativeUnits(double magnitude, FrequencyUnit unit) {
+    return new ImmutableFrequency(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  Frequency ofBaseUnits(double baseUnitMagnitude, FrequencyUnit unit) {
+    return new ImmutableFrequency(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Frequency copy();
+
+  @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) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Frequency unaryMinus() {
+    return (Frequency) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Frequency plus(Measure<? extends FrequencyUnit> other) {
+    return (Frequency) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Frequency minus(Measure<? extends FrequencyUnit> other) {
+    return (Frequency) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Frequency times(double multiplier) {
+    return (Frequency) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Frequency divide(double divisor) {
+    return (Frequency) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<FrequencyUnit> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<FrequencyUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<FrequencyUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default AngularVelocity times(Angle multiplier) {
+    return RadiansPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<FrequencyUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<FrequencyUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<FrequencyUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<FrequencyUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<FrequencyUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<FrequencyUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default AngularAcceleration times(AngularVelocity multiplier) {
+    return RadiansPerSecondPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<FrequencyUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<FrequencyUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<FrequencyUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<FrequencyUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Frequency divide(Dimensionless divisor) {
+    return (Frequency) Hertz.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Frequency times(Dimensionless multiplier) {
+    return (Frequency) Hertz.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default LinearVelocity times(Distance multiplier) {
+    return MetersPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<FrequencyUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<FrequencyUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<FrequencyUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<FrequencyUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<FrequencyUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, ForceUnit> divide(Force divisor) {
+    return (Per<FrequencyUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<FrequencyUnit, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(Frequency divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<FrequencyUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<FrequencyUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<FrequencyUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<FrequencyUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default LinearAcceleration times(LinearVelocity multiplier) {
+    return MetersPerSecondPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<FrequencyUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<FrequencyUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<FrequencyUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, MassUnit> divide(Mass divisor) {
+    return (Per<FrequencyUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<FrequencyUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<FrequencyUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<FrequencyUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<FrequencyUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<FrequencyUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<FrequencyUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<FrequencyUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, PowerUnit> divide(Power divisor) {
+    return (Per<FrequencyUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<FrequencyUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<FrequencyUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Dimensionless times(Time multiplier) {
+    return Value.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Velocity<FrequencyUnit> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<FrequencyUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<FrequencyUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<FrequencyUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<FrequencyUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<FrequencyUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<FrequencyUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<FrequencyUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<FrequencyUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+/** Converts this frequency to the time period between cycles. */
+default 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
new file mode 100644
index 00000000000..ab6f0449bfe
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAcceleration.java
@@ -0,0 +1,28 @@
+// 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
new file mode 100644
index 00000000000..352e19ea38a
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAngle.java
@@ -0,0 +1,28 @@
+// 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
new file mode 100644
index 00000000000..0c417e08c6f
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAngularAcceleration.java
@@ -0,0 +1,28 @@
+// 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
new file mode 100644
index 00000000000..7d00dd669ed
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAngularMomentum.java
@@ -0,0 +1,28 @@
+// 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
new file mode 100644
index 00000000000..c692a116d50
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableAngularVelocity.java
@@ -0,0 +1,28 @@
+// 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
new file mode 100644
index 00000000000..8710f57efee
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableCurrent.java
@@ -0,0 +1,28 @@
+// 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
new file mode 100644
index 00000000000..455bd2b4026
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableDimensionless.java
@@ -0,0 +1,28 @@
+// 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
new file mode 100644
index 00000000000..f9197822361
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableDistance.java
@@ -0,0 +1,28 @@
+// 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
new file mode 100644
index 00000000000..7e443075b05
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableEnergy.java
@@ -0,0 +1,28 @@
+// 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
new file mode 100644
index 00000000000..14f11ec7a19
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableForce.java
@@ -0,0 +1,28 @@
+// 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
new file mode 100644
index 00000000000..f9084ed569d
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableFrequency.java
@@ -0,0 +1,28 @@
+// 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
new file mode 100644
index 00000000000..3212588d059
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableLinearAcceleration.java
@@ -0,0 +1,28 @@
+// 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
new file mode 100644
index 00000000000..0d7afd654b6
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableLinearMomentum.java
@@ -0,0 +1,28 @@
+// 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
new file mode 100644
index 00000000000..7373307d39f
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableLinearVelocity.java
@@ -0,0 +1,28 @@
+// 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
new file mode 100644
index 00000000000..c74ad2711a6
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableMass.java
@@ -0,0 +1,28 @@
+// 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
new file mode 100644
index 00000000000..ea903c7652a
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableMomentOfInertia.java
@@ -0,0 +1,28 @@
+// 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
new file mode 100644
index 00000000000..fc69825ee4a
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableMult.java
@@ -0,0 +1,28 @@
+// 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
new file mode 100644
index 00000000000..3d9ad1fe14b
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutablePer.java
@@ -0,0 +1,28 @@
+// 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
new file mode 100644
index 00000000000..0c7ffc0d95b
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutablePower.java
@@ -0,0 +1,28 @@
+// 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/ImmutableTemperature.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableTemperature.java
new file mode 100644
index 00000000000..e035d809222
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableTemperature.java
@@ -0,0 +1,28 @@
+// 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
new file mode 100644
index 00000000000..1230d92028b
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableTime.java
@@ -0,0 +1,28 @@
+// 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
new file mode 100644
index 00000000000..7c756e75dcb
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableTorque.java
@@ -0,0 +1,28 @@
+// 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
new file mode 100644
index 00000000000..89256f9d055
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableVelocity.java
@@ -0,0 +1,28 @@
+// 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
new file mode 100644
index 00000000000..ca5dfebbf3d
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/ImmutableVoltage.java
@@ -0,0 +1,28 @@
+// 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
new file mode 100644
index 00000000000..f595bcc33ff
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearAcceleration.java
@@ -0,0 +1,334 @@
+// 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 interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
+  static  LinearAcceleration ofRelativeUnits(double magnitude, LinearAccelerationUnit unit) {
+    return new ImmutableLinearAcceleration(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  LinearAcceleration ofBaseUnits(double baseUnitMagnitude, LinearAccelerationUnit unit) {
+    return new ImmutableLinearAcceleration(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  LinearAcceleration copy();
+
+  @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) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearAcceleration unaryMinus() {
+    return (LinearAcceleration) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearAcceleration plus(Measure<? extends LinearAccelerationUnit> other) {
+    return (LinearAcceleration) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearAcceleration minus(Measure<? extends LinearAccelerationUnit> other) {
+    return (LinearAcceleration) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearAcceleration times(double multiplier) {
+    return (LinearAcceleration) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default LinearAcceleration divide(double divisor) {
+    return (LinearAcceleration) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<LinearAccelerationUnit> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<LinearAccelerationUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<LinearAccelerationUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<LinearAccelerationUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<LinearAccelerationUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<LinearAccelerationUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<LinearAccelerationUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<LinearAccelerationUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<LinearAccelerationUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<LinearAccelerationUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<LinearAccelerationUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<LinearAccelerationUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<LinearAccelerationUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default LinearAcceleration divide(Dimensionless divisor) {
+    return (LinearAcceleration) MetersPerSecondPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearAcceleration times(Dimensionless multiplier) {
+    return (LinearAcceleration) MetersPerSecondPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<LinearAccelerationUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<LinearAccelerationUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<LinearAccelerationUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<LinearAccelerationUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<LinearAccelerationUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, ForceUnit> divide(Force divisor) {
+    return (Per<LinearAccelerationUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<LinearAccelerationUnit, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default LinearVelocity divide(Frequency divisor) {
+    return MetersPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<LinearAccelerationUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(LinearAcceleration divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<LinearAccelerationUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<LinearAccelerationUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<LinearAccelerationUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<LinearAccelerationUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<LinearAccelerationUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, MassUnit> divide(Mass divisor) {
+    return (Per<LinearAccelerationUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<LinearAccelerationUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<LinearAccelerationUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<LinearAccelerationUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<LinearAccelerationUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<LinearAccelerationUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<LinearAccelerationUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<LinearAccelerationUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, PowerUnit> divide(Power divisor) {
+    return (Per<LinearAccelerationUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<LinearAccelerationUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<LinearAccelerationUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default LinearVelocity times(Time multiplier) {
+    return MetersPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Velocity<LinearAccelerationUnit> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<LinearAccelerationUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<LinearAccelerationUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<LinearAccelerationUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<LinearAccelerationUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearAccelerationUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<LinearAccelerationUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearAccelerationUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<LinearAccelerationUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}
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
new file mode 100644
index 00000000000..92177a9598c
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearMomentum.java
@@ -0,0 +1,334 @@
+// 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 interface LinearMomentum extends Measure<LinearMomentumUnit> {
+  static  LinearMomentum ofRelativeUnits(double magnitude, LinearMomentumUnit unit) {
+    return new ImmutableLinearMomentum(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  LinearMomentum ofBaseUnits(double baseUnitMagnitude, LinearMomentumUnit unit) {
+    return new ImmutableLinearMomentum(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  LinearMomentum copy();
+
+  @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) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearMomentum unaryMinus() {
+    return (LinearMomentum) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearMomentum plus(Measure<? extends LinearMomentumUnit> other) {
+    return (LinearMomentum) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearMomentum minus(Measure<? extends LinearMomentumUnit> other) {
+    return (LinearMomentum) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearMomentum times(double multiplier) {
+    return (LinearMomentum) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default LinearMomentum divide(double divisor) {
+    return (LinearMomentum) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Force per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<LinearMomentumUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<LinearMomentumUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<LinearMomentumUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<LinearMomentumUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<LinearMomentumUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<LinearMomentumUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<LinearMomentumUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<LinearMomentumUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<LinearMomentumUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<LinearMomentumUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<LinearMomentumUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<LinearMomentumUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default LinearMomentum divide(Dimensionless divisor) {
+    return (LinearMomentum) KilogramMetersPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearMomentum times(Dimensionless multiplier) {
+    return (LinearMomentum) KilogramMetersPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<LinearMomentumUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<LinearMomentumUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<LinearMomentumUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<LinearMomentumUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<LinearMomentumUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, ForceUnit> divide(Force divisor) {
+    return (Per<LinearMomentumUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Force times(Frequency multiplier) {
+    return Newtons.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<LinearMomentumUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<LinearMomentumUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<LinearMomentumUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<LinearMomentumUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(LinearMomentum divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<LinearMomentumUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Mass divide(LinearVelocity divisor) {
+    return Kilograms.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<LinearMomentumUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default LinearVelocity divide(Mass divisor) {
+    return MetersPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<LinearMomentumUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<LinearMomentumUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<LinearMomentumUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<LinearMomentumUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<LinearMomentumUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<LinearMomentumUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<LinearMomentumUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, PowerUnit> divide(Power divisor) {
+    return (Per<LinearMomentumUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<LinearMomentumUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<LinearMomentumUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, TimeUnit> times(Time multiplier) {
+    return (Mult<LinearMomentumUnit, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Force divide(Time divisor) {
+    return Newtons.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<LinearMomentumUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<LinearMomentumUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<LinearMomentumUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<LinearMomentumUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearMomentumUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<LinearMomentumUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearMomentumUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<LinearMomentumUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}
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
new file mode 100644
index 00000000000..4f3d1c389de
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearVelocity.java
@@ -0,0 +1,334 @@
+// 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 interface LinearVelocity extends Measure<LinearVelocityUnit> {
+  static  LinearVelocity ofRelativeUnits(double magnitude, LinearVelocityUnit unit) {
+    return new ImmutableLinearVelocity(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  LinearVelocity ofBaseUnits(double baseUnitMagnitude, LinearVelocityUnit unit) {
+    return new ImmutableLinearVelocity(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  LinearVelocity copy();
+
+  @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) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearVelocity unaryMinus() {
+    return (LinearVelocity) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearVelocity plus(Measure<? extends LinearVelocityUnit> other) {
+    return (LinearVelocity) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearVelocity minus(Measure<? extends LinearVelocityUnit> other) {
+    return (LinearVelocity) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearVelocity times(double multiplier) {
+    return (LinearVelocity) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default LinearVelocity divide(double divisor) {
+    return (LinearVelocity) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default LinearAcceleration per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<LinearVelocityUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<LinearVelocityUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<LinearVelocityUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<LinearVelocityUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<LinearVelocityUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<LinearVelocityUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<LinearVelocityUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<LinearVelocityUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<LinearVelocityUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<LinearVelocityUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<LinearVelocityUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<LinearVelocityUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default LinearVelocity divide(Dimensionless divisor) {
+    return (LinearVelocity) MetersPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearVelocity times(Dimensionless multiplier) {
+    return (LinearVelocity) MetersPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<LinearVelocityUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<LinearVelocityUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<LinearVelocityUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<LinearVelocityUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<LinearVelocityUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, ForceUnit> divide(Force divisor) {
+    return (Per<LinearVelocityUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default LinearAcceleration times(Frequency multiplier) {
+    return MetersPerSecondPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<LinearVelocityUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<LinearVelocityUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<LinearVelocityUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<LinearVelocityUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<LinearVelocityUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<LinearVelocityUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(LinearVelocity divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<LinearVelocityUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, MassUnit> divide(Mass divisor) {
+    return (Per<LinearVelocityUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<LinearVelocityUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<LinearVelocityUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<LinearVelocityUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<LinearVelocityUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<LinearVelocityUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<LinearVelocityUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<LinearVelocityUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, PowerUnit> divide(Power divisor) {
+    return (Per<LinearVelocityUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<LinearVelocityUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<LinearVelocityUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Distance times(Time multiplier) {
+    return Meters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default LinearAcceleration divide(Time divisor) {
+    return MetersPerSecondPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<LinearVelocityUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<LinearVelocityUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<LinearVelocityUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<LinearVelocityUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<LinearVelocityUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<LinearVelocityUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<LinearVelocityUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<LinearVelocityUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}
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
new file mode 100644
index 00000000000..6046be68d45
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mass.java
@@ -0,0 +1,334 @@
+// 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 interface Mass extends Measure<MassUnit> {
+  static  Mass ofRelativeUnits(double magnitude, MassUnit unit) {
+    return new ImmutableMass(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  Mass ofBaseUnits(double baseUnitMagnitude, MassUnit unit) {
+    return new ImmutableMass(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Mass copy();
+
+  @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) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Mass unaryMinus() {
+    return (Mass) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Mass plus(Measure<? extends MassUnit> other) {
+    return (Mass) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Mass minus(Measure<? extends MassUnit> other) {
+    return (Mass) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Mass times(double multiplier) {
+    return (Mass) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Mass divide(double divisor) {
+    return (Mass) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<MassUnit> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<MassUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<MassUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<MassUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<MassUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<MassUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<MassUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<MassUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<MassUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<MassUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<MassUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<MassUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<MassUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<MassUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Mass divide(Dimensionless divisor) {
+    return (Mass) Kilograms.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Mass times(Dimensionless multiplier) {
+    return (Mass) Kilograms.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<MassUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<MassUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<MassUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<MassUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<MassUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<MassUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, ForceUnit> divide(Force divisor) {
+    return (Per<MassUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<MassUnit, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<MassUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Force times(LinearAcceleration multiplier) {
+    return Newtons.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<MassUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<MassUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<MassUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<MassUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<MassUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<MassUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<MassUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(Mass divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<MassUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<MassUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<MassUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<MassUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<MassUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<MassUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<MassUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<MassUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, PowerUnit> divide(Power divisor) {
+    return (Per<MassUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<MassUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<MassUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, TimeUnit> times(Time multiplier) {
+    return (Mult<MassUnit, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Velocity<MassUnit> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<MassUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<MassUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<MassUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<MassUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<MassUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MassUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<MassUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MassUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<MassUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}
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
new file mode 100644
index 00000000000..c56c6ba0015
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MomentOfInertia.java
@@ -0,0 +1,334 @@
+// 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 interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
+  static  MomentOfInertia ofRelativeUnits(double magnitude, MomentOfInertiaUnit unit) {
+    return new ImmutableMomentOfInertia(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  MomentOfInertia ofBaseUnits(double baseUnitMagnitude, MomentOfInertiaUnit unit) {
+    return new ImmutableMomentOfInertia(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  MomentOfInertia copy();
+
+  @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) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default MomentOfInertia unaryMinus() {
+    return (MomentOfInertia) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default MomentOfInertia plus(Measure<? extends MomentOfInertiaUnit> other) {
+    return (MomentOfInertia) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default MomentOfInertia minus(Measure<? extends MomentOfInertiaUnit> other) {
+    return (MomentOfInertia) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default MomentOfInertia times(double multiplier) {
+    return (MomentOfInertia) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default MomentOfInertia divide(double divisor) {
+    return (MomentOfInertia) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<MomentOfInertiaUnit> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<MomentOfInertiaUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<MomentOfInertiaUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<MomentOfInertiaUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<MomentOfInertiaUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<MomentOfInertiaUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<MomentOfInertiaUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<MomentOfInertiaUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<MomentOfInertiaUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default AngularMomentum times(AngularVelocity multiplier) {
+    return KilogramMetersSquaredPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<MomentOfInertiaUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<MomentOfInertiaUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<MomentOfInertiaUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default MomentOfInertia divide(Dimensionless divisor) {
+    return (MomentOfInertia) KilogramSquareMeters.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default MomentOfInertia times(Dimensionless multiplier) {
+    return (MomentOfInertia) KilogramSquareMeters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<MomentOfInertiaUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<MomentOfInertiaUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<MomentOfInertiaUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<MomentOfInertiaUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<MomentOfInertiaUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, ForceUnit> divide(Force divisor) {
+    return (Per<MomentOfInertiaUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<MomentOfInertiaUnit, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<MomentOfInertiaUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<MomentOfInertiaUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<MomentOfInertiaUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<MomentOfInertiaUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<MomentOfInertiaUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<MomentOfInertiaUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<MomentOfInertiaUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<MomentOfInertiaUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, MassUnit> divide(Mass divisor) {
+    return (Per<MomentOfInertiaUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<MomentOfInertiaUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(MomentOfInertia divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<MomentOfInertiaUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<MomentOfInertiaUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<MomentOfInertiaUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<MomentOfInertiaUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<MomentOfInertiaUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, PowerUnit> divide(Power divisor) {
+    return (Per<MomentOfInertiaUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<MomentOfInertiaUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<MomentOfInertiaUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, TimeUnit> times(Time multiplier) {
+    return (Mult<MomentOfInertiaUnit, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Velocity<MomentOfInertiaUnit> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<MomentOfInertiaUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<MomentOfInertiaUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<MomentOfInertiaUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<MomentOfInertiaUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MomentOfInertiaUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<MomentOfInertiaUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MomentOfInertiaUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<MomentOfInertiaUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}
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
new file mode 100644
index 00000000000..9ea6033054f
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mult.java
@@ -0,0 +1,334 @@
+// 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 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);
+  }
+
+  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);
+  }
+
+  @Override
+  Mult<A, B> copy();
+
+  @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) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Mult<A, B> unaryMinus() {
+    return (Mult<A, B>) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default 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) {
+    return (Mult<A, B>) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Mult<A, B> times(double multiplier) {
+    return (Mult<A, B>) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Mult<A, B> divide(double divisor) {
+    return (Mult<A, B>) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<MultUnit<A, B>> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default 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<?>> divide(Acceleration<?> divisor) {
+    return (Per<MultUnit<A, B>, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(Angle divisor) {
+    return (Per<MultUnit<A, B>, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(AngularAcceleration divisor) {
+    return (Per<MultUnit<A, B>, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(AngularMomentum divisor) {
+    return (Per<MultUnit<A, B>, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(AngularVelocity divisor) {
+    return (Per<MultUnit<A, B>, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(Current divisor) {
+    return (Per<MultUnit<A, B>, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Mult<A, B> divide(Dimensionless divisor) {
+    return (Mult<A, B>) unit().of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default 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) {
+    return (Mult<MultUnit<A, B>, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<MultUnit<A, B>, DistanceUnit> divide(Distance divisor) {
+    return (Per<MultUnit<A, B>, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(Energy divisor) {
+    return (Per<MultUnit<A, B>, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(Force divisor) {
+    return (Per<MultUnit<A, B>, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(Frequency divisor) {
+    return (Per<MultUnit<A, B>, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(LinearAcceleration divisor) {
+    return (Per<MultUnit<A, B>, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(LinearMomentum divisor) {
+    return (Per<MultUnit<A, B>, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(LinearVelocity divisor) {
+    return (Per<MultUnit<A, B>, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(Mass divisor) {
+    return (Per<MultUnit<A, B>, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(MomentOfInertia divisor) {
+    return (Per<MultUnit<A, B>, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<MultUnit<A, B>, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<MultUnit<A, B>, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(Power divisor) {
+    return (Per<MultUnit<A, B>, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(Temperature divisor) {
+    return (Per<MultUnit<A, B>, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<MultUnit<A, B>, TimeUnit> times(Time multiplier) {
+    return (Mult<MultUnit<A, B>, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Velocity<MultUnit<A, B>> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default 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> divide(Torque divisor) {
+    return (Per<MultUnit<A, B>, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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<?>> divide(Velocity<?> divisor) {
+    return (Per<MultUnit<A, B>, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(Voltage divisor) {
+    return (Per<MultUnit<A, B>, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}
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
new file mode 100644
index 00000000000..ed74009c457
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAcceleration.java
@@ -0,0 +1,25 @@
+// 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
new file mode 100644
index 00000000000..ff356e33c2d
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAngle.java
@@ -0,0 +1,25 @@
+// 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
new file mode 100644
index 00000000000..8d7cecc8037
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAngularAcceleration.java
@@ -0,0 +1,25 @@
+// 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
new file mode 100644
index 00000000000..c7ee4726224
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAngularMomentum.java
@@ -0,0 +1,25 @@
+// 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
new file mode 100644
index 00000000000..d4083e179c1
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutAngularVelocity.java
@@ -0,0 +1,25 @@
+// 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
new file mode 100644
index 00000000000..3dab503de20
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutCurrent.java
@@ -0,0 +1,25 @@
+// 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
new file mode 100644
index 00000000000..13ee3f6e8c3
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutDimensionless.java
@@ -0,0 +1,25 @@
+// 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
new file mode 100644
index 00000000000..35f1e3faa95
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutDistance.java
@@ -0,0 +1,25 @@
+// 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
new file mode 100644
index 00000000000..bd23cd1e9b6
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutEnergy.java
@@ -0,0 +1,25 @@
+// 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
new file mode 100644
index 00000000000..da6c973164d
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutForce.java
@@ -0,0 +1,25 @@
+// 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
new file mode 100644
index 00000000000..091afd130bb
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutFrequency.java
@@ -0,0 +1,25 @@
+// 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
new file mode 100644
index 00000000000..dd074db5f8a
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutLinearAcceleration.java
@@ -0,0 +1,25 @@
+// 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
new file mode 100644
index 00000000000..da3113c3456
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutLinearMomentum.java
@@ -0,0 +1,25 @@
+// 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
new file mode 100644
index 00000000000..ffd19e3a7e0
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutLinearVelocity.java
@@ -0,0 +1,25 @@
+// 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
new file mode 100644
index 00000000000..c1b80c191e2
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutMass.java
@@ -0,0 +1,25 @@
+// 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
new file mode 100644
index 00000000000..b6f7481fa5a
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutMomentOfInertia.java
@@ -0,0 +1,25 @@
+// 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
new file mode 100644
index 00000000000..b743c950fd2
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutMult.java
@@ -0,0 +1,25 @@
+// 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
new file mode 100644
index 00000000000..054d87f19b8
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutPer.java
@@ -0,0 +1,25 @@
+// 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
new file mode 100644
index 00000000000..7a08663a7d4
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutPower.java
@@ -0,0 +1,25 @@
+// 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/MutTemperature.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutTemperature.java
new file mode 100644
index 00000000000..31ae1fe7b53
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutTemperature.java
@@ -0,0 +1,25 @@
+// 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
new file mode 100644
index 00000000000..4b9b81a745d
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutTime.java
@@ -0,0 +1,25 @@
+// 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
new file mode 100644
index 00000000000..30f91523291
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutTorque.java
@@ -0,0 +1,25 @@
+// 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
new file mode 100644
index 00000000000..660cfa9de2d
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutVelocity.java
@@ -0,0 +1,25 @@
+// 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
new file mode 100644
index 00000000000..7002767b9ed
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MutVoltage.java
@@ -0,0 +1,25 @@
+// 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
new file mode 100644
index 00000000000..b467e977a0e
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Per.java
@@ -0,0 +1,341 @@
+// 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 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);
+  }
+
+  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);
+  }
+
+  @Override
+  Per<Dividend, Divisor> copy();
+
+  @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) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<Dividend, Divisor> unaryMinus() {
+    return (Per<Dividend, Divisor>) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default 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) {
+    return (Per<Dividend, Divisor>) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<Dividend, Divisor> times(double multiplier) {
+    return (Per<Dividend, Divisor>) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Per<Dividend, Divisor> divide(double divisor) {
+    return (Per<Dividend, Divisor>) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<PerUnit<Dividend, Divisor>> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default 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<?>> divide(Acceleration<?> divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(Angle divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(AngularAcceleration divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(AngularMomentum divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(AngularVelocity divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(Current divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Per<Dividend, Divisor> divide(Dimensionless divisor) {
+    return (Per<Dividend, Divisor>) unit().of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default 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) {
+    return (Mult<PerUnit<Dividend, Divisor>, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, DistanceUnit> divide(Distance divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(Energy divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(Force divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(Frequency divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(LinearAcceleration divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(LinearMomentum divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(LinearVelocity divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(Mass divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(MomentOfInertia divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(Power divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(Temperature divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PerUnit<Dividend, Divisor>, TimeUnit> times(Time multiplier) {
+    return (Mult<PerUnit<Dividend, Divisor>, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Velocity<PerUnit<Dividend, Divisor>> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default 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> divide(Torque divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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<?>> divide(Velocity<?> divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default 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> divide(Voltage divisor) {
+    return (Per<PerUnit<Dividend, Divisor>, VoltageUnit>) Measure.super.divide(divisor);
+  }
+default Measure<Dividend> timesDivisor(Measure<? extends Divisor> multiplier) {
+  return (Measure<Dividend>) baseUnit().numerator().ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+}
+
+default 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
new file mode 100644
index 00000000000..054bfa785d4
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Power.java
@@ -0,0 +1,334 @@
+// 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 interface Power extends Measure<PowerUnit> {
+  static  Power ofRelativeUnits(double magnitude, PowerUnit unit) {
+    return new ImmutablePower(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  Power ofBaseUnits(double baseUnitMagnitude, PowerUnit unit) {
+    return new ImmutablePower(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Power copy();
+
+  @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) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Power unaryMinus() {
+    return (Power) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Power plus(Measure<? extends PowerUnit> other) {
+    return (Power) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Power minus(Measure<? extends PowerUnit> other) {
+    return (Power) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Power times(double multiplier) {
+    return (Power) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Power divide(double divisor) {
+    return (Power) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<PowerUnit> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<PowerUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<PowerUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<PowerUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<PowerUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<PowerUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<PowerUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<PowerUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<PowerUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<PowerUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<PowerUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<PowerUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<PowerUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Voltage divide(Current divisor) {
+    return Volts.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Power divide(Dimensionless divisor) {
+    return (Power) Watts.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Power times(Dimensionless multiplier) {
+    return (Power) Watts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<PowerUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<PowerUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<PowerUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<PowerUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Frequency divide(Energy divisor) {
+    return Hertz.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<PowerUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<PowerUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, ForceUnit> divide(Force divisor) {
+    return (Per<PowerUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<PowerUnit, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<PowerUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<PowerUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<PowerUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<PowerUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<PowerUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<PowerUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<PowerUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<PowerUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, MassUnit> divide(Mass divisor) {
+    return (Per<PowerUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<PowerUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<PowerUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<PowerUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<PowerUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<PowerUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<PowerUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<PowerUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(Power divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<PowerUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<PowerUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<PowerUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Energy times(Time multiplier) {
+    return Joules.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Velocity<PowerUnit> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<PowerUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<PowerUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<PowerUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<PowerUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<PowerUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<PowerUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<PowerUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<PowerUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Current divide(Voltage divisor) {
+    return Amps.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+}
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
new file mode 100644
index 00000000000..c9396f79223
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Temperature.java
@@ -0,0 +1,334 @@
+// 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 interface Temperature extends Measure<TemperatureUnit> {
+  static  Temperature ofRelativeUnits(double magnitude, TemperatureUnit unit) {
+    return new ImmutableTemperature(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  Temperature ofBaseUnits(double baseUnitMagnitude, TemperatureUnit unit) {
+    return new ImmutableTemperature(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Temperature copy();
+
+  @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) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Temperature unaryMinus() {
+    return (Temperature) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Temperature plus(Measure<? extends TemperatureUnit> other) {
+    return (Temperature) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Temperature minus(Measure<? extends TemperatureUnit> other) {
+    return (Temperature) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Temperature times(double multiplier) {
+    return (Temperature) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Temperature divide(double divisor) {
+    return (Temperature) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<TemperatureUnit> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<TemperatureUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<TemperatureUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<TemperatureUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<TemperatureUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<TemperatureUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<TemperatureUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<TemperatureUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<TemperatureUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<TemperatureUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<TemperatureUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<TemperatureUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<TemperatureUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Temperature divide(Dimensionless divisor) {
+    return (Temperature) Kelvin.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Temperature times(Dimensionless multiplier) {
+    return (Temperature) Kelvin.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<TemperatureUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<TemperatureUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<TemperatureUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<TemperatureUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<TemperatureUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, ForceUnit> divide(Force divisor) {
+    return (Per<TemperatureUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<TemperatureUnit, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<TemperatureUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<TemperatureUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<TemperatureUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<TemperatureUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<TemperatureUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<TemperatureUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<TemperatureUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<TemperatureUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, MassUnit> divide(Mass divisor) {
+    return (Per<TemperatureUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<TemperatureUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<TemperatureUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<TemperatureUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<TemperatureUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<TemperatureUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<TemperatureUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<TemperatureUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, PowerUnit> divide(Power divisor) {
+    return (Per<TemperatureUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<TemperatureUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(Temperature divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, TimeUnit> times(Time multiplier) {
+    return (Mult<TemperatureUnit, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Velocity<TemperatureUnit> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<TemperatureUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<TemperatureUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<TemperatureUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<TemperatureUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TemperatureUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<TemperatureUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TemperatureUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<TemperatureUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}
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
new file mode 100644
index 00000000000..aa4945c2a8d
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Time.java
@@ -0,0 +1,334 @@
+// 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 interface Time extends Measure<TimeUnit> {
+  static  Time ofRelativeUnits(double magnitude, TimeUnit unit) {
+    return new ImmutableTime(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  Time ofBaseUnits(double baseUnitMagnitude, TimeUnit unit) {
+    return new ImmutableTime(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Time copy();
+
+  @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) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Time unaryMinus() {
+    return (Time) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Time plus(Measure<? extends TimeUnit> other) {
+    return (Time) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Time minus(Measure<? extends TimeUnit> other) {
+    return (Time) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Time times(double multiplier) {
+    return (Time) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Time divide(double divisor) {
+    return (Time) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Dimensionless per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<TimeUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<TimeUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<TimeUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<TimeUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<TimeUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default AngularVelocity times(AngularAcceleration multiplier) {
+    return RadiansPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<TimeUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<TimeUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<TimeUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<TimeUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Angle times(AngularVelocity multiplier) {
+    return Radians.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<TimeUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<TimeUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<TimeUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<TimeUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Time divide(Dimensionless divisor) {
+    return (Time) Seconds.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Time times(Dimensionless multiplier) {
+    return (Time) Seconds.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<TimeUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<TimeUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<TimeUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<TimeUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<TimeUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<TimeUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, ForceUnit> divide(Force divisor) {
+    return (Per<TimeUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Dimensionless times(Frequency multiplier) {
+    return Value.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<TimeUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<TimeUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default LinearVelocity times(LinearAcceleration multiplier) {
+    return MetersPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<TimeUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<TimeUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<TimeUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<TimeUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Distance times(LinearVelocity multiplier) {
+    return Meters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<TimeUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<TimeUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<TimeUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, MassUnit> divide(Mass divisor) {
+    return (Per<TimeUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<TimeUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<TimeUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<TimeUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<TimeUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<TimeUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<TimeUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<TimeUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, PowerUnit> divide(Power divisor) {
+    return (Per<TimeUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<TimeUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<TimeUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, TimeUnit> times(Time multiplier) {
+    return (Mult<TimeUnit, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(Time divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<TimeUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<TimeUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<TimeUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<TimeUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<TimeUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TimeUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<TimeUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TimeUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<TimeUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+default 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
new file mode 100644
index 00000000000..ff1ccee5260
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Torque.java
@@ -0,0 +1,334 @@
+// 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 interface Torque extends Measure<TorqueUnit> {
+  static  Torque ofRelativeUnits(double magnitude, TorqueUnit unit) {
+    return new ImmutableTorque(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  Torque ofBaseUnits(double baseUnitMagnitude, TorqueUnit unit) {
+    return new ImmutableTorque(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Torque copy();
+
+  @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) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Torque unaryMinus() {
+    return (Torque) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Torque plus(Measure<? extends TorqueUnit> other) {
+    return (Torque) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Torque minus(Measure<? extends TorqueUnit> other) {
+    return (Torque) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Torque times(double multiplier) {
+    return (Torque) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Torque divide(double divisor) {
+    return (Torque) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<TorqueUnit> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<TorqueUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<TorqueUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<TorqueUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<TorqueUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<TorqueUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<TorqueUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<TorqueUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<TorqueUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<TorqueUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<TorqueUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, CurrentUnit> times(Current multiplier) {
+    return (Mult<TorqueUnit, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<TorqueUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Torque divide(Dimensionless divisor) {
+    return (Torque) NewtonMeters.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Torque times(Dimensionless multiplier) {
+    return (Torque) NewtonMeters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<TorqueUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Force divide(Distance divisor) {
+    return Newtons.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<TorqueUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<TorqueUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<TorqueUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Distance divide(Force divisor) {
+    return Meters.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<TorqueUnit, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<TorqueUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<TorqueUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<TorqueUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<TorqueUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<TorqueUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<TorqueUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<TorqueUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<TorqueUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, MassUnit> divide(Mass divisor) {
+    return (Per<TorqueUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<TorqueUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<TorqueUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<TorqueUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<TorqueUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<TorqueUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<TorqueUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<TorqueUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, PowerUnit> divide(Power divisor) {
+    return (Per<TorqueUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<TorqueUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<TorqueUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, TimeUnit> times(Time multiplier) {
+    return (Mult<TorqueUnit, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Velocity<TorqueUnit> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<TorqueUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(Torque divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<TorqueUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<TorqueUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<TorqueUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<TorqueUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<TorqueUnit, VoltageUnit> divide(Voltage divisor) {
+    return (Per<TorqueUnit, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}
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
new file mode 100644
index 00000000000..bc1c9ce8c25
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Velocity.java
@@ -0,0 +1,334 @@
+// 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 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);
+  }
+
+  static <D extends Unit> Velocity<D> ofBaseUnits(double baseUnitMagnitude, VelocityUnit<D> unit) {
+    return new ImmutableVelocity<D>(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Velocity<D> copy();
+
+  @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) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Velocity<D> unaryMinus() {
+    return (Velocity<D>) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default 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) {
+    return (Velocity<D>) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Velocity<D> times(double multiplier) {
+    return (Velocity<D>) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Velocity<D> divide(double divisor) {
+    return (Velocity<D>) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<VelocityUnit<D>> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<VelocityUnit<D>, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<VelocityUnit<D>, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, AngleUnit> times(Angle multiplier) {
+    return (Mult<VelocityUnit<D>, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, AngleUnit> divide(Angle divisor) {
+    return (Per<VelocityUnit<D>, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<VelocityUnit<D>, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<VelocityUnit<D>, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<VelocityUnit<D>, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<VelocityUnit<D>, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<VelocityUnit<D>, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<VelocityUnit<D>, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, CurrentUnit> times(Current multiplier) {
+    return (Mult<VelocityUnit<D>, CurrentUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, CurrentUnit> divide(Current divisor) {
+    return (Per<VelocityUnit<D>, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Velocity<D> divide(Dimensionless divisor) {
+    return (Velocity<D>) unit().of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Velocity<D> times(Dimensionless multiplier) {
+    return (Velocity<D>) unit().of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, DistanceUnit> times(Distance multiplier) {
+    return (Mult<VelocityUnit<D>, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, DistanceUnit> divide(Distance divisor) {
+    return (Per<VelocityUnit<D>, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, EnergyUnit> times(Energy multiplier) {
+    return (Mult<VelocityUnit<D>, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, EnergyUnit> divide(Energy divisor) {
+    return (Per<VelocityUnit<D>, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, ForceUnit> times(Force multiplier) {
+    return (Mult<VelocityUnit<D>, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, ForceUnit> divide(Force divisor) {
+    return (Per<VelocityUnit<D>, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<VelocityUnit<D>, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<VelocityUnit<D>, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<VelocityUnit<D>, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<VelocityUnit<D>, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<VelocityUnit<D>, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<VelocityUnit<D>, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<VelocityUnit<D>, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<VelocityUnit<D>, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, MassUnit> times(Mass multiplier) {
+    return (Mult<VelocityUnit<D>, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, MassUnit> divide(Mass divisor) {
+    return (Per<VelocityUnit<D>, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<VelocityUnit<D>, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<VelocityUnit<D>, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<VelocityUnit<D>, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<VelocityUnit<D>, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<VelocityUnit<D>, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<VelocityUnit<D>, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, PowerUnit> times(Power multiplier) {
+    return (Mult<VelocityUnit<D>, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, PowerUnit> divide(Power divisor) {
+    return (Per<VelocityUnit<D>, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<VelocityUnit<D>, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<VelocityUnit<D>, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, TimeUnit> times(Time multiplier) {
+    return (Mult<VelocityUnit<D>, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Velocity<VelocityUnit<D>> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, TorqueUnit> times(Torque multiplier) {
+    return (Mult<VelocityUnit<D>, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, TorqueUnit> divide(Torque divisor) {
+    return (Per<VelocityUnit<D>, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<VelocityUnit<D>, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<VelocityUnit<D>, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VelocityUnit<D>, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<VelocityUnit<D>, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VelocityUnit<D>, VoltageUnit> divide(Voltage divisor) {
+    return (Per<VelocityUnit<D>, VoltageUnit>) Measure.super.divide(divisor);
+  }
+
+}
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
new file mode 100644
index 00000000000..403bb7080ae
--- /dev/null
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Voltage.java
@@ -0,0 +1,334 @@
+// 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 interface Voltage extends Measure<VoltageUnit> {
+  static  Voltage ofRelativeUnits(double magnitude, VoltageUnit unit) {
+    return new ImmutableVoltage(magnitude, unit.toBaseUnits(magnitude), unit);
+  }
+
+  static  Voltage ofBaseUnits(double baseUnitMagnitude, VoltageUnit unit) {
+    return new ImmutableVoltage(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
+  }
+
+  @Override
+  Voltage copy();
+
+  @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) {
+    return unit.fromBaseUnits(baseUnitMagnitude());
+  }
+
+  @Override
+  default Voltage unaryMinus() {
+    return (Voltage) unit().ofBaseUnits(0 - baseUnitMagnitude());
+  }
+
+  @Override
+  default Voltage plus(Measure<? extends VoltageUnit> other) {
+    return (Voltage) unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Voltage minus(Measure<? extends VoltageUnit> other) {
+    return (Voltage) unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  }
+
+  @Override
+  default Voltage times(double multiplier) {
+    return (Voltage) unit().ofBaseUnits(baseUnitMagnitude() * multiplier);
+  }
+
+  @Override
+  default Voltage divide(double divisor) {
+    return (Voltage) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
+  }
+
+  @Override
+  default Velocity<VoltageUnit> per(TimeUnit period) {
+    return divide(period.of(1));
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, AccelerationUnit<?>> times(Acceleration<?> multiplier) {
+    return (Mult<VoltageUnit, AccelerationUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return (Per<VoltageUnit, AccelerationUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, AngleUnit> times(Angle multiplier) {
+    return (Mult<VoltageUnit, AngleUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, AngleUnit> divide(Angle divisor) {
+    return (Per<VoltageUnit, AngleUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
+    return (Mult<VoltageUnit, AngularAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return (Per<VoltageUnit, AngularAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
+    return (Mult<VoltageUnit, AngularMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return (Per<VoltageUnit, AngularMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
+    return (Mult<VoltageUnit, AngularVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return (Per<VoltageUnit, AngularVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Power times(Current multiplier) {
+    return Watts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  @Override
+  default Per<VoltageUnit, CurrentUnit> divide(Current divisor) {
+    return (Per<VoltageUnit, CurrentUnit>) Measure.super.divide(divisor);
+  }
+
+  @Override
+  default Voltage divide(Dimensionless divisor) {
+    return (Voltage) Volts.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  @Override
+  default Voltage times(Dimensionless multiplier) {
+    return (Voltage) Volts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, DistanceUnit> times(Distance multiplier) {
+    return (Mult<VoltageUnit, DistanceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, DistanceUnit> divide(Distance divisor) {
+    return (Per<VoltageUnit, DistanceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, EnergyUnit> times(Energy multiplier) {
+    return (Mult<VoltageUnit, EnergyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, EnergyUnit> divide(Energy divisor) {
+    return (Per<VoltageUnit, EnergyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, ForceUnit> times(Force multiplier) {
+    return (Mult<VoltageUnit, ForceUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, ForceUnit> divide(Force divisor) {
+    return (Per<VoltageUnit, ForceUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, FrequencyUnit> times(Frequency multiplier) {
+    return (Mult<VoltageUnit, FrequencyUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, FrequencyUnit> divide(Frequency divisor) {
+    return (Per<VoltageUnit, FrequencyUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
+    return (Mult<VoltageUnit, LinearAccelerationUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return (Per<VoltageUnit, LinearAccelerationUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
+    return (Mult<VoltageUnit, LinearMomentumUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return (Per<VoltageUnit, LinearMomentumUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
+    return (Mult<VoltageUnit, LinearVelocityUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return (Per<VoltageUnit, LinearVelocityUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, MassUnit> times(Mass multiplier) {
+    return (Mult<VoltageUnit, MassUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, MassUnit> divide(Mass divisor) {
+    return (Per<VoltageUnit, MassUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
+    return (Mult<VoltageUnit, MomentOfInertiaUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return (Per<VoltageUnit, MomentOfInertiaUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
+    return (Mult<VoltageUnit, MultUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return (Per<VoltageUnit, MultUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
+    return (Mult<VoltageUnit, PerUnit<?, ?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return (Per<VoltageUnit, PerUnit<?, ?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, PowerUnit> times(Power multiplier) {
+    return (Mult<VoltageUnit, PowerUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, PowerUnit> divide(Power divisor) {
+    return (Per<VoltageUnit, PowerUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, TemperatureUnit> times(Temperature multiplier) {
+    return (Mult<VoltageUnit, TemperatureUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, TemperatureUnit> divide(Temperature divisor) {
+    return (Per<VoltageUnit, TemperatureUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, TimeUnit> times(Time multiplier) {
+    return (Mult<VoltageUnit, TimeUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Velocity<VoltageUnit> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, TorqueUnit> times(Torque multiplier) {
+    return (Mult<VoltageUnit, TorqueUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, TorqueUnit> divide(Torque divisor) {
+    return (Per<VoltageUnit, TorqueUnit>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
+    return (Mult<VoltageUnit, VelocityUnit<?>>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Per<VoltageUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return (Per<VoltageUnit, VelocityUnit<?>>) Measure.super.divide(divisor);
+  }
+
+
+  @Override
+  default Mult<VoltageUnit, VoltageUnit> times(Voltage multiplier) {
+    return (Mult<VoltageUnit, VoltageUnit>) Measure.super.times(multiplier);
+  }
+
+  @Override
+  default Dimensionless divide(Voltage divisor) {
+    return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/AccelerationUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/AccelerationUnit.java
new file mode 100644
index 00000000000..7fe2bc1dd50
--- /dev/null
+++ b/wpiunits/src/main/java/edu/wpi/first/units/AccelerationUnit.java
@@ -0,0 +1,113 @@
+// 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.Acceleration;
+import edu.wpi.first.units.measure.ImmutableAcceleration;
+import edu.wpi.first.units.measure.MutAcceleration;
+
+/**
+ * A generic unit of acceleration.
+ *
+ * <p><strong>NOTE:</strong> This type is not compatible with unit-specific accelerations like
+ * {@link edu.wpi.first.units.measure.LinearAcceleration}. Authors of APIs that need to interact
+ * with all types should consider using a generic {@code Measure<? extends PerUnit<? extends
+ * PerUnit<[dimension>], TimeUnit>, TimeUnit>}. Bounded wildcards are necessary in order to
+ * interoperate with <i>any</i> subclass of the {@link edu.wpi.first.units.measure.Per} measurement
+ * type.
+ *
+ * @param <D> the unit of the accelerating quantity
+ */
+public final class AccelerationUnit<D extends Unit> extends PerUnit<VelocityUnit<D>, TimeUnit> {
+  @SuppressWarnings({"rawtypes", "unchecked"})
+  private static final CombinatoryUnitCache<VelocityUnit, TimeUnit, AccelerationUnit> cache =
+      new CombinatoryUnitCache<>(AccelerationUnit::new);
+
+  AccelerationUnit(VelocityUnit<D> velocity, TimeUnit period) {
+    super(
+        velocity.isBaseUnit() && period.isBaseUnit()
+            ? null
+            : combine(velocity.getBaseUnit(), period.getBaseUnit()),
+        velocity,
+        period);
+  }
+
+  AccelerationUnit(
+      AccelerationUnit<D> baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  @Override
+  public Acceleration<D> of(double magnitude) {
+    return new ImmutableAcceleration<>(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public Acceleration<D> ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableAcceleration<>(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  @SuppressWarnings({"unchecked", "rawtypes"})
+  public Acceleration<D> zero() {
+    return (Acceleration<D>) (Acceleration) super.zero();
+  }
+
+  @Override
+  @SuppressWarnings({"unchecked", "rawtypes"})
+  public Acceleration<D> one() {
+    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);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<AccelerationUnit<D>, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another time unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other time unit
+   * @param otherUnit the other time unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, AccelerationUnit<D> otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+
+  /**
+   * Combines a generic velocity and time period into a unit of acceleration.
+   *
+   * @param velocity the unit of velocity
+   * @param period the unit of the time period of acceleration
+   * @param <D> the unit of the accelerating quantity
+   * @return the combined acceleration unit
+   */
+  @SuppressWarnings("unchecked")
+  public static <D extends Unit> AccelerationUnit<D> combine(
+      VelocityUnit<D> velocity, TimeUnit period) {
+    return cache.combine(velocity, period);
+  }
+}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/Angle.java b/wpiunits/src/main/java/edu/wpi/first/units/Angle.java
deleted file mode 100644
index f20d98e7025..00000000000
--- a/wpiunits/src/main/java/edu/wpi/first/units/Angle.java
+++ /dev/null
@@ -1,32 +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;
-
-/**
- * Unit of angular dimension.
- *
- * <p>This is the base type for units of angular dimension. It is also used to specify the dimension
- * for {@link Measure}: <code>Measure&lt;Angle&gt;</code>.
- *
- * <p>Actual units (such as {@link Units#Degrees} and {@link Units#Radians}) can be found in the
- * {@link Units} class.
- */
-// technically, angles are unitless dimensions
-// eg Mass * Distance * Velocity<Angle> is equivalent to (Mass * Distance) / Time - otherwise known
-// as Power - in other words, Velocity<Angle> is /actually/ Frequency
-public class Angle extends Unit<Angle> {
-  Angle(Angle baseUnit, double baseUnitEquivalent, String name, String symbol) {
-    super(baseUnit, baseUnitEquivalent, name, symbol);
-  }
-
-  Angle(
-      Angle baseUnit,
-      UnaryFunction toBaseConverter,
-      UnaryFunction fromBaseConverter,
-      String name,
-      String symbol) {
-    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
-  }
-}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/AngleUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/AngleUnit.java
new file mode 100644
index 00000000000..d89d6d9ad6e
--- /dev/null
+++ b/wpiunits/src/main/java/edu/wpi/first/units/AngleUnit.java
@@ -0,0 +1,93 @@
+// 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.Angle;
+import edu.wpi.first.units.measure.MutAngle;
+
+/**
+ * Unit of angular dimension.
+ *
+ * <p>This is the base type for units of angular dimension. It is also used to specify the dimension
+ * for {@link Measure}: <code>Measure&lt;AngleUnit&gt;</code>.
+ *
+ * <p>Actual units (such as {@link Units#Degrees} and {@link Units#Radians}) can be found in the
+ * {@link Units} class.
+ */
+// technically, angles are unitless dimensions
+// eg MassUnit * DistanceUnit * VelocityUnit<AngleUnit> is equivalent to (MassUnit * DistanceUnit) /
+// TimeUnit - otherwise known
+// as PowerUnit - in other words, VelocityUnit<AngleUnit> is /actually/ Frequency
+public final class AngleUnit extends Unit {
+  AngleUnit(AngleUnit baseUnit, double baseUnitEquivalent, String name, String symbol) {
+    super(baseUnit, baseUnitEquivalent, name, symbol);
+  }
+
+  AngleUnit(
+      AngleUnit baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  @Override
+  public AngleUnit getBaseUnit() {
+    return (AngleUnit) super.getBaseUnit();
+  }
+
+  @Override
+  public Angle of(double magnitude) {
+    return Angle.ofRelativeUnits(magnitude, this);
+  }
+
+  @Override
+  public Angle ofBaseUnits(double baseUnitMagnitude) {
+    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);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<AngleUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another angle unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other angle unit
+   * @param otherUnit the other angle unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, AngleUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+
+  @Override
+  public Angle zero() {
+    return (Angle) super.zero();
+  }
+
+  @Override
+  public Angle one() {
+    return (Angle) super.one();
+  }
+}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/AngularAccelerationUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/AngularAccelerationUnit.java
new file mode 100644
index 00000000000..c818a16662f
--- /dev/null
+++ b/wpiunits/src/main/java/edu/wpi/first/units/AngularAccelerationUnit.java
@@ -0,0 +1,102 @@
+// 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.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> {
+  private static final CombinatoryUnitCache<AngularVelocityUnit, TimeUnit, AngularAccelerationUnit>
+      cache = new CombinatoryUnitCache<>(AngularAccelerationUnit::new);
+
+  AngularAccelerationUnit(AngularVelocityUnit velocity, TimeUnit period) {
+    super(
+        velocity.isBaseUnit() && period.isBaseUnit()
+            ? null
+            : combine(velocity.getBaseUnit(), period.getBaseUnit()),
+        velocity,
+        period);
+  }
+
+  AngularAccelerationUnit(
+      AngularAccelerationUnit baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  /**
+   * Combines an angular velocity and time period unit into an angular acceleration.
+   *
+   * @param velocity the unit of velocity
+   * @param period the unit of time
+   * @return the combined angular acceleration unit
+   */
+  public static AngularAccelerationUnit combine(AngularVelocityUnit velocity, TimeUnit period) {
+    return cache.combine(velocity, period);
+  }
+
+  @Override
+  public AngularAccelerationUnit getBaseUnit() {
+    return (AngularAccelerationUnit) super.getBaseUnit();
+  }
+
+  @Override
+  public AngularAcceleration of(double magnitude) {
+    return new ImmutableAngularAcceleration(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public AngularAcceleration ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableAngularAcceleration(
+        fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public AngularAcceleration zero() {
+    return (AngularAcceleration) super.zero();
+  }
+
+  @Override
+  public AngularAcceleration one() {
+    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);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<AngularAccelerationUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other unit
+   * @param otherUnit the other unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, AngularAccelerationUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/AngularMomentumUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/AngularMomentumUnit.java
new file mode 100644
index 00000000000..be54a135046
--- /dev/null
+++ b/wpiunits/src/main/java/edu/wpi/first/units/AngularMomentumUnit.java
@@ -0,0 +1,114 @@
+// 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.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
+ * from the axis of rotation.
+ */
+public final class AngularMomentumUnit extends MultUnit<LinearMomentumUnit, DistanceUnit> {
+  private static final CombinatoryUnitCache<LinearMomentumUnit, DistanceUnit, AngularMomentumUnit>
+      cache = new CombinatoryUnitCache<>(AngularMomentumUnit::new);
+
+  AngularMomentumUnit(LinearMomentumUnit momentumUnit, DistanceUnit distanceUnit) {
+    super(
+        momentumUnit.isBaseUnit() && distanceUnit.isBaseUnit()
+            ? null
+            : combine(momentumUnit.getBaseUnit(), distanceUnit.getBaseUnit()),
+        momentumUnit,
+        distanceUnit);
+  }
+
+  AngularMomentumUnit(
+      AngularMomentumUnit baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  /**
+   * Combines a linear momentum and distance to create a unit of angular momentum.
+   *
+   * @param linear the linear momentum unit
+   * @param distance the unit of distance from the axis of rotation
+   * @return the combined angular momentum unit
+   */
+  public static AngularMomentumUnit combine(LinearMomentumUnit linear, DistanceUnit distance) {
+    return cache.combine(linear, distance);
+  }
+
+  @Override
+  public AngularMomentumUnit getBaseUnit() {
+    return (AngularMomentumUnit) super.getBaseUnit();
+  }
+
+  @Override
+  public AngularMomentum of(double magnitude) {
+    return new ImmutableAngularMomentum(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public AngularMomentum ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableAngularMomentum(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public AngularMomentum zero() {
+    return (AngularMomentum) super.zero();
+  }
+
+  @Override
+  public AngularMomentum one() {
+    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);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<AngularMomentumUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other unit
+   * @param otherUnit the other unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, AngularMomentumUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+
+  /**
+   * Multiplies this angular momentum by an angular velocity to yield a unit of moment of inertia.
+   *
+   * @param omega the unit of angular velocity
+   * @return the moment of inertia unit
+   */
+  public MomentOfInertiaUnit mult(AngularVelocityUnit omega) {
+    return MomentOfInertiaUnit.combine(this, omega);
+  }
+}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/AngularVelocityUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/AngularVelocityUnit.java
new file mode 100644
index 00000000000..5a2f81b7610
--- /dev/null
+++ b/wpiunits/src/main/java/edu/wpi/first/units/AngularVelocityUnit.java
@@ -0,0 +1,101 @@
+// 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.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> {
+  private static final CombinatoryUnitCache<AngleUnit, TimeUnit, AngularVelocityUnit> cache =
+      new CombinatoryUnitCache<>(AngularVelocityUnit::new);
+
+  AngularVelocityUnit(AngleUnit numerator, TimeUnit denominator) {
+    super(
+        numerator.isBaseUnit() && denominator.isBaseUnit()
+            ? null
+            : combine(numerator.getBaseUnit(), denominator.getBaseUnit()),
+        numerator,
+        denominator);
+  }
+
+  AngularVelocityUnit(
+      AngularVelocityUnit baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  /**
+   * Combines an angle unit and a period of time into a unit of angular velocity.
+   *
+   * @param angle the unit of the changing angle
+   * @param time the period of the changing angle
+   * @return the combined angular velocity unit
+   */
+  public static AngularVelocityUnit combine(AngleUnit angle, TimeUnit time) {
+    return cache.combine(angle, time);
+  }
+
+  @Override
+  public AngularVelocityUnit getBaseUnit() {
+    return (AngularVelocityUnit) super.getBaseUnit();
+  }
+
+  @Override
+  public AngularVelocity of(double magnitude) {
+    return new ImmutableAngularVelocity(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public AngularVelocity ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableAngularVelocity(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public AngularVelocity zero() {
+    return (AngularVelocity) super.zero();
+  }
+
+  @Override
+  public AngularVelocity one() {
+    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);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<AngularVelocityUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other unit
+   * @param otherUnit the other unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, AngularVelocityUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/BaseUnits.java b/wpiunits/src/main/java/edu/wpi/first/units/BaseUnits.java
index ed10d0b3888..9794087d076 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/BaseUnits.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/BaseUnits.java
@@ -11,33 +11,30 @@ private BaseUnits() {
   }
 
   /** The standard unit of distance, meters. */
-  public static final Distance Distance = new Distance(null, 1, "Meter", "m");
+  public static final DistanceUnit DistanceUnit = new DistanceUnit(null, 1, "Meter", "m");
 
   /** The standard unit of time, seconds. */
-  public static final Time Time = new Time(null, 1, "Second", "s");
+  public static final TimeUnit TimeUnit = new TimeUnit(null, 1, "Second", "s");
 
   /** The standard unit of mass, kilograms. */
-  public static final Mass Mass = new Mass(null, 1, "Kilogram", "Kg");
+  public static final MassUnit MassUnit = new MassUnit(null, 1, "Kilogram", "Kg");
 
   /** The standard unit of angles, radians. */
-  public static final Angle Angle = new Angle(null, 1, "Radian", "rad");
+  public static final AngleUnit AngleUnit = new AngleUnit(null, 1, "Radian", "rad");
 
   /** The standard "unitless" unit. */
-  public static final Dimensionless Value = new Dimensionless(null, 1, "<?>", "<?>");
+  public static final DimensionlessUnit Value = new DimensionlessUnit(null, 1, "<?>", "<?>");
 
   /** The standard unit of voltage, volts. */
-  public static final Voltage Voltage = new Voltage(null, 1, "Volt", "V");
+  public static final VoltageUnit VoltageUnit = new VoltageUnit(null, 1, "Volt", "V");
 
   /** The standard unit of electric current, amperes. */
-  public static final Current Current = new Current(null, 1, "Amp", "A");
+  public static final CurrentUnit CurrentUnit = new CurrentUnit(null, 1, "Amp", "A");
 
   /** The standard unit of energy, joules. */
-  public static final Energy Energy = new Energy(null, 1, "Joule", "J");
-
-  /** The standard unit of power, watts. */
-  public static final Power Power = new Power(null, 1, "Watt", "W");
+  public static final EnergyUnit EnergyUnit = new EnergyUnit(null, 1, "Joule", "J");
 
   /** The standard unit of temperature, kelvin. */
-  public static final Temperature Temperature =
-      new Temperature(null, x -> x, x -> x, "Kelvin", "K");
+  public static final TemperatureUnit TemperatureUnit =
+      new TemperatureUnit(null, x -> x, x -> x, "Kelvin", "K");
 }
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/CombinatoryUnitCache.java b/wpiunits/src/main/java/edu/wpi/first/units/CombinatoryUnitCache.java
new file mode 100644
index 00000000000..53dc51cb471
--- /dev/null
+++ b/wpiunits/src/main/java/edu/wpi/first/units/CombinatoryUnitCache.java
@@ -0,0 +1,60 @@
+// 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.collections.LongToObjectHashMap;
+import java.util.Objects;
+import java.util.function.BiFunction;
+
+/**
+ * A helper class for creating and caching combined unit objects. This helps to reduce unnecessary
+ * object allocation by reusing already-created units.
+ *
+ * @param <A> the type of the first unit to be combined
+ * @param <B> the type of the second unit to be combined
+ * @param <Out> the type of the combinatorial unit
+ */
+public final class CombinatoryUnitCache<A extends Unit, B extends Unit, Out extends Unit> {
+  /**
+   * Keep a cache of created instances so expressions like Volts.per(Meter) don't do any allocations
+   * after the first.
+   */
+  private final LongToObjectHashMap<Out> m_cache = new LongToObjectHashMap<>();
+
+  private final BiFunction<? super A, ? super B, ? extends Out> m_constructor;
+
+  /**
+   * Creates a new combinatory unit cache. The cache is initially empty and is not shared across
+   * instances.
+   *
+   * @param constructor the constructor function to use to create new combined units
+   */
+  public CombinatoryUnitCache(BiFunction<? super A, ? super B, ? extends Out> constructor) {
+    this.m_constructor =
+        Objects.requireNonNull(constructor, "Cache unit constructor must be provided");
+  }
+
+  /**
+   * Combines two units together and returns the result. The resulting units are cached and will be
+   * returned on successive calls to avoid allocating many duplicate objects. The combination output
+   * type is determined by the factory function passed into the cache's constructor.
+   *
+   * @param a the first unit
+   * @param b the second unit
+   * @return the combined unit
+   */
+  public Out combine(A a, B b) {
+    final long key = ((long) a.hashCode()) << 32L | (b.hashCode() & 0xFFFFFFFFL);
+
+    var existing = m_cache.get(key);
+    if (existing != null) {
+      return existing;
+    }
+
+    var newUnit = m_constructor.apply(a, b);
+    m_cache.put(key, newUnit);
+    return newUnit;
+  }
+}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/Current.java b/wpiunits/src/main/java/edu/wpi/first/units/Current.java
deleted file mode 100644
index 244144fb47e..00000000000
--- a/wpiunits/src/main/java/edu/wpi/first/units/Current.java
+++ /dev/null
@@ -1,46 +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 static edu.wpi.first.units.Units.Watts;
-
-/**
- * Unit of electric current dimension.
- *
- * <p>This is the base type for units of current dimension. It is also used to specify the dimension
- * for {@link Measure}: <code>Measure&lt;Current&gt;</code>.
- *
- * <p>Actual units (such as {@link Units#Amps} and {@link Units#Milliamps}) can be found in the
- * {@link Units} class.
- */
-public class Current extends Unit<Current> {
-  Current(Current baseUnit, double baseUnitEquivalent, String name, String symbol) {
-    super(baseUnit, baseUnitEquivalent, name, symbol);
-  }
-
-  Current(
-      Current baseUnit,
-      UnaryFunction toBaseConverter,
-      UnaryFunction fromBaseConverter,
-      String name,
-      String symbol) {
-    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
-  }
-
-  /**
-   * Constructs a unit of power equivalent to this unit of electrical current multiplied by another
-   * unit of voltage. For example, {@code Amps.times(Volts)} will return a unit of power equivalent
-   * to one Watt; {@code Amps.times(Millivolts)} will return a unit of power equivalent to a
-   * milliwatt, and so on.
-   *
-   * @param voltage the voltage unit to multiply by
-   * @param name the name of the resulting unit of power
-   * @param symbol the symbol used to represent the unit of power
-   * @return the power unit
-   */
-  public Power times(Unit<Voltage> voltage, String name, String symbol) {
-    return new Power(Watts, this.toBaseUnits(1) * voltage.toBaseUnits(1), name, symbol);
-  }
-}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/CurrentUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/CurrentUnit.java
new file mode 100644
index 00000000000..e22ab54525f
--- /dev/null
+++ b/wpiunits/src/main/java/edu/wpi/first/units/CurrentUnit.java
@@ -0,0 +1,105 @@
+// 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.Current;
+import edu.wpi.first.units.measure.ImmutableCurrent;
+import edu.wpi.first.units.measure.MutCurrent;
+
+/**
+ * Unit of electric current dimension.
+ *
+ * <p>This is the base type for units of current dimension. It is also used to specify the dimension
+ * for {@link Measure}: <code>Measure&lt;CurrentUnit&gt;</code>.
+ *
+ * <p>Actual units (such as {@link Units#Amps} and {@link Units#Milliamps}) can be found in the
+ * {@link Units} class.
+ */
+public final class CurrentUnit extends Unit {
+  CurrentUnit(CurrentUnit baseUnit, double baseUnitEquivalent, String name, String symbol) {
+    super(baseUnit, baseUnitEquivalent, name, symbol);
+  }
+
+  CurrentUnit(
+      CurrentUnit baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  @Override
+  public CurrentUnit getBaseUnit() {
+    return (CurrentUnit) super.getBaseUnit();
+  }
+
+  /**
+   * Constructs a unit of power equivalent to this unit of electrical current multiplied by another
+   * unit of voltage. For example, {@code Amps.times(Volts)} will return a unit of power equivalent
+   * to one Watt; {@code Amps.times(Millivolts)} will return a unit of power equivalent to a
+   * milliwatt, and so on.
+   *
+   * @param voltage the voltage unit to multiply by
+   * @param name the name of the resulting unit of power
+   * @param symbol the symbol used to represent the unit of power
+   * @return the power unit
+   */
+  public PowerUnit mult(VoltageUnit voltage, String name, String symbol) {
+    return Units.derive(PowerUnit.combine(voltage, this)).named(name).symbol(symbol).make();
+  }
+
+  @Override
+  public Current of(double magnitude) {
+    return new ImmutableCurrent(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public Current ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableCurrent(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public Current zero() {
+    return (Current) super.zero();
+  }
+
+  @Override
+  public Current one() {
+    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);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<CurrentUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another current unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other current unit
+   * @param otherUnit the other current unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, CurrentUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/Dimensionless.java b/wpiunits/src/main/java/edu/wpi/first/units/Dimensionless.java
deleted file mode 100644
index 6a07f38e906..00000000000
--- a/wpiunits/src/main/java/edu/wpi/first/units/Dimensionless.java
+++ /dev/null
@@ -1,30 +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;
-
-/**
- * A type of unit that corresponds to raw values and not any physical dimension, such as percentage.
- */
-public class Dimensionless extends Unit<Dimensionless> {
-  /**
-   * Creates a new unit with the given name and multiplier to the base unit.
-   *
-   * @param baseUnitEquivalent the multiplier to convert this unit to the base unit of this type.
-   * @param name the name of the unit
-   * @param symbol the symbol of the unit
-   */
-  Dimensionless(Dimensionless baseUnit, double baseUnitEquivalent, String name, String symbol) {
-    super(baseUnit, baseUnitEquivalent, name, symbol);
-  }
-
-  Dimensionless(
-      Dimensionless baseUnit,
-      UnaryFunction toBaseConverter,
-      UnaryFunction fromBaseConverter,
-      String name,
-      String symbol) {
-    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
-  }
-}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/DimensionlessUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/DimensionlessUnit.java
new file mode 100644
index 00000000000..186476fb0b7
--- /dev/null
+++ b/wpiunits/src/main/java/edu/wpi/first/units/DimensionlessUnit.java
@@ -0,0 +1,99 @@
+// 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;
+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.
+ */
+public final class DimensionlessUnit extends Unit {
+  /**
+   * Creates a new unit with the given name and multiplier to the base unit.
+   *
+   * @param baseUnitEquivalent the multiplier to convert this unit to the base unit of this type.
+   * @param name the name of the unit
+   * @param symbol the symbol of the unit
+   */
+  DimensionlessUnit(
+      DimensionlessUnit baseUnit, double baseUnitEquivalent, String name, String symbol) {
+    super(baseUnit, baseUnitEquivalent, name, symbol);
+  }
+
+  DimensionlessUnit(
+      DimensionlessUnit baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  @Override
+  public DimensionlessUnit getBaseUnit() {
+    return (DimensionlessUnit) super.getBaseUnit();
+  }
+
+  @Override
+  public Dimensionless of(double magnitude) {
+    return new ImmutableDimensionless(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public Dimensionless ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableDimensionless(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public Dimensionless zero() {
+    return (Dimensionless) super.zero();
+  }
+
+  @Override
+  public Dimensionless one() {
+    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.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other dimensionless unit
+   * @param otherUnit the other dimensionless unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, DimensionlessUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+
+  /**
+   * Creates a frequency unit as the ratio of this dimensionless unit to the period of time in which
+   * a single cycle is made.
+   *
+   * @param period the cycle period
+   * @return the combined frequency unit
+   */
+  @Override
+  public FrequencyUnit per(TimeUnit period) {
+    return FrequencyUnit.combine(this, period);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<DimensionlessUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/Distance.java b/wpiunits/src/main/java/edu/wpi/first/units/Distance.java
deleted file mode 100644
index b8859b3ca1a..00000000000
--- a/wpiunits/src/main/java/edu/wpi/first/units/Distance.java
+++ /dev/null
@@ -1,29 +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;
-
-/**
- * Unit of linear dimension.
- *
- * <p>This is the base type for units of linear dimension. It is also used to specify the dimension
- * for {@link Measure}: <code>Measure&lt;Distance&gt;</code>.
- *
- * <p>Actual units (such as {@link Units#Meters} and {@link Units#Inches}) can be found in the
- * {@link Units} class.
- */
-public class Distance extends Unit<Distance> {
-  Distance(Distance baseUnit, double baseUnitEquivalent, String name, String symbol) {
-    super(baseUnit, baseUnitEquivalent, name, symbol);
-  }
-
-  Distance(
-      Distance baseUnit,
-      UnaryFunction toBaseConverter,
-      UnaryFunction fromBaseConverter,
-      String name,
-      String symbol) {
-    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
-  }
-}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/DistanceUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/DistanceUnit.java
new file mode 100644
index 00000000000..df4c1ffee47
--- /dev/null
+++ b/wpiunits/src/main/java/edu/wpi/first/units/DistanceUnit.java
@@ -0,0 +1,102 @@
+// 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.Distance;
+import edu.wpi.first.units.measure.ImmutableDistance;
+import edu.wpi.first.units.measure.MutDistance;
+
+/**
+ * Unit of linear dimension.
+ *
+ * <p>This is the base type for units of linear dimension. It is also used to specify the dimension
+ * for {@link Measure}: <code>Measure&lt;DistanceUnit&gt;</code>.
+ *
+ * <p>Actual units (such as {@link Units#Meters} and {@link Units#Inches}) can be found in the
+ * {@link Units} class.
+ */
+public final class DistanceUnit extends Unit {
+  DistanceUnit(DistanceUnit baseUnit, double baseUnitEquivalent, String name, String symbol) {
+    super(baseUnit, baseUnitEquivalent, name, symbol);
+  }
+
+  DistanceUnit(
+      DistanceUnit baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  @Override
+  public DistanceUnit getBaseUnit() {
+    return (DistanceUnit) super.getBaseUnit();
+  }
+
+  @Override
+  public LinearVelocityUnit per(TimeUnit period) {
+    return LinearVelocityUnit.combine(this, period);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<DistanceUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another distance unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other distance unit
+   * @param otherUnit the other distance unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, DistanceUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+
+  @Override
+  public Distance of(double magnitude) {
+    return new ImmutableDistance(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public Distance ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableDistance(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public Distance zero() {
+    return (Distance) super.zero();
+  }
+
+  @Override
+  public Distance one() {
+    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.
+   *
+   * @param force the unit of force
+   * @return the combined torque unit
+   */
+  public TorqueUnit multAsTorque(ForceUnit force) {
+    return TorqueUnit.combine(this, force);
+  }
+
+  // TODO: Add a multAsEnergy equivalent
+}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/Energy.java b/wpiunits/src/main/java/edu/wpi/first/units/Energy.java
deleted file mode 100644
index dc5be8de17f..00000000000
--- a/wpiunits/src/main/java/edu/wpi/first/units/Energy.java
+++ /dev/null
@@ -1,29 +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;
-
-/**
- * Unit of energy dimension.
- *
- * <p>This is the base type for units of energy dimension. It is also used to specify the dimension
- * for {@link Measure}: <code>Measure&lt;Energy&gt;</code>.
- *
- * <p>Actual units (such as {@link Units#Joules} and {@link Units#Kilojoules}) can be found in the
- * {@link Units} class.
- */
-public class Energy extends Unit<Energy> {
-  Energy(
-      Energy baseUnit,
-      UnaryFunction toBaseConverter,
-      UnaryFunction fromBaseConverter,
-      String name,
-      String symbol) {
-    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
-  }
-
-  Energy(Energy baseUnit, double baseUnitEquivalent, String name, String symbol) {
-    super(baseUnit, baseUnitEquivalent, name, symbol);
-  }
-}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/EnergyUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/EnergyUnit.java
new file mode 100644
index 00000000000..90a0be81efe
--- /dev/null
+++ b/wpiunits/src/main/java/edu/wpi/first/units/EnergyUnit.java
@@ -0,0 +1,96 @@
+// 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.Energy;
+import edu.wpi.first.units.measure.ImmutableEnergy;
+import edu.wpi.first.units.measure.MutEnergy;
+
+/**
+ * Unit of energy dimension.
+ *
+ * <p>This is the base type for units of energy dimension. It is also used to specify the dimension
+ * for {@link Measure}: <code>Measure&lt;EnergyUnit&gt;</code>.
+ *
+ * <p>Actual units (such as {@link Units#Joules} and {@link Units#Kilojoules}) can be found in the
+ * {@link Units} class.
+ */
+public final class EnergyUnit extends Unit {
+  EnergyUnit(
+      EnergyUnit baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  EnergyUnit(EnergyUnit baseUnit, double baseUnitEquivalent, String name, String symbol) {
+    super(baseUnit, baseUnitEquivalent, name, symbol);
+  }
+
+  @Override
+  public EnergyUnit getBaseUnit() {
+    return (EnergyUnit) super.getBaseUnit();
+  }
+
+  /**
+   * Combines this unit of energy with a unit of time to create a unit of power.
+   *
+   * @param period the period of the change in energy
+   * @return the combined unit of power
+   */
+  @Override
+  public PowerUnit per(TimeUnit period) {
+    return PowerUnit.combine(this, period);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<EnergyUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other unit
+   * @param otherUnit the other unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, EnergyUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+
+  @Override
+  public Energy of(double magnitude) {
+    return new ImmutableEnergy(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public Energy ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableEnergy(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public Energy zero() {
+    return (Energy) super.zero();
+  }
+
+  @Override
+  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
new file mode 100644
index 00000000000..9fead01b377
--- /dev/null
+++ b/wpiunits/src/main/java/edu/wpi/first/units/ForceUnit.java
@@ -0,0 +1,113 @@
+// 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.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> {
+  private static final CombinatoryUnitCache<MassUnit, LinearAccelerationUnit, ForceUnit> cache =
+      new CombinatoryUnitCache<>(ForceUnit::new);
+
+  ForceUnit(MassUnit mass, LinearAccelerationUnit acceleration) {
+    super(
+        mass.isBaseUnit() && acceleration.isBaseUnit()
+            ? null
+            : combine(mass.getBaseUnit(), acceleration.getBaseUnit()),
+        mass,
+        acceleration);
+  }
+
+  ForceUnit(
+      ForceUnit baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  /**
+   * Combines a mass and (linear) acceleration to form a unit of force.
+   *
+   * @param mass the unit of mass
+   * @param acceleration the unit of acceleration
+   * @return the combined unit of force
+   */
+  public static ForceUnit combine(MassUnit mass, LinearAccelerationUnit acceleration) {
+    return cache.combine(mass, acceleration);
+  }
+
+  @Override
+  public ForceUnit getBaseUnit() {
+    return (ForceUnit) super.getBaseUnit();
+  }
+
+  /**
+   * Multiplies this force unit by a unit of distance to create a unit of torque.
+   *
+   * @param distance the unit of distance
+   * @return the combined torque unit
+   */
+  public TorqueUnit multAsTorque(DistanceUnit distance) {
+    return TorqueUnit.combine(distance, this);
+  }
+
+  // TODO: Add a multAsEnergy equivalent
+
+  @Override
+  public Force of(double magnitude) {
+    return new ImmutableForce(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public Force ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableForce(toBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public Force zero() {
+    return (Force) super.zero();
+  }
+
+  @Override
+  public Force one() {
+    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);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<ForceUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other unit
+   * @param otherUnit the other unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, ForceUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/FrequencyUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/FrequencyUnit.java
new file mode 100644
index 00000000000..b2989fb8833
--- /dev/null
+++ b/wpiunits/src/main/java/edu/wpi/first/units/FrequencyUnit.java
@@ -0,0 +1,114 @@
+// 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 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> {
+  private static final CombinatoryUnitCache<DimensionlessUnit, TimeUnit, FrequencyUnit> cache =
+      new CombinatoryUnitCache<>(FrequencyUnit::new);
+
+  FrequencyUnit(DimensionlessUnit numerator, TimeUnit denominator) {
+    super(
+        numerator.isBaseUnit() && denominator.isBaseUnit()
+            ? null
+            : combine(numerator.getBaseUnit(), denominator.getBaseUnit()),
+        numerator,
+        denominator);
+  }
+
+  FrequencyUnit(
+      FrequencyUnit baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  /**
+   * Combines a dimensionless unit and a cycle period to create a frequency.
+   *
+   * @param dim the dimensionless unit
+   * @param period the unit of time
+   * @return the combined unit of frequency
+   */
+  public static FrequencyUnit combine(DimensionlessUnit dim, TimeUnit period) {
+    return cache.combine(dim, period);
+  }
+
+  @Override
+  public FrequencyUnit getBaseUnit() {
+    return (FrequencyUnit) super.getBaseUnit();
+  }
+
+  /**
+   * Inverts a unit of time to get its corresponding frequency (as if the unit of time is the period
+   * of the frequency).
+   *
+   * @param time period of the associated frequency
+   * @return the frequency associated with the period
+   */
+  public static FrequencyUnit inverse(TimeUnit time) {
+    return combine(Value, time);
+  }
+
+  @Override
+  public Frequency of(double magnitude) {
+    return new ImmutableFrequency(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public Frequency ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableFrequency(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public Frequency zero() {
+    return (Frequency) super.zero();
+  }
+
+  @Override
+  public Frequency one() {
+    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);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<FrequencyUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other unit
+   * @param otherUnit the other unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, FrequencyUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+}
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 60e92e5715a..1abb789f991 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/ImmutableMeasure.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/ImmutableMeasure.java
@@ -4,7 +4,8 @@
 
 package edu.wpi.first.units;
 
-import java.util.Objects;
+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
@@ -12,28 +13,13 @@
  * situations and gives compile-time safety. Two measures with the same <i>unit</i> and
  * <i>magnitude</i> are effectively equivalent objects.
  *
+ * @param magnitude the magnitude of the measure in terms of its unit
+ * @param baseUnitMagnitude the magnitude of the measure in terms of its base unit
+ * @param unit the unit of the measurement
  * @param <U> the unit type of the measure
  */
-public class ImmutableMeasure<U extends Unit<U>> implements Measure<U> {
-  private final double m_magnitude;
-  private final double m_baseUnitMagnitude;
-  private final U m_unit;
-
-  /**
-   * Creates a new immutable measure instance. This shouldn't be used directly; prefer one of the
-   * factory methods instead.
-   *
-   * @param magnitude the magnitude of this measure
-   * @param unit the unit of this measure.
-   */
-  @SuppressWarnings("unchecked")
-  ImmutableMeasure(double magnitude, double baseUnitMagnitude, Unit<U> unit) {
-    Objects.requireNonNull(unit, "Unit cannot be null");
-    m_magnitude = magnitude;
-    m_baseUnitMagnitude = baseUnitMagnitude;
-    m_unit = (U) unit;
-  }
-
+public record ImmutableMeasure<U extends Unit>(double magnitude, double baseUnitMagnitude, U unit)
+    implements Measure<U> {
   /**
    * Creates a new measure in the given unit with a magnitude equal to the given one in base units.
    *
@@ -42,8 +28,7 @@ public class ImmutableMeasure<U extends Unit<U>> implements Measure<U> {
    * @param unit the unit of measure
    * @return a new measure
    */
-  public static <U extends Unit<U>> ImmutableMeasure<U> ofBaseUnits(
-      double baseUnitMagnitude, Unit<U> unit) {
+  public static <U extends Unit> ImmutableMeasure<U> ofBaseUnits(double baseUnitMagnitude, U unit) {
     return new ImmutableMeasure<>(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
   }
 
@@ -55,51 +40,53 @@ public static <U extends Unit<U>> ImmutableMeasure<U> ofBaseUnits(
    * @param unit the unit of measure
    * @return a new measure
    */
-  public static <U extends Unit<U>> ImmutableMeasure<U> ofRelativeUnits(
-      double relativeMagnitude, Unit<U> unit) {
+  public static <U extends Unit> ImmutableMeasure<U> ofRelativeUnits(
+      double relativeMagnitude, U unit) {
     return new ImmutableMeasure<>(relativeMagnitude, unit.toBaseUnits(relativeMagnitude), unit);
   }
 
-  /** Gets the unitless magnitude of this measure. */
   @Override
-  public double magnitude() {
-    return m_magnitude;
+  public Measure<U> copy() {
+    return this; // already immutable, no need to allocate a new object
   }
 
   @Override
-  public double baseUnitMagnitude() {
-    return m_baseUnitMagnitude;
+  public MutableMeasure<U, ?, ?> mutableCopy() {
+    return new GenericMutableMeasureImpl<>(magnitude, baseUnitMagnitude, unit);
   }
 
-  /** Gets the units of this measure. */
   @Override
-  public U unit() {
-    return m_unit;
+  public Measure<U> unaryMinus() {
+    return ofBaseUnits(0 - baseUnitMagnitude, unit);
   }
 
-  /**
-   * Checks for <i>object equality</i>. To check if two measures are <i>equivalent</i>, use {@link
-   * #isEquivalent(Measure) isEquivalent}.
-   */
   @Override
-  public boolean equals(Object o) {
-    return o instanceof Measure<?> that
-        && Objects.equals(m_unit, that.unit())
-        && m_baseUnitMagnitude == that.baseUnitMagnitude();
+  public Measure<U> plus(Measure<? extends U> other) {
+    return ofBaseUnits(baseUnitMagnitude + other.baseUnitMagnitude(), unit);
   }
 
   @Override
-  public int hashCode() {
-    return Objects.hash(m_magnitude, m_unit);
+  public Measure<U> minus(Measure<? extends U> other) {
+    return ofBaseUnits(baseUnitMagnitude - other.baseUnitMagnitude(), unit);
   }
 
   @Override
-  public Measure<U> copy() {
-    return this; // already immutable, no need to allocate a new object
+  public Measure<U> times(double multiplier) {
+    return ofBaseUnits(baseUnitMagnitude * multiplier, unit);
+  }
+
+  @Override
+  public Measure<U> times(Dimensionless multiplier) {
+    return ofBaseUnits(baseUnitMagnitude * multiplier.baseUnitMagnitude(), unit);
+  }
+
+  @Override
+  public Measure<U> divide(double divisor) {
+    return ofBaseUnits(baseUnitMagnitude / divisor, unit);
   }
 
   @Override
-  public String toString() {
-    return toShortString();
+  public Measure<U> divide(Dimensionless divisor) {
+    return ofBaseUnits(baseUnitMagnitude / divisor.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
new file mode 100644
index 00000000000..9756ca6084a
--- /dev/null
+++ b/wpiunits/src/main/java/edu/wpi/first/units/LinearAccelerationUnit.java
@@ -0,0 +1,125 @@
+// 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.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}.
+ */
+public final class LinearAccelerationUnit extends PerUnit<LinearVelocityUnit, TimeUnit> {
+  private static final CombinatoryUnitCache<LinearVelocityUnit, TimeUnit, LinearAccelerationUnit>
+      cache = new CombinatoryUnitCache<>(LinearAccelerationUnit::new);
+
+  LinearAccelerationUnit(LinearVelocityUnit numerator, TimeUnit denominator) {
+    super(
+        numerator.isBaseUnit() && denominator.isBaseUnit()
+            ? null
+            : combine(numerator.getBaseUnit(), denominator.getBaseUnit()),
+        numerator,
+        denominator);
+  }
+
+  LinearAccelerationUnit(
+      LinearAccelerationUnit baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  /**
+   * Combines a linear velocity and time unit to form a unit of linear acceleration.
+   *
+   * @param velocity the unit of linear velocity
+   * @param period the unit of time
+   * @return the combined unit of linear acceleration
+   */
+  public static LinearAccelerationUnit combine(LinearVelocityUnit velocity, TimeUnit period) {
+    return cache.combine(velocity, period);
+  }
+
+  @Override
+  public LinearAccelerationUnit getBaseUnit() {
+    return (LinearAccelerationUnit) super.getBaseUnit();
+  }
+
+  @Override
+  public LinearAcceleration of(double magnitude) {
+    return new ImmutableLinearAcceleration(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public LinearAcceleration ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableLinearAcceleration(
+        fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public LinearAcceleration zero() {
+    return (LinearAcceleration) super.zero();
+  }
+
+  @Override
+  public LinearAcceleration one() {
+    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);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<LinearAccelerationUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other unit
+   * @param otherUnit the other unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, LinearAccelerationUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+
+  /**
+   * Gets the unit of the changing velocity. This is equivalent to {@link #numerator()} and is left
+   * for historical purposes.
+   *
+   * @return the unit of the changing velocity
+   */
+  public LinearVelocityUnit getUnit() {
+    return numerator();
+  }
+
+  /**
+   * Gets the unit of the acceleration period (how long it takes for a measured velocity to change
+   * by one unit of velocity). This is equivalent to {@link #numerator()} and is left for historical
+   * purposes.
+   *
+   * @return the unit of the acceleration period
+   */
+  public TimeUnit getPeriod() {
+    return denominator();
+  }
+}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/LinearMomentumUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/LinearMomentumUnit.java
new file mode 100644
index 00000000000..489955b3a6d
--- /dev/null
+++ b/wpiunits/src/main/java/edu/wpi/first/units/LinearMomentumUnit.java
@@ -0,0 +1,111 @@
+// 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.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> {
+  private static final CombinatoryUnitCache<MassUnit, LinearVelocityUnit, LinearMomentumUnit>
+      cache = new CombinatoryUnitCache<>(LinearMomentumUnit::new);
+
+  LinearMomentumUnit(MassUnit unit, LinearVelocityUnit linearVelocityUnit) {
+    super(
+        unit.isBaseUnit() && linearVelocityUnit.isBaseUnit()
+            ? null
+            : combine(unit.getBaseUnit(), linearVelocityUnit.getBaseUnit()),
+        unit,
+        linearVelocityUnit);
+  }
+
+  LinearMomentumUnit(
+      MultUnit<MassUnit, LinearVelocityUnit> baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  /**
+   * Combines a mass and linear velocity unit to form a combined linear momentum unit.
+   *
+   * @param mass the unit of mass
+   * @param velocity the unit of velocity
+   * @return the combined unit of momentum
+   */
+  public static LinearMomentumUnit combine(MassUnit mass, LinearVelocityUnit velocity) {
+    return cache.combine(mass, velocity);
+  }
+
+  @Override
+  public LinearMomentumUnit getBaseUnit() {
+    return (LinearMomentumUnit) super.getBaseUnit();
+  }
+
+  @Override
+  public LinearMomentum of(double magnitude) {
+    return new ImmutableLinearMomentum(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public LinearMomentum ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableLinearMomentum(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public LinearMomentum zero() {
+    return (LinearMomentum) super.zero();
+  }
+
+  @Override
+  public LinearMomentum one() {
+    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);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<LinearMomentumUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other unit
+   * @param otherUnit the other unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, LinearMomentumUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+
+  /**
+   * Multiplies this unit by distance to form a unit of angular momentum.
+   *
+   * @param distance the unit of distance
+   * @return the combined unit of angular momentum
+   */
+  public AngularMomentumUnit mult(DistanceUnit distance) {
+    return AngularMomentumUnit.combine(this, distance);
+  }
+}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/LinearVelocityUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/LinearVelocityUnit.java
new file mode 100644
index 00000000000..ca155ce0cda
--- /dev/null
+++ b/wpiunits/src/main/java/edu/wpi/first/units/LinearVelocityUnit.java
@@ -0,0 +1,107 @@
+// 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.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> {
+  private static final CombinatoryUnitCache<DistanceUnit, TimeUnit, LinearVelocityUnit> cache =
+      new CombinatoryUnitCache<>(LinearVelocityUnit::new);
+
+  LinearVelocityUnit(DistanceUnit unit, TimeUnit period) {
+    super(
+        unit.isBaseUnit() && period.isBaseUnit()
+            ? null
+            : combine(unit.getBaseUnit(), period.getBaseUnit()),
+        unit,
+        period);
+  }
+
+  LinearVelocityUnit(
+      PerUnit<DistanceUnit, TimeUnit> baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  /**
+   * Combines a distance and time unit for form a combined unit of velocity.
+   *
+   * @param distance the unit of distance
+   * @param period the unit of time
+   * @return the combined velocity unit
+   */
+  public static LinearVelocityUnit combine(DistanceUnit distance, TimeUnit period) {
+    return cache.combine(distance, period);
+  }
+
+  @Override
+  public LinearVelocityUnit getBaseUnit() {
+    return (LinearVelocityUnit) super.getBaseUnit();
+  }
+
+  @Override
+  public LinearVelocity of(double magnitude) {
+    return new ImmutableLinearVelocity(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public LinearVelocity ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableLinearVelocity(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public LinearVelocity zero() {
+    return (LinearVelocity) super.zero();
+  }
+
+  @Override
+  public LinearVelocity one() {
+    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.
+   *
+   * @param period the period of change in the velocity
+   * @return the combined acceleration unit
+   */
+  @Override
+  public LinearAccelerationUnit per(TimeUnit period) {
+    return LinearAccelerationUnit.combine(this, period);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<LinearVelocityUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other unit
+   * @param otherUnit the other unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, LinearVelocityUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/Mass.java b/wpiunits/src/main/java/edu/wpi/first/units/Mass.java
deleted file mode 100644
index 5d41753603b..00000000000
--- a/wpiunits/src/main/java/edu/wpi/first/units/Mass.java
+++ /dev/null
@@ -1,30 +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;
-
-/**
- * Unit of mass dimension.
- *
- * <p>This is the base type for units of mass dimension. It is also used to specify the dimension
- * for {@link Measure}: <code>Measure&lt;Mass&gt;</code>.
- *
- * <p>Actual units (such as {@link Units#Grams} and {@link Units#Pounds}) can be found in the {@link
- * Units} class.
- */
-public class Mass extends Unit<Mass> {
-  /** Creates a new unit with the given name and multiplier to the base unit. */
-  Mass(Mass baseUnit, double baseUnitEquivalent, String name, String symbol) {
-    super(baseUnit, baseUnitEquivalent, name, symbol);
-  }
-
-  Mass(
-      Mass baseUnit,
-      UnaryFunction toBaseConverter,
-      UnaryFunction fromBaseConverter,
-      String name,
-      String symbol) {
-    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
-  }
-}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/MassUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/MassUnit.java
new file mode 100644
index 00000000000..dad3fd41489
--- /dev/null
+++ b/wpiunits/src/main/java/edu/wpi/first/units/MassUnit.java
@@ -0,0 +1,112 @@
+// 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.ImmutableMass;
+import edu.wpi.first.units.measure.Mass;
+import edu.wpi.first.units.measure.MutMass;
+
+/**
+ * Unit of mass dimension.
+ *
+ * <p>This is the base type for units of mass dimension. It is also used to specify the dimension
+ * for the mass-specific {@link Mass} measurement type.
+ *
+ * <p>Actual units (such as {@link Units#Grams} and {@link Units#Pounds}) can be found in the {@link
+ * Units} class.
+ */
+public final class MassUnit extends Unit {
+  /** Creates a new unit with the given name and multiplier to the base unit. */
+  MassUnit(MassUnit baseUnit, double baseUnitEquivalent, String name, String symbol) {
+    super(baseUnit, baseUnitEquivalent, name, symbol);
+  }
+
+  MassUnit(
+      MassUnit baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  @Override
+  public MassUnit getBaseUnit() {
+    return (MassUnit) super.getBaseUnit();
+  }
+
+  @Override
+  public Mass of(double magnitude) {
+    return new ImmutableMass(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public Mass ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableMass(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public Mass zero() {
+    return (Mass) super.zero();
+  }
+
+  @Override
+  public Mass one() {
+    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);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<MassUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another mass unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other mass unit
+   * @param otherUnit the other mass unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, MassUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+
+  /**
+   * Multiplies this mass unit by a unit of linear velocity to form a combined unit of linear
+   * momentum.
+   *
+   * @param velocity the unit of velocity
+   * @return the combined unit of momentum
+   */
+  public LinearMomentumUnit mult(LinearVelocityUnit velocity) {
+    return LinearMomentumUnit.combine(this, velocity);
+  }
+
+  /**
+   * Multiplies this mass unit by a unit of linear acceleration to form a combined unit of force.
+   *
+   * @param acceleration the unit of acceleration
+   * @return the combined unit of force
+   */
+  public ForceUnit mult(LinearAccelerationUnit acceleration) {
+    return ForceUnit.combine(this, acceleration);
+  }
+}
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 f71b80238f8..86c8de9a887 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/Measure.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/Measure.java
@@ -4,7 +4,32 @@
 
 package edu.wpi.first.units;
 
-import static edu.wpi.first.units.Units.Seconds;
+import static edu.wpi.first.units.Units.Value;
+
+import edu.wpi.first.units.measure.Acceleration;
+import edu.wpi.first.units.measure.Angle;
+import edu.wpi.first.units.measure.AngularAcceleration;
+import edu.wpi.first.units.measure.AngularMomentum;
+import edu.wpi.first.units.measure.AngularVelocity;
+import edu.wpi.first.units.measure.Current;
+import edu.wpi.first.units.measure.Dimensionless;
+import edu.wpi.first.units.measure.Distance;
+import edu.wpi.first.units.measure.Energy;
+import edu.wpi.first.units.measure.Force;
+import edu.wpi.first.units.measure.Frequency;
+import edu.wpi.first.units.measure.LinearAcceleration;
+import edu.wpi.first.units.measure.LinearMomentum;
+import edu.wpi.first.units.measure.LinearVelocity;
+import edu.wpi.first.units.measure.Mass;
+import edu.wpi.first.units.measure.MomentOfInertia;
+import edu.wpi.first.units.measure.Mult;
+import edu.wpi.first.units.measure.Per;
+import edu.wpi.first.units.measure.Power;
+import edu.wpi.first.units.measure.Temperature;
+import edu.wpi.first.units.measure.Time;
+import edu.wpi.first.units.measure.Torque;
+import edu.wpi.first.units.measure.Velocity;
+import edu.wpi.first.units.measure.Voltage;
 
 /**
  * A measure holds the magnitude and unit of some dimension, such as distance, time, or speed. Two
@@ -12,7 +37,7 @@
  *
  * @param <U> the unit type of the measure
  */
-public interface Measure<U extends Unit<U>> extends Comparable<Measure<U>> {
+public interface Measure<U extends Unit> extends Comparable<Measure<U>> {
   /**
    * The threshold for two measures to be considered equivalent if converted to the same unit. This
    * is only needed due to floating-point error.
@@ -53,7 +78,7 @@ public interface Measure<U extends Unit<U>> extends Comparable<Measure<U>> {
    * @param unit the unit to convert this measure to
    * @return the value of this measure in the given unit
    */
-  default double in(Unit<U> unit) {
+  default double in(U unit) {
     if (this.unit().equals(unit)) {
       return magnitude();
     } else {
@@ -62,18 +87,74 @@ default double in(Unit<U> unit) {
   }
 
   /**
-   * Multiplies this measurement by some constant multiplier and returns the result. The magnitude
-   * of the result will be the <i>base</i> magnitude multiplied by the scalar value. If the measure
-   * uses a unit with a non-linear relation to its base unit (such as Fahrenheit for temperature),
-   * then the result will only be a multiple <i>in terms of the base unit</i>.
+   * A convenience method to get the base unit of the measurement. Equivalent to {@code
+   * unit().getBaseUnit()}.
    *
-   * @param multiplier the constant to multiply by
-   * @return the resulting measure
+   * @return the base unit of measure.
    */
-  default Measure<U> times(double multiplier) {
-    return ImmutableMeasure.ofBaseUnits(baseUnitMagnitude() * multiplier, unit());
+  @SuppressWarnings("unchecked")
+  default U baseUnit() {
+    return (U) unit().getBaseUnit();
   }
 
+  /**
+   * 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
+   * Kelvin). In effect, this means code like {@code Celsius.of(10).unaryMinus()} returns a value
+   * equivalent to -10 Kelvin, and <i>not</i> -10° Celsius.
+   *
+   * @return a measure equal to zero minus this measure
+   */
+  Measure<U> unaryMinus();
+
+  /**
+   * Adds another measure of the same unit type to this one.
+   *
+   * @param other the measurement to add
+   * @return a measure of the sum of both measures
+   */
+  Measure<U> plus(Measure<? extends U> other);
+
+  /**
+   * Subtracts another measure of the same unit type from this one.
+   *
+   * @param other the measurement to subtract
+   * @return a measure of the difference between the measures
+   */
+  Measure<U> minus(Measure<? extends U> other);
+
+  /**
+   * Multiplies this measure by a scalar unitless multiplier.
+   *
+   * @param multiplier the scalar multiplication factor
+   * @return the scaled result
+   */
+  Measure<U> times(double multiplier);
+
+  /**
+   * Multiplies this measure by a scalar dimensionless multiplier.
+   *
+   * @param multiplier the scalar multiplication factor
+   * @return the scaled result
+   */
+  Measure<U> times(Dimensionless multiplier);
+
   /**
    * Generates a new measure that is equal to this measure multiplied by another. Some dimensional
    * analysis is performed to reduce the units down somewhat; for example, multiplying a {@code
@@ -81,170 +162,825 @@ default Measure<U> times(double multiplier) {
    * Measure<Distance>} instead of the naive {@code Measure<Mult<Time, Velocity<Distance>>}. This is
    * not guaranteed to perform perfect dimensional analysis.
    *
-   * @param <U2> the type of the other measure to multiply by
-   * @param other the unit to multiply by
+   * @param multiplier the unit to multiply by
    * @return the multiplicative unit
    */
-  default <U2 extends Unit<U2>> Measure<?> times(Measure<U2> other) {
-    if (other.unit() instanceof Dimensionless) {
-      // scalar multiplication
-      return times(other.baseUnitMagnitude());
-    }
+  default Measure<?> times(Measure<?> multiplier) {
+    final double baseUnitResult = baseUnitMagnitude() * multiplier.baseUnitMagnitude();
 
-    if (unit() instanceof Per<?, ?> per
-        && other.unit().getBaseUnit().equals(per.denominator().getBaseUnit())) {
-      // denominator of the Per cancels out, return with just the units of the numerator
-      Unit<?> numerator = per.numerator();
-      return numerator.ofBaseUnits(baseUnitMagnitude() * other.baseUnitMagnitude());
-    } else if (unit() instanceof Velocity<?> v && other.unit().getBaseUnit().equals(Seconds)) {
-      // Multiplying a velocity by a time, return the scalar unit (eg Distance)
-      Unit<?> numerator = v.getUnit();
-      return numerator.ofBaseUnits(baseUnitMagnitude() * other.baseUnitMagnitude());
-    } else if (other.unit() instanceof Per<?, ?> per
-        && unit().getBaseUnit().equals(per.denominator().getBaseUnit())) {
-      Unit<?> numerator = per.numerator();
-      return numerator.ofBaseUnits(baseUnitMagnitude() * other.baseUnitMagnitude());
-    } else if (unit() instanceof Per<?, ?> per
-        && other.unit() instanceof Per<?, ?> otherPer
+    // First try to eliminate any common units
+    if (unit() instanceof PerUnit<?, ?> ratio
+        && multiplier.baseUnit().equals(ratio.denominator().getBaseUnit())) {
+      // Per<N, D> * D -> yield N
+      // Case 1: denominator of the Per cancels out, return with just the units of the numerator
+      return ratio.numerator().ofBaseUnits(baseUnitResult);
+    } else if (multiplier.baseUnit() instanceof PerUnit<?, ?> ratio
+        && baseUnit().equals(ratio.denominator().getBaseUnit())) {
+      // D * Per<N, D) -> yield N
+      // Case 2: Same as Case 1, just flipped between this and the multiplier
+      return ratio.numerator().ofBaseUnits(baseUnitResult);
+    } else if (unit() instanceof PerUnit<?, ?> per
+        && multiplier.unit() instanceof PerUnit<?, ?> otherPer
         && per.denominator().getBaseUnit().equals(otherPer.numerator().getBaseUnit())
         && per.numerator().getBaseUnit().equals(otherPer.denominator().getBaseUnit())) {
       // multiplying eg meters per second * milliseconds per foot
       // return a scalar
-      return Units.Value.of(baseUnitMagnitude() * other.baseUnitMagnitude());
+      return Value.of(baseUnitResult);
+    }
+
+    // No common units to eliminate, is one of them dimensionless?
+    // Note that this must come *after* the multiplier cases, otherwise
+    // Per<U, Dimensionless> * Dimensionless will not return a U
+    if (multiplier.unit() instanceof DimensionlessUnit) {
+      // scalar multiplication of this
+      return times(multiplier.baseUnitMagnitude());
+    } else if (unit() instanceof DimensionlessUnit) {
+      // scalar multiplication of multiplier
+      return multiplier.times(baseUnitMagnitude());
     }
 
-    // Dimensional analysis fallthrough, do a basic unit multiplication
-    return unit().mult(other.unit()).ofBaseUnits(baseUnitMagnitude() * other.baseUnitMagnitude());
+    if (multiplier instanceof Acceleration<?> acceleration) {
+      return times(acceleration);
+    } else if (multiplier instanceof Angle angle) {
+      return times(angle);
+    } else if (multiplier instanceof AngularAcceleration angularAcceleration) {
+      return times(angularAcceleration);
+    } else if (multiplier instanceof AngularMomentum angularMomentum) {
+      return times(angularMomentum);
+    } else if (multiplier instanceof AngularVelocity angularVelocity) {
+      return times(angularVelocity);
+    } else if (multiplier instanceof Current current) {
+      return times(current);
+    } else if (multiplier instanceof Dimensionless dimensionless) {
+      // n.b. this case should already be covered
+      return times(dimensionless);
+    } else if (multiplier instanceof Distance distance) {
+      return times(distance);
+    } else if (multiplier instanceof Energy energy) {
+      return times(energy);
+    } else if (multiplier instanceof Force force) {
+      return times(force);
+    } else if (multiplier instanceof Frequency frequency) {
+      return times(frequency);
+    } else if (multiplier instanceof LinearAcceleration linearAcceleration) {
+      return times(linearAcceleration);
+    } else if (multiplier instanceof LinearVelocity linearVelocity) {
+      return times(linearVelocity);
+    } else if (multiplier instanceof Mass mass) {
+      return times(mass);
+    } else if (multiplier instanceof MomentOfInertia momentOfInertia) {
+      return times(momentOfInertia);
+    } else if (multiplier instanceof Mult<?, ?> mult) {
+      return times(mult);
+    } else if (multiplier instanceof Per<?, ?> per) {
+      return times(per);
+    } else if (multiplier instanceof Power power) {
+      return times(power);
+    } else if (multiplier instanceof Temperature temperature) {
+      return times(temperature);
+    } else if (multiplier instanceof Time time) {
+      return times(time);
+    } else if (multiplier instanceof Torque torque) {
+      return times(torque);
+    } else if (multiplier instanceof Velocity<?> velocity) {
+      return times(velocity);
+    } else if (multiplier instanceof Voltage voltage) {
+      return times(voltage);
+    } else {
+      // Dimensional analysis fallthrough or a generic input measure type
+      // Do a basic unit multiplication
+      return MultUnit.combine(unit(), multiplier.unit()).ofBaseUnits(baseUnitResult);
+    }
   }
 
   /**
-   * Divides this measurement by some constant divisor and returns the result. This is equivalent to
-   * {@code times(1 / divisor)}
+   * Multiplies this measure by an acceleration and returns the resulting measure in the most
+   * appropriate unit.
    *
-   * @param divisor the constant to divide by
-   * @return the resulting measure
-   * @see #times(double)
+   * @param multiplier the measurement to multiply by.
+   * @return the multiplication result
+   */
+  default Measure<?> times(Acceleration<?> multiplier) {
+    return MultUnit.combine(unit(), multiplier.unit())
+        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  /**
+   * Multiplies this measure by an angle and returns the resulting measure in the most appropriate
+   * unit.
+   *
+   * @param multiplier the measurement to multiply by.
+   * @return the multiplication result
+   */
+  default Measure<?> times(Angle multiplier) {
+    return MultUnit.combine(unit(), multiplier.unit())
+        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  /**
+   * Multiplies this measure by an angular acceleration and returns the resulting measure in the
+   * most appropriate unit.
+   *
+   * @param multiplier the measurement to multiply by.
+   * @return the multiplication result
+   */
+  default Measure<?> times(AngularAcceleration multiplier) {
+    return MultUnit.combine(unit(), multiplier.unit())
+        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  /**
+   * Multiplies this measure by an angular momentum and returns the resulting measure in the most
+   * appropriate unit.
+   *
+   * @param multiplier the measurement to multiply by.
+   * @return the multiplication result
+   */
+  default Measure<?> times(AngularMomentum multiplier) {
+    return MultUnit.combine(unit(), multiplier.unit())
+        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  /**
+   * Multiplies this measure by an angular velocity and returns the resulting measure in the most
+   * appropriate unit.
+   *
+   * @param multiplier the measurement to multiply by.
+   * @return the multiplication result
+   */
+  default Measure<?> times(AngularVelocity multiplier) {
+    return MultUnit.combine(unit(), multiplier.unit())
+        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  /**
+   * Multiplies this measure by an electric current and returns the resulting measure in the most
+   * appropriate unit.
+   *
+   * @param multiplier the measurement to multiply by.
+   * @return the multiplication result
+   */
+  default Measure<?> times(Current multiplier) {
+    return MultUnit.combine(unit(), multiplier.unit())
+        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  /**
+   * Multiplies this measure by a distance and returns the resulting measure in the most appropriate
+   * unit.
+   *
+   * @param multiplier the measurement to multiply by.
+   * @return the multiplication result
+   */
+  default Measure<?> times(Distance multiplier) {
+    return MultUnit.combine(unit(), multiplier.unit())
+        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  /**
+   * Multiplies this measure by an energy and returns the resulting measure in the most appropriate
+   * unit.
+   *
+   * @param multiplier the measurement to multiply by.
+   * @return the multiplication result
+   */
+  default Measure<?> times(Energy multiplier) {
+    return MultUnit.combine(unit(), multiplier.unit())
+        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  /**
+   * Multiplies this measure by a force and returns the resulting measure in the most appropriate
+   * unit.
+   *
+   * @param multiplier the measurement to multiply by.
+   * @return the multiplication result
+   */
+  default Measure<?> times(Force multiplier) {
+    return MultUnit.combine(unit(), multiplier.unit())
+        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  /**
+   * Multiplies this measure by a frequency and returns the resulting measure in the most
+   * appropriate unit. This often - but not always - means implementations return a variation of a
+   * {@link Per} measure.
+   *
+   * @param multiplier the measurement to multiply by.
+   * @return the multiplication result
+   */
+  default Measure<?> times(Frequency multiplier) {
+    return MultUnit.combine(unit(), multiplier.unit())
+        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  /**
+   * Multiplies this measure by a linear acceleration and returns the resulting measure in the most
+   * appropriate unit.
+   *
+   * @param multiplier the measurement to multiply by.
+   * @return the multiplication result
+   */
+  default Measure<?> times(LinearAcceleration multiplier) {
+    return MultUnit.combine(unit(), multiplier.unit())
+        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  /**
+   * Multiplies this measure by a linear momentum and returns the resulting measure in the most
+   * appropriate unit.
+   *
+   * @param multiplier the measurement to multiply by.
+   * @return the multiplication result
+   */
+  default Measure<?> times(LinearMomentum multiplier) {
+    return MultUnit.combine(unit(), multiplier.unit())
+        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  /**
+   * Multiplies this measure by a linear velocity and returns the resulting measure in the most
+   * appropriate unit.
+   *
+   * @param multiplier the measurement to multiply by.
+   * @return the multiplication result
+   */
+  default Measure<?> times(LinearVelocity multiplier) {
+    return MultUnit.combine(unit(), multiplier.unit())
+        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  /**
+   * Multiplies this measure by a mass and returns the resulting measure in the most appropriate
+   * unit.
+   *
+   * @param multiplier the measurement to multiply by.
+   * @return the multiplication result
+   */
+  default Measure<?> times(Mass multiplier) {
+    return MultUnit.combine(unit(), multiplier.unit())
+        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  /**
+   * Multiplies this measure by a moment of intertia and returns the resulting measure in the most
+   * appropriate unit.
+   *
+   * @param multiplier the measurement to multiply by.
+   * @return the multiplication result
+   */
+  default Measure<?> times(MomentOfInertia multiplier) {
+    return MultUnit.combine(unit(), multiplier.unit())
+        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  /**
+   * Multiplies this measure by a generic multiplied measure and returns the resulting measure in
+   * the most appropriate unit.
+   *
+   * @param multiplier the measurement to multiply by.
+   * @return the multiplication result
    */
-  default Measure<U> divide(double divisor) {
-    return times(1 / divisor);
+  default Measure<?> times(Mult<?, ?> multiplier) {
+    return MultUnit.combine(unit(), multiplier.unit())
+        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
   }
 
+  /**
+   * Multiplies this measure by a power and returns the resulting measure in the most appropriate
+   * unit.
+   *
+   * @param multiplier the measurement to multiply by.
+   * @return the multiplication result
+   */
+  default Measure<?> times(Power multiplier) {
+    return MultUnit.combine(unit(), multiplier.unit())
+        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  /**
+   * Multiplies this measure by a generic ratio measurement and returns the resulting measure in the
+   * most appropriate unit.
+   *
+   * @param multiplier the measurement to multiply by.
+   * @return the multiplication result
+   */
+  default Measure<?> times(Per<?, ?> multiplier) {
+    return MultUnit.combine(unit(), multiplier.unit())
+        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  /**
+   * Multiplies this measure by a temperature and returns the resulting measure in the most
+   * appropriate unit.
+   *
+   * @param multiplier the measurement to multiply by.
+   * @return the multiplication result
+   */
+  default Measure<?> times(Temperature multiplier) {
+    return MultUnit.combine(unit(), multiplier.unit())
+        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  /**
+   * Multiplies this measure by a time and returns the resulting measure in the most appropriate
+   * unit.
+   *
+   * @param multiplier the measurement to multiply by.
+   * @return the multiplication result
+   */
+  default Measure<?> times(Time multiplier) {
+    return MultUnit.combine(unit(), multiplier.unit())
+        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  /**
+   * Multiplies this measure by a torque and returns the resulting measure in the most appropriate
+   * unit.
+   *
+   * @param multiplier the measurement to multiply by.
+   * @return the multiplication result
+   */
+  default Measure<?> times(Torque multiplier) {
+    return MultUnit.combine(unit(), multiplier.unit())
+        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  /**
+   * Multiplies this measure by a generic velocity and returns the resulting measure in the most
+   * appropriate unit.
+   *
+   * @param multiplier the measurement to multiply by.
+   * @return the multiplication result
+   */
+  default Measure<?> times(Velocity<?> multiplier) {
+    return MultUnit.combine(unit(), multiplier.unit())
+        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  /**
+   * Multiplies this measure by a voltage and returns the resulting measure in the most appropriate
+   * unit.
+   *
+   * @param multiplier the measurement to multiply by.
+   * @return the multiplication result
+   */
+  default Measure<?> times(Voltage multiplier) {
+    return MultUnit.combine(unit(), multiplier.unit())
+        .ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  /**
+   * Multiplies this measure by a conversion factor, returning the converted measurement. Unlike
+   * {@link #times(Per)}, this allows for basic unit cancellation to return measurements of a known
+   * dimension.
+   *
+   * @param conversionFactor the conversion factor by which to multiply
+   * @param <Other> the unit type to convert to
+   * @param <M> the concrete return unit type. <strong>Note: the conversion factor's numerator unit
+   *     must return instances of this type from {@link Unit#ofBaseUnits(double)}}</strong>
+   * @return the converted result
+   */
+  @SuppressWarnings("unchecked")
+  default <Other extends Unit, M extends Measure<Other>> M timesConversionFactor(
+      Measure<? extends PerUnit<Other, U>> conversionFactor) {
+    return (M)
+        conversionFactor
+            .unit()
+            .getBaseUnit()
+            .numerator()
+            .ofBaseUnits(baseUnitMagnitude() * conversionFactor.baseUnitMagnitude());
+  }
+
+  /**
+   * Multiplies this measure by another measurement of the inverse unit type (eg Time multiplied by
+   * Frequency) and returns the resulting dimensionless measure.
+   *
+   * @param multiplier the measurement to multiply by.
+   * @return the multiplication result
+   */
+  default Dimensionless timesInverse(
+      Measure<? extends PerUnit<DimensionlessUnit, ? extends U>> multiplier) {
+    return Value.ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
+  }
+
+  /**
+   * Multiplies this measure by another measurement of something over the unit type (eg Time
+   * multiplied by LinearVelocity) and returns the resulting measure of the ratio's dividend unit.
+   *
+   * @param ratio the measurement to multiply by.
+   * @param <Other> other unit that the results are in terms of
+   * @return the multiplication result
+   */
+  default <Other extends Unit> Measure<Other> timesRatio(
+      Measure<? extends PerUnit<? extends Other, U>> ratio) {
+    return ImmutableMeasure.ofBaseUnits(
+        baseUnitMagnitude() * ratio.baseUnitMagnitude(), ratio.unit().numerator());
+  }
+
+  /**
+   * Divides this measure by a unitless scalar and returns the result.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   */
+  Measure<U> divide(double divisor);
+
+  /**
+   * Divides this measure by a dimensionless scalar and returns the result.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   */
+  Measure<U> divide(Dimensionless divisor);
+
   /**
    * Divides this measurement by another measure and performs some dimensional analysis to reduce
    * the units.
    *
-   * @param <U2> the type of the other measure to multiply by
-   * @param other the unit to multiply by
+   * @param divisor the unit to divide by
    * @return the resulting measure
    */
-  default <U2 extends Unit<U2>> Measure<?> divide(Measure<U2> other) {
-    if (unit().getBaseUnit().equals(other.unit().getBaseUnit())) {
-      return Units.Value.ofBaseUnits(baseUnitMagnitude() / other.baseUnitMagnitude());
+  default Measure<?> divide(Measure<?> divisor) {
+    final double baseUnitResult = baseUnitMagnitude() / divisor.baseUnitMagnitude();
+
+    if (unit().getBaseUnit().equals(divisor.unit().getBaseUnit())) {
+      // These are the same unit, return a dimensionless
+      return Value.ofBaseUnits(baseUnitResult);
     }
-    if (other.unit() instanceof Dimensionless) {
-      return divide(other.baseUnitMagnitude());
+
+    if (divisor instanceof Dimensionless) {
+      // Dividing by a dimensionless, do a scalar division
+      return unit().ofBaseUnits(baseUnitResult);
     }
-    if (other.unit() instanceof Velocity<?> velocity
-        && velocity.getUnit().getBaseUnit().equals(unit().getBaseUnit())) {
-      return times(velocity.reciprocal().ofBaseUnits(1 / other.baseUnitMagnitude()));
+
+    if (unit() instanceof DimensionlessUnit) {
+      // Numerator is a dimensionless
+      if (divisor.unit() instanceof PerUnit<?, ?> ratio) {
+        // Dividing by a ratio, return its reciprocal scaled by this
+        return ratio.reciprocal().ofBaseUnits(baseUnitResult);
+      }
+      if (divisor.unit() instanceof PerUnit<?, ?> ratio) {
+        // Dividing by a Per<Time, U>, return its reciprocal velocity scaled by this
+        // Note: Per<Time, U>.reciprocal() is coded to return a Velocity<U>
+        return ratio.reciprocal().ofBaseUnits(baseUnitResult);
+      }
     }
-    if (other.unit() instanceof Per<?, ?> per
-        && per.numerator().getBaseUnit().equals(unit().getBaseUnit())) {
-      return times(per.reciprocal().ofBaseUnits(1 / other.baseUnitMagnitude()));
+
+    if (divisor.unit() instanceof PerUnit<?, ?> ratio
+        && ratio.numerator().getBaseUnit().equals(baseUnit())) {
+      // Numerator of the ratio cancels out
+      // N / (N / D) -> N * D / N -> D
+      // Note: all Velocity and Acceleration units inherit from PerUnit
+      return ratio.denominator().ofBaseUnits(baseUnitResult);
+    }
+
+    if (divisor.unit() instanceof TimeUnit time) {
+      // Dividing by a time, return a Velocity
+      return VelocityUnit.combine(unit(), time).ofBaseUnits(baseUnitResult);
+    }
+
+    if (divisor instanceof Acceleration<?> acceleration) {
+      return divide(acceleration);
+    } else if (divisor instanceof Angle angle) {
+      return divide(angle);
+    } else if (divisor instanceof AngularAcceleration angularAcceleration) {
+      return divide(angularAcceleration);
+    } else if (divisor instanceof AngularMomentum angularMomentum) {
+      return divide(angularMomentum);
+    } else if (divisor instanceof AngularVelocity angularVelocity) {
+      return divide(angularVelocity);
+    } else if (divisor instanceof Current current) {
+      return divide(current);
+    } else if (divisor instanceof Dimensionless dimensionless) {
+      // n.b. this case should already be covered
+      return divide(dimensionless);
+    } else if (divisor instanceof Distance distance) {
+      return divide(distance);
+    } else if (divisor instanceof Energy energy) {
+      return divide(energy);
+    } else if (divisor instanceof Force force) {
+      return divide(force);
+    } else if (divisor instanceof Frequency frequency) {
+      return divide(frequency);
+    } else if (divisor instanceof LinearAcceleration linearAcceleration) {
+      return divide(linearAcceleration);
+    } else if (divisor instanceof LinearVelocity linearVelocity) {
+      return divide(linearVelocity);
+    } else if (divisor instanceof Mass mass) {
+      return divide(mass);
+    } else if (divisor instanceof MomentOfInertia momentOfInertia) {
+      return divide(momentOfInertia);
+    } else if (divisor instanceof Mult<?, ?> mult) {
+      return divide(mult);
+    } else if (divisor instanceof Per<?, ?> per) {
+      return divide(per);
+    } else if (divisor instanceof Power power) {
+      return divide(power);
+    } else if (divisor instanceof Temperature temperature) {
+      return divide(temperature);
+    } else if (divisor instanceof Time time) {
+      return divide(time);
+    } else if (divisor instanceof Torque torque) {
+      return divide(torque);
+    } else if (divisor instanceof Velocity<?> velocity) {
+      return divide(velocity);
+    } else if (divisor instanceof Voltage voltage) {
+      return divide(voltage);
+    } else {
+      // Dimensional analysis fallthrough or a generic input measure type
+      // Do a basic unit multiplication
+      return PerUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitResult);
     }
-    return unit().per(other.unit()).ofBaseUnits(baseUnitMagnitude() / other.baseUnitMagnitude());
   }
 
   /**
-   * Creates a velocity measure by dividing this one by a time period measure.
+   * Divides this measure by a generic acceleration and returns the result in the most appropriate
+   * unit.
    *
-   * <pre>
-   *   Meters.of(1).per(Second) // Measure&lt;Velocity&lt;Distance&gt;&gt;
-   * </pre>
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   */
+  default Measure<?> divide(Acceleration<?> divisor) {
+    return PerUnit.combine(unit(), divisor.unit())
+        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  /**
+   * Divides this measure by an angle and returns the result in the most appropriate unit.
    *
-   * @param period the time period to divide by.
-   * @return the velocity result
+   * @param divisor the measurement to divide by.
+   * @return the division result
    */
-  default Measure<Velocity<U>> per(Measure<Time> period) {
-    var newUnit = unit().per(period.unit());
-    return ImmutableMeasure.ofBaseUnits(baseUnitMagnitude() / period.baseUnitMagnitude(), newUnit);
+  default Measure<?> divide(Angle divisor) {
+    return PerUnit.combine(unit(), divisor.unit())
+        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
   /**
-   * Creates a relational measure equivalent to this one per some other unit.
+   * Divides this measure by an angular acceleration and returns the result in the most appropriate
+   * unit.
    *
-   * <pre>
-   *   Volts.of(1.05).per(Meter) // V/m, potential PID constant
-   * </pre>
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   */
+  default Measure<?> divide(AngularAcceleration divisor) {
+    return PerUnit.combine(unit(), divisor.unit())
+        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  /**
+   * Divides this measure by an angular momentum and returns the result in the most appropriate
+   * unit.
    *
-   * @param <U2> the type of the denominator unit
-   * @param denominator the denominator unit being divided by
-   * @return the relational measure
+   * @param divisor the measurement to divide by.
+   * @return the division result
    */
-  default <U2 extends Unit<U2>> Measure<Per<U, U2>> per(U2 denominator) {
-    var newUnit = unit().per(denominator);
-    return newUnit.of(magnitude());
+  default Measure<?> divide(AngularMomentum divisor) {
+    return PerUnit.combine(unit(), divisor.unit())
+        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
   /**
-   * Creates a velocity measure equivalent to this one per a unit of time.
+   * Divides this measure by an angular velocity and returns the result in the most appropriate
+   * unit.
    *
-   * <pre>
-   *   Radians.of(3.14).per(Second) // Velocity&lt;Angle&gt; equivalent to RadiansPerSecond.of(3.14)
-   * </pre>
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   */
+  default Measure<?> divide(AngularVelocity divisor) {
+    return PerUnit.combine(unit(), divisor.unit())
+        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  /**
+   * Divides this measure by an electric current and returns the result in the most appropriate
+   * unit.
    *
-   * @param time the unit of time
-   * @return the velocity measure
+   * @param divisor the measurement to divide by.
+   * @return the division result
    */
-  default Measure<Velocity<U>> per(Time time) {
-    var newUnit = unit().per(time);
-    return newUnit.of(magnitude());
+  default Measure<?> divide(Current divisor) {
+    return PerUnit.combine(unit(), divisor.unit())
+        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
   /**
-   * Adds another measure to this one. The resulting measure has the same unit as this one.
+   * Divides this measure by a distance and returns the result in the most appropriate unit.
    *
-   * @param other the measure to add to this one
-   * @return a new measure containing the result
+   * @param divisor the measurement to divide by.
+   * @return the division result
    */
-  default Measure<U> plus(Measure<U> other) {
-    return unit().ofBaseUnits(baseUnitMagnitude() + other.baseUnitMagnitude());
+  default Measure<?> divide(Distance divisor) {
+    return PerUnit.combine(unit(), divisor.unit())
+        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
   /**
-   * Subtracts another measure from this one. The resulting measure has the same unit as this one.
+   * Divides this measure by an energy and returns the result in the most appropriate unit.
    *
-   * @param other the measure to subtract from this one
-   * @return a new measure containing the result
+   * @param divisor the measurement to divide by.
+   * @return the division result
    */
-  default Measure<U> minus(Measure<U> other) {
-    return unit().ofBaseUnits(baseUnitMagnitude() - other.baseUnitMagnitude());
+  default Measure<?> divide(Energy divisor) {
+    return PerUnit.combine(unit(), divisor.unit())
+        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
   /**
-   * Negates this measure and returns the result.
+   * Divides this measure by a force and returns the result in the most appropriate unit.
    *
-   * @return the resulting measure
+   * @param divisor the measurement to divide by.
+   * @return the division result
    */
-  default Measure<U> negate() {
-    return times(-1);
+  default Measure<?> divide(Force divisor) {
+    return PerUnit.combine(unit(), divisor.unit())
+        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
   /**
-   * Returns an immutable copy of this measure. The copy can be used freely and is guaranteed never
-   * to change.
+   * Divides this measure by a frequency and returns the result in the most appropriate unit.
    *
-   * @return the copied measure
+   * @param divisor the measurement to divide by.
+   * @return the division result
    */
-  Measure<U> copy();
+  default Measure<?> divide(Frequency divisor) {
+    return PerUnit.combine(unit(), divisor.unit())
+        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  /**
+   * Divides this measure by a linear acceleration and returns the result in the most appropriate
+   * unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   */
+  default Measure<?> divide(LinearAcceleration divisor) {
+    return PerUnit.combine(unit(), divisor.unit())
+        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  /**
+   * Divides this measure by a linear momentum and returns the result in the most appropriate unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   */
+  default Measure<?> divide(LinearMomentum divisor) {
+    return PerUnit.combine(unit(), divisor.unit())
+        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  /**
+   * Divides this measure by a linear velocity and returns the result in the most appropriate unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   */
+  default Measure<?> divide(LinearVelocity divisor) {
+    return PerUnit.combine(unit(), divisor.unit())
+        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  /**
+   * Divides this measure by a mass and returns the result in the most appropriate unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   */
+  default Measure<?> divide(Mass divisor) {
+    return PerUnit.combine(unit(), divisor.unit())
+        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  /**
+   * Divides this measure by a moment of inertia and returns the result in the most appropriate
+   * unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   */
+  default Measure<?> divide(MomentOfInertia divisor) {
+    return PerUnit.combine(unit(), divisor.unit())
+        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  /**
+   * Divides this measure by a generic multiplication and returns the result in the most appropriate
+   * unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   */
+  default Measure<?> divide(Mult<?, ?> divisor) {
+    return PerUnit.combine(unit(), divisor.unit())
+        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  /**
+   * Divides this measure by a power and returns the result in the most appropriate unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   */
+  default Measure<?> divide(Power divisor) {
+    return PerUnit.combine(unit(), divisor.unit())
+        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  /**
+   * Divides this measure by a generic ratio and returns the result in the most appropriate unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   */
+  default Measure<?> divide(Per<?, ?> divisor) {
+    return PerUnit.combine(unit(), divisor.unit())
+        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  /**
+   * Divides this measure by a temperature and returns the result in the most appropriate unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   */
+  default Measure<?> divide(Temperature divisor) {
+    return PerUnit.combine(unit(), divisor.unit())
+        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  /**
+   * Divides this measure by a time and returns the result in the most appropriate unit. This will
+   * often - but not always - result in a {@link Per} type like {@link LinearVelocity} or {@link
+   * Acceleration}.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   */
+  default Measure<?> divide(Time divisor) {
+    return VelocityUnit.combine(unit(), divisor.unit())
+        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  /**
+   * Divides this measure by a torque and returns the result in the most appropriate unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   */
+  default Measure<?> divide(Torque divisor) {
+    return PerUnit.combine(unit(), divisor.unit())
+        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  /**
+   * Divides this measure by a generic velocity and returns the result in the most appropriate unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   */
+  default Measure<?> divide(Velocity<?> divisor) {
+    return PerUnit.combine(unit(), divisor.unit())
+        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  /**
+   * Divides this measure by a voltage and returns the result in the most appropriate unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   */
+  default Measure<?> divide(Voltage divisor) {
+    return PerUnit.combine(unit(), divisor.unit())
+        .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
+  }
+
+  /**
+   * Divides this measure by a ratio in terms of this measurement's unit to another unit, returning
+   * a measurement in terms of the other unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @param <Other> the other unit that results are in terms of
+   * @return the division result
+   */
+  // eg Dimensionless / (Dimensionless / Time) -> Time
+  default <Other extends Unit> Measure<Other> divideRatio(
+      Measure<? extends PerUnit<? extends U, Other>> divisor) {
+    return ImmutableMeasure.ofBaseUnits(
+        baseUnitMagnitude() / divisor.baseUnitMagnitude(), divisor.unit().denominator());
+  }
 
   /**
-   * Creates a new mutable copy of this measure.
+   * Divides this measure by a time period and returns the result in the most appropriate unit. This
+   * is equivalent to {@code divide(period.of(1))}.
    *
-   * @return a mutable measure initialized to be identical to this measure
+   * @param period the time period measurement to divide by.
+   * @return the division result
    */
-  default MutableMeasure<U> mutableCopy() {
-    return MutableMeasure.mutable(this);
+  default Measure<?> per(TimeUnit period) {
+    return divide(period.of(1));
   }
 
   /**
@@ -358,7 +1094,7 @@ default boolean lte(Measure<U> o) {
    * @return the measure with the greatest positive magnitude, or null if no measures were provided
    */
   @SafeVarargs
-  static <U extends Unit<U>> Measure<U> max(Measure<U>... measures) {
+  static <U extends Unit> Measure<U> max(Measure<U>... measures) {
     if (measures.length == 0) {
       return null; // nothing to compare
     }
@@ -381,7 +1117,7 @@ static <U extends Unit<U>> Measure<U> max(Measure<U>... measures) {
    * @return the measure with the greatest negative magnitude
    */
   @SafeVarargs
-  static <U extends Unit<U>> Measure<U> min(Measure<U>... measures) {
+  static <U extends Unit> Measure<U> min(Measure<U>... measures) {
     if (measures.length == 0) {
       return null; // nothing to compare
     }
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/MomentOfInertiaUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/MomentOfInertiaUnit.java
new file mode 100644
index 00000000000..74362d9a9f1
--- /dev/null
+++ b/wpiunits/src/main/java/edu/wpi/first/units/MomentOfInertiaUnit.java
@@ -0,0 +1,107 @@
+// 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.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
+ * of inertia describe how much an object resists being rotated, analogous to mass's resistance to
+ * being accelerated along a line.
+ */
+public final class MomentOfInertiaUnit extends PerUnit<AngularMomentumUnit, AngularVelocityUnit> {
+  private static final CombinatoryUnitCache<
+          AngularMomentumUnit, AngularVelocityUnit, MomentOfInertiaUnit>
+      cache = new CombinatoryUnitCache<>(MomentOfInertiaUnit::new);
+
+  MomentOfInertiaUnit(AngularMomentumUnit numerator, AngularVelocityUnit denominator) {
+    super(
+        numerator.isBaseUnit() && denominator.isBaseUnit()
+            ? null
+            : combine(numerator.getBaseUnit(), denominator.getBaseUnit()),
+        numerator,
+        denominator);
+  }
+
+  MomentOfInertiaUnit(
+      PerUnit<AngularMomentumUnit, AngularVelocityUnit> baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  /**
+   * Combines an angular momentum and angular velocity unit to form a moment of inertia unit.
+   *
+   * @param momentumUnit the unit of angular momentum
+   * @param velocityUnit the unit of angular velocity
+   * @return the combined moment of inertia unit
+   */
+  public static MomentOfInertiaUnit combine(
+      AngularMomentumUnit momentumUnit, AngularVelocityUnit velocityUnit) {
+    return cache.combine(momentumUnit, velocityUnit);
+  }
+
+  @Override
+  public MomentOfInertiaUnit getBaseUnit() {
+    return (MomentOfInertiaUnit) super.getBaseUnit();
+  }
+
+  @Override
+  public MomentOfInertia of(double magnitude) {
+    return new ImmutableMomentOfInertia(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public MomentOfInertia ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableMomentOfInertia(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public MomentOfInertia zero() {
+    return (MomentOfInertia) super.zero();
+  }
+
+  @Override
+  public MomentOfInertia one() {
+    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);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<MomentOfInertiaUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other unit
+   * @param otherUnit the other unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, MomentOfInertiaUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/Mult.java b/wpiunits/src/main/java/edu/wpi/first/units/Mult.java
deleted file mode 100644
index fa3570e4cc8..00000000000
--- a/wpiunits/src/main/java/edu/wpi/first/units/Mult.java
+++ /dev/null
@@ -1,123 +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.collections.LongToObjectHashMap;
-import java.util.Objects;
-
-/**
- * A combinatory unit type that is equivalent to the product of two other others. Note that
- * algebraic reduction is not possible in Java's generic type system, so {@code Mult<A, B>} is not
- * type-compatible with {@code Mult<B, A>}!
- *
- * @param <A> the type of the first unit in the result
- * @param <B> the type of the second unit in the result
- */
-public class Mult<A extends Unit<A>, B extends Unit<B>> extends Unit<Mult<A, B>> {
-  private final A m_unitA;
-  private final B m_unitB;
-
-  @SuppressWarnings("rawtypes")
-  private static final LongToObjectHashMap<Mult> cache = new LongToObjectHashMap<>();
-
-  /**
-   * Creates a new product unit. Consider using {@link #combine} instead of manually calling this
-   * constructor.
-   *
-   * @param a the first unit of the product
-   * @param b the second unit of the product
-   */
-  protected Mult(A a, B b) {
-    super(
-        a.isBaseUnit() && b.isBaseUnit() ? null : combine(a.getBaseUnit(), b.getBaseUnit()),
-        a.toBaseUnits(1) * b.toBaseUnits(1),
-        a.name() + "-" + b.name(),
-        a.symbol() + "*" + b.symbol());
-    m_unitA = a;
-    m_unitB = b;
-  }
-
-  Mult(
-      Mult<A, B> baseUnit,
-      UnaryFunction toBaseConverter,
-      UnaryFunction fromBaseConverter,
-      String name,
-      String symbol) {
-    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
-    m_unitA = baseUnit.unitA();
-    m_unitB = baseUnit.unitB();
-  }
-
-  /**
-   * Creates a new Mult unit derived from two arbitrary units multiplied together.
-   *
-   * <pre>
-   *   Mult.combine(Volts, Meters) // Volt-Meters
-   * </pre>
-   *
-   * <p>It's recommended to use the convenience function {@link Unit#mult(Unit)} instead of calling
-   * this factory directly.
-   *
-   * @param <A> the type of the first unit
-   * @param <B> the type of the second unit
-   * @param a the first unit
-   * @param b the second unit
-   * @return the combined unit
-   */
-  @SuppressWarnings("unchecked")
-  public static <A extends Unit<A>, B extends Unit<B>> Mult<A, B> combine(A a, B b) {
-    final long key = ((long) a.hashCode()) << 32L | (b.hashCode() & 0xFFFFFFFFL);
-    if (cache.containsKey(key)) {
-      return cache.get(key);
-    }
-
-    var mult = new Mult<A, B>(a, b);
-    cache.put(key, mult);
-    return mult;
-  }
-
-  /**
-   * Gets the first unit of the product.
-   *
-   * @return the first unit
-   */
-  public A unitA() {
-    return m_unitA;
-  }
-
-  /**
-   * Gets the second unit of the product.
-   *
-   * @return the second unit
-   */
-  public B unitB() {
-    return m_unitB;
-  }
-
-  @Override
-  public String toString() {
-    return "(" + m_unitA.toString() + " * " + m_unitB.toString() + ")";
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) {
-      return true;
-    }
-    if (o == null || getClass() != o.getClass()) {
-      return false;
-    }
-    if (!super.equals(o)) {
-      return false;
-    }
-    Mult<?, ?> mult = (Mult<?, ?>) o;
-    return Objects.equals(m_unitA, mult.m_unitA) && Objects.equals(m_unitB, mult.m_unitB);
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(super.hashCode(), m_unitA, m_unitB);
-  }
-}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/MultUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/MultUnit.java
new file mode 100644
index 00000000000..2c6906c7178
--- /dev/null
+++ b/wpiunits/src/main/java/edu/wpi/first/units/MultUnit.java
@@ -0,0 +1,229 @@
+// 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.ImmutableMult;
+import edu.wpi.first.units.measure.Mult;
+import edu.wpi.first.units.measure.MutMult;
+import java.util.Objects;
+
+/**
+ * A combinatory unit type that is equivalent to the product of two other others. Note that
+ * algebraic reduction is not possible in Java's generic type system, so {@code MultUnit<A, B>} is
+ * not type-compatible with {@code MultUnit<B, A>}!
+ *
+ * @param <A> the type of the first unit in the result
+ * @param <B> the type of the second unit in the result
+ */
+public class MultUnit<A extends Unit, B extends Unit> extends Unit {
+  private final A m_unitA;
+  private final B m_unitB;
+
+  @SuppressWarnings("rawtypes")
+  private static final CombinatoryUnitCache<Unit, Unit, MultUnit> cache =
+      new CombinatoryUnitCache<>(MultUnit::new);
+
+  /**
+   * Creates a new product unit. Consider using {@link #combine} instead of manually calling this
+   * constructor.
+   *
+   * @param a the first unit of the product
+   * @param b the second unit of the product
+   */
+  private MultUnit(A a, B b) {
+    super(
+        a.isBaseUnit() && b.isBaseUnit() ? null : combine(a.getBaseUnit(), b.getBaseUnit()),
+        a.toBaseUnits(1) * b.toBaseUnits(1),
+        a.name() + "-" + b.name(),
+        a.symbol() + "*" + b.symbol());
+    m_unitA = a;
+    m_unitB = b;
+  }
+
+  /**
+   * Creates a new product unit. Subclasses of {@code MultUnit} should use this constructor.
+   *
+   * @param baseUnit the base unit. Set this to null if the unit being constructed is its own base
+   *     unit
+   * @param a the first unit of the product
+   * @param b the second unit of the product
+   */
+  protected MultUnit(MultUnit<A, B> baseUnit, A a, B b) {
+    super(
+        baseUnit,
+        a.toBaseUnits(1) * b.toBaseUnits(1),
+        a.name() + "-" + b.name(),
+        a.symbol() + "*" + b.symbol());
+    m_unitA = a;
+    m_unitB = b;
+  }
+
+  MultUnit(
+      MultUnit<A, B> baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+    m_unitA = getBaseUnit().unitA();
+    m_unitB = getBaseUnit().unitB();
+  }
+
+  /**
+   * Creates a new MultUnit unit derived from two arbitrary units multiplied together.
+   *
+   * <pre>
+   *   MultUnit.combine(Volts, Meters) // Volt-Meters
+   * </pre>
+   *
+   * @param <A> the type of the first unit
+   * @param <B> the type of the second unit
+   * @param a the first unit
+   * @param b the second unit
+   * @return the combined unit
+   */
+  @SuppressWarnings("unchecked")
+  public static <A extends Unit, B extends Unit> MultUnit<A, B> combine(A a, B b) {
+    return cache.combine(a, b);
+  }
+
+  /**
+   * {@inheritDoc}
+   *
+   * <p>Note: When called on an object of type {@code MultUnit} (and <i>not</i> a subclass!), this
+   * method will always return a {@link edu.wpi.first.units.measure.Mult} instance. If you want to
+   * avoid casting, use {@link #ofNativeBaseUnits(double)} that returns a {@code Per} instance
+   * directly.
+   *
+   * @param magnitude the magnitude of the measure in terms of its base units.
+   * @return the measurement object
+   */
+  @Override
+  public Measure<? extends MultUnit<A, B>> of(double magnitude) {
+    return ofNative(magnitude);
+  }
+
+  /**
+   * {@inheritDoc}
+   *
+   * <p>Note: When called on an object of type {@code MultUnit} (and <i>not</i> a subclass!), this
+   * method will always return a {@link edu.wpi.first.units.measure.Mult} instance. If you want to
+   * avoid casting, use {@link #ofNativeBaseUnits(double)} that returns a {@code Per} instance
+   * directly.
+   *
+   * @param baseUnitMagnitude the magnitude of the measure in terms of its base units.
+   * @return the measurement object
+   */
+  @Override
+  public Measure<? extends MultUnit<A, B>> ofBaseUnits(double baseUnitMagnitude) {
+    return ofNativeBaseUnits(baseUnitMagnitude);
+  }
+
+  /**
+   * Creates a new immutable measurement of the given magnitude in terms of this unit. This will
+   * always return a {@code Mult} object and cannot be overridden by subclasses.
+   *
+   * @param magnitude the magnitude of the measurement.
+   * @return the measurement object
+   * @see #of(double)
+   */
+  public final Mult<A, B> ofNative(double magnitude) {
+    return new ImmutableMult<>(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  /**
+   * Creates a new immutable measurement of the given magnitude in terms of the unit's base unit.
+   * This will always return a {@code Mult} object and cannot be overridden by subclasses.
+   *
+   * @param baseUnitMagnitude the magnitude of the measure in terms of its base units.
+   * @return the measurement object
+   * @see #ofBaseUnits(double)
+   */
+  public final Mult<A, B> ofNativeBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableMult<>(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  @SuppressWarnings("unchecked")
+  public Measure<? extends MultUnit<A, B>> zero() {
+    return (Measure<? extends MultUnit<A, B>>) super.zero();
+  }
+
+  @Override
+  @SuppressWarnings("unchecked")
+  public Measure<? extends MultUnit<A, B>> one() {
+    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);
+  }
+
+  /**
+   * Converts a measurement value in terms of another unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other unit
+   * @param otherUnit the other unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, MultUnit<A, B> otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+
+  @Override
+  @SuppressWarnings("unchecked")
+  public MultUnit<A, B> getBaseUnit() {
+    return (MultUnit<A, B>) super.getBaseUnit();
+  }
+
+  /**
+   * Gets the first unit of the product.
+   *
+   * @return the first unit
+   */
+  public A unitA() {
+    return m_unitA;
+  }
+
+  /**
+   * Gets the second unit of the product.
+   *
+   * @return the second unit
+   */
+  public B unitB() {
+    return m_unitB;
+  }
+
+  @Override
+  public String toString() {
+    return "(" + m_unitA.toString() + " * " + m_unitB.toString() + ")";
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    if (!super.equals(o)) {
+      return false;
+    }
+    MultUnit<?, ?> multUnit = (MultUnit<?, ?>) o;
+    return Objects.equals(m_unitA, multUnit.m_unitA) && Objects.equals(m_unitB, multUnit.m_unitB);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(super.hashCode(), m_unitA, m_unitB);
+  }
+}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/MutableMeasure.java b/wpiunits/src/main/java/edu/wpi/first/units/MutableMeasure.java
index f62433f174d..672dbe61f0f 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/MutableMeasure.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/MutableMeasure.java
@@ -4,111 +4,54 @@
 
 package edu.wpi.first.units;
 
-import java.util.Objects;
+import edu.wpi.first.units.measure.Dimensionless;
 
 /**
- * A specialization of {@link Measure} that allows for mutability. This is intended to be used for
- * memory use reasons (such as on the memory-restricted roboRIO 1 or 2 or SBC coprocessors) and
- * should NOT be exposed in the public API for a class that uses it.
+ * 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.
  *
- * <p>The advantage of using this class is to reuse one instance of a measurement object, as opposed
- * to instantiating a new immutable instance every time an operation is performed. This will reduce
- * memory pressure, but comes at the cost of increased code complexity and sensitivity to race
- * conditions if misused.
- *
- * <p>Any unsafe methods are prefixed with {@code mut_*}, such as {@link #mut_plus(Measure)} or
- * {@link #mut_replace(Measure)}. These methods will change the internal state of the measurement
- * object, and as such can be dangerous to use. They are primarily intended for use to track
- * internal state of things like sensors
- *
- * @param <U> the type of the unit of measure
+ * @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 final class MutableMeasure<U extends Unit<U>> implements Measure<U> {
-  private double m_magnitude;
-  private double m_baseUnitMagnitude;
-  private U m_unit;
-
-  private MutableMeasure(double initialMagnitude, double baseUnitMagnitude, U unit) {
-    m_magnitude = initialMagnitude;
-    m_baseUnitMagnitude = baseUnitMagnitude;
-    m_unit = unit;
-  }
-
-  /**
-   * Creates a new mutable measure that is a copy of the given one.
-   *
-   * @param <U> the type of the units of measure
-   * @param measure the measure to create a mutable copy of
-   * @return a new mutable measure with an initial state equal to the given measure
-   */
-  public static <U extends Unit<U>> MutableMeasure<U> mutable(Measure<U> measure) {
-    return new MutableMeasure<>(measure.magnitude(), measure.baseUnitMagnitude(), measure.unit());
-  }
-
-  /**
-   * Creates a new mutable measure with a magnitude of 0 in the given unit.
-   *
-   * @param <U> the type of the units of measure
-   * @param unit the unit of measure
-   * @return a new mutable measure
-   */
-  public static <U extends Unit<U>> MutableMeasure<U> zero(U unit) {
-    return mutable(unit.zero());
-  }
-
+public interface MutableMeasure<
+        U extends Unit, Base extends Measure<U>, MutSelf extends MutableMeasure<U, Base, MutSelf>>
+    extends Measure<U> {
   /**
-   * Creates a new mutable measure in the given unit with a magnitude equal to the given one in base
-   * units.
+   * Overwrites the state of this measure with new values.
    *
-   * @param <U> the type of the units of measure
-   * @param baseUnitMagnitude the magnitude of the measure, in terms of the base unit of measure
-   * @param unit the unit of measure
-   * @return a new mutable measure
+   * @param magnitude the new magnitude in terms of the new unit
+   * @param newUnit the new unit
+   * @return this measure
    */
-  public static <U extends Unit<U>> MutableMeasure<U> ofBaseUnits(
-      double baseUnitMagnitude, U unit) {
-    return new MutableMeasure<>(unit.fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, unit);
-  }
+  MutSelf mut_replace(double magnitude, U newUnit);
 
   /**
-   * Creates a new mutable measure in the given unit with a magnitude in terms of that unit.
+   * 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 <U> the type of the units of measure
-   * @param relativeMagnitude the magnitude of the measure
-   * @param unit the unit of measure
-   * @return a new mutable measure
+   * @param other the other measure to copy values from
+   * @return this measure
    */
-  public static <U extends Unit<U>> MutableMeasure<U> ofRelativeUnits(
-      double relativeMagnitude, U unit) {
-    return new MutableMeasure<>(relativeMagnitude, unit.toBaseUnits(relativeMagnitude), unit);
-  }
-
-  @Override
-  public double magnitude() {
-    return m_magnitude;
+  default MutSelf mut_replace(Base other) {
+    return mut_replace(other.magnitude(), other.unit());
   }
 
   @Override
-  public double baseUnitMagnitude() {
-    return m_baseUnitMagnitude;
-  }
-
-  @Override
-  public U unit() {
-    return m_unit;
-  }
-
-  // UNSAFE
+  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
    */
-  public void mut_setMagnitude(double magnitude) {
-    m_magnitude = magnitude;
-    m_baseUnitMagnitude = m_unit.toBaseUnits(magnitude);
+  default MutSelf mut_setMagnitude(double magnitude) {
+    return mut_replace(magnitude, unit());
   }
 
   /**
@@ -116,37 +59,10 @@ public void mut_setMagnitude(double magnitude) {
    * the current unit.
    *
    * @param baseUnitMagnitude the new magnitude of the measurement
+   * @return this mutable measure
    */
-  public void mut_setBaseUnitMagnitude(double baseUnitMagnitude) {
-    m_baseUnitMagnitude = baseUnitMagnitude;
-    m_magnitude = m_unit.fromBaseUnits(baseUnitMagnitude);
-  }
-
-  /**
-   * Overwrites the state of this measure and replaces it with values from the given one.
-   *
-   * @param other the other measure to copy values from
-   * @return this measure
-   */
-  public MutableMeasure<U> mut_replace(Measure<U> other) {
-    m_magnitude = other.magnitude();
-    m_baseUnitMagnitude = other.baseUnitMagnitude();
-    m_unit = other.unit();
-    return this;
-  }
-
-  /**
-   * Overwrites the state of this measure with new values.
-   *
-   * @param magnitude the new magnitude in terms of the new unit
-   * @param unit the new unit
-   * @return this measure
-   */
-  public MutableMeasure<U> mut_replace(double magnitude, U unit) {
-    this.m_magnitude = magnitude;
-    this.m_baseUnitMagnitude = unit.toBaseUnits(magnitude);
-    this.m_unit = unit;
-    return this;
+  default MutSelf mut_setBaseUnitMagnitude(double baseUnitMagnitude) {
+    return mut_replace(unit().fromBaseUnits(baseUnitMagnitude), unit());
   }
 
   /**
@@ -156,29 +72,20 @@ public MutableMeasure<U> mut_replace(double magnitude, U unit) {
    * @param raw the raw value to accumulate by
    * @return the measure
    */
-  public MutableMeasure<U> mut_acc(double raw) {
-    this.m_magnitude += raw;
-    this.m_baseUnitMagnitude += m_unit.toBaseUnits(raw);
-    return this;
+  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 the measure
+   * @return this measure
    */
-  public MutableMeasure<U> mut_acc(Measure<U> other) {
-    m_baseUnitMagnitude += other.baseUnitMagnitude();
-
-    // can't naively use m_magnitude += other.in(m_unit) because the units may not
-    // be scalar multiples (eg adding 0C to 100K should result in 373.15K, not 100K)
-    m_magnitude = m_unit.fromBaseUnits(m_baseUnitMagnitude);
-    return this;
+  default MutSelf mut_acc(Base other) {
+    return mut_setMagnitude(magnitude() + unit().fromBaseUnits(other.baseUnitMagnitude()));
   }
 
-  // Math
-
   /**
    * Adds another measurement to this one. This will mutate the object instead of generating a new
    * measurement object.
@@ -186,8 +93,8 @@ public MutableMeasure<U> mut_acc(Measure<U> other) {
    * @param other the measurement to add
    * @return this measure
    */
-  public MutableMeasure<U> mut_plus(Measure<U> other) {
-    return mut_plus(other.magnitude(), other.unit());
+  default MutSelf mut_plus(Base other) {
+    return mut_acc(other);
   }
 
   /**
@@ -196,36 +103,35 @@ public MutableMeasure<U> mut_plus(Measure<U> other) {
    * 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 unit the unit of the other measurement
+   * @param otherUnit the unit of the other measurement
    * @return this measure
    */
-  public MutableMeasure<U> mut_plus(double magnitude, U unit) {
-    mut_setBaseUnitMagnitude(m_baseUnitMagnitude + unit.toBaseUnits(magnitude));
-    return this;
+  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 add
+   * @param other the measurement to subtract from this one
    * @return this measure
    */
-  public MutableMeasure<U> mut_minus(Measure<U> other) {
-    return mut_minus(other.magnitude(), other.unit());
+  default MutSelf mut_minus(Base other) {
+    return mut_setBaseUnitMagnitude(baseUnitMagnitude() - other.baseUnitMagnitude());
   }
 
   /**
-   * Subtracts 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_minus(Measure)} to avoid
-   * having to wrap raw numbers in a {@code Measure} object and pay for an object allocation.
+   * 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 unit the unit of the other measurement
+   * @param otherUnit the unit of the other measurement
    * @return this measure
    */
-  public MutableMeasure<U> mut_minus(double magnitude, U unit) {
-    return mut_plus(-magnitude, unit);
+  default MutSelf mut_minus(double magnitude, U otherUnit) {
+    return mut_setBaseUnitMagnitude(baseUnitMagnitude() - otherUnit.toBaseUnits(magnitude));
   }
 
   /**
@@ -235,9 +141,8 @@ public MutableMeasure<U> mut_minus(double magnitude, U unit) {
    * @param multiplier the multiplier to scale the measurement by
    * @return this measure
    */
-  public MutableMeasure<U> mut_times(double multiplier) {
-    mut_setBaseUnitMagnitude(m_baseUnitMagnitude * multiplier);
-    return this;
+  default MutSelf mut_times(double multiplier) {
+    return mut_setBaseUnitMagnitude(baseUnitMagnitude() * multiplier);
   }
 
   /**
@@ -247,7 +152,7 @@ public MutableMeasure<U> mut_times(double multiplier) {
    * @param multiplier the multiplier to scale the measurement by
    * @return this measure
    */
-  public MutableMeasure<U> mut_times(Measure<? extends Dimensionless> multiplier) {
+  default MutSelf mut_times(Dimensionless multiplier) {
     return mut_times(multiplier.baseUnitMagnitude());
   }
 
@@ -258,9 +163,8 @@ public MutableMeasure<U> mut_times(Measure<? extends Dimensionless> multiplier)
    * @param divisor the divisor to scale the measurement by
    * @return this measure
    */
-  public MutableMeasure<U> mut_divide(double divisor) {
-    mut_setBaseUnitMagnitude(m_baseUnitMagnitude / divisor);
-    return this;
+  default MutSelf mut_divide(double divisor) {
+    return mut_times(1 / divisor);
   }
 
   /**
@@ -270,29 +174,7 @@ public MutableMeasure<U> mut_divide(double divisor) {
    * @param divisor the divisor to scale the measurement by
    * @return this measure
    */
-  public MutableMeasure<U> mut_divide(Measure<? extends Dimensionless> divisor) {
+  default MutSelf mut_divide(Dimensionless divisor) {
     return mut_divide(divisor.baseUnitMagnitude());
   }
-
-  @Override
-  public Measure<U> copy() {
-    return new ImmutableMeasure<>(m_magnitude, m_baseUnitMagnitude, m_unit);
-  }
-
-  @Override
-  public String toString() {
-    return toShortString();
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    return o instanceof Measure<?> that
-        && Objects.equals(m_unit, that.unit())
-        && this.isEquivalent(that);
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(m_magnitude, m_unit);
-  }
 }
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/Per.java b/wpiunits/src/main/java/edu/wpi/first/units/Per.java
deleted file mode 100644
index fe9131487e8..00000000000
--- a/wpiunits/src/main/java/edu/wpi/first/units/Per.java
+++ /dev/null
@@ -1,140 +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.collections.LongToObjectHashMap;
-import java.util.Objects;
-
-/**
- * Generic combinatory unit type that represents the proportion of one unit to another, such as
- * Meters per Second or Radians per Celsius.
- *
- * <p>Note: {@link Velocity} is used to represent the velocity dimension, rather than {@code
- * Per<Distance, Time>}.
- *
- * @param <N> the type of the numerator unit
- * @param <D> the type of the denominator unit
- */
-public class Per<N extends Unit<N>, D extends Unit<D>> extends Unit<Per<N, D>> {
-  private final N m_numerator;
-  private final D m_denominator;
-
-  /**
-   * Keep a cache of created instances so expressions like Volts.per(Meter) don't do any allocations
-   * after the first.
-   */
-  @SuppressWarnings("rawtypes")
-  private static final LongToObjectHashMap<Per> cache = new LongToObjectHashMap<>();
-
-  /**
-   * Creates a new proportional unit derived from the ratio of one unit to another. Consider using
-   * {@link #combine} instead of manually calling this constructor.
-   *
-   * @param numerator the numerator unit
-   * @param denominator the denominator unit
-   */
-  protected Per(N numerator, D denominator) {
-    super(
-        numerator.isBaseUnit() && denominator.isBaseUnit()
-            ? null
-            : combine(numerator.getBaseUnit(), denominator.getBaseUnit()),
-        numerator.toBaseUnits(1) / denominator.toBaseUnits(1),
-        numerator.name() + " per " + denominator.name(),
-        numerator.symbol() + "/" + denominator.symbol());
-    m_numerator = numerator;
-    m_denominator = denominator;
-  }
-
-  Per(
-      Per<N, D> baseUnit,
-      UnaryFunction toBaseConverter,
-      UnaryFunction fromBaseConverter,
-      String name,
-      String symbol) {
-    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
-    m_numerator = baseUnit.numerator();
-    m_denominator = baseUnit.denominator();
-  }
-
-  /**
-   * Creates a new Per unit derived from an arbitrary numerator and time denominator units. Using a
-   * denominator with a unit of time is discouraged; use {@link Velocity} instead.
-   *
-   * <pre>
-   *   Per.combine(Volts, Meters) // possible PID constant
-   * </pre>
-   *
-   * <p>It's recommended to use the convenience function {@link Unit#per(Unit)} instead of calling
-   * this factory directly.
-   *
-   * @param <N> the type of the numerator unit
-   * @param <D> the type of the denominator unit
-   * @param numerator the numerator unit
-   * @param denominator the denominator for unit time
-   * @return the combined unit
-   */
-  @SuppressWarnings("unchecked")
-  public static <N extends Unit<N>, D extends Unit<D>> Per<N, D> combine(
-      N numerator, D denominator) {
-    final long key = ((long) numerator.hashCode()) << 32L | (denominator.hashCode() & 0xFFFFFFFFL);
-
-    var existing = cache.get(key);
-    if (existing != null) {
-      return existing;
-    }
-
-    var newUnit = new Per<>(numerator, denominator);
-    cache.put(key, newUnit);
-    return newUnit;
-  }
-
-  /**
-   * Gets the numerator unit. For a {@code Per<A, B>}, this will return the {@code A} unit.
-   *
-   * @return the numerator unit
-   */
-  public N numerator() {
-    return m_numerator;
-  }
-
-  /**
-   * Gets the denominator unit. For a {@code Per<A, B>}, this will return the {@code B} unit.
-   *
-   * @return the denominator unit
-   */
-  public D denominator() {
-    return m_denominator;
-  }
-
-  /**
-   * Returns the reciprocal of this Per.
-   *
-   * @return the reciprocal
-   */
-  public Per<D, N> reciprocal() {
-    return m_denominator.per(m_numerator);
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) {
-      return true;
-    }
-    if (o == null || getClass() != o.getClass()) {
-      return false;
-    }
-    if (!super.equals(o)) {
-      return false;
-    }
-    Per<?, ?> per = (Per<?, ?>) o;
-    return Objects.equals(m_numerator, per.m_numerator)
-        && Objects.equals(m_denominator, per.m_denominator);
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(super.hashCode(), m_numerator, m_denominator);
-  }
-}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/PerUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/PerUnit.java
new file mode 100644
index 00000000000..3c7de4ad3cf
--- /dev/null
+++ b/wpiunits/src/main/java/edu/wpi/first/units/PerUnit.java
@@ -0,0 +1,287 @@
+// 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.ImmutablePer;
+import edu.wpi.first.units.measure.MutPer;
+import edu.wpi.first.units.measure.Per;
+import java.util.Objects;
+
+/**
+ * Generic combinatory unit type that represents the proportion of one unit to another, such as
+ * Meters per Second or Radians per Celsius.
+ *
+ * @param <N> the type of the numerator unit
+ * @param <D> the type of the denominator unit
+ */
+public class PerUnit<N extends Unit, D extends Unit> extends Unit {
+  private final N m_numerator;
+  private final D m_denominator;
+
+  /**
+   * Keep a cache of created instances so expressions like Volts.per(Meter) don't do any allocations
+   * after the first.
+   */
+  @SuppressWarnings("rawtypes")
+  private static final CombinatoryUnitCache<Unit, Unit, PerUnit> cache =
+      new CombinatoryUnitCache<>(PerUnit::new);
+
+  /**
+   * Creates a new proportional unit derived from the ratio of one unit to another. Consider using
+   * {@link #combine} instead of manually calling this constructor.
+   *
+   * @param numerator the numerator unit
+   * @param denominator the denominator unit
+   */
+  private PerUnit(N numerator, D denominator) {
+    super(
+        numerator.isBaseUnit() && denominator.isBaseUnit()
+            ? null
+            : combine(numerator.getBaseUnit(), denominator.getBaseUnit()),
+        numerator.toBaseUnits(1) / denominator.toBaseUnits(1),
+        numerator.name() + " per " + denominator.name(),
+        numerator.symbol() + "/" + denominator.symbol());
+    m_numerator = numerator;
+    m_denominator = denominator;
+  }
+
+  /**
+   * Creates a new proportional unit derived from the ratio of one unit to another. Subclasses of
+   * {@code PerUnit} should use this constructor.
+   *
+   * @param baseUnit the base unit. Set this to null if the unit being constructed is its own base
+   *     unit
+   * @param numerator the numerator unit
+   * @param denominator the denominator unit
+   */
+  protected PerUnit(PerUnit<N, D> baseUnit, N numerator, D denominator) {
+    super(
+        baseUnit,
+        numerator.toBaseUnits(1) / denominator.toBaseUnits(1),
+        numerator.name() + " per " + denominator.name(),
+        numerator.symbol() + "/" + denominator.symbol());
+    m_numerator = numerator;
+    m_denominator = denominator;
+  }
+
+  /** {@inheritDoc} */
+  PerUnit(
+      PerUnit<N, D> baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+    m_numerator = getBaseUnit().numerator();
+    m_denominator = getBaseUnit().denominator();
+  }
+
+  /**
+   * Creates a new PerUnit unit derived from an arbitrary numerator and time denominator units.
+   *
+   * <pre>
+   *   PerUnit.combine(Volts, Meters) // possible PID constant
+   * </pre>
+   *
+   * @param <N> the type of the numerator unit
+   * @param <D> the type of the denominator unit
+   * @param numerator the numerator unit
+   * @param denominator the denominator for unit time
+   * @return the combined unit
+   */
+  @SuppressWarnings("unchecked")
+  public static <N extends Unit, D extends Unit> PerUnit<N, D> combine(N numerator, D denominator) {
+    return cache.combine(numerator, denominator);
+  }
+
+  @Override
+  @SuppressWarnings("unchecked")
+  public PerUnit<N, D> getBaseUnit() {
+    return (PerUnit<N, D>) super.getBaseUnit();
+  }
+
+  /**
+   * Gets the numerator unit. For a {@code PerUnit<A, B>}, this will return the {@code A} unit.
+   *
+   * @return the numerator unit
+   */
+  public N numerator() {
+    return m_numerator;
+  }
+
+  /**
+   * Gets the denominator unit. For a {@code PerUnit<A, B>}, this will return the {@code B} unit.
+   *
+   * @return the denominator unit
+   */
+  public D denominator() {
+    return m_denominator;
+  }
+
+  /**
+   * Returns the reciprocal of this PerUnit.
+   *
+   * @return the reciprocal
+   */
+  @SuppressWarnings("unchecked")
+  public PerUnit<D, N> reciprocal() {
+    if (m_numerator instanceof TimeUnit t) {
+      // Dividing by time, return a velocity
+      return (PerUnit<D, N>) VelocityUnit.combine(m_denominator, t);
+    } else {
+      // Generic case
+      return combine(m_denominator, m_numerator);
+    }
+  }
+
+  /**
+   * Multiplies this unit by a unit of its denominator.
+   *
+   * @param denom the denominator-typed unit to multiply by
+   * @return the result
+   */
+  public N mult(D denom) {
+    if (denom.equivalent(denominator())) {
+      return numerator();
+    }
+
+    return Units.derive(numerator())
+        .toBase(denom.getConverterToBase().div(denominator().getConverterToBase()))
+        .fromBase(denom.getConverterFromBase().div(denominator().getConverterFromBase()))
+        .named(name() + " " + denom.name())
+        .symbol(symbol() + "-" + denom.symbol())
+        .make();
+  }
+
+  /**
+   * {@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.Per} instance. If you want to
+   * avoid casting, use {@link #ofNative(double)} that returns a {@code Per} instance directly.
+   *
+   * @param magnitude the magnitude of the measure
+   * @return the ratio measure
+   */
+  @Override
+  public Measure<? extends PerUnit<N, D>> of(double magnitude) {
+    return ofNative(magnitude);
+  }
+
+  /**
+   * {@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.Per} instance. If you want to
+   * avoid casting, use {@link #ofNativeBaseUnits(double)} that returns a {@code Per} instance
+   * directly.
+   *
+   * @param baseUnitMagnitude the magnitude of the measure in terms of its base units.
+   * @return the ratio measure
+   */
+  @Override
+  public Measure<? extends PerUnit<N, D>> ofBaseUnits(double baseUnitMagnitude) {
+    return ofNativeBaseUnits(baseUnitMagnitude);
+  }
+
+  /**
+   * Creates a new immutable 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 magnitude the magnitude of the measurement.
+   * @return the measurement object
+   * @see #of(double)
+   */
+  public final Per<N, D> ofNative(double magnitude) {
+    return new ImmutablePer<>(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  /**
+   * Creates a new immutable measurement of the given magnitude in terms of the ratio unit's base
+   * unit. This will always return a {@code Per} object and cannot be overridden by subclasses.
+   *
+   * @param baseUnitMagnitude the magnitude of the measure in terms of its base units.
+   * @return the measurement object
+   * @see #ofBaseUnits(double)
+   */
+  public final Per<N, D> ofNativeBaseUnits(double baseUnitMagnitude) {
+    return new ImmutablePer<>(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  @SuppressWarnings("unchecked")
+  public Measure<? extends PerUnit<N, D>> zero() {
+    return (Measure<? extends PerUnit<N, D>>) super.zero();
+  }
+
+  @Override
+  @SuppressWarnings("unchecked")
+  public Measure<? extends PerUnit<N, D>> one() {
+    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);
+  }
+
+  /**
+   * Converts a measurement value in terms of another unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other unit
+   * @param otherUnit the other unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, PerUnit<? extends N, ? extends D> otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    if (!super.equals(o)) {
+      return false;
+    }
+    PerUnit<?, ?> perUnit = (PerUnit<?, ?>) o;
+    return Objects.equals(m_numerator, perUnit.m_numerator)
+        && Objects.equals(m_denominator, perUnit.m_denominator);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(super.hashCode(), m_numerator, m_denominator);
+  }
+}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/Power.java b/wpiunits/src/main/java/edu/wpi/first/units/Power.java
deleted file mode 100644
index 5d43f144d66..00000000000
--- a/wpiunits/src/main/java/edu/wpi/first/units/Power.java
+++ /dev/null
@@ -1,29 +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;
-
-/**
- * Unit of power dimension.
- *
- * <p>This is the base type for units of power dimension. It is also used to specify the dimension
- * for {@link Measure}: <code>Measure&lt;Power&gt;</code>.
- *
- * <p>Actual units (such as {@link Units#Watts} and {@link Units#Horsepower}) can be found in the
- * {@link Units} class.
- */
-public class Power extends Unit<Power> {
-  Power(Power baseUnit, double baseUnitEquivalent, String name, String symbol) {
-    super(baseUnit, baseUnitEquivalent, name, symbol);
-  }
-
-  Power(
-      Power baseUnit,
-      UnaryFunction toBaseConverter,
-      UnaryFunction fromBaseConverter,
-      String name,
-      String symbol) {
-    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
-  }
-}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/PowerUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/PowerUnit.java
new file mode 100644
index 00000000000..4129b22177d
--- /dev/null
+++ b/wpiunits/src/main/java/edu/wpi/first/units/PowerUnit.java
@@ -0,0 +1,164 @@
+// 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 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;
+
+/**
+ * Unit of power dimension.
+ *
+ * <p>This is the base type for units of power dimension. It is also used to specify the dimension
+ * for {@link Measure}: <code>Measure&lt;PowerUnit&gt;</code>.
+ *
+ * <p>Actual units (such as {@link Units#Watts} and {@link Units#Horsepower}) can be found in the
+ * {@link Units} class.
+ */
+public final class PowerUnit extends PerUnit<EnergyUnit, TimeUnit> {
+  private static final CombinatoryUnitCache<EnergyUnit, TimeUnit, PowerUnit> cache =
+      new CombinatoryUnitCache<>(PowerUnit::new);
+
+  PowerUnit(EnergyUnit energy, TimeUnit time) {
+    super(
+        energy.isBaseUnit() && time.isBaseUnit()
+            ? null
+            : combine(energy.getBaseUnit(), time.getBaseUnit()),
+        energy,
+        time);
+  }
+
+  PowerUnit(
+      PowerUnit baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  /**
+   * Combines an energy and a time unit to form a unit of power.
+   *
+   * @param energy the unit of energy
+   * @param period the unit of time
+   * @return the combined unit of power
+   */
+  public static PowerUnit combine(EnergyUnit energy, TimeUnit period) {
+    return cache.combine(energy, period);
+  }
+
+  /**
+   * Combines voltage and current into power.
+   *
+   * @param voltage the unit of voltage
+   * @param current the unit of current
+   * @return the combined unit of power
+   */
+  public static PowerUnit combine(VoltageUnit voltage, CurrentUnit current) {
+    return combine(
+        new EnergyUnit(
+            Joules,
+            voltage.toBaseUnits(1) * current.toBaseUnits(1),
+            voltage.name() + "-" + current.name(),
+            voltage.symbol() + "*" + current.symbol()),
+        Seconds);
+  }
+
+  /**
+   * Combines voltage and current into power.
+   *
+   * @param current the unit of current
+   * @param voltage the unit of voltage
+   * @return the combined unit of power
+   */
+  public static PowerUnit combine(CurrentUnit current, VoltageUnit voltage) {
+    return combine(voltage, current);
+  }
+
+  /**
+   * Combines angular velocity and torque into power. Useful when dealing with motors and flywheels.
+   *
+   * @param angularVelocity the unit of angular velocity
+   * @param torque the unit of torque
+   * @return the combined unit of power
+   */
+  public static PowerUnit combine(AngularVelocityUnit angularVelocity, TorqueUnit torque) {
+    return combine(
+        new EnergyUnit(Joules, angularVelocity.toBaseUnits(1) * torque.toBaseUnits(1), "", ""),
+        Seconds);
+  }
+
+  /**
+   * Combines angular velocity and torque into power. Useful when dealing with motors and flywheels.
+   *
+   * @param torque the unit of torque
+   * @param angularVelocity the unit of angular velocity
+   * @return the combined unit of power
+   */
+  public static PowerUnit combine(TorqueUnit torque, AngularVelocityUnit angularVelocity) {
+    return combine(angularVelocity, torque);
+  }
+
+  @Override
+  public PowerUnit getBaseUnit() {
+    return (PowerUnit) super.getBaseUnit();
+  }
+
+  @Override
+  public Power of(double magnitude) {
+    return new ImmutablePower(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public Power ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutablePower(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public Power zero() {
+    return (Power) super.zero();
+  }
+
+  @Override
+  public Power one() {
+    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);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<PowerUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another power unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other power unit
+   * @param otherUnit the other power unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, PowerUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/Temperature.java b/wpiunits/src/main/java/edu/wpi/first/units/Temperature.java
deleted file mode 100644
index 3138b1ac867..00000000000
--- a/wpiunits/src/main/java/edu/wpi/first/units/Temperature.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.
-
-package edu.wpi.first.units;
-
-/**
- * Unit of temperature dimension.
- *
- * <p>This is the base type for units of temperature dimension. It is also used to specify the
- * dimension for {@link Measure}: <code>Measure&lt;Temperature&gt;</code>.
- *
- * <p>Actual units (such as {@link Units#Celsius} and {@link Units#Fahrenheit}) can be found in the
- * {@link Units} class.
- */
-public class Temperature extends Unit<Temperature> {
-  Temperature(
-      Temperature baseUnit,
-      UnaryFunction toBaseConverter,
-      UnaryFunction fromBaseConverter,
-      String name,
-      String symbol) {
-    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
-  }
-}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/TemperatureUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/TemperatureUnit.java
new file mode 100644
index 00000000000..479c7e847a1
--- /dev/null
+++ b/wpiunits/src/main/java/edu/wpi/first/units/TemperatureUnit.java
@@ -0,0 +1,86 @@
+// 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.ImmutableTemperature;
+import edu.wpi.first.units.measure.MutTemperature;
+import edu.wpi.first.units.measure.Temperature;
+
+/**
+ * Unit of temperature dimension.
+ *
+ * <p>This is the base type for units of temperature dimension. It is also used to specify the
+ * dimension for {@link Measure}: <code>Measure&lt;TemperatureUnit&gt;</code>.
+ *
+ * <p>Actual units (such as {@link Units#Celsius} and {@link Units#Fahrenheit}) can be found in the
+ * {@link Units} class.
+ */
+public final class TemperatureUnit extends Unit {
+  TemperatureUnit(
+      TemperatureUnit baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  @Override
+  public TemperatureUnit getBaseUnit() {
+    return (TemperatureUnit) super.getBaseUnit();
+  }
+
+  @Override
+  public Temperature of(double magnitude) {
+    return new ImmutableTemperature(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public Temperature ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableTemperature(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public Temperature zero() {
+    return (Temperature) super.zero();
+  }
+
+  @Override
+  public Temperature one() {
+    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);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<TemperatureUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another temperature unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other temperature unit
+   * @param otherUnit the other temperature unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, TemperatureUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/Time.java b/wpiunits/src/main/java/edu/wpi/first/units/Time.java
deleted file mode 100644
index 5d1ec87e062..00000000000
--- a/wpiunits/src/main/java/edu/wpi/first/units/Time.java
+++ /dev/null
@@ -1,29 +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;
-
-/**
- * Unit of time dimension.
- *
- * <p>This is the base type for units of time dimension. It is also used to specify the dimension
- * for {@link Measure}: <code>Measure&lt;Time&gt;</code>.
- *
- * <p>Actual units (such as {@link Units#Seconds} and {@link Units#Milliseconds}) can be found in
- * the {@link Units} class.
- */
-public class Time extends Unit<Time> {
-  Time(Time baseUnit, double baseUnitEquivalent, String name, String symbol) {
-    super(baseUnit, baseUnitEquivalent, name, symbol);
-  }
-
-  Time(
-      Time baseUnit,
-      UnaryFunction toBaseConverter,
-      UnaryFunction fromBaseConverter,
-      String name,
-      String symbol) {
-    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
-  }
-}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/TimeUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/TimeUnit.java
new file mode 100644
index 00000000000..c8afa47098a
--- /dev/null
+++ b/wpiunits/src/main/java/edu/wpi/first/units/TimeUnit.java
@@ -0,0 +1,102 @@
+// 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.ImmutableTime;
+import edu.wpi.first.units.measure.MutTime;
+import edu.wpi.first.units.measure.Time;
+
+/**
+ * Unit of time dimension.
+ *
+ * <p>This is the base type for units of time dimension. It is also used to specify the dimension
+ * for {@link Measure}: <code>Measure&lt;TimeUnit&gt;</code>.
+ *
+ * <p>Actual units (such as {@link Units#Seconds} and {@link Units#Milliseconds}) can be found in
+ * the {@link Units} class.
+ */
+public final class TimeUnit extends Unit {
+  TimeUnit(TimeUnit baseUnit, double baseUnitEquivalent, String name, String symbol) {
+    super(baseUnit, baseUnitEquivalent, name, symbol);
+  }
+
+  TimeUnit(
+      TimeUnit baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  @Override
+  public TimeUnit getBaseUnit() {
+    return (TimeUnit) super.getBaseUnit();
+  }
+
+  /**
+   * Creates a dimensionless unit corresponding to the scale factor between this and another unit of
+   * time.
+   *
+   * @param other the other unit of time
+   * @return the result
+   */
+  @Override
+  public DimensionlessUnit per(TimeUnit other) {
+    return Units.derive(Units.Value)
+        .toBase(this.getConverterToBase().div(other.getConverterToBase()))
+        .fromBase(other.getConverterFromBase().div(this.getConverterFromBase()))
+        .named(this.name() + " per " + other.name())
+        .symbol(this.symbol() + "/" + other.symbol())
+        .make();
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<TimeUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other unit
+   * @param otherUnit the other unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, TimeUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+
+  @Override
+  public Time of(double magnitude) {
+    return new ImmutableTime(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public Time ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableTime(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public Time zero() {
+    return (Time) super.zero();
+  }
+
+  @Override
+  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
new file mode 100644
index 00000000000..3aeef3b55d2
--- /dev/null
+++ b/wpiunits/src/main/java/edu/wpi/first/units/TorqueUnit.java
@@ -0,0 +1,101 @@
+// 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.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}. */
+public final class TorqueUnit extends MultUnit<DistanceUnit, ForceUnit> {
+  private static final CombinatoryUnitCache<DistanceUnit, ForceUnit, TorqueUnit> cache =
+      new CombinatoryUnitCache<>(TorqueUnit::new);
+
+  TorqueUnit(DistanceUnit distanceUnit, ForceUnit forceUnit) {
+    super(
+        distanceUnit.isBaseUnit() && forceUnit.isBaseUnit()
+            ? null
+            : combine(distanceUnit.getBaseUnit(), forceUnit.getBaseUnit()),
+        distanceUnit,
+        forceUnit);
+  }
+
+  TorqueUnit(
+      MultUnit<DistanceUnit, ForceUnit> baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  /**
+   * Combines a unit of distance and force to create a unit of torque.
+   *
+   * @param distance the distance unit
+   * @param force the force unit
+   * @return the combined torque unit
+   */
+  public static TorqueUnit combine(DistanceUnit distance, ForceUnit force) {
+    return cache.combine(distance, force);
+  }
+
+  @Override
+  public TorqueUnit getBaseUnit() {
+    return (TorqueUnit) super.getBaseUnit();
+  }
+
+  @Override
+  public Torque of(double magnitude) {
+    return new ImmutableTorque(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public Torque ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableTorque(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public Torque zero() {
+    return (Torque) super.zero();
+  }
+
+  @Override
+  public Torque one() {
+    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);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<TorqueUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other unit
+   * @param otherUnit the other unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, TorqueUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+}
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 65339f87ce1..1dfc36f8ebf 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/Unit.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/Unit.java
@@ -11,21 +11,19 @@
  *
  * <p>This is the base class for units. Actual units (such as {@link Units#Grams} and {@link
  * Units#Meters}) can be found in the {@link Units} class.
- *
- * @param <U> the self type, e.g. {@code class SomeUnit extends Unit<SomeUnit>}
  */
-public class Unit<U extends Unit<U>> {
+public abstract class Unit {
   private final UnaryFunction m_toBaseConverter;
   private final UnaryFunction m_fromBaseConverter;
 
-  private final U m_baseUnit;
-
-  private Measure<U> m_zero;
-  private Measure<U> m_one;
+  private final Unit m_baseUnit;
 
   private final String m_name;
   private final String m_symbol;
 
+  private final Measure<?> m_zero;
+  private final Measure<?> m_one;
+
   /**
    * Creates a new unit defined by its relationship to some base unit.
    *
@@ -36,18 +34,21 @@ public class Unit<U extends Unit<U>> {
    * @param name the name of the unit. This should be a singular noun (so "Meter", not "Meters")
    * @param symbol the short symbol for the unit, such as "m" for meters or "lb." for pounds
    */
-  @SuppressWarnings("unchecked")
+  @SuppressWarnings("this-escape")
   protected Unit(
-      U baseUnit,
+      Unit baseUnit,
       UnaryFunction toBaseConverter,
       UnaryFunction fromBaseConverter,
       String name,
       String symbol) {
-    m_baseUnit = baseUnit == null ? (U) this : baseUnit;
+    m_baseUnit = baseUnit == null ? this : baseUnit;
     m_toBaseConverter = Objects.requireNonNull(toBaseConverter);
     m_fromBaseConverter = Objects.requireNonNull(fromBaseConverter);
     m_name = Objects.requireNonNull(name);
     m_symbol = Objects.requireNonNull(symbol);
+
+    m_zero = of(0);
+    m_one = of(1);
   }
 
   /**
@@ -60,14 +61,79 @@ protected Unit(
    * @param name the name of the unit. This should be a singular noun (so "Meter", not "Meters")
    * @param symbol the short symbol for the unit, such as "m" for meters or "lb." for pounds
    */
-  protected Unit(U baseUnit, double baseUnitEquivalent, String name, String symbol) {
+  protected Unit(Unit baseUnit, double baseUnitEquivalent, String name, String symbol) {
     this(baseUnit, x -> x * baseUnitEquivalent, x -> x / baseUnitEquivalent, name, symbol);
   }
 
+  /**
+   * Creates a new immutable measurement of 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 magnitude the magnitude of the measurement.
+   * @return the measurement object
+   */
+  public abstract Measure<?> of(double magnitude);
+
+  /**
+   * Creates a new immutable measurement of the given magnitude in terms of this unit's base unit.
+   * Implementations are <strong>strongly</strong> recommended to sharpen the return type to a
+   * unit-specific measurement implementation.
+   *
+   * @param baseUnitMagnitude the magnitude in terms of the base unit
+   * @return the measurement object
+   */
+  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
+   * method to sharpen the return type.
+   *
+   * @return a zero-magnitude measure of this unit
+   */
+  public Measure<?> zero() {
+    return m_zero;
+  }
+
+  /**
+   * Gets a measure with a magnitude of 1.0 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 method to sharpen the return type.
+   *
+   * @return a measure of magnitude 1.0 in terms of this unit
+   */
+  public Measure<?> one() {
+    return m_one;
+  }
+
+  /**
+   * Combines this unit with a unit of time. This often - but not always - results in a velocity.
+   * Subclasses should sharpen the return type to be unit-specific.
+   *
+   * @param time the unit of time
+   * @return the combined unit
+   */
+  public abstract Unit per(TimeUnit time);
+
   /**
    * Gets the base unit of measurement that this unit is derived from. If the unit is the base unit,
    * the unit will be returned.
    *
+   * <p><strong>NOTE:</strong> Subclasses <strong>must</strong> override this method to provide the
+   * correct return type. Failing to do say will make unit combinations that use it break at
+   * runtime!
+   *
    * <pre><code>
    *   Unit baseUnit = new Unit(null, ...);
    *   baseUnit.getBaseUnit(); // returns baseUnit
@@ -78,7 +144,7 @@ protected Unit(U baseUnit, double baseUnitEquivalent, String name, String symbol
    *
    * @return the base unit
    */
-  public U getBaseUnit() {
+  public Unit getBaseUnit() {
     return m_baseUnit;
   }
 
@@ -111,27 +177,6 @@ public double toBaseUnits(double valueInNativeUnits) {
     return m_toBaseConverter.apply(valueInNativeUnits);
   }
 
-  /**
-   * Converts a magnitude in terms of another unit of the same dimension to a magnitude in terms of
-   * this unit.
-   *
-   * <pre>
-   *   Inches.convertFrom(12, Feet) // 144.0
-   *   Kilograms.convertFrom(2.2, Pounds) // 0.9979024
-   * </pre>
-   *
-   * @param magnitude a magnitude measured in another unit
-   * @param otherUnit the unit to convert the magnitude to
-   * @return the corresponding value in terms of this unit.
-   */
-  public double convertFrom(double magnitude, Unit<U> otherUnit) {
-    if (this.equivalent(otherUnit)) {
-      // same unit, don't bother converting
-      return magnitude;
-    }
-    return this.fromBaseUnits(otherUnit.toBaseUnits(magnitude));
-  }
-
   /**
    * Gets the conversion function used to convert values to base unit terms. This generally
    * shouldn't need to be used directly; prefer {@link #toBaseUnits(double)} instead.
@@ -152,113 +197,6 @@ public UnaryFunction getConverterFromBase() {
     return m_fromBaseConverter;
   }
 
-  /**
-   * Creates a new measure of this unit with the given value. The resulting measure is
-   * <i>immutable</i> and cannot have its value modified.
-   *
-   * @param magnitude the magnitude of the measure to create
-   * @return the measure
-   */
-  public Measure<U> of(double magnitude) {
-    if (magnitude == 0) {
-      // reuse static object
-      return zero();
-    }
-    if (magnitude == 1) {
-      // reuse static object
-      return one();
-    }
-    return ImmutableMeasure.ofRelativeUnits(magnitude, this);
-  }
-
-  /**
-   * Creates a new measure with a magnitude equal to the given base unit magnitude, converted to be
-   * in terms of this unit.
-   *
-   * @param baseUnitMagnitude the magnitude of the measure in terms of the base unit
-   * @return the measure
-   */
-  public Measure<U> ofBaseUnits(double baseUnitMagnitude) {
-    return ImmutableMeasure.ofBaseUnits(baseUnitMagnitude, this);
-  }
-
-  /**
-   * Gets a measure with a magnitude of 0 in terms of this unit.
-   *
-   * @return the zero-valued measure
-   */
-  public Measure<U> zero() {
-    // lazy init because 'this' is null in object initialization
-    if (m_zero == null) {
-      m_zero = ImmutableMeasure.ofRelativeUnits(0, this);
-    }
-    return m_zero;
-  }
-
-  /**
-   * Gets a measure with a magnitude of 1 in terms of this unit.
-   *
-   * @return the 1-valued measure
-   */
-  public Measure<U> one() {
-    // lazy init because 'this' is null in object initialization
-    if (m_one == null) {
-      m_one = ImmutableMeasure.ofRelativeUnits(1, this);
-    }
-    return m_one;
-  }
-
-  /**
-   * Creates a velocity unit derived from this one. Can be chained to denote velocity, acceleration,
-   * jerk, etc.
-   *
-   * <pre>
-   *   Meters.per(Second) // linear velocity
-   *   Kilograms.per(Second) // mass flow
-   *   Feet.per(Second).per(Second).of(32) // roughly 1G of acceleration
-   * </pre>
-   *
-   * @param period the time period of the velocity, such as seconds or milliseconds
-   * @return a velocity unit corresponding to the rate of change of this unit over time
-   */
-  public Velocity<U> per(Time period) {
-    return Velocity.combine(this, period);
-  }
-
-  /**
-   * Takes this unit and creates a new proportional unit where this unit is the numerator and the
-   * given denominator is the denominator.
-   *
-   * <pre>
-   *   Volts.per(Meter) // V/m
-   * </pre>
-   *
-   * @param <D> the type of the denominator units
-   * @param denominator the denominator of the proportional unit
-   * @return a combined proportional unit
-   */
-  @SuppressWarnings("unchecked")
-  public <D extends Unit<D>> Per<U, D> per(D denominator) {
-    return Per.combine((U) this, denominator);
-  }
-
-  /**
-   * Takes this unit and creates a new combinatory unit equivalent to this unit multiplied by
-   * another.
-   *
-   * <pre>
-   *   Volts.mult(Meter) // V*m
-   * </pre>
-   *
-   * @param <U2> the type of the unit to multiply by
-   * @param other the unit to multiply by
-   * @return a combined unit equivalent to this unit multiplied by the other
-   */
-  @SuppressWarnings("unchecked")
-  public <U2 extends Unit<U2>> Mult<U, U2> mult(U2 other) {
-    return Mult.combine((U) this, other);
-  }
-
   /**
    * Checks if this unit is equivalent to another one. Equivalence is determined by both units
    * having the same base type and treat the same base unit magnitude as the same magnitude in their
@@ -267,7 +205,7 @@ public <U2 extends Unit<U2>> Mult<U, U2> mult(U2 other) {
    * @param other the unit to compare to.
    * @return true if both units are equivalent, false if not
    */
-  public boolean equivalent(Unit<?> other) {
+  public boolean equivalent(Unit other) {
     if (!getClass().equals(other.getClass())) {
       // different unit types, not compatible
       return false;
@@ -287,7 +225,7 @@ public boolean equivalent(Unit<?> other) {
   @Override
   public boolean equals(Object o) {
     return this == o
-        || o instanceof Unit<?> that
+        || o instanceof Unit that
             && m_name.equals(that.m_name)
             && m_symbol.equals(that.m_symbol)
             && this.equivalent(that);
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/UnitBuilder.java b/wpiunits/src/main/java/edu/wpi/first/units/UnitBuilder.java
index 01e014f6d96..f3541b28744 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/UnitBuilder.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/UnitBuilder.java
@@ -18,7 +18,7 @@
  *
  * @param <U> the type of the unit
  */
-public final class UnitBuilder<U extends Unit<U>> {
+public final class UnitBuilder<U extends Unit> {
   private final U m_base;
   private UnaryFunction m_fromBase = UnaryFunction.IDENTITY;
   private UnaryFunction m_toBase = UnaryFunction.IDENTITY;
@@ -191,7 +191,7 @@ public UnitBuilder<U> aggregate(double aggregation) {
    * @param <U> the type of the unit
    */
   @FunctionalInterface
-  public interface UnitConstructorFunction<U extends Unit<U>> {
+  public interface UnitConstructorFunction<U extends Unit> {
     /**
      * Creates a new unit instance based on its relation to the base unit of measure.
      *
@@ -220,6 +220,7 @@ U create(
    * @return the new derived unit
    * @throws NullPointerException if the unit conversions, unit name, or unit symbol were not set
    */
+  @SuppressWarnings("unchecked")
   public U make(UnitConstructorFunction<U> constructor) {
     Objects.requireNonNull(m_fromBase, "fromBase function was not set");
     Objects.requireNonNull(m_toBase, "toBase function was not set");
@@ -227,7 +228,7 @@ public U make(UnitConstructorFunction<U> constructor) {
     Objects.requireNonNull(m_symbol, "new unit symbol was not set");
 
     return constructor.create(
-        m_base.getBaseUnit(),
+        (U) m_base.getBaseUnit(),
         m_toBase.pipeTo(m_base.getConverterToBase()),
         m_base.getConverterFromBase().pipeTo(m_fromBase),
         m_name,
@@ -242,7 +243,6 @@ public U make(UnitConstructorFunction<U> constructor) {
    * @throws RuntimeException if the base unit does not define a constructor accepting the
    *     conversion functions, unit name, and unit symbol - in that order
    */
-  @SuppressWarnings({"PMD.AvoidAccessibilityAlteration", "unchecked"})
   public U make() {
     return make(
         (baseUnit, toBaseUnits, fromBaseUnits, name, symbol) -> {
@@ -251,7 +251,7 @@ public U make() {
           try {
             var ctor = getConstructor(baseUnit);
 
-            return (U) ctor.newInstance(baseUnit, toBaseUnits, fromBaseUnits, name, symbol);
+            return ctor.newInstance(baseUnit, toBaseUnits, fromBaseUnits, name, symbol);
           } catch (InstantiationException e) {
             throw new RuntimeException("Could not instantiate class " + baseClass.getName(), e);
           } catch (IllegalAccessException e) {
@@ -272,7 +272,7 @@ public U make() {
   }
 
   @SuppressWarnings({"unchecked", "PMD.AvoidAccessibilityAlteration"})
-  private static <U extends Unit<U>> Constructor<? extends Unit<U>> getConstructor(U baseUnit)
+  private static <U extends Unit> Constructor<? extends U> getConstructor(U baseUnit)
       throws NoSuchMethodException {
     var baseClass = baseUnit.getClass();
 
@@ -288,6 +288,6 @@ private static <U extends Unit<U>> Constructor<? extends Unit<U>> getConstructor
     // and protected constructors
     ctor.setAccessible(true);
 
-    return (Constructor<? extends Unit<U>>) ctor;
+    return (Constructor<? extends U>) ctor;
   }
 }
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/Units.java b/wpiunits/src/main/java/edu/wpi/first/units/Units.java
index b71a977ba94..cc2042c823e 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/Units.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/Units.java
@@ -14,365 +14,478 @@ private Units() {
 
   // Pseudo-classes describing the more common units of measure.
 
-  // Distance
+  // Unitless
+  /** A dimensionless unit that performs no scaling whatsoever. */
+  public static final DimensionlessUnit Value = BaseUnits.Value;
+
+  /**
+   * A dimensionless unit equal to to 1/100th of a {@link #Value}. A measurement of {@code
+   * Percent.of(42)} would be equivalent to {@code Value.of(0.42)}.
+   */
+  public static final DimensionlessUnit Percent =
+      derive(Value).splitInto(100).named("Percent").symbol("%").make();
+
+  // DistanceUnit
   /** The base unit of distance. */
-  public static final Distance Meters = BaseUnits.Distance;
+  public static final DistanceUnit Meters = BaseUnits.DistanceUnit;
 
   /** The base unit of distance. */
-  public static final Distance Meter = Meters; // alias
+  public static final DistanceUnit Meter = Meters; // alias
 
   /** 1/1000 of a {@link #Meter}. */
-  public static final Distance Millimeters = Milli(Meters, "Millimeter", "mm");
+  public static final DistanceUnit Millimeters = Milli(Meters, "Millimeter", "mm");
 
   /** 1/1000 of a {@link #Meter}. */
-  public static final Distance Millimeter = Millimeters; // alias
+  public static final DistanceUnit Millimeter = Millimeters; // alias
 
   /** 1/100 of a {@link #Meter}. */
-  public static final Distance Centimeters =
+  public static final DistanceUnit Centimeters =
       derive(Meters).splitInto(100).named("Centimeter").symbol("cm").make();
 
   /** 1/100 of a {@link #Meter}. */
-  public static final Distance Centimeter = Centimeters; // alias
+  public static final DistanceUnit Centimeter = Centimeters; // alias
 
   /** 25.4/1000 of a {@link #Meter} and 1/12 of a {@link #Foot}. */
-  public static final Distance Inches =
+  public static final DistanceUnit Inches =
       derive(Millimeters).aggregate(25.4).named("Inch").symbol("in").make();
 
   /** 25.4/1000 of a {@link #Meter} and 1/12 of a {@link #Foot}. */
-  public static final Distance Inch = Inches; // alias
+  public static final DistanceUnit Inch = Inches; // alias
 
   /** 304.8/1000 of a {@link #Meter}, or 12 {@link #Inches}. */
-  public static final Distance Feet =
+  public static final DistanceUnit Feet =
       derive(Inches).aggregate(12).named("Foot").symbol("ft").make();
 
   /** 304.8/1000 of a {@link #Meter}, or 12 {@link #Inches}. */
-  public static final Distance Foot = Feet; // alias
+  public static final DistanceUnit Foot = Feet; // alias
 
-  // Time
+  // TimeUnit
   /** The base unit of time. */
-  public static final Time Seconds = BaseUnits.Time;
+  public static final TimeUnit Seconds = BaseUnits.TimeUnit;
 
   /** Alias for {@link #Seconds} to make combined unit definitions read more smoothly. */
-  public static final Time Second = Seconds; // singularized alias
+  public static final TimeUnit Second = Seconds; // singularized alias
 
   /** 1/1000 of a {@link #Seconds Second}. */
-  public static final Time Milliseconds = Milli(Seconds);
+  public static final TimeUnit Milliseconds = Milli(Seconds);
 
   /** Alias for {@link #Milliseconds} to make combined unit definitions read more smoothly. */
-  public static final Time Millisecond = Milliseconds; // singularized alias
+  public static final TimeUnit Millisecond = Milliseconds; // singularized alias
 
   /** 1/1,000,000 of a {@link #Seconds Second}. */
-  public static final Time Microseconds = Micro(Seconds);
+  public static final TimeUnit Microseconds = Micro(Seconds);
 
   /** Alias for {@link #Microseconds} to make combined unit definitions read more smoothly. */
-  public static final Time Microsecond = Microseconds; // singularized alias
+  public static final TimeUnit Microsecond = Microseconds; // singularized alias
 
   /** 60 {@link #Seconds}. */
-  public static final Time Minutes =
+  public static final TimeUnit Minutes =
       derive(Seconds).aggregate(60).named("Minute").symbol("min").make();
 
   /** Alias for {@link #Minutes} to make combined unit definitions read more smoothly. */
-  public static final Time Minute = Minutes; // singularized alias
+  public static final TimeUnit Minute = Minutes; // singularized alias
 
-  // Angle
+  // AngleUnit
   /**
-   * The base SI unit of angle, represented by the distance that the radius of a unit circle can
+   * The standard SI unit of angle, represented by the distance that the radius of a unit circle can
    * wrap around its circumference.
    */
-  public static final Angle Radians = BaseUnits.Angle;
+  public static final AngleUnit Radians = BaseUnits.AngleUnit;
 
   /**
-   * The base SI unit of angle, represented by the distance that the radius of a unit circle can
+   * The standard SI unit of angle, represented by the distance that the radius of a unit circle can
    * wrap around its circumference.
    */
-  public static final Angle Radian = Radians; // alias
+  public static final AngleUnit Radian = Radians; // alias
 
   /**
    * A single turn of an object around an external axis. Numerically equivalent to {@link
    * #Rotations}, but may be semantically more expressive in certain scenarios.
    */
-  public static final Angle Revolutions =
+  public static final AngleUnit Revolutions =
       derive(Radians).aggregate(2 * Math.PI).named("Revolution").symbol("R").make();
 
   /**
    * A single turn of an object around an external axis. Numerically equivalent to a {@link
    * #Rotation}, but may be semantically more expressive in certain scenarios.
    */
-  public static final Angle Revolution = Revolutions; // alias
+  public static final AngleUnit Revolution = Revolutions; // alias
 
   /**
    * A single turn of an object around an internal axis. Numerically equivalent to {@link
    * #Revolutions}, but may be semantically more expressive in certain scenarios.
    */
-  public static final Angle Rotations = derive(Revolutions).named("Rotation").symbol("R").make();
+  public static final AngleUnit Rotations =
+      derive(Revolutions).named("Rotation").symbol("R").make();
 
   /**
    * A single turn of an object around an internal axis. Numerically equivalent to a {@link
    * #Revolution}, but may be semantically more expressive in certain scenarios.
    */
-  public static final Angle Rotation = Rotations; // alias
+  public static final AngleUnit Rotation = Rotations; // alias
 
   /** 1/360 of a turn around a circle, or 1/57.3 {@link #Radians}. */
-  public static final Angle Degrees =
+  public static final AngleUnit Degrees =
       derive(Revolutions).splitInto(360).named("Degree").symbol("°").make();
 
   /** 1/360 of a turn around a circle, or 1/57.3 {@link #Radians}. */
-  public static final Angle Degree = Degrees; // alias
+  public static final AngleUnit Degree = Degrees; // alias
 
-  // Velocity
+  // VelocityUnit
   /**
    * The standard SI unit of linear velocity, equivalent to travelling at a rate of one {@link
    * #Meters Meter} per {@link #Second}.
    */
-  public static final Velocity<Distance> MetersPerSecond = Meters.per(Second);
+  public static final LinearVelocityUnit MetersPerSecond = Meters.per(Second);
 
   /**
    * A unit of linear velocity equivalent to travelling at a rate one {@link #Feet Foot} per {@link
    * #Second}.
    */
-  public static final Velocity<Distance> FeetPerSecond = Feet.per(Second);
+  public static final LinearVelocityUnit FeetPerSecond = Feet.per(Second);
 
   /**
    * A unit of linear velocity equivalent to travelling at a rate of one {@link #Inches Inch} per
    * {@link #Second}.
    */
-  public static final Velocity<Distance> InchesPerSecond = Inches.per(Second);
+  public static final LinearVelocityUnit InchesPerSecond = Inches.per(Second);
 
   /**
    * A unit of angular velocity equivalent to spinning at a rate of one {@link #Revolutions
    * Revolution} per {@link #Second}.
    */
-  public static final Velocity<Angle> RevolutionsPerSecond = Revolutions.per(Second);
+  public static final AngularVelocityUnit RevolutionsPerSecond = Revolutions.per(Second);
 
   /**
    * A unit of angular velocity equivalent to spinning at a rate of one {@link #Rotations Rotation}
    * per {@link #Second}.
    */
-  public static final Velocity<Angle> RotationsPerSecond = Rotations.per(Second);
+  public static final AngularVelocityUnit RotationsPerSecond = Rotations.per(Second);
 
   /**
    * A unit of angular velocity equivalent to spinning at a rate of one {@link #Rotations Rotation}
    * per {@link #Minute}. Motor spec sheets often list maximum speeds in terms of RPM.
    */
-  public static final Velocity<Angle> RPM = Rotations.per(Minute);
+  public static final AngularVelocityUnit RPM = Rotations.per(Minute);
 
   /**
    * The standard SI unit of angular velocity, equivalent to spinning at a rate of one {@link
    * #Radians Radian} per {@link #Second}.
    */
-  public static final Velocity<Angle> RadiansPerSecond = Radians.per(Second);
+  public static final AngularVelocityUnit RadiansPerSecond = Radians.per(Second);
 
   /**
    * A unit of angular velocity equivalent to spinning at a rate of one {@link #Degrees Degree} per
    * {@link #Second}.
    */
-  public static final Velocity<Angle> DegreesPerSecond = Degrees.per(Second);
+  public static final AngularVelocityUnit DegreesPerSecond = Degrees.per(Second);
+
+  /**
+   * The standard SI unit of frequency, equivalent to a periodic signal repeating once every {@link
+   * #Second}.
+   */
+  public static final FrequencyUnit Hertz =
+      derive(Value.per(Second)).named("Hertz").symbol("hz").make();
+
+  /** 1/1000th of a {@link #Hertz}. */
+  public static final FrequencyUnit Millihertz = Milli(Hertz);
 
   // Acceleration
   /**
    * The standard SI unit of linear acceleration, equivalent to accelerating at a rate of one {@link
    * #Meters Meter} per {@link #Second} every second.
    */
-  public static final Velocity<Velocity<Distance>> MetersPerSecondPerSecond =
-      MetersPerSecond.per(Second);
+  public static final LinearAccelerationUnit MetersPerSecondPerSecond = MetersPerSecond.per(Second);
 
   /**
    * A unit of linear acceleration equivalent to accelerating at a rate of one {@link #Foot Foot}
    * per {@link #Second} every second.
    */
-  public static final Velocity<Velocity<Distance>> FeetPerSecondPerSecond =
-      FeetPerSecond.per(Second);
+  public static final LinearAccelerationUnit FeetPerSecondPerSecond = FeetPerSecond.per(Second);
 
   /**
    * A unit of angular acceleration equivalent to accelerating at a rate of one {@link #Rotations
    * Rotation} per {@link #Second} every second.
    */
-  public static final Velocity<Velocity<Angle>> RotationsPerSecondPerSecond =
+  public static final AngularAccelerationUnit RotationsPerSecondPerSecond =
       RotationsPerSecond.per(Second);
 
   /**
    * The standard SI unit of angular acceleration, equivalent to accelerating at a rate of one
    * {@link #Radians Radian} per {@link #Second} every second.
    */
-  public static final Velocity<Velocity<Angle>> RadiansPerSecondPerSecond =
+  public static final AngularAccelerationUnit RadiansPerSecondPerSecond =
       RadiansPerSecond.per(Second);
 
   /**
    * A unit of angular acceleration equivalent to accelerating at a rate of one {@link #Degrees
    * Degree} per {@link #Second} every second.
    */
-  public static final Velocity<Velocity<Angle>> DegreesPerSecondPerSecond =
+  public static final AngularAccelerationUnit DegreesPerSecondPerSecond =
       DegreesPerSecond.per(Second);
 
   /**
    * A unit of acceleration equivalent to the pull of gravity on an object at sea level on Earth.
    */
-  public static final Velocity<Velocity<Distance>> Gs =
+  public static final LinearAccelerationUnit Gs =
       derive(MetersPerSecondPerSecond).aggregate(9.80665).named("G").symbol("G").make();
 
-  // Mass
-  /** The base SI unit of mass. */
-  public static final Mass Kilograms = BaseUnits.Mass;
+  // MassUnit
+  /** The standard SI unit of mass. */
+  public static final MassUnit Kilograms = BaseUnits.MassUnit;
 
-  /** The base SI unit of mass. */
-  public static final Mass Kilogram = Kilograms; // alias
+  /** The standard SI unit of mass. */
+  public static final MassUnit Kilogram = Kilograms; // alias
 
   /** 1/1000 of a {@link #Kilogram}. */
-  public static final Mass Grams = Milli(Kilograms, "Gram", "g");
+  public static final MassUnit Grams = Milli(Kilograms, "Gram", "g");
 
   /** 1/1000 of a {@link #Kilogram}. */
-  public static final Mass Gram = Grams; // alias
+  public static final MassUnit Gram = Grams; // alias
 
   /**
    * A unit of mass equivalent to approximately 453 {@link #Grams}. This is <i>not</i> equivalent to
    * pounds-force, which is the amount of force required to accelerate an object with one pound of
    * mass at a rate of one {@link #Gs G}.
+   *
+   * @see #PoundsForce
    */
-  public static final Mass Pounds =
+  public static final MassUnit Pounds =
       derive(Grams).aggregate(453.592).named("Pound").symbol("lb.").make();
 
   /**
    * A unit of mass equivalent to approximately 453 {@link #Grams}. This is <i>not</i> equivalent to
    * pounds-force, which is the amount of force required to accelerate an object with one pound of
    * mass at a rate of one {@link #Gs G}.
+   *
+   * @see #PoundForce
    */
-  public static final Mass Pound = Pounds; // alias
+  public static final MassUnit Pound = Pounds; // alias
 
   /** 1/16 of a {@link #Pound}. */
-  public static final Mass Ounces =
+  public static final MassUnit Ounces =
       derive(Pounds).splitInto(16).named("Ounce").symbol("oz.").make();
 
   /** 1/16 of a {@link #Pound}. */
-  public static final Mass Ounce = Ounces; // alias
+  public static final MassUnit Ounce = Ounces; // alias
 
-  // Moment of Inertia
-  /** The base SI unit for moment of inertia. */
-  public static final Mult<Mult<Mass, Distance>, Distance> KilogramSquareMeters =
-      Kilograms.mult(Meters).mult(Meters);
+  // Force
 
-  // Unitless
-  /** A dimensionless unit that performs no scaling whatsoever. */
-  public static final Dimensionless Value = BaseUnits.Value;
+  /**
+   * The standard unit of force, equivalent to accelerating a mass of one {@link #Kilogram} at a
+   * rate of one {@link #MetersPerSecondPerSecond meter per second per second}.
+   */
+  public static final ForceUnit Newtons =
+      derive(Kilograms.mult(MetersPerSecondPerSecond)).named("Newton").symbol("N").make();
 
   /**
-   * A dimensionless unit equal to to 1/100th of a {@link #Value}. A measurement of {@code
-   * Percent.of(42)} would be equivalent to {@code Value.of(0.42)}.
+   * The standard unit of force, equivalent to the standard force of gravity applied to a one {@link
+   * #Kilogram} mass.
    */
-  public static final Dimensionless Percent =
-      derive(Value).splitInto(100).named("Percent").symbol("%").make();
+  public static final ForceUnit Newton = Newtons;
+
+  /**
+   * The standard Imperial unit of force, equivalent to the standard force of gravity applied to a
+   * one {@link #Pound} mass.
+   */
+  public static final ForceUnit PoundsForce =
+      derive(Pounds.mult(Gs)).named("Pound-force").symbol("lbsf.").make();
+
+  /**
+   * The standard Imperial unit of force, equivalent to the standard force of gravity applied to a
+   * one {@link #Pound} mass.
+   */
+  public static final ForceUnit PoundForce = PoundsForce;
+
+  /**
+   * 1/16th of {@link #PoundsForce}, equivalent to the standard force of gravity applied to a one
+   * {@link #Ounce} mass.
+   */
+  public static final ForceUnit OuncesForce =
+      derive(Ounces.mult(Gs)).named("Ounce-force").symbol("ozf").make();
+
+  /**
+   * 1/16th of {@link #PoundsForce}, equivalent to the standard force of gravity applied to a one
+   * {@link #Ounce} mass.
+   */
+  public static final ForceUnit OunceForce = OuncesForce;
+
+  // Torque
+
+  /** The standard SI unit for torque. */
+  public static final TorqueUnit NewtonMeters = Meters.multAsTorque(Newtons);
+
+  /** The standard SI unit for torque. */
+  public static final TorqueUnit NewtonMeter = NewtonMeters;
+
+  /**
+   * The equivalent of one {@link #PoundsForce pound of force} applied to an object one {@link
+   * #Foot} away from its center of rotation.
+   */
+  public static final TorqueUnit PoundFeet = Feet.multAsTorque(PoundsForce);
+
+  /**
+   * The equivalent of one {@link #PoundsForce pound of force} applied to an object one {@link
+   * #Foot} away from its center of rotation.
+   */
+  public static final TorqueUnit PoundFoot = PoundFeet;
+
+  /**
+   * The equivalent of one {@link #PoundsForce pound of force} applied to an object one {@link
+   * #Inch} away from its center of rotation.
+   */
+  public static final TorqueUnit PoundInches = Inches.multAsTorque(PoundsForce);
+
+  /**
+   * The equivalent of one {@link #PoundsForce pound of force} applied to an object one {@link
+   * #Inch} away from its center of rotation.
+   */
+  public static final TorqueUnit PoundInch = PoundInches;
+
+  /**
+   * The equivalent of one {@link #OunceForce ounce of force} applied to an object one {@link #Inch}
+   * away from its center of rotation.
+   */
+  public static final TorqueUnit OunceInches = Inches.multAsTorque(OuncesForce);
+
+  /**
+   * The equivalent of one {@link #OunceForce ounce of force} applied to an object one {@link #Inch}
+   * away from its center of rotation.
+   */
+  public static final TorqueUnit OunceInch = OunceInches;
+
+  // Linear momentum
+
+  /**
+   * The standard SI unit for linear momentum, equivalent to a one {@link #Kilogram} mass moving at
+   * one {@link #MetersPerSecond}.
+   */
+  public static final LinearMomentumUnit KilogramMetersPerSecond = Kilograms.mult(MetersPerSecond);
+
+  // Angular momentum
+
+  /** The standard SI unit for angular momentum. */
+  public static final AngularMomentumUnit KilogramMetersSquaredPerSecond =
+      KilogramMetersPerSecond.mult(Meters);
+
+  // Moment of Inertia
+
+  /** The standard SI unit for moment of inertia. */
+  public static final MomentOfInertiaUnit KilogramSquareMeters =
+      KilogramMetersSquaredPerSecond.mult(RadiansPerSecond);
 
-  // Voltage
+  // VoltageUnit
   /** The base unit of electric potential. */
-  public static final Voltage Volts = BaseUnits.Voltage;
+  public static final VoltageUnit Volts = BaseUnits.VoltageUnit;
 
   /** The base unit of electric potential. */
-  public static final Voltage Volt = Volts; // alias
+  public static final VoltageUnit Volt = Volts; // alias
 
   /**
    * 1/1000 of a {@link #Volt}. Useful when dealing with low-voltage applications like LED drivers
    * or low-power circuits.
    */
-  public static final Voltage Millivolts = Milli(Volts);
+  public static final VoltageUnit Millivolts = Milli(Volts);
 
   /**
    * 1/1000 of a {@link #Volt}. Useful when dealing with low-voltage applications like LED drivers
    * or low-power circuits.
    */
-  public static final Voltage Millivolt = Millivolts; // alias
+  public static final VoltageUnit Millivolt = Millivolts; // alias
 
-  // Current
+  // CurrentUnit
   /** The base unit of electrical current. */
-  public static final Current Amps = BaseUnits.Current;
+  public static final CurrentUnit Amps = BaseUnits.CurrentUnit;
 
   /** The base unit of electrical current. */
-  public static final Current Amp = Amps; // alias
+  public static final CurrentUnit Amp = Amps; // alias
 
   /**
    * A unit equal to 1/1000 of an {@link #Amp}. Useful when dealing with low-current applications
    * like LED drivers or low-power circuits.
    */
-  public static final Current Milliamps = Milli(Amps);
+  public static final CurrentUnit Milliamps = Milli(Amps);
 
   /**
    * A unit equal to 1/1000 of an {@link #Amp}. Useful when dealing with low-current applications
    * like LED drivers or low-power circuits.
    */
-  public static final Current Milliamp = Milliamps; // alias
+  public static final CurrentUnit Milliamp = Milliamps; // alias
 
-  // Energy
+  // EnergyUnit
   /** The base unit of energy. */
-  public static final Energy Joules = BaseUnits.Energy;
+  public static final EnergyUnit Joules = BaseUnits.EnergyUnit;
 
   /** The base unit of energy. */
-  public static final Energy Joule = Joules; // alias
+  public static final EnergyUnit Joule = Joules; // alias
 
   /**
    * A unit equal to 1/1000 of a {@link #Joule}. Useful when dealing with lower-power applications.
    */
-  public static final Energy Millijoules = Milli(Joules);
+  public static final EnergyUnit Millijoules = Milli(Joules);
 
   /**
    * A unit equal to 1/1000 of a {@link #Joule}. Useful when dealing with lower-power applications.
    */
-  public static final Energy Millijoule = Millijoules; // alias
+  public static final EnergyUnit Millijoule = Millijoules; // alias
 
   /**
    * A unit equal to 1,000 {@link #Joules}. Useful when dealing with higher-level robot energy
    * usage.
    */
-  public static final Energy Kilojoules = Kilo(Joules);
+  public static final EnergyUnit Kilojoules = Kilo(Joules);
 
   /**
    * A unit equal to 1,000 {@link #Joules}. Useful when dealing with higher-level robot energy
    * usage.
    */
-  public static final Energy Kilojoule = Kilojoules; // alias
+  public static final EnergyUnit Kilojoule = Kilojoules; // alias
 
-  // Power
+  // PowerUnit
   /** The base unit of power. Equivalent to one {@link #Joule} per {@link #Second}. */
-  public static final Power Watts = BaseUnits.Power;
+  public static final PowerUnit Watts = derive(Joules.per(Second)).named("Watt").symbol("W").make();
 
   /** The base unit of power. Equivalent to one {@link #Joule} per {@link #Second}. */
-  public static final Power Watt = Watts; // alias
+  public static final PowerUnit Watt = Watts; // alias
 
   /**
    * A unit equal to 1/1000 of a {@link #Watt}. Useful when dealing with lower-power applications.
    */
-  public static final Power Milliwatts = Milli(Watts);
+  public static final PowerUnit Milliwatts = Milli(Watts);
 
   /**
    * A unit equal to 1/1000 of a {@link #Watt}. Useful when dealing with lower-power applications.
    */
-  public static final Power Milliwatt = Milliwatts; // alias
+  public static final PowerUnit Milliwatt = Milliwatts; // alias
 
   /**
    * A unit equal to 745.7 {@link #Watts}. May be useful when dealing with high-power gearboxes and
    * motors.
    */
-  public static final Power Horsepower =
+  public static final PowerUnit Horsepower =
       derive(Watts).aggregate(745.7).named("Horsepower").symbol("HP").make();
 
-  // Temperature
+  // TemperatureUnit
   /**
    * The base unit of temperature, where a value of 0 corresponds with absolutely zero energy in the
    * measured system. Not particularly useful for robots unless you're cooling motors with liquid
    * helium.
    */
-  public static final Temperature Kelvin = BaseUnits.Temperature;
+  public static final TemperatureUnit Kelvin = BaseUnits.TemperatureUnit;
 
   /**
-   * The base SI unit of temperature, where a value of 0 roughly corresponds to the freezing point
-   * of water and a value of 100 corresponds to the boiling point. Electronics tend to exhibit
+   * The standard SI unit of temperature, where a value of 0 roughly corresponds to the freezing
+   * point of water and a value of 100 corresponds to the boiling point. Electronics tend to exhibit
    * degraded performance or damage above 90 degrees Celsius.
    */
-  public static final Temperature Celsius =
+  public static final TemperatureUnit Celsius =
       derive(Kelvin).offset(+273.15).named("Celsius").symbol("°C").make();
 
   /**
    * The base imperial (American) unit of temperature, where a value of 32 roughly corresponds to
    * the freezing point of water and a value of 212 corresponds to the boiling point.
    */
-  public static final Temperature Fahrenheit =
+  public static final TemperatureUnit Fahrenheit =
       derive(Celsius)
           .mappingInputRange(0, 100)
           .toOutputRange(32, 212)
@@ -386,28 +499,28 @@ private Units() {
    * A standard unit for measuring linear mechanisms' feedforward voltages based on a model of the
    * system and a desired commanded linear velocity.
    */
-  public static final Per<Voltage, Velocity<Distance>> VoltsPerMeterPerSecond =
+  public static final PerUnit<VoltageUnit, LinearVelocityUnit> VoltsPerMeterPerSecond =
       Volts.per(MetersPerSecond);
 
   /**
    * A standard unit for measuring linear mechanisms' feedforward voltages based on a model of the
    * system and a desired commanded linear acceleration.
    */
-  public static final Per<Voltage, Velocity<Velocity<Distance>>> VoltsPerMeterPerSecondSquared =
+  public static final PerUnit<VoltageUnit, LinearAccelerationUnit> VoltsPerMeterPerSecondSquared =
       Volts.per(MetersPerSecondPerSecond);
 
   /**
    * A standard unit for measuring angular mechanisms' feedforward voltages based on a model of the
    * system and a desired commanded angular velocity.
    */
-  public static final Per<Voltage, Velocity<Angle>> VoltsPerRadianPerSecond =
+  public static final PerUnit<VoltageUnit, AngularVelocityUnit> VoltsPerRadianPerSecond =
       Volts.per(RadiansPerSecond);
 
   /**
    * A standard unit for measuring angular mechanisms' feedforward voltages based on a model of the
    * system and a desired commanded angular acceleration.
    */
-  public static final Per<Voltage, Velocity<Velocity<Angle>>> VoltsPerRadianPerSecondSquared =
+  public static final PerUnit<VoltageUnit, AngularAccelerationUnit> VoltsPerRadianPerSecondSquared =
       Volts.per(RadiansPerSecond.per(Second));
 
   /**
@@ -420,7 +533,7 @@ private Units() {
    * @return the milli-unit
    */
   @SuppressWarnings("checkstyle:methodname")
-  public static <U extends Unit<U>> U Milli(Unit<U> baseUnit, String name, String symbol) {
+  public static <U extends Unit> U Milli(U baseUnit, String name, String symbol) {
     return derive(baseUnit).splitInto(1000).named(name).symbol(symbol).make();
   }
 
@@ -432,7 +545,7 @@ public static <U extends Unit<U>> U Milli(Unit<U> baseUnit, String name, String
    * @return the milli-unit
    */
   @SuppressWarnings("checkstyle:methodname")
-  public static <U extends Unit<U>> U Milli(Unit<U> baseUnit) {
+  public static <U extends Unit> U Milli(U baseUnit) {
     return Milli(
         baseUnit, "Milli" + baseUnit.name().toLowerCase(Locale.ROOT), "m" + baseUnit.symbol());
   }
@@ -448,7 +561,7 @@ public static <U extends Unit<U>> U Milli(Unit<U> baseUnit) {
    * @return the micro-unit
    */
   @SuppressWarnings("checkstyle:methodname")
-  public static <U extends Unit<U>> U Micro(Unit<U> baseUnit, String name, String symbol) {
+  public static <U extends Unit> U Micro(U baseUnit, String name, String symbol) {
     return derive(baseUnit).splitInto(1_000_000).named(name).symbol(symbol).make();
   }
 
@@ -460,7 +573,7 @@ public static <U extends Unit<U>> U Micro(Unit<U> baseUnit, String name, String
    * @return the micro-unit
    */
   @SuppressWarnings("checkstyle:methodname")
-  public static <U extends Unit<U>> U Micro(Unit<U> baseUnit) {
+  public static <U extends Unit> U Micro(U baseUnit) {
     return Micro(
         baseUnit, "Micro" + baseUnit.name().toLowerCase(Locale.ROOT), "u" + baseUnit.symbol());
   }
@@ -475,7 +588,7 @@ public static <U extends Unit<U>> U Micro(Unit<U> baseUnit) {
    * @return the kilo-unit
    */
   @SuppressWarnings("checkstyle:methodname")
-  public static <U extends Unit<U>> U Kilo(Unit<U> baseUnit, String name, String symbol) {
+  public static <U extends Unit> U Kilo(U baseUnit, String name, String symbol) {
     return derive(baseUnit).aggregate(1000).named(name).symbol(symbol).make();
   }
 
@@ -487,7 +600,7 @@ public static <U extends Unit<U>> U Kilo(Unit<U> baseUnit, String name, String s
    * @return the kilo-unit
    */
   @SuppressWarnings("checkstyle:methodname")
-  public static <U extends Unit<U>> U Kilo(Unit<U> baseUnit) {
+  public static <U extends Unit> U Kilo(U baseUnit) {
     return Kilo(
         baseUnit, "Kilo" + baseUnit.name().toLowerCase(Locale.ROOT), "K" + baseUnit.symbol());
   }
@@ -500,8 +613,7 @@ public static <U extends Unit<U>> U Kilo(Unit<U> baseUnit) {
    * @param <U> the dimension of the unit to derive
    * @return a builder object
    */
-  @SuppressWarnings("unchecked")
-  public static <U extends Unit<U>> UnitBuilder<U> derive(Unit<U> unit) {
-    return new UnitBuilder<>((U) unit);
+  public static <U extends Unit> UnitBuilder<U> derive(U unit) {
+    return new UnitBuilder<>(unit);
   }
 }
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/Velocity.java b/wpiunits/src/main/java/edu/wpi/first/units/Velocity.java
deleted file mode 100644
index 287c1601633..00000000000
--- a/wpiunits/src/main/java/edu/wpi/first/units/Velocity.java
+++ /dev/null
@@ -1,188 +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.collections.LongToObjectHashMap;
-import java.util.Objects;
-
-/**
- * Unit of velocity dimension that is a combination of a distance unit (numerator) and a time unit
- * (denominator).
- *
- * <p>This is the base type for units of velocity dimension. It is also used in combination with a
- * distance dimension to specify the dimension for {@link Measure}. For example: <code>
- * Measure&lt;Velocity&lt;Distance&gt;&gt;</code>.
- *
- * <p>Actual units (such as {@link Units#MetersPerSecond} and {@link Units#RPM}) can be found in the
- * {@link Units} class.
- *
- * @param <D> the distance unit, such as {@link Angle} or {@link Distance}
- */
-public class Velocity<D extends Unit<D>> extends Unit<Velocity<D>> {
-  private final D m_unit;
-  private final Time m_period;
-
-  /**
-   * Stores velocity units that were created ad-hoc using {@link #combine(Unit, Time, String,
-   * String)}. Does not store objects created directly by constructors.
-   */
-  @SuppressWarnings("rawtypes")
-  private static final LongToObjectHashMap<Velocity> cache = new LongToObjectHashMap<>();
-
-  /** Generates a cache key used for cache lookups. */
-  private static long cacheKey(Unit<?> numerator, Unit<?> denominator) {
-    return ((long) numerator.hashCode()) << 32L | (denominator.hashCode() & 0xFFFFFFFFL);
-  }
-
-  /**
-   * Creates a new velocity unit derived from an arbitrary numerator and time period units.
-   *
-   * <p>Results of this method are cached so future invocations with the same arguments will return
-   * the pre-existing units instead of generating new identical ones.
-   *
-   * <pre>
-   *   Velocity.combine(Kilograms, Second) // mass flow
-   *   Velocity.combine(Feet, Millisecond) // linear speed
-   *   Velocity.combine(Radians, Second) // angular speed
-   *
-   *   Velocity.combine(Feet.per(Second), Second) // linear acceleration in ft/s/s
-   *   Velocity.combine(Radians.per(Second), Second) // angular acceleration
-   * </pre>
-   *
-   * <p>It's recommended to use the convenience function {@link Unit#per(Time)} instead of calling
-   * this factory directly.
-   *
-   * @param <D> the type of the numerator unit
-   * @param numerator the numerator unit
-   * @param period the period for unit time
-   * @param name the name of the new velocity unit
-   * @param symbol the symbol of the new velocity unit
-   * @return the new unit
-   */
-  @SuppressWarnings("unchecked")
-  public static <D extends Unit<D>> Velocity<D> combine(
-      Unit<D> numerator, Time period, String name, String symbol) {
-    long key = cacheKey(numerator, period);
-    if (cache.containsKey(key)) {
-      return cache.get(key);
-    }
-
-    Velocity<D> velocity = new Velocity<>((D) numerator, period, name, symbol);
-    cache.put(key, velocity);
-    return velocity;
-  }
-
-  /**
-   * Creates a new velocity unit derived from an arbitrary numerator and time period units.
-   *
-   * <p>Results of this method are cached so future invocations with the same arguments will return
-   * the pre-existing units instead of generating new identical ones.
-   *
-   * <p>This method automatically generates a new name and symbol for the new velocity unit.
-   *
-   * <pre>
-   *   Velocity.combine(Kilograms, Second) // mass flow
-   *   Velocity.combine(Feet, Millisecond) // linear speed
-   *   Velocity.combine(Radians, Second) // angular speed
-   *
-   *   Velocity.combine(Feet.per(Second), Second) // linear acceleration in ft/s/s
-   *   Velocity.combine(Radians.per(Second), Second) // angular acceleration
-   * </pre>
-   *
-   * <p>It's recommended to use the convenience function {@link Unit#per(Time)} instead of calling
-   * this factory directly.
-   *
-   * @param <D> the type of the numerator unit
-   * @param numerator the numerator unit
-   * @param period the period for unit time
-   * @return the new unit
-   */
-  @SuppressWarnings("unchecked")
-  public static <D extends Unit<D>> Velocity<D> combine(Unit<D> numerator, Time period) {
-    long key = cacheKey(numerator, period);
-    if (cache.containsKey(key)) {
-      return cache.get(key);
-    }
-
-    var name = numerator.name() + " per " + period.name();
-    var symbol = numerator.symbol() + "/" + period.symbol();
-
-    Velocity<D> velocity = new Velocity<>((D) numerator, period, name, symbol);
-    cache.put(key, velocity);
-    return velocity;
-  }
-
-  @SuppressWarnings({"unchecked", "rawtypes"})
-  Velocity(D unit, Time period, String name, String symbol) {
-    super(
-        unit.isBaseUnit() && period.isBaseUnit()
-            ? null
-            : combine(unit.getBaseUnit(), period.getBaseUnit()),
-        unit.toBaseUnits(1) / period.toBaseUnits(1),
-        name,
-        symbol);
-    this.m_unit = unit;
-    this.m_period = period;
-  }
-
-  @SuppressWarnings({"unchecked", "rawtypes"})
-  Velocity(
-      Velocity<D> baseUnit,
-      UnaryFunction toBaseConverter,
-      UnaryFunction fromBaseConverter,
-      String name,
-      String symbol) {
-    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
-    this.m_unit = baseUnit.getUnit();
-    this.m_period = baseUnit.getPeriod();
-  }
-
-  /**
-   * Gets the major unit being measured (eg Meters for Meters per Second).
-   *
-   * @return the major unit
-   */
-  public D getUnit() {
-    return m_unit;
-  }
-
-  /**
-   * Gets the period unit of the velocity, eg Seconds or Milliseconds.
-   *
-   * @return the period unit
-   */
-  public Time getPeriod() {
-    return m_period;
-  }
-
-  /**
-   * Returns the reciprocal of this velocity.
-   *
-   * @return the reciprocal
-   */
-  public Per<Time, D> reciprocal() {
-    return m_period.per(m_unit);
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) {
-      return true;
-    }
-    if (o == null || getClass() != o.getClass()) {
-      return false;
-    }
-    if (!super.equals(o)) {
-      return false;
-    }
-    Velocity<?> velocity = (Velocity<?>) o;
-    return m_unit.equals(velocity.m_unit) && m_period.equals(velocity.m_period);
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(super.hashCode(), m_unit, m_period);
-  }
-}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/VelocityUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/VelocityUnit.java
new file mode 100644
index 00000000000..d954166db4d
--- /dev/null
+++ b/wpiunits/src/main/java/edu/wpi/first/units/VelocityUnit.java
@@ -0,0 +1,140 @@
+// 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.ImmutableVelocity;
+import edu.wpi.first.units.measure.MutVelocity;
+import edu.wpi.first.units.measure.Velocity;
+
+/**
+ * Unit of velocity dimension that is a combination of a distance unit (numerator) and a time unit
+ * (denominator).
+ *
+ * <p>This is a generic velocity type for units that do not have discrete velocity units (eg {@link
+ * DistanceUnit} has {@link LinearVelocityUnit}, and so would not use this class).
+ *
+ * @param <D> the unit of the changing quantity, such as {@link VoltageUnit} or {@link
+ *     TemperatureUnit}
+ */
+public final class VelocityUnit<D extends Unit> extends PerUnit<D, TimeUnit> {
+  @SuppressWarnings("rawtypes")
+  private static final CombinatoryUnitCache<Unit, TimeUnit, VelocityUnit> cache =
+      new CombinatoryUnitCache<>(VelocityUnit::new);
+
+  @SuppressWarnings("unchecked")
+  VelocityUnit(D numerator, TimeUnit denominator) {
+    super(
+        numerator.isBaseUnit() && denominator.isBaseUnit()
+            ? null
+            : combine((D) numerator.getBaseUnit(), denominator.getBaseUnit()),
+        numerator,
+        denominator);
+  }
+
+  VelocityUnit(
+      VelocityUnit<D> baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  /**
+   * Combines a dimension unit and a unit of the period of change to create a unit of velocity.
+   *
+   * @param unit the unit of the changing dimension
+   * @param period the unit of the period of change in the velocity
+   * @param <D> the unit of the changing dimension
+   * @return the combined velocity unit
+   */
+  @SuppressWarnings("unchecked")
+  public static <D extends Unit> VelocityUnit<D> combine(D unit, TimeUnit period) {
+    return cache.combine(unit, period);
+  }
+
+  @Override
+  public VelocityUnit<D> getBaseUnit() {
+    return (VelocityUnit<D>) super.getBaseUnit();
+  }
+
+  /**
+   * Gets the major unit being measured (eg Meters for Meters per Second).
+   *
+   * @return the major unit
+   */
+  public D getUnit() {
+    return numerator();
+  }
+
+  /**
+   * Gets the period unit of the velocity, eg Seconds or Milliseconds.
+   *
+   * @return the period unit
+   */
+  public TimeUnit getPeriod() {
+    return denominator();
+  }
+
+  @Override
+  public Velocity<D> of(double magnitude) {
+    return new ImmutableVelocity<>(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public Velocity<D> ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableVelocity<>(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  @SuppressWarnings("unchecked")
+  public Measure<? extends VelocityUnit<D>> zero() {
+    return (Measure<? extends VelocityUnit<D>>) super.zero();
+  }
+
+  @Override
+  @SuppressWarnings("unchecked")
+  public Measure<? extends VelocityUnit<D>> one() {
+    return (Measure<? extends VelocityUnit<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.
+   *
+   * @param period the unit of the period of change
+   * @return the acceleration unit
+   */
+  @Override
+  public AccelerationUnit<D> per(TimeUnit period) {
+    return AccelerationUnit.combine(this, period);
+  }
+
+  /**
+   * Creates a ratio unit between this unit and an arbitrary other unit.
+   *
+   * @param other the other unit
+   * @param <U> the type of the other unit
+   * @return the ratio unit
+   */
+  public <U extends Unit> PerUnit<VelocityUnit<D>, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another velocity unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other velocity unit
+   * @param otherUnit the other velocity unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, VelocityUnit<? extends D> otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/Voltage.java b/wpiunits/src/main/java/edu/wpi/first/units/Voltage.java
deleted file mode 100644
index 6867121ae12..00000000000
--- a/wpiunits/src/main/java/edu/wpi/first/units/Voltage.java
+++ /dev/null
@@ -1,46 +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 static edu.wpi.first.units.Units.Watts;
-
-/**
- * Unit of electric voltage dimension.
- *
- * <p>This is the base type for units of voltage dimension. It is also used to specify the dimension
- * for {@link Measure}: <code>Measure&lt;Voltage&gt;</code>.
- *
- * <p>Actual units (such as {@link Units#Volts} and {@link Units#Millivolts}) can be found in the
- * {@link Units} class.
- */
-public class Voltage extends Unit<Voltage> {
-  Voltage(Voltage baseUnit, double baseUnitEquivalent, String name, String symbol) {
-    super(baseUnit, baseUnitEquivalent, name, symbol);
-  }
-
-  Voltage(
-      Voltage baseUnit,
-      UnaryFunction toBaseConverter,
-      UnaryFunction fromBaseConverter,
-      String name,
-      String symbol) {
-    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
-  }
-
-  /**
-   * Constructs a unit of power equivalent to this unit of voltage multiplied by another unit of
-   * electrical current. For example, {@code Volts.times(Amps)} will return a unit of power
-   * equivalent to one Watt; {@code Volts.times(Milliams)} will return a unit of power equivalent to
-   * a milliwatt, and so on.
-   *
-   * @param current the current unit to multiply by
-   * @param name the name of the resulting unit of power
-   * @param symbol the symbol used to represent the unit of power
-   * @return the power unit
-   */
-  public Power times(Unit<Current> current, String name, String symbol) {
-    return new Power(Watts, toBaseUnits(1) * current.toBaseUnits(1), name, symbol);
-  }
-}
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/VoltageUnit.java b/wpiunits/src/main/java/edu/wpi/first/units/VoltageUnit.java
new file mode 100644
index 00000000000..07774031b0c
--- /dev/null
+++ b/wpiunits/src/main/java/edu/wpi/first/units/VoltageUnit.java
@@ -0,0 +1,105 @@
+// 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.ImmutableVoltage;
+import edu.wpi.first.units.measure.MutVoltage;
+import edu.wpi.first.units.measure.Voltage;
+
+/**
+ * Unit of electric voltage dimension.
+ *
+ * <p>This is the base type for units of voltage dimension. It is also used to specify the dimension
+ * for {@link Measure}: <code>Measure&lt;VoltageUnit&gt;</code>.
+ *
+ * <p>Actual units (such as {@link Units#Volts} and {@link Units#Millivolts}) can be found in the
+ * {@link Units} class.
+ */
+public final class VoltageUnit extends Unit {
+  VoltageUnit(VoltageUnit baseUnit, double baseUnitEquivalent, String name, String symbol) {
+    super(baseUnit, baseUnitEquivalent, name, symbol);
+  }
+
+  VoltageUnit(
+      VoltageUnit baseUnit,
+      UnaryFunction toBaseConverter,
+      UnaryFunction fromBaseConverter,
+      String name,
+      String symbol) {
+    super(baseUnit, toBaseConverter, fromBaseConverter, name, symbol);
+  }
+
+  @Override
+  public VoltageUnit getBaseUnit() {
+    return (VoltageUnit) super.getBaseUnit();
+  }
+
+  /**
+   * Constructs a unit of power equivalent to this unit of voltage multiplied by another unit of
+   * electrical current. For example, {@code Volts.times(Amps)} will return a unit of power
+   * equivalent to one Watt; {@code Volts.times(Milliamps)} will return a unit of power equivalent
+   * to a milliwatt, and so on.
+   *
+   * @param current the current unit to multiply by
+   * @param name the name of the resulting unit of power
+   * @param symbol the symbol used to represent the unit of power
+   * @return the power unit
+   */
+  public PowerUnit mult(CurrentUnit current, String name, String symbol) {
+    return Units.derive(PowerUnit.combine(this, current)).named(name).symbol(symbol).make();
+  }
+
+  @Override
+  public Voltage of(double magnitude) {
+    return new ImmutableVoltage(magnitude, toBaseUnits(magnitude), this);
+  }
+
+  @Override
+  public Voltage ofBaseUnits(double baseUnitMagnitude) {
+    return new ImmutableVoltage(fromBaseUnits(baseUnitMagnitude), baseUnitMagnitude, this);
+  }
+
+  @Override
+  public Voltage zero() {
+    return (Voltage) super.zero();
+  }
+
+  @Override
+  public Voltage one() {
+    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);
+  }
+
+  /**
+   * Creates a generic ratio unit of this voltage to a different unit type.
+   *
+   * @param other the other unit type
+   * @param <U> the type of the other unit
+   * @return the combined ratio type
+   */
+  public <U extends Unit> PerUnit<VoltageUnit, U> per(U other) {
+    return PerUnit.combine(this, other);
+  }
+
+  /**
+   * Converts a measurement value in terms of another voltage unit to this unit.
+   *
+   * @param magnitude the magnitude of the measurement in terms of the other voltage unit
+   * @param otherUnit the other voltage unit
+   * @return the value of the measurement in terms of this unit
+   */
+  public double convertFrom(double magnitude, VoltageUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+}
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
new file mode 100644
index 00000000000..c5ae7916504
--- /dev/null
+++ b/wpiunits/src/main/java/edu/wpi/first/units/mutable/GenericMutableMeasureImpl.java
@@ -0,0 +1,79 @@
+// 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> divide(double divisor) {
+    return ImmutableMeasure.ofBaseUnits(m_baseUnitMagnitude / divisor, m_unit);
+  }
+
+  @Override
+  public Measure<U> divide(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
new file mode 100644
index 00000000000..3314e809b2b
--- /dev/null
+++ b/wpiunits/src/main/java/edu/wpi/first/units/mutable/MutableMeasureBase.java
@@ -0,0 +1,86 @@
+// 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/CurrentTest.java b/wpiunits/src/test/java/edu/wpi/first/units/CurrentUnitTest.java
similarity index 52%
rename from wpiunits/src/test/java/edu/wpi/first/units/CurrentTest.java
rename to wpiunits/src/test/java/edu/wpi/first/units/CurrentUnitTest.java
index d383094cbab..5c215f7bf35 100644
--- a/wpiunits/src/test/java/edu/wpi/first/units/CurrentTest.java
+++ b/wpiunits/src/test/java/edu/wpi/first/units/CurrentUnitTest.java
@@ -4,14 +4,15 @@
 
 package edu.wpi.first.units;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import org.junit.jupiter.api.Test;
 
-class CurrentTest {
+class CurrentUnitTest {
   @Test
   void testAmpsTimesVolts() {
-    Power combined = Units.Amps.times(Units.Volts, "Watt", "w");
+    PowerUnit combined = Units.Amps.mult(Units.Volts, "Watt", "w");
 
     assertTrue(combined.equivalent(Units.Watts));
   }
@@ -19,8 +20,11 @@ void testAmpsTimesVolts() {
   @Test
   void testMilliAmpsTimesMilliVolts() {
     // results in microwatts
-    assertTrue(
-        Units.Milliamps.times(Units.Millivolts, "Microwatt", "uW")
-            .equivalent(Units.Milli(Units.Milliwatts)));
+    PowerUnit times = Units.Milliamps.mult(Units.Millivolts, "Microwatt", "uW");
+    PowerUnit millimilli = Units.Milli(Units.Milliwatts);
+
+    assertEquals(1, times.convertFrom(1e-6, Units.Watts));
+    assertEquals(1, millimilli.convertFrom(1e-6, Units.Watts));
+    assertTrue(times.equivalent(millimilli));
   }
 }
diff --git a/wpiunits/src/test/java/edu/wpi/first/units/DistanceTest.java b/wpiunits/src/test/java/edu/wpi/first/units/DistanceUnitTest.java
similarity index 83%
rename from wpiunits/src/test/java/edu/wpi/first/units/DistanceTest.java
rename to wpiunits/src/test/java/edu/wpi/first/units/DistanceUnitTest.java
index 2ce9cf33853..08a6612172b 100644
--- a/wpiunits/src/test/java/edu/wpi/first/units/DistanceTest.java
+++ b/wpiunits/src/test/java/edu/wpi/first/units/DistanceUnitTest.java
@@ -9,18 +9,18 @@
 
 import org.junit.jupiter.api.Test;
 
-class DistanceTest {
+class DistanceUnitTest {
   @Test
   void testBaseUnitDistancePerTime() {
-    Velocity<Distance> anonBaseUnit =
-        new Distance(null, 1, "D", "d").per(new Time(null, 1, "T", "t"));
+    LinearVelocityUnit anonBaseUnit =
+        new DistanceUnit(null, 1, "D", "d").per(new TimeUnit(null, 1, "T", "t"));
 
     assertTrue(Units.MetersPerSecond.equivalent(anonBaseUnit));
   }
 
   @Test
   void testFeetPerSecond() {
-    Velocity<Distance> feetPerMillisecond = Units.Feet.per(Units.Milliseconds);
+    LinearVelocityUnit feetPerMillisecond = Units.Feet.per(Units.Milliseconds);
 
     // one foot per millisecond
     // = (1 / 3.28084) meters per (1 / 1000) seconds
diff --git a/wpiunits/src/test/java/edu/wpi/first/units/EncoderTest.java b/wpiunits/src/test/java/edu/wpi/first/units/EncoderTest.java
deleted file mode 100644
index b78a4af6d7f..00000000000
--- a/wpiunits/src/test/java/edu/wpi/first/units/EncoderTest.java
+++ /dev/null
@@ -1,91 +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 static edu.wpi.first.units.Units.Inches;
-import static edu.wpi.first.units.Units.Revolutions;
-import static edu.wpi.first.units.Units.Second;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-import org.junit.jupiter.api.Test;
-
-class EncoderTest {
-  static class Encoder<U extends Unit<U>> {
-    int m_ticks; // = 0
-    private Measure<U> m_distancePerPulse;
-    private MutableMeasure<U> m_distance;
-    private MutableMeasure<Velocity<U>> m_rate;
-
-    void setDistancePerPulse(Measure<U> distancePerPulse) {
-      m_distancePerPulse = distancePerPulse;
-      m_distance = MutableMeasure.zero(distancePerPulse.unit());
-      m_rate = MutableMeasure.zero(distancePerPulse.unit().per(Second));
-    }
-
-    Measure<U> getDistance() {
-      return m_distance;
-    }
-
-    Measure<Velocity<U>> getRate() {
-      return m_rate;
-    }
-
-    void setTicks(int ticks) {
-      // pretend we read from JNI here instead of being passed a specific value
-      var change = ticks - m_ticks;
-      m_ticks = ticks;
-      m_distance.mut_setMagnitude(m_distancePerPulse.magnitude() * ticks);
-
-      // assumes the last update was 1 second ago - fine for tests
-      m_rate.mut_setMagnitude(m_distancePerPulse.magnitude() * change);
-    }
-  }
-
-  @Test
-  void testAsDistance() {
-    double ticksPerRevolution = 2048;
-
-    var encoder = new Encoder<Distance>();
-
-    // distance per rotation = (wheel circumference / gear ratio)
-    // distance per tick = distance per rotation / ticks per rotation
-    var wheelDiameter = Inches.of(6);
-    double gearRatio = 10; // 10:1 ratio
-    Measure<Distance> distancePerPulse =
-        wheelDiameter.times(Math.PI).divide(gearRatio).divide(ticksPerRevolution);
-    encoder.setDistancePerPulse(distancePerPulse);
-
-    encoder.m_ticks = 0;
-    assertEquals(0, encoder.getDistance().in(Inches), Measure.EQUIVALENCE_THRESHOLD);
-    assertEquals(0, encoder.getRate().in(Inches.per(Second)), Measure.EQUIVALENCE_THRESHOLD);
-
-    // one full encoder turn, 1/10th of a wheel rotation
-    encoder.setTicks(2048);
-    assertEquals(6 * Math.PI / 10, encoder.getDistance().in(Inches), Measure.EQUIVALENCE_THRESHOLD);
-
-    // one full encoder turn back, 1/10th of a wheel rotation - rate should be negative
-    encoder.setTicks(0);
-    assertEquals(
-        -6 * Math.PI / 10, encoder.getRate().in(Inches.per(Second)), Measure.EQUIVALENCE_THRESHOLD);
-  }
-
-  @Test
-  void testAsRevolutions() {
-    double ticksPerRevolution = 2048;
-
-    var encoder = new Encoder<Angle>();
-
-    Measure<Angle> distancePerPulse = Revolutions.of(1).divide(ticksPerRevolution);
-    encoder.setDistancePerPulse(distancePerPulse);
-
-    encoder.m_ticks = 0;
-    assertEquals(0, encoder.getDistance().in(Revolutions), Measure.EQUIVALENCE_THRESHOLD);
-    assertEquals(0, encoder.getRate().in(Revolutions.per(Second)), Measure.EQUIVALENCE_THRESHOLD);
-
-    encoder.setTicks(2048); // one full encoder turn, 1/10th of a wheel rotation
-    assertEquals(1, encoder.getDistance().in(Revolutions), Measure.EQUIVALENCE_THRESHOLD);
-    assertEquals(1, encoder.getRate().in(Revolutions.per(Second)), Measure.EQUIVALENCE_THRESHOLD);
-  }
-}
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 d03bb640603..cc4b272f88a 100644
--- a/wpiunits/src/test/java/edu/wpi/first/units/ExampleUnit.java
+++ b/wpiunits/src/test/java/edu/wpi/first/units/ExampleUnit.java
@@ -4,7 +4,9 @@
 
 package edu.wpi.first.units;
 
-class ExampleUnit extends Unit<ExampleUnit> {
+import edu.wpi.first.units.mutable.GenericMutableMeasureImpl;
+
+class ExampleUnit extends Unit {
   ExampleUnit(double baseUnitEquivalent) {
     this(baseUnitEquivalent, "Example", "ex");
   }
@@ -21,4 +23,28 @@ class ExampleUnit extends Unit<ExampleUnit> {
   ExampleUnit(double baseUnitEquivalent, String name, String symbol) {
     super(null, baseUnitEquivalent, name, symbol);
   }
+
+  public double convertFrom(double magnitude, ExampleUnit otherUnit) {
+    return fromBaseUnits(otherUnit.toBaseUnits(magnitude));
+  }
+
+  @Override
+  public Measure<ExampleUnit> of(double magnitude) {
+    return ImmutableMeasure.ofRelativeUnits(magnitude, this);
+  }
+
+  @Override
+  public Measure<ExampleUnit> ofBaseUnits(double baseUnitMagnitude) {
+    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);
+  }
 }
diff --git a/wpiunits/src/test/java/edu/wpi/first/units/MeasureTest.java b/wpiunits/src/test/java/edu/wpi/first/units/MeasureTest.java
index 05f63985200..2454aa75aa2 100644
--- a/wpiunits/src/test/java/edu/wpi/first/units/MeasureTest.java
+++ b/wpiunits/src/test/java/edu/wpi/first/units/MeasureTest.java
@@ -11,69 +11,106 @@
 import static org.junit.jupiter.api.Assertions.assertSame;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
+import edu.wpi.first.units.measure.Angle;
+import edu.wpi.first.units.measure.AngularMomentum;
+import edu.wpi.first.units.measure.Distance;
+import edu.wpi.first.units.measure.LinearVelocity;
+import edu.wpi.first.units.measure.Per;
+import edu.wpi.first.units.measure.Time;
 import org.junit.jupiter.api.Test;
 
 class MeasureTest {
   @Test
   void testBasics() {
-    Unit<Distance> unit = Units.Feet;
+    DistanceUnit unit = Units.Feet;
     double magnitude = 10;
-    Measure<Distance> m = unit.of(magnitude);
+    Distance m = unit.of(magnitude);
     assertEquals(unit, m.unit(), "Wrong units");
     assertEquals(magnitude, m.magnitude(), 0, "Wrong magnitude");
   }
 
   @Test
   void testMultiply() {
-    Measure<Distance> m = Units.Feet.of(1);
-    Measure<Distance> m2 = m.times(10);
-    assertEquals(10, m2.magnitude(), 1e-12);
+    Distance m = Units.Feet.of(1);
+    Distance m2 = m.times(10);
+    assertEquals(10, m2.in(Units.Feet), 1e-12);
     assertNotSame(m2, m); // make sure state wasn't changed
   }
 
+  @Test
+  void testTimesConversionFactor() {
+    Distance m = Units.Feet.of(10);
+
+    Per<AngleUnit, DistanceUnit> conversion = Units.Degrees.of(10).divide(Units.Feet.of(1));
+    Angle result = m.timesConversionFactor(conversion);
+    assertEquals(Units.Degrees.of(100), result);
+  }
+
+  @Test
+  void testTimesConversionFactorComplex() {
+    Distance m = Units.Feet.of(1);
+
+    // Using a complex compound unit here
+    // (Per<Mult<Mult<Mass, Per<Distance, Time>>, Distance>, Distance>)
+    Per<AngularMomentumUnit, DistanceUnit> conversion =
+        Units.KilogramMetersSquaredPerSecond.of(1).divide(Units.Foot.one());
+
+    AngularMomentum result = m.timesConversionFactor(conversion);
+    assertEquals(Units.KilogramMetersSquaredPerSecond.of(1), result);
+  }
+
+  @Test
+  void testTimesVelocityConversionFactor() {
+    Time m = Units.Seconds.of(10);
+
+    LinearVelocity conversion = Units.MetersPerSecond.of(10);
+    Distance result = m.timesConversionFactor(conversion);
+    assertEquals(Units.Meters.of(100), result);
+  }
+
   @Test
   void testDivide() {
-    Measure<Distance> m = Units.Meters.of(1);
-    Measure<Distance> m2 = m.divide(10);
+    Distance m = Units.Meters.of(1);
+    Distance m2 = m.divide(10);
     assertEquals(0.1, m2.magnitude(), 0);
     assertNotSame(m2, m);
   }
 
   @Test
   void testAdd() {
-    Measure<Distance> m1 = Units.Feet.of(1);
-    Measure<Distance> m2 = Units.Inches.of(2);
+    Distance m1 = Units.Feet.of(1);
+    Distance m2 = Units.Inches.of(2);
     assertTrue(m1.plus(m2).isEquivalent(Units.Feet.of(1 + 2 / 12d)));
     assertTrue(m2.plus(m1).isEquivalent(Units.Inches.of(14)));
   }
 
   @Test
   void testSubtract() {
-    Measure<Distance> m1 = Units.Feet.of(1);
-    Measure<Distance> m2 = Units.Inches.of(2);
+    Distance m1 = Units.Feet.of(1);
+    Distance m2 = Units.Inches.of(2);
     assertTrue(m1.minus(m2).isEquivalent(Units.Feet.of(1 - 2 / 12d)));
     assertTrue(m2.minus(m1).isEquivalent(Units.Inches.of(-10)));
   }
 
   @Test
-  void testNegate() {
-    Measure<Distance> m = Units.Feet.of(123);
-    Measure<Distance> n = m.negate();
-    assertEquals(-m.magnitude(), n.magnitude(), 1e-12);
-    assertEquals(m.unit(), n.unit());
+  void testUnaryMinus() {
+    Distance m = Units.Feet.of(123);
+    Distance negated = m.unaryMinus();
+    assertEquals(-123, negated.in(Units.Feet), 1e-12);
+    assertEquals(Units.Feet, negated.unit());
   }
 
   @Test
   void testEquivalency() {
-    Measure<Distance> inches = Units.Inches.of(12);
-    Measure<Distance> feet = Units.Feet.of(1);
+    Distance inches = Units.Inches.of(12);
+    Distance feet = Units.Feet.of(1);
     assertTrue(inches.isEquivalent(feet));
     assertTrue(feet.isEquivalent(inches));
   }
 
   @Test
   void testAs() {
-    Measure<Distance> m = Units.Inches.of(12);
+    Distance m = Units.Inches.of(12);
     assertEquals(1, m.in(Units.Feet), Measure.EQUIVALENCE_THRESHOLD);
   }
 
@@ -84,7 +121,7 @@ void testPerMeasureTime() {
 
     // 144 Kg / (53 ms) = (1000 / 53) * 144 Kg/s = (144,000 / 53) Kg/s
 
-    var result = measure.per(dt);
+    var result = measure.divide(dt);
     assertEquals(144_000.0 / 53, result.baseUnitMagnitude(), 1e-5);
     assertEquals(Units.Kilograms.per(Units.Milliseconds), result.unit());
   }
@@ -94,106 +131,33 @@ void testPerUnitTime() {
     var measure = Units.Kilograms.of(144);
     var result = measure.per(Units.Millisecond);
 
-    assertEquals(Velocity.class, result.unit().getClass());
+    assertEquals(VelocityUnit.class, result.unit().getClass());
     assertEquals(144_000.0, result.baseUnitMagnitude(), 1e-5);
     assertEquals(Units.Kilograms.per(Units.Milliseconds), result.unit());
   }
 
-  @Test
-  void testTimesMeasure() {
-    var m1 = Units.Volts.of(1.567);
-    var m2 = Units.Kilograms.of(8.4e-5);
-
-    assertEquals(Units.Volts.mult(Units.Kilograms).of(1.567 * 8.4e-5), m1.times(m2));
-  }
-
-  @Test
-  void testTimesUnitless() {
-    var unit = new ExampleUnit(6);
-    var measure = unit.of(2.5);
-    var multiplier = Units.Percent.of(125); // 125% or 1.25x
-    Measure<?> result = measure.times(multiplier);
-    assertSame(unit, result.unit());
-
-    assertEquals(2.5 * 1.25, result.magnitude());
-    assertEquals(2.5 * 1.25 * 6, result.baseUnitMagnitude());
-  }
-
-  @Test
-  void testTimesPerWithDimensionalAnalysis() {
-    var measureA = Units.Feet.of(62); // 62 feet
-    var measureB = Units.Radians.of(6).per(Units.Inches); // 6 radians per inch
-    Measure<?> aTimesB = measureA.times(measureB); // (62 feet) * (6 rad/inch) = 4464 rad
-    assertEquals(Units.Radians, aTimesB.unit());
-    assertEquals(4464, aTimesB.magnitude(), 1e-12);
-
-    Measure<?> bTimesA = measureB.times(measureA); // should be identical to the above
-    assertTrue(bTimesA.isEquivalent(aTimesB));
-    assertTrue(aTimesB.isEquivalent(bTimesA));
-  }
-
-  @Test
-  void testPerTimesPerWithDimensionalAnalysis() {
-    var measureA = Units.Inches.of(16).per(Units.Volts);
-    var measureB = Units.Millivolts.of(14).per(Units.Meters);
-    Measure<?> aTimesB = measureA.times(measureB);
-    assertEquals(Units.Value, aTimesB.unit());
-    assertEquals((16 * 25.4 / 1000) * (14 / 1000.0), aTimesB.magnitude());
-    assertEquals((16 * 25.4 / 1000) * (14 / 1000.0), aTimesB.baseUnitMagnitude());
-
-    Measure<?> bTimesA = measureB.times(measureA); // should be identical to the above
-    assertTrue(bTimesA.isEquivalent(aTimesB));
-    assertTrue(aTimesB.isEquivalent(bTimesA));
-  }
-
-  @Test
-  void testPerTimesMeasure() {
-    var m1 = Units.Feet.per(Units.Milliseconds).of(19);
-    var m2 = Units.Seconds.of(44);
-
-    // 19 ft/ms = 19,000 ft/s
-    // 19,000 ft/s * 44s = 836,000 ft
-    assertTrue(Units.Feet.of(836_000).isNear(m1.times(m2), 1e-12));
-
-    // 42 ex per foot * 17mm = 42 ex * 17mm / (304.8mm/ft) = 42 * 17 / 304.8 = 2.34252
-    var exampleUnit = new ExampleUnit(1);
-    var m3 = exampleUnit.per(Units.Feet).of(42);
-    var m4 = Units.Millimeters.of(17);
-    assertEquals(exampleUnit.of(42 * 17 / (12 * 25.4)), m3.times(m4));
-  }
-
   @Test
   void testDivideMeasure() {
     // Dimensionless divide
     var m1 = Units.Meters.of(6);
     var m2 = Units.Value.of(3);
     var result = m1.divide(m2);
-    assertEquals(m1.divide(m2).magnitude(), 2);
-    assertEquals(result.unit(), Units.Meters);
+    assertEquals(2, m1.divide(m2).magnitude());
+    assertEquals(Units.Meters, result.unit());
     // Velocity divide
     var m3 = Units.Meters.of(8);
     var m4 = Units.Meters.per(Units.Second).of(4);
-    result = m3.divide(m4);
-    assertEquals(result.magnitude(), 2);
-    assertEquals(result.unit(), Units.Second);
-    // Per divide
+    var time = m3.divide(m4);
+    assertEquals(2, time.magnitude());
+    assertEquals(Units.Second, time.unit());
+    // PerUnit divide
     var m5 = Units.Volts.of(6);
     var m6 = Units.Volts.per(Units.Meter).of(2);
-    result = m5.divide(m6);
-    assertEquals(result.magnitude(), 3);
-    assertEquals(result.unit(), Units.Meter);
-    // Fallthrough divide
-    var m7 = Units.Seconds.of(10);
-    var m8 = Units.Amps.of(2);
-    result = m7.divide(m8);
-    assertEquals(result.magnitude(), 5);
-    assertEquals(result.unit(), Units.Seconds.per(Units.Amps));
-    // Same base unit divide
-    var m9 = Units.Meters.of(8);
-    var m10 = Units.Meters.of(4);
-    result = m9.divide(m10);
-    assertEquals(result.magnitude(), 2);
-    assertEquals(result.unit(), Units.Value);
+
+    // Voltage/(Voltage/Distance) -> Voltage * Distance/Voltage -> Distance
+    var dist = m5.divide(m6);
+    assertEquals(3, dist.magnitude());
+    assertEquals(Units.Meter, dist.unit());
   }
 
   @Test
@@ -249,57 +213,6 @@ void testCompare() {
     assertFalse(base.gt(base));
   }
 
-  @Test
-  void testTimesScalar() {
-    var unit = new ExampleUnit(42);
-    var measure = unit.of(4.2);
-    var scalar = 18;
-    var result = measure.times(scalar);
-    assertNotSame(measure, result);
-    assertSame(unit, result.unit());
-    assertEquals(4.2 * 18, result.magnitude());
-    assertEquals(4.2 * 42 * 18, result.baseUnitMagnitude());
-  }
-
-  @Test
-  void testPerUnit() {
-    var unitA = new ExampleUnit(10);
-    var unitB = new ExampleUnit(12);
-    var measure = unitA.of(1.2);
-    var result = measure.per(unitB);
-    assertEquals(Per.combine(unitA, unitB), result.unit()); // A/B has base equivalent of 10/12
-    assertEquals(1, result.baseUnitMagnitude()); // 10/12 * 12/10 = 1
-    assertEquals(measure.magnitude(), result.magnitude());
-  }
-
-  @Test
-  void testAddMeasureSameUnit() {
-    var unit = new ExampleUnit(8.2);
-    var measureA = unit.of(3.1);
-    var measureB = unit.of(91.6);
-    var result = measureA.plus(measureB);
-    assertEquals(unit, result.unit());
-    assertEquals(94.7, result.magnitude(), 1e-12);
-  }
-
-  @Test
-  void testAddMeasuresDifferentUnits() {
-    var unitA = new ExampleUnit(8.2);
-    var unitB = new ExampleUnit(7.3);
-    var measureA = unitA.of(5);
-    var measureB = unitB.of(16);
-    var aPlusB = measureA.plus(measureB);
-
-    assertEquals(unitA, aPlusB.unit());
-    assertEquals(8.2 * 5 + 7.3 * 16, aPlusB.baseUnitMagnitude(), 1e-12);
-    assertEquals(5 + (16 * 7.3 / 8.2), aPlusB.magnitude(), 1e-12);
-
-    var bPlusA = measureB.plus(measureA);
-    assertEquals(unitB, bPlusA.unit());
-    assertEquals(8.2 * 5 + 7.3 * 16, bPlusA.baseUnitMagnitude(), 1e-12);
-    assertEquals(16 + (5 * 8.2 / 7.3), bPlusA.magnitude(), 1e-12);
-  }
-
   @Test
   void testMinNoArgs() {
     var min = Measure.min();
@@ -388,29 +301,29 @@ void testIsNearMeasureTolerance() {
     assertTrue(measureCompared.isNear(measureComparing, Units.Millimeters.of(300)));
     assertFalse(measureCompared.isNear(measureComparing, Units.Centimeters.of(10)));
 
-    measureCompared = measureCompared.negate();
-    measureComparing = measureComparing.negate();
+    measureCompared = measureCompared.unaryMinus();
+    measureComparing = measureComparing.unaryMinus();
 
     // Negative value with positive tolerance
     assertTrue(measureCompared.isNear(measureComparing, Units.Millimeters.of(300)));
     assertFalse(measureCompared.isNear(measureComparing, Units.Centimeters.of(10)));
 
-    measureCompared = measureCompared.negate();
-    measureComparing = measureComparing.negate();
+    measureCompared = measureCompared.unaryMinus();
+    measureComparing = measureComparing.unaryMinus();
 
     // Positive value with negative tolerance
     assertTrue(measureCompared.isNear(measureComparing, Units.Millimeters.of(-300)));
     assertFalse(measureCompared.isNear(measureComparing, Units.Centimeters.of(-10)));
 
-    measureCompared = measureCompared.negate();
-    measureComparing = measureComparing.negate();
+    measureCompared = measureCompared.unaryMinus();
+    measureComparing = measureComparing.unaryMinus();
 
     // Negative value with negative tolerance.
     assertTrue(measureCompared.isNear(measureComparing, Units.Millimeters.of(-300)));
     assertFalse(measureCompared.isNear(measureComparing, Units.Centimeters.of(-10)));
 
-    measureCompared = measureCompared.negate();
-    measureComparing = measureComparing.negate();
+    measureCompared = measureCompared.unaryMinus();
+    measureComparing = measureComparing.unaryMinus();
 
     // Tolerance exact difference between measures.
     assertTrue(measureCompared.isNear(measureComparing, Units.Millimeters.of(200)));
diff --git a/wpiunits/src/test/java/edu/wpi/first/units/MultTest.java b/wpiunits/src/test/java/edu/wpi/first/units/MultUnitTest.java
similarity index 80%
rename from wpiunits/src/test/java/edu/wpi/first/units/MultTest.java
rename to wpiunits/src/test/java/edu/wpi/first/units/MultUnitTest.java
index 383ea1665a9..8815e81d50e 100644
--- a/wpiunits/src/test/java/edu/wpi/first/units/MultTest.java
+++ b/wpiunits/src/test/java/edu/wpi/first/units/MultUnitTest.java
@@ -9,12 +9,12 @@
 
 import org.junit.jupiter.api.Test;
 
-class MultTest {
+class MultUnitTest {
   @Test
   void testAutomaticNames() {
     var unitA = new ExampleUnit(1, "Ay", "a");
     var unitB = new ExampleUnit(1, "Bee", "b");
-    var mult = Mult.combine(unitA, unitB);
+    var mult = MultUnit.combine(unitA, unitB);
     assertEquals("Ay-Bee", mult.name());
     assertEquals("a*b", mult.symbol());
   }
@@ -23,7 +23,7 @@ void testAutomaticNames() {
   void testCombine() {
     var unitA = new ExampleUnit(100);
     var unitB = new ExampleUnit(0.912);
-    var mult = Mult.combine(unitA, unitB);
+    var mult = MultUnit.combine(unitA, unitB);
     assertEquals(91.2, mult.toBaseUnits(1));
   }
 
@@ -31,7 +31,7 @@ void testCombine() {
   void testCaches() {
     var unitA = new ExampleUnit(1);
     var unitB = new ExampleUnit(2);
-    var mult = Mult.combine(unitA, unitB);
-    assertSame(mult, Mult.combine(unitA, unitB));
+    var mult = MultUnit.combine(unitA, unitB);
+    assertSame(mult, MultUnit.combine(unitA, unitB));
   }
 }
diff --git a/wpiunits/src/test/java/edu/wpi/first/units/MutableMeasureTest.java b/wpiunits/src/test/java/edu/wpi/first/units/MutableMeasureTest.java
deleted file mode 100644
index 50088849395..00000000000
--- a/wpiunits/src/test/java/edu/wpi/first/units/MutableMeasureTest.java
+++ /dev/null
@@ -1,133 +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 static edu.wpi.first.units.Units.Centimeters;
-import static edu.wpi.first.units.Units.FeetPerSecond;
-import static edu.wpi.first.units.Units.InchesPerSecond;
-import static edu.wpi.first.units.Units.Meters;
-import static edu.wpi.first.units.Units.Millisecond;
-import static edu.wpi.first.units.Units.Millivolts;
-import static edu.wpi.first.units.Units.Second;
-import static edu.wpi.first.units.Units.Volts;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertSame;
-
-import org.junit.jupiter.api.Test;
-
-class MutableMeasureTest {
-  @Test
-  void testWrapper() {
-    var unit = new ExampleUnit(1);
-    var measure = unit.of(1234);
-    var mutable = MutableMeasure.mutable(measure);
-    assertEquals(measure.magnitude(), mutable.magnitude(), 0);
-    assertEquals(measure.unit(), mutable.unit());
-  }
-
-  @Test
-  void testSetMagnitude() {
-    var measure = MutableMeasure.ofRelativeUnits(0, FeetPerSecond);
-    double newMagnitude = 48.123;
-    measure.mut_setMagnitude(newMagnitude);
-    assertEquals(newMagnitude, measure.magnitude(), 0); // should be an exact match
-    double feetToMeters = 0.3048;
-    assertEquals(newMagnitude * feetToMeters, measure.baseUnitMagnitude(), 1e-12);
-  }
-
-  @Test
-  void testMut_times() {
-    var measure = MutableMeasure.ofRelativeUnits(18, FeetPerSecond);
-    double scalar = Math.PI;
-    var result = measure.mut_times(scalar);
-    assertSame(measure, result, "mut_times should return the same object");
-    assertEquals(18 * Math.PI, measure.magnitude(), 1e-12);
-  }
-
-  @Test
-  void testMut_divide() {
-    var measure = MutableMeasure.ofRelativeUnits(18, FeetPerSecond);
-    double scalar = Math.PI;
-    var result = measure.mut_divide(scalar);
-    assertSame(measure, result, "mut_times should return the same object");
-    assertEquals(18 / Math.PI, measure.magnitude(), 1e-12);
-  }
-
-  @Test
-  void testReplaceMeasure() {
-    var measure = MutableMeasure.ofRelativeUnits(17.6, FeetPerSecond);
-    var replacer = Meters.per(Millisecond).of(94.872);
-    var result = measure.mut_replace(replacer);
-    assertSame(measure, result, "Replacing should return the mutable measure");
-    assertSame(replacer.unit(), measure.unit());
-    assertEquals(replacer.magnitude(), measure.magnitude(), 0);
-  }
-
-  @Test
-  void testReplaceRaw() {
-    var measure = MutableMeasure.ofRelativeUnits(-542, FeetPerSecond);
-    var result = measure.mut_replace(62, Meters.per(Millisecond));
-    assertSame(measure, result, "Replacing should return the mutable measure");
-    assertSame(Meters.per(Millisecond), measure.unit());
-    assertEquals(62, measure.magnitude(), 0);
-  }
-
-  @Test
-  void testAccMeasure() {
-    var measure = MutableMeasure.ofRelativeUnits(8.5431, FeetPerSecond);
-    var acc = Meters.per(Millisecond).of(-23.62);
-    var result = measure.mut_acc(acc);
-    assertSame(measure, result, "Acc should return the mutable measure");
-    assertSame(FeetPerSecond, measure.unit(), "Unit shouldn't change");
-    assertEquals(8.5431 - (23.62 * (1 / 0.3048) * 1000), measure.magnitude(), 1e-10);
-  }
-
-  @Test
-  void testAccRaw() {
-    var measure = MutableMeasure.ofRelativeUnits(99.999999, FeetPerSecond);
-    var result = measure.mut_acc(22.981);
-    assertSame(measure, result);
-    assertSame(FeetPerSecond, measure.unit());
-    assertEquals(122.980999, measure.magnitude(), 0);
-  }
-
-  @Test
-  void testMutPlusMeasure() {
-    var measure = MutableMeasure.ofRelativeUnits(400, InchesPerSecond);
-    var other = Centimeters.per(Second).of(41.312);
-    var result = measure.mut_plus(other);
-    assertSame(measure, result);
-    assertSame(InchesPerSecond, result.unit());
-    assertEquals(416.2645669291339, measure.magnitude(), 1e-12);
-  }
-
-  @Test
-  void testMutPlusRaw() {
-    var measure = MutableMeasure.ofRelativeUnits(31.51, Volts);
-    var result = measure.mut_plus(66.641, Millivolts);
-    assertSame(measure, result);
-    assertSame(Volts, result.unit());
-    assertEquals(31.576641, result.magnitude(), 1e-10);
-  }
-
-  @Test
-  void testMutMinusMeasure() {
-    var measure = MutableMeasure.ofRelativeUnits(400, InchesPerSecond);
-    var other = Centimeters.per(Second).of(41.312);
-    var result = measure.mut_minus(other);
-    assertSame(measure, result);
-    assertSame(InchesPerSecond, result.unit());
-    assertEquals(383.7354330708662, measure.magnitude(), 1e-12);
-  }
-
-  @Test
-  void testMutMinusRaw() {
-    var measure = MutableMeasure.ofRelativeUnits(31.51, Volts);
-    var result = measure.mut_minus(66.641, Millivolts);
-    assertSame(measure, result);
-    assertSame(Volts, result.unit());
-    assertEquals(31.443359, result.magnitude(), 1e-10);
-  }
-}
diff --git a/wpiunits/src/test/java/edu/wpi/first/units/PerUnitTest.java b/wpiunits/src/test/java/edu/wpi/first/units/PerUnitTest.java
new file mode 100644
index 00000000000..c964684c51d
--- /dev/null
+++ b/wpiunits/src/test/java/edu/wpi/first/units/PerUnitTest.java
@@ -0,0 +1,56 @@
+// 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 static edu.wpi.first.units.Units.Degrees;
+import static edu.wpi.first.units.Units.Foot;
+import static edu.wpi.first.units.Units.Inches;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertSame;
+
+import org.junit.jupiter.api.Test;
+
+class PerUnitTest {
+  @Test
+  void ofNative() {
+    ExampleUnit part = new ExampleUnit(1);
+    var unit = PerUnit.combine(part, part);
+    assertEquals(10, unit.ofNative(10).in(unit));
+
+    // Does not compile:
+    // unit.of(10).in(unit);
+    //
+    // error: incompatible types: PerUnit<ExampleUnit,ExampleUnit> cannot be converted to CAP#1
+    //    unit.of(10).in(unit);
+    //                   ^
+    //  where CAP#1 is a fresh type-variable:
+    //    CAP#1 extends PerUnit<ExampleUnit,ExampleUnit>
+    //    from capture of ? extends PerUnit<ExampleUnit,ExampleUnit>
+    // This is because `of` returns a `Measure<? extends PerUnit<ExampleUnit, ExampleUnit>>`,
+    // and a `Per<ExampleUnit, ExampleUnit>` object isn't a subtype of that anonymous wildcard bound
+  }
+
+  @Test
+  void multSameDenom() {
+    var unit = Degrees.per(Foot);
+    var result = unit.mult(Foot);
+
+    // Multiplying by the same unit as the divisor should return the dividend unit
+    assertSame(Degrees, result);
+  }
+
+  @Test
+  void multOtherDenom() {
+    var unit = Degrees.per(Foot);
+
+    // (Degrees / Foot) x Inches, or 1/12 of a degree
+    var result = unit.mult(Inches);
+    assertInstanceOf(AngleUnit.class, result);
+    assertEquals(1 / 12.0, result.of(1).in(Degrees), 1e-9);
+    assertEquals("Degree per Foot Inch", result.name());
+    assertEquals("°/ft-in", result.symbol());
+  }
+}
diff --git a/wpiunits/src/test/java/edu/wpi/first/units/UnitsTest.java b/wpiunits/src/test/java/edu/wpi/first/units/UnitsTest.java
index 988c2ac3879..723b1db78ed 100644
--- a/wpiunits/src/test/java/edu/wpi/first/units/UnitsTest.java
+++ b/wpiunits/src/test/java/edu/wpi/first/units/UnitsTest.java
@@ -42,27 +42,28 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
+import java.util.function.DoubleFunction;
 import org.junit.jupiter.api.Test;
 
 class UnitsTest {
   // Be accurate to 0.01%
   private static final double thresh = 1e-5;
 
-  void testBaseUnit(Unit<?> baseUnit) {
-    assertEquals(0, baseUnit.of(0).baseUnitMagnitude(), 0);
-    assertEquals(1, baseUnit.of(1).baseUnitMagnitude(), 0);
-    assertEquals(-1, baseUnit.of(-1).baseUnitMagnitude(), 0);
-    assertEquals(100, baseUnit.of(100).baseUnitMagnitude(), 0);
-    assertEquals(8.281723, baseUnit.of(8.281723).baseUnitMagnitude(), 0);
-    assertEquals(Float.MAX_VALUE, baseUnit.of(Float.MAX_VALUE).baseUnitMagnitude(), 0);
-    assertEquals(Float.MIN_VALUE, baseUnit.of(Float.MIN_VALUE).baseUnitMagnitude(), 0);
+  void testBaseUnit(DoubleFunction<Measure<?>> baseUnit) {
+    assertEquals(0, baseUnit.apply(0).baseUnitMagnitude(), 0);
+    assertEquals(1, baseUnit.apply(1).baseUnitMagnitude(), 0);
+    assertEquals(-1, baseUnit.apply(-1).baseUnitMagnitude(), 0);
+    assertEquals(100, baseUnit.apply(100).baseUnitMagnitude(), 0);
+    assertEquals(8.281723, baseUnit.apply(8.281723).baseUnitMagnitude(), 0);
+    assertEquals(Float.MAX_VALUE, baseUnit.apply(Float.MAX_VALUE).baseUnitMagnitude(), 0);
+    assertEquals(Float.MIN_VALUE, baseUnit.apply(Float.MIN_VALUE).baseUnitMagnitude(), 0);
   }
 
   // Distances
 
   @Test
   void testMeters() {
-    testBaseUnit(Meters);
+    testBaseUnit(Meters::of);
     assertEquals("Meter", Meters.name());
     assertEquals("m", Meters.symbol());
   }
@@ -105,7 +106,7 @@ void testFeet() {
 
   @Test
   void testMetersPerSecond() {
-    testBaseUnit(MetersPerSecond);
+    testBaseUnit(MetersPerSecond::of);
     assertEquals("Meter per Second", MetersPerSecond.name());
     assertEquals("m/s", MetersPerSecond.symbol());
   }
@@ -122,7 +123,7 @@ void testFeetPerSecond() {
 
   @Test
   void testMetersPerSecondPerSecond() {
-    testBaseUnit(MetersPerSecondPerSecond);
+    testBaseUnit(MetersPerSecondPerSecond::of);
     assertEquals("Meter per Second per Second", MetersPerSecondPerSecond.name());
     assertEquals("m/s/s", MetersPerSecondPerSecond.symbol());
     assertEquals(MetersPerSecond, MetersPerSecondPerSecond.getUnit());
@@ -143,7 +144,7 @@ void testGs() {
 
   @Test
   void testSeconds() {
-    testBaseUnit(Seconds);
+    testBaseUnit(Seconds::of);
     assertEquals("Second", Seconds.name());
     assertEquals("s", Seconds.symbol());
   }
@@ -173,7 +174,7 @@ void testMinutes() {
 
   @Test
   void testKilograms() {
-    testBaseUnit(Kilograms);
+    testBaseUnit(Kilograms::of);
     assertEquals("Kilogram", Kilograms.name());
     assertEquals("Kg", Kilograms.symbol());
   }
@@ -210,7 +211,7 @@ void testRevolutions() {
 
   @Test
   void testRadians() {
-    testBaseUnit(Radians);
+    testBaseUnit(Radians::of);
     assertEquals(2 * Math.PI, Radians.convertFrom(1, Revolutions), thresh);
     assertEquals(2 * Math.PI, Radians.convertFrom(360, Degrees), thresh);
     assertEquals("Radian", Radians.name());
@@ -229,7 +230,7 @@ void testDegrees() {
 
   @Test
   void testValue() {
-    testBaseUnit(Value);
+    testBaseUnit(Value::of);
     assertEquals("<?>", Value.name());
     assertEquals("<?>", Value.symbol());
   }
@@ -245,7 +246,7 @@ void testPercent() {
 
   @Test
   void testVolts() {
-    testBaseUnit(Volts);
+    testBaseUnit(Volts::of);
     assertEquals("Volt", Volts.name());
     assertEquals("V", Volts.symbol());
   }
@@ -261,7 +262,7 @@ void testMillivolts() {
 
   @Test
   void testAmps() {
-    testBaseUnit(Amps);
+    testBaseUnit(Amps::of);
     assertEquals("Amp", Amps.name());
     assertEquals("A", Amps.symbol());
   }
@@ -277,7 +278,7 @@ void testMilliamps() {
 
   @Test
   void testWatts() {
-    testBaseUnit(Watts);
+    testBaseUnit(Watts::of);
     assertEquals("Watt", Watts.name());
     assertEquals("W", Watts.symbol());
   }
@@ -300,7 +301,7 @@ void testHorsepower() {
 
   @Test
   void testKelvin() {
-    testBaseUnit(Kelvin);
+    testBaseUnit(Kelvin::of);
     assertEquals("Kelvin", Kelvin.name());
     assertEquals("K", Kelvin.symbol()); // note: there's no degree symbol for Kelvin!
   }
diff --git a/wpiunits/src/test/java/edu/wpi/first/units/VelocityTest.java b/wpiunits/src/test/java/edu/wpi/first/units/VelocityUnitTest.java
similarity index 72%
rename from wpiunits/src/test/java/edu/wpi/first/units/VelocityTest.java
rename to wpiunits/src/test/java/edu/wpi/first/units/VelocityUnitTest.java
index c7f745c5be8..f392ceca37c 100644
--- a/wpiunits/src/test/java/edu/wpi/first/units/VelocityTest.java
+++ b/wpiunits/src/test/java/edu/wpi/first/units/VelocityUnitTest.java
@@ -10,14 +10,17 @@
 import static edu.wpi.first.units.Units.MetersPerSecond;
 import static edu.wpi.first.units.Units.MetersPerSecondPerSecond;
 import static edu.wpi.first.units.Units.Millisecond;
+import static edu.wpi.first.units.Units.Minute;
+import static edu.wpi.first.units.Units.Radians;
 import static edu.wpi.first.units.Units.Second;
+import static edu.wpi.first.units.Units.Seconds;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertSame;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import org.junit.jupiter.api.Test;
 
-class VelocityTest {
+class VelocityUnitTest {
   @Test
   void testBaseUnit() {
     assertTrue(MetersPerSecond.equivalent(MetersPerSecond));
@@ -26,7 +29,7 @@ void testBaseUnit() {
 
   @Test
   void testToAcceleration() {
-    Velocity<Velocity<Distance>> metersPerSecondPerMillisecond = MetersPerSecond.per(Millisecond);
+    LinearAccelerationUnit metersPerSecondPerMillisecond = MetersPerSecond.per(Millisecond);
 
     assertEquals(1000, metersPerSecondPerMillisecond.of(1).in(MetersPerSecondPerSecond), 0);
     assertEquals(0, metersPerSecondPerMillisecond.of(0).in(MetersPerSecondPerSecond), 0);
@@ -38,8 +41,8 @@ void testCache() {
         FeetPerSecond, Feet.per(Second), "Feet.per(Second) should return a cached object instance");
 
     // completely arbitrary units chosen because they won't have already been cached
-    var someDistance = new ExampleUnit(5);
-    var someTime = new ExampleUnit(600);
+    var someDistance = new AngleUnit(Radians, 123, "a", "a");
+    var someTime = new TimeUnit(Seconds, 123, "t", "t");
     var firstInvocation = someDistance.per(someTime);
     var secondInvocation = someDistance.per(someTime);
     assertSame(
@@ -50,9 +53,11 @@ void testCache() {
 
   @Test
   void testMult() {
+    // 92 per millisecond => 92,000 per second (base unit equivalent) => 5,520,000 per minute
     var baseUnit = new ExampleUnit(92);
-    var vel = baseUnit.per(Millisecond);
-    var mult = vel.mult(Second);
-    assertEquals(92_000, mult.toBaseUnits(1), 1e-5);
+    var vel = VelocityUnit.combine(baseUnit, Millisecond);
+    var mult = vel.mult(Minute);
+    assertEquals(1 / 92000.0, mult.fromBaseUnits(1), 1e-5);
+    assertEquals(5_520_000, mult.toBaseUnits(1), 1e-5);
   }
 }
diff --git a/wpiunits/src/test/java/edu/wpi/first/units/VoltageTest.java b/wpiunits/src/test/java/edu/wpi/first/units/VoltageUnitTest.java
similarity index 67%
rename from wpiunits/src/test/java/edu/wpi/first/units/VoltageTest.java
rename to wpiunits/src/test/java/edu/wpi/first/units/VoltageUnitTest.java
index d3d1ef3293d..3696b06cda4 100644
--- a/wpiunits/src/test/java/edu/wpi/first/units/VoltageTest.java
+++ b/wpiunits/src/test/java/edu/wpi/first/units/VoltageUnitTest.java
@@ -8,16 +8,15 @@
 
 import org.junit.jupiter.api.Test;
 
-class VoltageTest {
+class VoltageUnitTest {
   @Test
   void testVoltsTimesAmps() {
-    assertTrue(Units.Volts.times(Units.Amps, "", "").equivalent(Units.Watts));
+    assertTrue(Units.Volts.mult(Units.Amps, "", "").equivalent(Units.Watts));
   }
 
   @Test
   void testMilliVoltsTimesMilliAmps() {
     // results in microwatts
-    assertTrue(
-        Units.Millivolts.times(Units.Milliamps, "", "").equivalent(Units.Milli(Units.Milliwatts)));
+    assertTrue(Units.Millivolts.mult(Units.Milliamps, "", "").equivalent(Units.Micro(Units.Watts)));
   }
 }