diff --git a/src/DynamicQuantities.jl b/src/DynamicQuantities.jl
index 2e82cabb..0c3b21f2 100644
--- a/src/DynamicQuantities.jl
+++ b/src/DynamicQuantities.jl
@@ -8,6 +8,8 @@ export ulength, umass, utime, ucurrent, utemperature, uluminosity, uamount
 export uparse, @u_str, sym_uparse, @us_str, expand_units
 
 include("fixed_rational.jl")
+include("lazy_float.jl")
+
 include("types.jl")
 include("utils.jl")
 include("math.jl")
@@ -17,7 +19,7 @@ include("uparse.jl")
 include("symbolic_dimensions.jl")
 
 import Requires: @init, @require
-import .Units
+import .Units: DEFAULT_UNIT_TYPE
 import .Constants
 import .UnitsParse: uparse, @u_str
 
diff --git a/src/constants.jl b/src/constants.jl
index 736a71b4..2d401735 100644
--- a/src/constants.jl
+++ b/src/constants.jl
@@ -1,12 +1,11 @@
 module Constants
 
-import ..DEFAULT_QUANTITY_TYPE
 import ..Quantity
 import ..Units as U
-import ..Units: _add_prefixes
+import ..Units: _add_prefixes, DEFAULT_UNIT_TYPE
 
 const _CONSTANT_SYMBOLS = Symbol[]
-const _CONSTANT_VALUES = DEFAULT_QUANTITY_TYPE[]
+const _CONSTANT_VALUES = DEFAULT_UNIT_TYPE[]
 
 macro register_constant(name, value)
     return esc(_register_constant(name, value))
@@ -20,7 +19,7 @@ end
 function _register_constant(name::Symbol, value)
     s = string(name)
     return quote
-        const $name = $value
+        const $name = convert(DEFAULT_UNIT_TYPE, $value)
         push!(_CONSTANT_SYMBOLS, Symbol($s))
         push!(_CONSTANT_VALUES, $name)
     end
@@ -87,7 +86,7 @@ end
 )
 
 # Measured
-@register_constant alpha DEFAULT_QUANTITY_TYPE(7.2973525693e-3)
+@register_constant alpha DEFAULT_UNIT_TYPE(7.2973525693e-3)
 @register_constant u 1.66053906660e-27 * U.kg
 @register_constant G 6.67430e-11 * U.m^3 / (U.kg * U.s^2)
 @register_constant mu_0 4π * alpha * hbar / (e^2 * c)
diff --git a/src/lazy_float.jl b/src/lazy_float.jl
new file mode 100644
index 00000000..24789901
--- /dev/null
+++ b/src/lazy_float.jl
@@ -0,0 +1,33 @@
+# This is used to store floats without forcing promotion on other
+# numeric types.
+struct LazyFloat64 <: AbstractFloat
+    value::Float64
+end
+
+LazyFloat64(x::LazyFloat64) = x
+LazyFloat64(x::Number) = LazyFloat64(convert(Float64, x))
+float(x::LazyFloat64) = x.value
+
+Base.convert(::Type{LazyFloat64}, x::LazyFloat64) = x
+Base.convert(::Type{LazyFloat64}, x::FixedRational) = LazyFloat64(convert(Float64, x))
+Base.convert(::Type{LazyFloat64}, x::Number) = LazyFloat64(x)
+Base.convert(::Type{T}, x::LazyFloat64) where {T<:Number} = convert(T, float(x))
+Base.promote_rule(::Type{LazyFloat64}, ::Type{T}) where {T<:AbstractFloat} = T
+Base.promote_rule(::Type{LazyFloat64}, ::Type{T}) where {T} = promote_type(Float64, T)
+
+(::Type{T})(x::LazyFloat64) where {T<:Number} = T(float(x))
+
+Base.show(io::IO, x::LazyFloat64) = print(io, float(x))
+
+Base.:+(a::LazyFloat64, b::LazyFloat64) = LazyFloat64(float(a) + float(b))
+Base.:-(a::LazyFloat64) = LazyFloat64(-float(a))
+Base.:-(a::LazyFloat64, b::LazyFloat64) = LazyFloat64(float(a) - float(b))
+Base.:*(a::LazyFloat64, b::LazyFloat64) = LazyFloat64(float(a) * float(b))
+Base.inv(a::LazyFloat64) = LazyFloat64(inv(float(a)))
+Base.abs(a::LazyFloat64) = LazyFloat64(abs(float(a)))
+Base.:/(a::LazyFloat64, b::LazyFloat64) = a * inv(b)
+Base.:^(a::LazyFloat64, b::Int) = LazyFloat64(float(a) ^ b)
+Base.:^(a::LazyFloat64, b::LazyFloat64) = LazyFloat64(float(a) ^ float(b))
+Base.sqrt(a::LazyFloat64) = LazyFloat64(sqrt(float(a)))
+Base.cbrt(a::LazyFloat64) = LazyFloat64(cbrt(float(a)))
+Base.eps(::Type{LazyFloat64}) = eps(Float64)
diff --git a/src/units.jl b/src/units.jl
index 644d7448..041ee78a 100644
--- a/src/units.jl
+++ b/src/units.jl
@@ -2,13 +2,15 @@ module Units
 
 import ..DEFAULT_DIM_TYPE
 import ..DEFAULT_VALUE_TYPE
-import ..DEFAULT_QUANTITY_TYPE
 import ..Quantity
+import ..Quantity
+import ..LazyFloat64
 
-@assert DEFAULT_VALUE_TYPE == Float64 "`units.jl` must be updated to support a different default value type."
+const DEFAULT_UNIT_BASE_TYPE = LazyFloat64
+const DEFAULT_UNIT_TYPE = Quantity{DEFAULT_UNIT_BASE_TYPE,DEFAULT_DIM_TYPE}
 
 const _UNIT_SYMBOLS = Symbol[]
-const _UNIT_VALUES = DEFAULT_QUANTITY_TYPE[]
+const _UNIT_VALUES = DEFAULT_UNIT_TYPE[]
 
 macro register_unit(name, value)
     return esc(_register_unit(name, value))
@@ -22,7 +24,7 @@ end
 function _register_unit(name::Symbol, value)
     s = string(name)
     return quote
-        const $name = $value
+        const $name = convert(DEFAULT_UNIT_TYPE, $value)
         push!(_UNIT_SYMBOLS, Symbol($s))
         push!(_UNIT_VALUES, $name)
     end
@@ -37,19 +39,19 @@ function _add_prefixes(base_unit::Symbol, prefixes, register_function)
     for (prefix, value) in zip(keys(all_prefixes), values(all_prefixes))
         prefix in prefixes || continue
         new_unit = Symbol(prefix, base_unit)
-        push!(expr.args, register_function(new_unit, :($value * $base_unit)))
+        push!(expr.args, register_function(new_unit, :(convert(DEFAULT_UNIT_TYPE, $value * $base_unit))))
     end
     return expr
 end
 
 # SI base units
-@register_unit m DEFAULT_QUANTITY_TYPE(1.0, length=1)
-@register_unit g DEFAULT_QUANTITY_TYPE(1e-3, mass=1)
-@register_unit s DEFAULT_QUANTITY_TYPE(1.0, time=1)
-@register_unit A DEFAULT_QUANTITY_TYPE(1.0, current=1)
-@register_unit K DEFAULT_QUANTITY_TYPE(1.0, temperature=1)
-@register_unit cd DEFAULT_QUANTITY_TYPE(1.0, luminosity=1)
-@register_unit mol DEFAULT_QUANTITY_TYPE(1.0, amount=1)
+@register_unit m Quantity(1.0, length=1)
+@register_unit g Quantity(1e-3, mass=1)
+@register_unit s Quantity(1.0, time=1)
+@register_unit A Quantity(1.0, current=1)
+@register_unit K Quantity(1.0, temperature=1)
+@register_unit cd Quantity(1.0, luminosity=1)
+@register_unit mol Quantity(1.0, amount=1)
 
 @add_prefixes m (f, p, n, μ, u, c, d, m, k, M, G)
 @add_prefixes g (μ, u, m, k)
diff --git a/test/unittests.jl b/test/unittests.jl
index b3799309..d0d367f1 100644
--- a/test/unittests.jl
+++ b/test/unittests.jl
@@ -1,6 +1,6 @@
 using DynamicQuantities
 using DynamicQuantities: FixedRational
-using DynamicQuantities: DEFAULT_DIM_BASE_TYPE, DEFAULT_DIM_TYPE, DEFAULT_VALUE_TYPE
+using DynamicQuantities: DEFAULT_DIM_BASE_TYPE, DEFAULT_DIM_TYPE, DEFAULT_VALUE_TYPE, DEFAULT_UNIT_TYPE
 using Ratios: SimpleRatio
 using SaferIntegers: SafeInt16
 using Test
@@ -335,13 +335,22 @@ end
     @test ustrip(z) ≈ 60 * 60 * 24 * 365.25
 
     # Test type stability of extreme range of units
-    @test typeof(u"1") == Quantity{Float64,DEFAULT_DIM_TYPE}
-    @test typeof(u"1f0") == Quantity{Float64,DEFAULT_DIM_TYPE}
-    @test typeof(u"s"^2) == Quantity{Float64,DEFAULT_DIM_TYPE}
-    @test typeof(u"Ω") == Quantity{Float64,DEFAULT_DIM_TYPE}
-    @test typeof(u"Gyr") == Quantity{Float64,DEFAULT_DIM_TYPE}
-    @test typeof(u"fm") == Quantity{Float64,DEFAULT_DIM_TYPE}
-    @test typeof(u"fm"^2) == Quantity{Float64,DEFAULT_DIM_TYPE}
+    @test typeof(u"1") == Quantity{DEFAULT_UNIT_TYPE,DEFAULT_DIM_TYPE}
+    @test typeof(u"1f0") == Quantity{DEFAULT_UNIT_TYPE,DEFAULT_DIM_TYPE}
+    @test typeof(u"s"^2) == Quantity{DEFAULT_UNIT_TYPE,DEFAULT_DIM_TYPE}
+    @test typeof(u"Ω") == Quantity{DEFAULT_UNIT_TYPE,DEFAULT_DIM_TYPE}
+    @test typeof(u"Gyr") == Quantity{DEFAULT_UNIT_TYPE,DEFAULT_DIM_TYPE}
+    @test typeof(u"fm") == Quantity{DEFAULT_UNIT_TYPE,DEFAULT_DIM_TYPE}
+    @test typeof(u"fm"^2) == Quantity{DEFAULT_UNIT_TYPE,DEFAULT_DIM_TYPE}
+
+    # Test type demotion
+    @test typeof(1u"m") == Quantity{Int64,DEFAULT_DIM_TYPE}
+    @test typeof(1f0u"m") == Quantity{Float32,DEFAULT_DIM_TYPE}
+    @test typeof(1.0u"m") == Quantity{Float64,DEFAULT_DIM_TYPE}
+
+    @test typeof(1u"m^2/s") == Quantity{Int64,DEFAULT_DIM_TYPE}
+    @test typeof(1f0u"m^2/s") == Quantity{Float32,DEFAULT_DIM_TYPE}
+    @test typeof(1.0u"m^2/s") == Quantity{Float64,DEFAULT_DIM_TYPE}
 
     @test_throws LoadError eval(:(u":x"))
 end