units/quantity.mojo, units/si.mojo and units/temperature.mojo. Every measurement carries its dimension in its type. The compiler checks dimensions and erases them. A Quantity is the size of the float inside it.

three.js has no units. It leaves world units to the application. Here world space is meters.

Quantity[length, mass, time, angle, temperature, dtype] holds one float in canonical units: meters, kilograms, seconds, radians and kelvin. The first five parameters are exponents. The temperature exponent defaults to zero, so Quantity[1, 0, 0, 0] is a length. The dtype parameter defaults to DType.float32.

Angle is a base dimension here. Strict SI treats a radian as dimensionless. The deviation makes degrees-for-radians a compile error.

The engineering extensions use these aliases. A temperature exponent of one is a temperature difference in kelvin.

Use a Float64 quantity for engineering analysis. A Float32 keeps about seven digits, and a stiffness matrix loses more than that. Each alias above, and each base alias, has a 64 form: Length64, Force64, ThermalConductivity64.

var span = Length64(0.3048, METER)           # every digit kept
var coarse = span.cast[DType.float32]()      # a Length

Two quantities combine only when their dtype is the same. A Length64 plus a Length is a compile error. Use cast to change the float type.

A Unit holds its factor as a Float32 by default, so it is safe in GPU code, which has no Float64. A unit of either float type converts a quantity of either float type. FOOT64, INCH64 and DEGREE64 are Float64 units for factors that a Float32 rounds. Use them where a Float64 quantity must keep every digit.

A Unit is a factor to the canonical unit and a symbol.

| Energy | JOULE, KILOWATT_HOUR | | Power | WATT, KILOWATT | | Heat flux | WATT_PER_SQUARE_METER | | Thermal conductivity | WATT_PER_METER_KELVIN | | Thermal transmittance | WATT_PER_SQUARE_METER_KELVIN | | Thermal resistance | SQUARE_METER_KELVIN_PER_WATT | | Specific heat capacity | JOULE_PER_KILOGRAM_KELVIN | | Heat capacity | JOULE_PER_KELVIN | | Thermal conductance | WATT_PER_KELVIN | | Thermal expansion | PER_KELVIN | | Moment | NEWTON_METER, KILONEWTON_METER | | Force, structural | KILONEWTON | | Line load | NEWTON_PER_METER, KILONEWTON_PER_METER | | Pressure, structural | KILOPASCAL | | Second moment of area | METER_TO_THE_FOURTH | | Flow | CUBIC_METER_PER_SECOND, KILOGRAM_PER_SECOND |

STANDARD_GRAVITY is 9.80665 meters per second squared. Weight on Earth is mass times that acceleration.

units/temperature.mojo. A Temperature is an absolute temperature, kept in kelvin. It is not a Quantity, because the Celsius scale has a different zero. KELVIN and CELSIUS are its scales.

var inside = Temperature64(20, CELSIUS)
var outside = Temperature64(-5, CELSIUS)
var drop = inside - outside                   # 25 K, a TemperatureDifference64
var k = ThermalConductivity64(0.8, WATT_PER_METER_KELVIN)
var flux = k * drop / Length64(0.2, METER)    # 100 W/m^2, a HeatFlux64

Two temperatures do not add. Only a difference adds to a temperature. KELVIN_DIFFERENCE is the unit of a difference.

units/photometry.mojo. Light has its own two types, because the luminous intensity is not one of the four dimensions of Quantity.

Each type adds, subtracts and compares with its own type only. A Float32 scales either type from the left or the right. The ratio of two of the same type is a Float32. diffuse_luminance(e) gives the luminance of a white diffuse surface under the illuminance e: e / pi.

var noon = Illuminance(100, KILOLUX)
noon.to(LUX)                                 # 100000
diffuse_luminance(noon).to(NIT)              # 31831

A bare Float32 in place of either type is a compile error. A Luminance in place of an Illuminance is a compile error too.

var height = Length(1.0, METER)
height.to(FOOT)                           # 3.2808399
var area = height * Length(2.0, METER)    # Area
var side = area.sqrt()                    # Length
var total = Length(1.0, METER) + Length(1.0, FOOT)   # 1.3048 m
var turn = Angle(90.0, DEGREE)
turn.value                                # radians

abs(a) clears the sign of the stored value, including negative zero and NaN. It keeps the dimension.

Length(1.0, METER) + Duration(1.0, SECOND)   # error
Length(1.0, METER).to(SECOND)                # error
Volume(8.0).sqrt()                           # error: odd exponent
Length64(1.0, METER) + Length(1.0, METER)    # error: dtype differs
inside + outside                             # error: two temperatures
rotation_z(90.0)                             # error: needs an Angle

A test suite cannot contain these lines. Each lives in tests/compile_fail/, and make compile-fail checks that the compiler rejects every one.

The check first builds a valid control. Each negative case must then produce a source error in that case. A missing compiler, missing import, error in a dependency, crash or timeout fails the check. A failed build alone is not a valid rejection.

Each case has expected error locations and messages in tools/compile_fail_expectations.json. An unexpected source error also fails. Review the case before you update an expectation. Do not accept new errors just to make the check pass. Use the explicit regeneration workflow for selected cases. Normal checks never update the manifest.

core/clock.mojo. A Clock measures the time an animation loop runs, in Durations. It reads a monotonic counter, so an interval never runs backwards. three.js's Clock.

The clock keeps whole nanoseconds. The elapsed time is the counter's reading less the start. It does not drift with the frame rate, as a sum of deltas does. Seconds are made only in the answer.

var clock = Clock()
var step = clock.delta()                     # a Duration
var moved = Velocity(2.0) * step             # a Length: two meters per second, for one step
node.position.x += moved.value

core/timer.mojo. A Timer gives an animation loop one delta per frame, scaled by a time scale. three.js's Timer, which three.js recommends over Clock. Call update once a frame. Every question after it in the same frame gets the same answer.

A hidden window gives a delta of zero. Showing it again resets the timer, so the first frame back does not jump. three.js does this when connect gives it the page's document. There is no document here, so set_hidden takes the place of the visibilitychange event.

var timer = Timer()
timer.set_timescale(0.5)                     # slow motion
# In the loop:
timer.update()
var step = timer.delta()                     # the same Duration until the next update