diff --git a/Project.toml b/Project.toml
index 3c90706e..31d5446e 100644
--- a/Project.toml
+++ b/Project.toml
@@ -3,19 +3,18 @@ uuid = "1986cc42-f94f-5a68-af5c-568840ba703d"
 version = "1.6.0"
 
 [deps]
-ConstructionBase = "187b0558-2788-49d3-abe0-74a17ed4e7c9"
 Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
-LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
-Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
+Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
+UnitfulBase = "66b8c3f9-6ee5-42bf-afc1-12298118d236"
 
 [compat]
-ConstructionBase = "1"
 julia = "1"
 
 [extras]
+ConstructionBase = "187b0558-2788-49d3-abe0-74a17ed4e7c9"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["LinearAlgebra", "Test", "Random"]
+test = ["LinearAlgebra", "Test", "Random", "ConstructionBase"]
diff --git a/UnitfulBase/Project.toml b/UnitfulBase/Project.toml
new file mode 100644
index 00000000..34d3003b
--- /dev/null
+++ b/UnitfulBase/Project.toml
@@ -0,0 +1,13 @@
+name = "UnitfulBase"
+uuid = "66b8c3f9-6ee5-42bf-afc1-12298118d236"
+version = "1.0.0"
+
+[deps]
+ConstructionBase = "187b0558-2788-49d3-abe0-74a17ed4e7c9"
+LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
+
+[compat]
+ConstructionBase = "1"
+
+julia = "1"
diff --git a/UnitfulBase/src/UnitfulBase.jl b/UnitfulBase/src/UnitfulBase.jl
new file mode 100644
index 00000000..e12cf443
--- /dev/null
+++ b/UnitfulBase/src/UnitfulBase.jl
@@ -0,0 +1,71 @@
+module UnitfulBase
+
+import Base: ==, <, <=, +, -, *, /, //, ^, isequal
+import Base: show, convert
+import Base: abs, abs2, angle, float, fma, muladd, inv, sqrt, cbrt
+import Base: min, max, floor, ceil, real, imag, conj
+import Base: complex, widen, reim # handled in complex.jl
+import Base: exp, exp10, exp2, expm1, log, log10, log1p, log2
+import Base: sin, cos, tan, asin, acos, atan, sinh, cosh, tanh, asinh, acosh, atanh,
+             sinpi, cospi, sinc, cosc, cis
+import Base: eps, mod, rem, div, fld, cld, divrem, trunc, round, sign, signbit
+import Base: isless, isapprox, isinteger, isreal, isinf, isfinite, isnan
+import Base: copysign, flipsign
+import Base: prevfloat, nextfloat, maxintfloat, rat, step
+import Base: length, float, last, one, oneunit, zero, range
+import Base: getindex, eltype, step, last, first, frexp
+import Base: Integer, Rational, typemin, typemax
+import Base: steprange_last, unsigned
+@static if VERSION ≥ v"1.7.0-DEV.119"
+    import Base: isunordered
+end
+
+import LinearAlgebra: Diagonal, Bidiagonal, Tridiagonal, SymTridiagonal
+import LinearAlgebra: istril, istriu, norm
+import Random
+
+import ConstructionBase: constructorof
+
+export logunit, unit, absoluteunit, dimension, uconvert, ustrip, upreferred
+export @dimension, @derived_dimension, @refunit, @unit, @affineunit, @u_str
+export Quantity, DimensionlessQuantity, NoUnits, NoDims
+
+export uconvertp, uconvertrp, convertr, convertrp, reflevel, linear
+export @logscale, @logunit, @dB, @B, @cNp, @Np
+export Level, Gain
+export uparse
+
+const unitmodules = Vector{Module}()
+
+function _basefactors(m::Module)
+    # A hidden symbol which will be automatically attached to any module
+    # defining units, allowing `Unitful.register()` to merge in the units from
+    # that module.
+    basefactors_name = Symbol("#Unitful_basefactors")
+    if isdefined(m, basefactors_name)
+        getproperty(m, basefactors_name)
+    else
+        m.eval(:(const $basefactors_name = Dict{Symbol,Tuple{Float64,Rational{Int}}}()))
+    end
+end
+
+const basefactors = _basefactors(UnitfulBase)
+
+include("types.jl")
+const promotion = Dict{Symbol,Unit}()
+
+include("user.jl")
+include("utils.jl")
+include("dimensions.jl")
+include("units.jl")
+include("quantities.jl")
+include("display.jl")
+include("promotion.jl")
+include("conversion.jl")
+include("range.jl")
+include("fastmath.jl")
+include("logarithm.jl")
+include("complex.jl")
+include("angles.jl")
+
+end
diff --git a/UnitfulBase/src/angles.jl b/UnitfulBase/src/angles.jl
new file mode 100644
index 00000000..040e8dc4
--- /dev/null
+++ b/UnitfulBase/src/angles.jl
@@ -0,0 +1,11 @@
+# Angles and solid angles
+@unit sr      "sr"      Steradian   1                       true
+@unit rad     "rad"     Radian      1                       true
+@unit °       "°"       Degree      pi/180                  false
+# For numerical accuracy, specific to the degree
+import Base: sind, cosd, tand, secd, cscd, cotd
+for (_x,_y) in ((:sin,:sind), (:cos,:cosd), (:tan,:tand),
+        (:sec,:secd), (:csc,:cscd), (:cot,:cotd))
+    @eval ($_x)(x::Quantity{T, NoDims, typeof(°)}) where {T} = ($_y)(ustrip(x))
+    @eval ($_y)(x::Quantity{T, NoDims, typeof(°)}) where {T} = ($_y)(ustrip(x))
+end
diff --git a/src/complex.jl b/UnitfulBase/src/complex.jl
similarity index 100%
rename from src/complex.jl
rename to UnitfulBase/src/complex.jl
diff --git a/src/conversion.jl b/UnitfulBase/src/conversion.jl
similarity index 100%
rename from src/conversion.jl
rename to UnitfulBase/src/conversion.jl
diff --git a/src/dimensions.jl b/UnitfulBase/src/dimensions.jl
similarity index 100%
rename from src/dimensions.jl
rename to UnitfulBase/src/dimensions.jl
diff --git a/src/display.jl b/UnitfulBase/src/display.jl
similarity index 100%
rename from src/display.jl
rename to UnitfulBase/src/display.jl
diff --git a/src/fastmath.jl b/UnitfulBase/src/fastmath.jl
similarity index 100%
rename from src/fastmath.jl
rename to UnitfulBase/src/fastmath.jl
diff --git a/src/logarithm.jl b/UnitfulBase/src/logarithm.jl
similarity index 100%
rename from src/logarithm.jl
rename to UnitfulBase/src/logarithm.jl
diff --git a/src/promotion.jl b/UnitfulBase/src/promotion.jl
similarity index 100%
rename from src/promotion.jl
rename to UnitfulBase/src/promotion.jl
diff --git a/src/quantities.jl b/UnitfulBase/src/quantities.jl
similarity index 99%
rename from src/quantities.jl
rename to UnitfulBase/src/quantities.jl
index ecda9443..6bd9065d 100644
--- a/src/quantities.jl
+++ b/UnitfulBase/src/quantities.jl
@@ -122,7 +122,7 @@ for f = (:div, :cld, :fld, :rem, :mod)
 end
 
 Base.mod2pi(x::DimensionlessQuantity) = mod2pi(uconvert(NoUnits, x))
-Base.mod2pi(x::AbstractQuantity{S, NoDims, <:Units{(Unitful.Unit{:Degree, NoDims}(0, 1//1),),
+Base.mod2pi(x::AbstractQuantity{S, NoDims, <:Units{(UnitfulBase.Unit{:Degree, NoDims}(0, 1//1),),
     NoDims}}) where S = mod(x, 360°)
 
 # Addition / subtraction
@@ -398,7 +398,7 @@ isnan(x::AbstractQuantity) = isnan(x.val)
 end
 
 eps(x::T) where {T<:AbstractQuantity} = T(eps(x.val))
-eps(x::Type{T}) where {T<:AbstractQuantity} = eps(Unitful.numtype(T))
+eps(x::Type{T}) where {T<:AbstractQuantity} = eps(UnitfulBase.numtype(T))
 
 unsigned(x::AbstractQuantity) = Quantity(unsigned(x.val), unit(x))
 
diff --git a/src/range.jl b/UnitfulBase/src/range.jl
similarity index 100%
rename from src/range.jl
rename to UnitfulBase/src/range.jl
diff --git a/src/types.jl b/UnitfulBase/src/types.jl
similarity index 99%
rename from src/types.jl
rename to UnitfulBase/src/types.jl
index 05b76f61..fedc0390 100644
--- a/src/types.jl
+++ b/UnitfulBase/src/types.jl
@@ -153,8 +153,8 @@ end
 # Field-only constructor
 Quantity{<:Any,D,U}(val) where {D,U} = Quantity{typeof(val),D,U}(val)
 
-constructorof(::Type{Unitful.Quantity{_,D,U}}) where {_,D,U} =
-    Unitful.Quantity{T,D,U} where T
+constructorof(::Type{UnitfulBase.Quantity{_,D,U}}) where {_,D,U} =
+    UnitfulBase.Quantity{T,D,U} where T
 
 """
     DimensionlessUnits{U}
diff --git a/src/units.jl b/UnitfulBase/src/units.jl
similarity index 99%
rename from src/units.jl
rename to UnitfulBase/src/units.jl
index d0aed6f9..e9b1128e 100644
--- a/src/units.jl
+++ b/UnitfulBase/src/units.jl
@@ -302,6 +302,6 @@ factory defaults, this function will return a product of powers of base SI units
 (as [`Unitful.FreeUnits`](@ref)).
 """
 @generated function upreferred(x::Dimensions{D}) where {D}
-    u = *(FreeUnits{((Unitful.promotion[name(z)]^z.power for z in D)...,),()}())
+    u = *(FreeUnits{((UnitfulBase.promotion[name(z)]^z.power for z in D)...,),()}())
     :($u)
 end
diff --git a/src/user.jl b/UnitfulBase/src/user.jl
similarity index 94%
rename from src/user.jl
rename to UnitfulBase/src/user.jl
index 4e1e5e8b..481c627a 100644
--- a/src/user.jl
+++ b/UnitfulBase/src/user.jl
@@ -19,9 +19,9 @@ end #module
 ```
 """
 function register(unit_module::Module)
-    push!(Unitful.unitmodules, unit_module)
-    if unit_module !== Unitful
-        merge!(Unitful.basefactors, _basefactors(unit_module))
+    push!(UnitfulBase.unitmodules, unit_module)
+    if unit_module !== UnitfulBase
+        merge!(UnitfulBase.basefactors, _basefactors(unit_module))
     end
 end
 
@@ -59,7 +59,7 @@ macro dimension(symb, abbr, name)
     uname = Symbol(name,"Units")
     funame = Symbol(name,"FreeUnits")
     esc(quote
-        $Unitful.abbr(::$Dimension{$x}) = $abbr
+        $UnitfulBase.abbr(::$Dimension{$x}) = $abbr
         const global $s = $Dimensions{($Dimension{$x}(1),)}()
         const global ($name){T,U} = Union{
             $Quantity{T,$s,U},
@@ -133,16 +133,16 @@ macro refunit(symb, abbr, name, dimension, tf)
     n = Meta.quot(Symbol(name))
 
     push!(expr.args, quote
-        $Unitful.abbr(::$Unit{$n, $dimension}) = $abbr
+        $UnitfulBase.abbr(::$Unit{$n, $dimension}) = $abbr
     end)
 
     if tf
         push!(expr.args, quote
-            $Unitful.@prefixed_unit_symbols $symb $name $dimension (1.0, 1)
+            $UnitfulBase.@prefixed_unit_symbols $symb $name $dimension (1.0, 1)
         end)
     else
         push!(expr.args, quote
-            $Unitful.@unit_symbols $symb $name $dimension (1.0, 1)
+            $UnitfulBase.@unit_symbols $symb $name $dimension (1.0, 1)
         end)
     end
 
@@ -175,16 +175,16 @@ macro unit(symb,abbr,name,equals,tf)
                                  ($equals)/$unit($equals),
                                  $tensfactor($unit($equals)), 1))
     push!(expr.args, quote
-        $Unitful.abbr(::$Unit{$n, $d}) = $abbr
+        $UnitfulBase.abbr(::$Unit{$n, $d}) = $abbr
     end)
 
     if tf
         push!(expr.args, quote
-            $Unitful.@prefixed_unit_symbols $symb $name $d $basef
+            $UnitfulBase.@prefixed_unit_symbols $symb $name $d $basef
         end)
     else
         push!(expr.args, quote
-            $Unitful.@unit_symbols $symb $name $d $basef
+            $UnitfulBase.@unit_symbols $symb $name $d $basef
         end)
     end
 
@@ -210,15 +210,15 @@ macro affineunit(symb, abbr, offset)
 end
 
 function basefactors_expr(m::Module, n, basefactor)
-    if m === Unitful
-        :($(_basefactors(Unitful))[$n] = $basefactor)
+    if m === UnitfulBase
+        :($(_basefactors(UnitfulBase))[$n] = $basefactor)
     else
         # We add the base factor to dictionaries both in Unitful and the other
         # module so that the factor is available both interactively and with
         # precompilation.
         quote
             $(_basefactors(m))[$n] = $basefactor
-            $(_basefactors(Unitful))[$n] = $basefactor
+            $(_basefactors(UnitfulBase))[$n] = $basefactor
         end
     end
 end
@@ -290,7 +290,7 @@ function preferunits(u0::Units, u::Units...)
 
     units = (u0, u...)
     any(x->x isa AffineUnits, units) &&
-        error("cannot use `Unitful.preferunits` with affine units; try `Unitful.ContextUnits`.")
+        error("cannot use `UnitfulBase.preferunits` with affine units; try `UnitfulBase.ContextUnits`.")
 
     dims = map(dimension, units)
     if length(union(dims)) != length(dims)
@@ -388,10 +388,10 @@ julia> @dΠ π*W/1W
 """
 macro logscale(symb,abbr,name,base,prefactor,irp)
     quote
-        $Unitful.abbr(::LogInfo{$(QuoteNode(name))}) = $abbr
+        $UnitfulBase.abbr(::LogInfo{$(QuoteNode(name))}) = $abbr
 
         const global $(esc(name)) = LogInfo{$(QuoteNode(name)), $base, $prefactor}
-        $Unitful.isrootpower(::Type{$(esc(name))}) = $irp
+        $UnitfulBase.isrootpower(::Type{$(esc(name))}) = $irp
 
         const global $(esc(symb)) = MixedUnits{Gain{$(esc(name)), :?}}()
         const global $(esc(Symbol(symb,"_rp"))) = MixedUnits{Gain{$(esc(name)), :rp}}()
@@ -453,7 +453,7 @@ Defines a logarithmic unit. For examples see `src/pkgdefaults.jl`.
 """
 macro logunit(symb, abbr, logscale, reflevel)
     quote
-        $Unitful.abbr(::Level{$(esc(logscale)), $(esc(reflevel))}) = $abbr
+        $UnitfulBase.abbr(::Level{$(esc(logscale)), $(esc(reflevel))}) = $abbr
         const global $(esc(symb)) =
             MixedUnits{Level{$(esc(logscale)), $(esc(reflevel))}}()
     end
@@ -502,8 +502,8 @@ julia> u"ħ"
 """
 macro u_str(unit)
     ex = Meta.parse(unit)
-    unitmods = [Unitful]
-    for m in Unitful.unitmodules
+    unitmods = [UnitfulBase]
+    for m in UnitfulBase.unitmodules
         # Find registered unit extension modules which are also loaded by
         # __module__ (required so that precompilation will work).
         if isdefined(__module__, nameof(m)) && getfield(__module__, nameof(m)) === m
@@ -531,7 +531,7 @@ julia> uparse("1.0*dB")
 1.0 dB
 ```
 """
-function uparse(str; unit_context=Unitful)
+function uparse(str, unit_context)
     ex = Meta.parse(str)
     eval(lookup_units(unit_context, ex))
 end
diff --git a/src/utils.jl b/UnitfulBase/src/utils.jl
similarity index 100%
rename from src/utils.jl
rename to UnitfulBase/src/utils.jl
diff --git a/src/Unitful.jl b/src/Unitful.jl
index 343f49b6..3e7057d4 100644
--- a/src/Unitful.jl
+++ b/src/Unitful.jl
@@ -1,73 +1,28 @@
 module Unitful
 
-import Base: ==, <, <=, +, -, *, /, //, ^, isequal
-import Base: show, convert
-import Base: abs, abs2, angle, float, fma, muladd, inv, sqrt, cbrt
-import Base: min, max, floor, ceil, real, imag, conj
-import Base: complex, widen, reim # handled in complex.jl
-import Base: exp, exp10, exp2, expm1, log, log10, log1p, log2
-import Base: sin, cos, tan, asin, acos, atan, sinh, cosh, tanh, asinh, acosh, atanh,
-             sinpi, cospi, sinc, cosc, cis
-import Base: eps, mod, rem, div, fld, cld, divrem, trunc, round, sign, signbit
-import Base: isless, isapprox, isinteger, isreal, isinf, isfinite, isnan
-import Base: copysign, flipsign
-import Base: prevfloat, nextfloat, maxintfloat, rat, step
-import Base: length, float, last, one, oneunit, zero, range
-import Base: getindex, eltype, step, last, first, frexp
-import Base: Integer, Rational, typemin, typemax
-import Base: steprange_last, unsigned
-@static if VERSION ≥ v"1.7.0-DEV.119"
-    import Base: isunordered
-end
-
-import Dates
-import LinearAlgebra: Diagonal, Bidiagonal, Tridiagonal, SymTridiagonal
-import LinearAlgebra: istril, istriu, norm
-import Random
-
-import ConstructionBase: constructorof
-
-export logunit, unit, absoluteunit, dimension, uconvert, ustrip, upreferred
-export @dimension, @derived_dimension, @refunit, @unit, @affineunit, @u_str
-export Quantity, DimensionlessQuantity, NoUnits, NoDims
+using Reexport
+@reexport using UnitfulBase
 
-export uconvertp, uconvertrp, convertr, convertrp, reflevel, linear
-export @logscale, @logunit, @dB, @B, @cNp, @Np
-export Level, Gain
-export uparse
+using UnitfulBase: register
+import UnitfulBase: dimension, unit, ustrip, uconvert, numtype, isrootpower_dim
 
-const unitmodules = Vector{Module}()
+import UnitfulBase: uparse
+uparse(str; unit_context=Unitful) = uparse(str, unit_context)
 
-function _basefactors(m::Module)
-    # A hidden symbol which will be automatically attached to any module
-    # defining units, allowing `Unitful.register()` to merge in the units from
-    # that module.
-    basefactors_name = Symbol("#Unitful_basefactors")
-    if isdefined(m, basefactors_name)
-        getproperty(m, basefactors_name)
-    else
-        m.eval(:(const $basefactors_name = Dict{Symbol,Tuple{Float64,Rational{Int}}}()))
-    end
-end
+import Dates
 
-const basefactors = _basefactors(Unitful)
+import Base: round, floor, ceil, trunc, convert
+import Base: +, -, *, /, //, fld, cld, mod, rem, atan, ==, isequal, <, isless, <=
+import Base: div, isapprox 
 
-include("types.jl")
-const promotion = Dict{Symbol,Unit}()
+const promotion = UnitfulBase.promotion
 
-include("user.jl")
-include("utils.jl")
-include("dimensions.jl")
-include("units.jl")
-include("quantities.jl")
-include("display.jl")
-include("promotion.jl")
-include("conversion.jl")
-include("range.jl")
-include("fastmath.jl")
-include("logarithm.jl")
-include("complex.jl")
 include("pkgdefaults.jl")
 include("dates.jl")
 
+function __init__()
+    register(Unitful)
+    merge!(UnitfulBase.promotion, promotion)
+end
+
 end
diff --git a/src/dates.jl b/src/dates.jl
index c1738098..29d1a487 100644
--- a/src/dates.jl
+++ b/src/dates.jl
@@ -6,7 +6,7 @@ for (period, unit) = ((Dates.Week, wk), (Dates.Day, d), (Dates.Hour, hr),
                       (Dates.Minute, minute), (Dates.Second, s), (Dates.Millisecond, ms),
                       (Dates.Microsecond, μs), (Dates.Nanosecond, ns))
     @eval unit(::Type{$period}) = $unit
-    @eval (::Type{$period})(x::AbstractQuantity) = $period(ustrip(unit($period), x))
+    @eval (::Type{$period})(x::UnitfulBase.AbstractQuantity) = $period(ustrip(unit($period), x))
 end
 
 dimension(p::Dates.FixedPeriod) = dimension(typeof(p))
@@ -55,50 +55,50 @@ julia> Quantity(Second(5))
 """
 Quantity(period::Dates.FixedPeriod) = Quantity(ustrip(period), unit(period))
 
-uconvert(u::Units, period::Dates.FixedPeriod) = uconvert(u, Quantity(period))
+uconvert(u::UnitfulBase.Units, period::Dates.FixedPeriod) = uconvert(u, UnitfulBase.Quantity(period))
 
-(T::Type{<:AbstractQuantity})(period::Dates.FixedPeriod) = T(Quantity(period))
+(T::Type{<:UnitfulBase.AbstractQuantity})(period::Dates.FixedPeriod) = T(UnitfulBase.Quantity(period))
 
-convert(T::Type{<:AbstractQuantity}, period::Dates.FixedPeriod) = T(period)
-convert(T::Type{<:Dates.FixedPeriod}, x::AbstractQuantity) = T(x)
+convert(T::Type{<:UnitfulBase.AbstractQuantity}, period::Dates.FixedPeriod) = T(period)
+convert(T::Type{<:Dates.FixedPeriod}, x::UnitfulBase.AbstractQuantity) = T(x)
 
-round(T::Type{<:Dates.FixedPeriod}, x::AbstractQuantity, r::RoundingMode=RoundNearest) =
+round(T::Type{<:Dates.FixedPeriod}, x::UnitfulBase.AbstractQuantity, r::RoundingMode=RoundNearest) =
     T(round(numtype(T), ustrip(unit(T), x), r))
-round(u::Units, period::Dates.FixedPeriod, r::RoundingMode=RoundNearest; kwargs...) =
+round(u::UnitfulBase.Units, period::Dates.FixedPeriod, r::RoundingMode=RoundNearest; kwargs...) =
     round(u, Quantity(period), r; kwargs...)
-round(T::Type{<:Number}, u::Units, period::Dates.FixedPeriod, r::RoundingMode=RoundNearest;
-      kwargs...) = round(T, u, Quantity(period), r; kwargs...)
-round(T::Type{<:AbstractQuantity}, period::Dates.FixedPeriod, r::RoundingMode=RoundNearest;
+round(T::Type{<:Number}, u::UnitfulBase.Units, period::Dates.FixedPeriod, r::RoundingMode=RoundNearest;
+      kwargs...) = round(T, u, UnitfulBase.Quantity(period), r; kwargs...)
+round(T::Type{<:UnitfulBase.AbstractQuantity}, period::Dates.FixedPeriod, r::RoundingMode=RoundNearest;
       kwargs...) = round(T, Quantity(period), r; kwargs...)
 
 for (f, r) in ((:floor,:RoundDown), (:ceil,:RoundUp), (:trunc,:RoundToZero))
-    @eval $f(T::Type{<:Dates.FixedPeriod}, x::AbstractQuantity) = round(T, x, $r)
-    @eval $f(u::Units, period::Dates.FixedPeriod; kwargs...) =
+    @eval $f(T::Type{<:Dates.FixedPeriod}, x::UnitfulBase.AbstractQuantity) = round(T, x, $r)
+    @eval $f(u::UnitfulBase.Units, period::Dates.FixedPeriod; kwargs...) =
         round(u, period, $r; kwargs...)
-    @eval $f(T::Type{<:Number}, u::Units, period::Dates.FixedPeriod; kwargs...) =
+    @eval $f(T::Type{<:Number}, u::UnitfulBase.Units, period::Dates.FixedPeriod; kwargs...) =
         round(T, u, period, $r; kwargs...)
-    @eval $f(T::Type{<:AbstractQuantity}, period::Dates.FixedPeriod; kwargs...) =
+    @eval $f(T::Type{<:UnitfulBase.AbstractQuantity}, period::Dates.FixedPeriod; kwargs...) =
         round(T, period, $r; kwargs...)
 end
 
 for op = (:+, :-, :*, :/, ://, :fld, :cld, :mod, :rem, :atan,
           :(==), :isequal, :<, :isless, :≤)
-    @eval $op(x::Dates.FixedPeriod, y::AbstractQuantity) = $op(Quantity(x), y)
-    @eval $op(x::AbstractQuantity, y::Dates.FixedPeriod) = $op(x, Quantity(y))
+    @eval $op(x::Dates.FixedPeriod, y::UnitfulBase.AbstractQuantity) = $op(Quantity(x), y)
+    @eval $op(x::UnitfulBase.AbstractQuantity, y::Dates.FixedPeriod) = $op(x, Quantity(y))
 end
 for op = (:*, :/, ://)
-    @eval $op(x::Dates.FixedPeriod, y::Units) = $op(Quantity(x), y)
-    @eval $op(x::Units, y::Dates.FixedPeriod) = $op(x, Quantity(y))
+    @eval $op(x::Dates.FixedPeriod, y::UnitfulBase.Units) = $op(Quantity(x), y)
+    @eval $op(x::UnitfulBase.Units, y::Dates.FixedPeriod) = $op(x, Quantity(y))
 end
-div(x::Dates.FixedPeriod, y::AbstractQuantity, r...) = div(Quantity(x), y, r...)
-div(x::AbstractQuantity, y::Dates.FixedPeriod, r...) = div(x, Quantity(y), r...)
+div(x::Dates.FixedPeriod, y::UnitfulBase.AbstractQuantity, r...) = div(Quantity(x), y, r...)
+div(x::UnitfulBase.AbstractQuantity, y::Dates.FixedPeriod, r...) = div(x, Quantity(y), r...)
 
-isapprox(x::Dates.FixedPeriod, y::AbstractQuantity; kwargs...) =
+isapprox(x::Dates.FixedPeriod, y::UnitfulBase.AbstractQuantity; kwargs...) =
     isapprox(Quantity(x), y; kwargs...)
-isapprox(x::AbstractQuantity, y::Dates.FixedPeriod; kwargs...) =
+isapprox(x::UnitfulBase.AbstractQuantity, y::Dates.FixedPeriod; kwargs...) =
     isapprox(x, Quantity(y); kwargs...)
 
-function isapprox(x::AbstractArray{<:AbstractQuantity}, y::AbstractArray{T};
+function isapprox(x::AbstractArray{<:UnitfulBase.AbstractQuantity}, y::AbstractArray{T};
                   kwargs...) where {T<:Dates.Period}
     if isconcretetype(T)
         y′ = reinterpret(quantitytype(T), y)
@@ -107,7 +107,7 @@ function isapprox(x::AbstractArray{<:AbstractQuantity}, y::AbstractArray{T};
     end
     isapprox(x, y′; kwargs...)
 end
-isapprox(x::AbstractArray{<:Dates.FixedPeriod}, y::AbstractArray{<:AbstractQuantity};
+isapprox(x::AbstractArray{<:Dates.FixedPeriod}, y::AbstractArray{<:UnitfulBase.AbstractQuantity};
          kwargs...) = isapprox(y, x; kwargs...)
 
 Base.promote_rule(::Type{Quantity{T,𝐓,U}}, ::Type{S}) where {T,U,S<:Dates.FixedPeriod} =
@@ -118,12 +118,12 @@ Base.promote_rule(::Type{Quantity{T,𝐓,U}}, ::Type{S}) where {T,U,S<:Dates.Fix
 dimension(p::Dates.CompoundPeriod) = dimension(typeof(p))
 dimension(::Type{<:Dates.CompoundPeriod}) = 𝐓
 
-uconvert(u::Units, period::Dates.CompoundPeriod) =
-    Quantity{promote_type(Int64,typeof(convfact(u,ns))),dimension(u),typeof(u)}(period)
+uconvert(u::UnitfulBase.Units, period::Dates.CompoundPeriod) =
+    Quantity{promote_type(Int64,typeof(UnitfulBase.convfact(u,ns))),dimension(u),typeof(u)}(period)
 
-try_uconvert(u::Units, period::Dates.CompoundPeriod) = nothing
+try_uconvert(u::UnitfulBase.Units, period::Dates.CompoundPeriod) = nothing
 function try_uconvert(u::TimeUnits, period::Dates.CompoundPeriod)
-    T = Quantity{promote_type(Int64,typeof(convfact(u,ns))),dimension(u),typeof(u)}
+    T = Quantity{promote_type(Int64,typeof(UnitfulBase.convfact(u,ns))),dimension(u),typeof(u)}
     val = zero(T)
     for p in period.periods
         p isa Dates.FixedPeriod || return nothing
@@ -132,50 +132,50 @@ function try_uconvert(u::TimeUnits, period::Dates.CompoundPeriod)
     val
 end
 
-(T::Type{<:AbstractQuantity})(period::Dates.CompoundPeriod) =
+(T::Type{<:UnitfulBase.AbstractQuantity})(period::Dates.CompoundPeriod) =
     mapreduce(T, +, period.periods, init=zero(T))
 
-convert(T::Type{<:AbstractQuantity}, period::Dates.CompoundPeriod) = T(period)
+convert(T::Type{<:UnitfulBase.AbstractQuantity}, period::Dates.CompoundPeriod) = T(period)
 
-round(u::Units, period::Dates.CompoundPeriod, r::RoundingMode=RoundNearest; kwargs...) =
+round(u::UnitfulBase.Units, period::Dates.CompoundPeriod, r::RoundingMode=RoundNearest; kwargs...) =
     round(u, uconvert(u, period), r; kwargs...)
-round(T::Type{<:Number}, u::Units, period::Dates.CompoundPeriod,
+round(T::Type{<:Number}, u::UnitfulBase.Units, period::Dates.CompoundPeriod,
       r::RoundingMode=RoundNearest; kwargs...) =
     round(T, u, uconvert(u, period), r; kwargs...)
-round(T::Type{<:AbstractQuantity}, period::Dates.CompoundPeriod,
+round(T::Type{<:UnitfulBase.AbstractQuantity}, period::Dates.CompoundPeriod,
       r::RoundingMode=RoundNearest; kwargs...) =
     round(T, T(period), r; kwargs...)
 
 for (f, r) in ((:floor,:RoundDown), (:ceil,:RoundUp), (:trunc,:RoundToZero))
-    @eval $f(u::Units, period::Dates.CompoundPeriod; kwargs...) =
+    @eval $f(u::UnitfulBase.Units, period::Dates.CompoundPeriod; kwargs...) =
         round(u, period, $r; kwargs...)
-    @eval $f(T::Type{<:Number}, u::Units, period::Dates.CompoundPeriod; kwargs...) =
+    @eval $f(T::Type{<:Number}, u::UnitfulBase.Units, period::Dates.CompoundPeriod; kwargs...) =
         round(T, u, period, $r; kwargs...)
-    @eval $f(T::Type{<:AbstractQuantity}, period::Dates.CompoundPeriod; kwargs...) =
+    @eval $f(T::Type{<:UnitfulBase.AbstractQuantity}, period::Dates.CompoundPeriod; kwargs...) =
         round(T, period, $r; kwargs...)
 end
 
 for op = (:fld, :cld, :atan, :<, :isless, :≤)
-    @eval $op(x::Dates.CompoundPeriod, y::AbstractQuantity) = $op(uconvert(unit(y),x), y)
-    @eval $op(x::AbstractQuantity, y::Dates.CompoundPeriod) = $op(x, uconvert(unit(x),y))
+    @eval $op(x::Dates.CompoundPeriod, y::UnitfulBase.AbstractQuantity) = $op(uconvert(unit(y),x), y)
+    @eval $op(x::UnitfulBase.AbstractQuantity, y::Dates.CompoundPeriod) = $op(x, uconvert(unit(x),y))
 end
-div(x::Dates.CompoundPeriod, y::AbstractQuantity, r...) = div(uconvert(unit(y),x), y, r...)
-div(x::AbstractQuantity, y::Dates.CompoundPeriod, r...) = div(x, uconvert(unit(x),y), r...)
-mod(x::Dates.CompoundPeriod, y::AbstractQuantity) = mod(uconvert(unit(y),x), y)
-rem(x::Dates.CompoundPeriod, y::AbstractQuantity) = rem(uconvert(unit(y),x), y)
+div(x::Dates.CompoundPeriod, y::UnitfulBase.AbstractQuantity, r...) = div(uconvert(unit(y),x), y, r...)
+div(x::UnitfulBase.AbstractQuantity, y::Dates.CompoundPeriod, r...) = div(x, uconvert(unit(x),y), r...)
+mod(x::Dates.CompoundPeriod, y::UnitfulBase.AbstractQuantity) = mod(uconvert(unit(y),x), y)
+rem(x::Dates.CompoundPeriod, y::UnitfulBase.AbstractQuantity) = rem(uconvert(unit(y),x), y)
 for op = (:(==), :isequal)
-    @eval $op(x::Dates.CompoundPeriod, y::AbstractQuantity{T,𝐓,U}) where {T,U} =
+    @eval $op(x::Dates.CompoundPeriod, y::UnitfulBase.AbstractQuantity{T,𝐓,U}) where {T,U} =
         $op(try_uconvert(U(), x), y)
-    @eval $op(x::AbstractQuantity{T,𝐓,U}, y::Dates.CompoundPeriod) where {T,U} =
+    @eval $op(x::UnitfulBase.AbstractQuantity{T,𝐓,U}, y::Dates.CompoundPeriod) where {T,U} =
         $op(x, try_uconvert(U(), y))
 end
 
-isapprox(x::Dates.CompoundPeriod, y::AbstractQuantity; kwargs...) =
+isapprox(x::Dates.CompoundPeriod, y::UnitfulBase.AbstractQuantity; kwargs...) =
     dimension(y) === 𝐓 ? isapprox(uconvert(unit(y), x), y; kwargs...) : false
-isapprox(x::AbstractQuantity, y::Dates.CompoundPeriod; kwargs...) =
+isapprox(x::UnitfulBase.AbstractQuantity, y::Dates.CompoundPeriod; kwargs...) =
     dimension(x) === 𝐓 ? isapprox(x, uconvert(unit(x), y); kwargs...) : false
 
-function isapprox(x::AbstractArray{<:AbstractQuantity},
+function isapprox(x::AbstractArray{<:UnitfulBase.AbstractQuantity},
                   y::AbstractArray{Dates.CompoundPeriod}; kwargs...)
     if dimension(eltype(x)) === 𝐓
         isapprox(x, uconvert.(unit(eltype(x)), y); kwargs...)
@@ -184,5 +184,5 @@ function isapprox(x::AbstractArray{<:AbstractQuantity},
     end
 end
 
-isapprox(x::AbstractArray{Dates.CompoundPeriod}, y::AbstractArray{<:AbstractQuantity};
+isapprox(x::AbstractArray{Dates.CompoundPeriod}, y::AbstractArray{<:UnitfulBase.AbstractQuantity};
          kwargs...) = isapprox(y, x; kwargs...)
diff --git a/src/pkgdefaults.jl b/src/pkgdefaults.jl
index 5d30aa57..7c5a102f 100644
--- a/src/pkgdefaults.jl
+++ b/src/pkgdefaults.jl
@@ -9,8 +9,8 @@
 @dimension 𝚯 "𝚯" Temperature    # This one is \bfTheta
 @dimension 𝐉 "𝐉" Luminosity
 @dimension 𝐍 "𝐍" Amount
-const RelativeScaleTemperature = Quantity{T, 𝚯, <:AffineUnits} where T
-const AbsoluteScaleTemperature = Quantity{T, 𝚯, <:ScalarUnits} where T
+const RelativeScaleTemperature = Quantity{T, 𝚯, <:UnitfulBase.AffineUnits} where T
+const AbsoluteScaleTemperature = Quantity{T, 𝚯, <:UnitfulBase.ScalarUnits} where T
 
 # Define derived dimensions.
 @derived_dimension Area                     𝐋^2
@@ -61,17 +61,7 @@ const AbsoluteScaleTemperature = Quantity{T, 𝚯, <:ScalarUnits} where T
 @refunit  g       "g"      Gram      𝐌           true
 @refunit  mol     "mol"    Mole      𝐍           true
 
-# Angles and solid angles
-@unit sr      "sr"      Steradian   1                       true
-@unit rad     "rad"     Radian      1                       true
-@unit °       "°"       Degree      pi/180                  false
-# For numerical accuracy, specific to the degree
-import Base: sind, cosd, tand, secd, cscd, cotd
-for (_x,_y) in ((:sin,:sind), (:cos,:cosd), (:tan,:tand),
-        (:sec,:secd), (:csc,:cscd), (:cot,:cotd))
-    @eval ($_x)(x::Quantity{T, NoDims, typeof(°)}) where {T} = ($_y)(ustrip(x))
-    @eval ($_y)(x::Quantity{T, NoDims, typeof(°)}) where {T} = ($_y)(ustrip(x))
-end
+using UnitfulBase: sr, rad, °
 
 # SI and related units
 @unit Hz              "Hz"   Hertz           1/s                true
@@ -112,7 +102,7 @@ end
 # Area
 # The hectare is used more frequently than any other power-of-ten of an are.
 @unit a      "a"        Are         100m^2                  false
-const ha = Unitful.FreeUnits{(Unitful.Unit{:Are, 𝐋^2}(2, 1//1),), 𝐋^2}()
+const ha = UnitfulBase.FreeUnits{(UnitfulBase.Unit{:Are, 𝐋^2}(2, 1//1),), 𝐋^2}()
 @unit b      "b"        Barn        100fm^2                 true
 
 # Volume
@@ -230,7 +220,7 @@ const Å = Å = angstrom
 @logunit  dBu   "dBu"      Decibel      sqrt(0.6)V
 @logunit  dBμV  "dBμV"     Decibel      1μV
 @logunit  dBSPL "dBSPL"    Decibel      20μPa
-@logunit  dBFS  "dBFS"     Decibel      RootPowerRatio(1)
+@logunit  dBFS  "dBFS"     Decibel      UnitfulBase.RootPowerRatio(1)
 @logunit  dBΩ   "dBΩ"      Decibel      1Ω
 @logunit  dBS   "dBS"      Decibel      1S
 
@@ -262,7 +252,7 @@ isrootpower_dim(::typeof(dimension(J)))         = false
 const si_prefixes = (:y, :z, :a, :f, :p, :n, :μ, :µ, :m, :c, :d,
     Symbol(""), :da, :h, :k, :M, :G, :T, :P, :E, :Z, :Y)
 
-const si_no_prefix = (:m, :s, :A, :K, :g, :mol, :rad, :sr, :Hz, :N, :Pa, #:cd,
+const si_no_prefix = (:m, :s, :A, :K, :g, :mol, :Hz, :N, :Pa, #:cd,
     :J, :W, :C, :V, :F, :Ω, :S, :Wb, :T, :H, :lm, :lx, :Bq, :Gy, :Sv, :kat)
 
 baremodule DefaultSymbols
@@ -278,18 +268,22 @@ baremodule DefaultSymbols
             Core.eval(DefaultSymbols, Expr(:import, Expr(:(.), :Unitful, Symbol(p,u))))
             Core.eval(DefaultSymbols, Expr(:export, Symbol(p,u)))
         end
+        for u in (:rad, :sr)
+            Core.eval(DefaultSymbols, Expr(:import, Expr(:(.), :UnitfulBase, Symbol(p,u))))
+            Core.eval(DefaultSymbols, Expr(:export, Symbol(p,u)))
+        end
     end
 
     Core.eval(DefaultSymbols, Expr(:import, Expr(:(.), :Unitful, :°C)))
     Core.eval(DefaultSymbols, Expr(:export, :°C))
 
-    Core.eval(DefaultSymbols, Expr(:import, Expr(:(.), :Unitful, :°)))
+    Core.eval(DefaultSymbols, Expr(:import, Expr(:(.), :UnitfulBase, :°)))
     Core.eval(DefaultSymbols, Expr(:export, :°))
 end
 
 #########
 
-preferunits(kg) # others done in @refunit
+UnitfulBase.preferunits(kg) # others done in @refunit
 
 """
     Unitful.promote_to_derived()
diff --git a/test/runtests.jl b/test/runtests.jl
index 315e4a19..d120567d 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -1,8 +1,9 @@
-using Unitful
+using UnitfulBase, Unitful
 using Test, LinearAlgebra, Random, ConstructionBase
-import Unitful: DimensionError, AffineError
-import Unitful: LogScaled, LogInfo, Level, Gain, MixedUnits, Decibel
-import Unitful: FreeUnits, ContextUnits, FixedUnits, AffineUnits, AffineQuantity
+import UnitfulBase: DimensionError, AffineError
+import UnitfulBase: LogScaled, LogInfo, Level, Gain, MixedUnits
+import UnitfulBase: FreeUnits, ContextUnits, FixedUnits, AffineUnits, AffineQuantity
+import Unitful: Decibel
 
 import Unitful:
     nm, μm, mm, cm, m, km, inch, ft, mi,
@@ -43,20 +44,20 @@ const colon = Base.:(:)
 
 @testset "Construction" begin
     @test isa(NoUnits, FreeUnits)
-    @test typeof(𝐋) === Unitful.Dimensions{(Unitful.Dimension{:Length}(1),)}
+    @test typeof(𝐋) === UnitfulBase.Dimensions{(UnitfulBase.Dimension{:Length}(1),)}
     @test 𝐋*𝐋 === 𝐋^2
-    @test typeof(1.0m) === Unitful.Quantity{Float64, 𝐋,
-        Unitful.FreeUnits{(Unitful.Unit{:Meter, 𝐋}(0,1),), 𝐋, nothing}}
-    @test typeof(1m^2) === Unitful.Quantity{Int, 𝐋^2,
-            Unitful.FreeUnits{(Unitful.Unit{:Meter, 𝐋}(0,2),), 𝐋^2, nothing}}
-    @test typeof(1ac) === Unitful.Quantity{Int, 𝐋^2,
-            Unitful.FreeUnits{(Unitful.Unit{:Acre, 𝐋^2}(0,1),), 𝐋^2, nothing}}
+    @test typeof(1.0m) === UnitfulBase.Quantity{Float64, 𝐋,
+        UnitfulBase.FreeUnits{(UnitfulBase.Unit{:Meter, 𝐋}(0,1),), 𝐋, nothing}}
+    @test typeof(1m^2) === UnitfulBase.Quantity{Int, 𝐋^2,
+            UnitfulBase.FreeUnits{(UnitfulBase.Unit{:Meter, 𝐋}(0,2),), 𝐋^2, nothing}}
+    @test typeof(1ac) === UnitfulBase.Quantity{Int, 𝐋^2,
+            UnitfulBase.FreeUnits{(UnitfulBase.Unit{:Acre, 𝐋^2}(0,1),), 𝐋^2, nothing}}
     @test typeof(ContextUnits(m,μm)) ===
-        ContextUnits{(Unitful.Unit{:Meter, 𝐋}(0,1),), 𝐋, typeof(μm), nothing}
-    @test typeof(1.0*ContextUnits(m,μm)) === Unitful.Quantity{Float64, 𝐋,
-        ContextUnits{(Unitful.Unit{:Meter, 𝐋}(0,1),), 𝐋, typeof(μm), nothing}}
-    @test typeof(1.0*FixedUnits(m)) === Unitful.Quantity{Float64, 𝐋,
-        FixedUnits{(Unitful.Unit{:Meter, 𝐋}(0,1),), 𝐋, nothing}}
+        ContextUnits{(UnitfulBase.Unit{:Meter, 𝐋}(0,1),), 𝐋, typeof(μm), nothing}
+    @test typeof(1.0*ContextUnits(m,μm)) === UnitfulBase.Quantity{Float64, 𝐋,
+        ContextUnits{(UnitfulBase.Unit{:Meter, 𝐋}(0,1),), 𝐋, typeof(μm), nothing}}
+    @test typeof(1.0*FixedUnits(m)) === UnitfulBase.Quantity{Float64, 𝐋,
+        FixedUnits{(UnitfulBase.Unit{:Meter, 𝐋}(0,1),), 𝐋, nothing}}
     @test 3mm != 3*(m*m)                        # mm not interpreted as m*m
     @test (3+4im)*V === V*(3+4im) === (3V+4V*im)  # Complex quantity construction
     @test !isreal(Base.complex(3.0/m, 4.0/m))
@@ -261,7 +262,7 @@ include("dates.jl")
 
         # The next test is a little funky but checks the `affineunit` functionality
         @test @inferred(uconvert(°F,
-            0*Unitful.affineunit(27315K//100 + 5K//9))) === (33//1)°F
+            0*UnitfulBase.affineunit(27315K//100 + 5K//9))) === (33//1)°F
     end
     @testset "Temperature differences" begin
         @test @inferred(uconvert(Ra, 0K)) === 0Ra//1
@@ -292,7 +293,7 @@ include("dates.jl")
         end
     end
     @testset "Promotion" begin
-        @test_throws ErrorException Unitful.preferunits(°C)
+        @test_throws ErrorException UnitfulBase.preferunits(°C)
         @test @inferred(eltype([1°C, 1K])) <: Quantity{Rational{Int}, 𝚯, typeof(K)}
         @test @inferred(eltype([1.0°C, 1K])) <: Quantity{Float64, 𝚯, typeof(K)}
         @test @inferred(eltype([1°C, 1°F])) <: Quantity{Rational{Int}, 𝚯, typeof(K)}
@@ -328,26 +329,26 @@ end
         @test ismissing(upreferred(missing))
     end
     @testset "> promote_unit" begin
-        @test Unitful.promote_unit(FreeUnits(m)) === FreeUnits(m)
-        @test Unitful.promote_unit(ContextUnits(m,mm)) === ContextUnits(m,mm)
-        @test Unitful.promote_unit(FixedUnits(kg)) === FixedUnits(kg)
-        @test Unitful.promote_unit(ContextUnits(m,mm), ContextUnits(km,mm)) ===
+        @test UnitfulBase.promote_unit(FreeUnits(m)) === FreeUnits(m)
+        @test UnitfulBase.promote_unit(ContextUnits(m,mm)) === ContextUnits(m,mm)
+        @test UnitfulBase.promote_unit(FixedUnits(kg)) === FixedUnits(kg)
+        @test UnitfulBase.promote_unit(ContextUnits(m,mm), ContextUnits(km,mm)) ===
             ContextUnits(mm,mm)
-        @test Unitful.promote_unit(FreeUnits(m), ContextUnits(mm,km)) ===
+        @test UnitfulBase.promote_unit(FreeUnits(m), ContextUnits(mm,km)) ===
             ContextUnits(km,km)
-        @test Unitful.promote_unit(FixedUnits(kg), ContextUnits(g,g)) === FixedUnits(kg)
-        @test Unitful.promote_unit(ContextUnits(g,g), FixedUnits(kg)) === FixedUnits(kg)
-        @test Unitful.promote_unit(FixedUnits(kg), FreeUnits(g)) === FixedUnits(kg)
-        @test Unitful.promote_unit(FreeUnits(g), FixedUnits(kg)) === FixedUnits(kg)
-        @test_throws DimensionError Unitful.promote_unit(m,kg)
+        @test UnitfulBase.promote_unit(FixedUnits(kg), ContextUnits(g,g)) === FixedUnits(kg)
+        @test UnitfulBase.promote_unit(ContextUnits(g,g), FixedUnits(kg)) === FixedUnits(kg)
+        @test UnitfulBase.promote_unit(FixedUnits(kg), FreeUnits(g)) === FixedUnits(kg)
+        @test UnitfulBase.promote_unit(FreeUnits(g), FixedUnits(kg)) === FixedUnits(kg)
+        @test_throws DimensionError UnitfulBase.promote_unit(m,kg)
 
         # FixedUnits throw a promotion error
-        @test_throws ErrorException Unitful.promote_unit(FixedUnits(m), FixedUnits(mm))
+        @test_throws ErrorException UnitfulBase.promote_unit(FixedUnits(m), FixedUnits(mm))
 
         # Only because we favor SI, we have the following:
-        @test Unitful.promote_unit(m,km) === m
-        @test Unitful.promote_unit(m,km,cm) === m
-        @test Unitful.promote_unit(ContextUnits(m,mm), ContextUnits(km,cm)) ===
+        @test UnitfulBase.promote_unit(m,km) === m
+        @test UnitfulBase.promote_unit(m,km,cm) === m
+        @test UnitfulBase.promote_unit(ContextUnits(m,mm), ContextUnits(km,cm)) ===
             FreeUnits(m)
     end
     @testset "> Simple promotion" begin
@@ -1120,8 +1121,8 @@ end
                 StepRangeLen{typeof(1.0m), Base.TwicePrecision{typeof(1.0m)}})
             @test isa(@inferred(range(1m, stop=10m, length=5)),
                 StepRangeLen{typeof(1.0m), Base.TwicePrecision{typeof(1.0m)}})
-            @test_throws Unitful.DimensionError range(1m, stop=10, length=5)
-            @test_throws Unitful.DimensionError range(1, stop=10m, length=5)
+            @test_throws UnitfulBase.DimensionError range(1m, stop=10, length=5)
+            @test_throws UnitfulBase.DimensionError range(1, stop=10m, length=5)
             r = range(1m, stop=3m, length=3)
             @test r[1:2:end] == range(1m, stop=3m, length=2)
         end
@@ -1659,8 +1660,8 @@ end
             @test repr(3u"dB/Hz") == "[3 dB] Hz^-1"
             @test repr("text/plain", 3u"dB/Hz") == "[3 dB] Hz^-1"
         end
-        @test Unitful.abbr(3u"dBm") == "dBm"
-        @test Unitful.abbr(@dB 3V/1.241V) == "dB (1.241 V)"
+        @test UnitfulBase.abbr(3u"dBm") == "dBm"
+        @test UnitfulBase.abbr(@dB 3V/1.241V) == "dB (1.241 V)"
         @test string(360°) == "360°"
     end
 
@@ -1676,15 +1677,15 @@ end
 end
 
 @testset "Output ordered by unit exponent" begin
-    ordered = Unitful.sortexp(typeof(u"J*mol^-1*K^-1").parameters[1])
-    @test typeof(ordered[1]) <: Unitful.Unit{:Joule,<:Any}
-    @test typeof(ordered[2]) <: Unitful.Unit{:Kelvin,<:Any}
-    @test typeof(ordered[3]) <: Unitful.Unit{:Mole,<:Any}
-
-    ordered = Unitful.sortexp(typeof(u"mol*J^-1*K^-1").parameters[1])
-    @test typeof(ordered[1]) <: Unitful.Unit{:Mole,<:Any}
-    @test typeof(ordered[2]) <: Unitful.Unit{:Joule,<:Any}
-    @test typeof(ordered[3]) <: Unitful.Unit{:Kelvin,<:Any}
+    ordered = UnitfulBase.sortexp(typeof(u"J*mol^-1*K^-1").parameters[1])
+    @test typeof(ordered[1]) <: UnitfulBase.Unit{:Joule,<:Any}
+    @test typeof(ordered[2]) <: UnitfulBase.Unit{:Kelvin,<:Any}
+    @test typeof(ordered[3]) <: UnitfulBase.Unit{:Mole,<:Any}
+
+    ordered = UnitfulBase.sortexp(typeof(u"mol*J^-1*K^-1").parameters[1])
+    @test typeof(ordered[1]) <: UnitfulBase.Unit{:Mole,<:Any}
+    @test typeof(ordered[2]) <: UnitfulBase.Unit{:Joule,<:Any}
+    @test typeof(ordered[3]) <: UnitfulBase.Unit{:Kelvin,<:Any}
 end
 
 # Test that the @u_str macro will find units in other modules.
@@ -1695,7 +1696,7 @@ module ShadowUnits
 end
 
 @test (@test_logs (:warn, r"found in multiple") eval(:(typeof(u"m")))) ==
-    Unitful.FreeUnits{(Unitful.Unit{:MyMeter, 𝐋}(0, 1//1),), 𝐋, nothing}
+    UnitfulBase.FreeUnits{(UnitfulBase.Unit{:MyMeter, 𝐋}(0, 1//1),), 𝐋, nothing}
 
 # Test that the @u_str macro will not find units in modules which are
 # not loaded before the u_str invocation.
@@ -1722,12 +1723,12 @@ end
 @test uparse("foo", unit_context=[Unitful, FooUnits]) === u"foo"
 @test uparse("foo", unit_context=[FooUnits, Unitful]) === u"foo"
 
-# Test for #272
-module OnlyUstrImported
-    import Unitful: @u_str
-    u = u"m"
-end
-@test OnlyUstrImported.u === m
+## Test for #272
+#module OnlyUstrImported
+#    import Unitful: @u_str
+#    u = u"m"
+#end
+#@test OnlyUstrImported.u === m
 
 # Test to make sure user macros are working properly
 module TUM
@@ -1741,7 +1742,7 @@ module TUM
 end
 
 @testset "User macros" begin
-    @test typeof(TUM.f) == Unitful.Dimensions{(Unitful.Dimension{:FakeDim12345}(1//1),)}
+    @test typeof(TUM.f) == UnitfulBase.Dimensions{(UnitfulBase.Dimension{:FakeDim12345}(1//1),)}
     @test 1(TUM.fu) == 1(TUM.fu2)
     @test isa(1(TUM.fu), TUM.FakeDim12345)
     @test isa(TUM.fu, TUM.FakeDim12345Units)