diff --git a/docs/src/lib/lib.md b/docs/src/lib/lib.md
index d22bb792d..64bc81294 100644
--- a/docs/src/lib/lib.md
+++ b/docs/src/lib/lib.md
@@ -5,7 +5,7 @@
 FiniteMPS
 InfiniteMPS
 WindowMPS
-MPSMultiline
+MultilineMPS
 ```
 
 ## Operators
diff --git a/docs/src/man/states.md b/docs/src/man/states.md
index 060dd5fe0..b473aab8a 100644
--- a/docs/src/man/states.md
+++ b/docs/src/man/states.md
@@ -133,9 +133,9 @@ Such a set can be created by
 
 ```julia
 data = fill(TensorMap(rand,ComplexF64,ℂ^10*ℂ^2,ℂ^10),2,2);
-MPSMultiline(data);
+MultilineMPS(data);
 ```
-MPSMultiline is also used extensively in as of yet unreleased peps code.
+MultilineMPS is also used extensively in as of yet unreleased peps code.
 
 You can access properties by calling
 ```julia
@@ -153,7 +153,7 @@ struct Multiline{T}
 end
 ```
 
-MPSMultiline/MPOMultiline are then defined as
+MultilineMPS/MultilineMPO are then defined as
 ```julia
-const MPSMultiline = Multiline{<:InfiniteMPS}
-const MPOMultiline = Multiline{<:DenseMPO}
+const MultilineMPS = Multiline{<:InfiniteMPS}
+const MultilineMPO = Multiline{<:DenseMPO}
diff --git a/src/MPSKit.jl b/src/MPSKit.jl
index 57fa0d3c5..d2073039f 100644
--- a/src/MPSKit.jl
+++ b/src/MPSKit.jl
@@ -18,7 +18,7 @@ using Base: @kwdef
 using LoggingExtras
 
 # bells and whistles for mpses
-export InfiniteMPS, FiniteMPS, WindowMPS, MPSMultiline
+export InfiniteMPS, FiniteMPS, WindowMPS, MultilineMPS
 export PeriodicArray, PeriodicVector, PeriodicMatrix, WindowArray
 export MPSTensor
 export QP, LeftGaugedQP, RightGaugedQP
@@ -34,7 +34,7 @@ export braille
 export AbstractMPO
 export MPO, FiniteMPO, InfiniteMPO
 export MPOHamiltonian, FiniteMPOHamiltonian, InfiniteMPOHamiltonian
-export SparseMPO, DenseMPO, MPOMultiline
+export SparseMPO, DenseMPO, MultilineMPO
 export UntimedOperator, TimedOperator, MultipliedOperator, LazySum
 
 export ∂C, ∂AC, ∂AC2, environments, expectation_value, effective_excitation_hamiltonian
@@ -83,7 +83,7 @@ include("utility/linearcombination.jl")
 # maybe we should introduce an abstract state type
 include("states/abstractmps.jl")
 include("states/infinitemps.jl")
-include("states/mpsmultiline.jl")
+include("states/multilinemps.jl")
 include("states/finitemps.jl")
 include("states/windowmps.jl")
 include("states/orthoview.jl")
@@ -93,7 +93,7 @@ include("states/ortho.jl")
 include("operators/abstractmpo.jl")
 include("operators/mpo.jl")
 include("operators/mpohamiltonian.jl") # the mpohamiltonian objects
-include("operators/mpomultiline.jl")
+include("operators/multilinempo.jl")
 include("operators/projection.jl")
 include("operators/timedependence.jl")
 include("operators/multipliedoperator.jl")
diff --git a/src/algorithms/approximate/idmrg.jl b/src/algorithms/approximate/idmrg.jl
index 0a80603b3..c55af5b3a 100644
--- a/src/algorithms/approximate/idmrg.jl
+++ b/src/algorithms/approximate/idmrg.jl
@@ -1,4 +1,4 @@
-function approximate(ost::MPSMultiline, toapprox::Tuple{<:MPOMultiline,<:MPSMultiline},
+function approximate(ost::MultilineMPS, toapprox::Tuple{<:MultilineMPO,<:MultilineMPS},
                      alg::IDMRG1, oenvs=environments(ost, toapprox))
     ψ = copy(ost)
     mpo, above = toapprox
@@ -52,12 +52,12 @@ function approximate(ost::MPSMultiline, toapprox::Tuple{<:MPOMultiline,<:MPSMult
         end
     end
 
-    nst = MPSMultiline(map(x -> x, ψ.AR); tol=alg.tol_gauge)
+    nst = MultilineMPS(map(x -> x, ψ.AR); tol=alg.tol_gauge)
     nenvs = environments(nst, toapprox)
     return nst, nenvs, ϵ
 end
 
-function approximate(ost::MPSMultiline, toapprox::Tuple{<:MPOMultiline,<:MPSMultiline},
+function approximate(ost::MultilineMPS, toapprox::Tuple{<:MultilineMPO,<:MultilineMPS},
                      alg::IDMRG2, oenvs=environments(ost, toapprox))
     length(ost) < 2 && throw(ArgumentError("unit cell should be >= 2"))
     mpo, above = toapprox
@@ -139,7 +139,7 @@ function approximate(ost::MPSMultiline, toapprox::Tuple{<:MPOMultiline,<:MPSMult
         end
     end
 
-    nst = MPSMultiline(map(x -> x, ψ.AR); tol=alg.tol_gauge)
+    nst = MultilineMPS(map(x -> x, ψ.AR); tol=alg.tol_gauge)
     nenvs = environments(nst, toapprox)
     return nst, nenvs, ϵ
 end
diff --git a/src/algorithms/approximate/vomps.jl b/src/algorithms/approximate/vomps.jl
index 7cfb537bd..59489e38c 100644
--- a/src/algorithms/approximate/vomps.jl
+++ b/src/algorithms/approximate/vomps.jl
@@ -1,22 +1,22 @@
 function approximate(ψ::InfiniteMPS,
                      toapprox::Tuple{<:InfiniteMPO,<:InfiniteMPS}, algorithm,
                      envs=environments(ψ, toapprox))
-    # PeriodicMPO's always act on MPSMultiline's. To avoid code duplication, define everything in terms of MPSMultiline's.
-    multi, envs = approximate(convert(MPSMultiline, ψ),
-                              (convert(MPOMultiline, toapprox[1]),
-                               convert(MPSMultiline, toapprox[2])), algorithm, envs)
+    # PeriodicMPO's always act on MultilineMPS's. To avoid code duplication, define everything in terms of MultilineMPS's.
+    multi, envs = approximate(convert(MultilineMPS, ψ),
+                              (convert(MultilineMPO, toapprox[1]),
+                               convert(MultilineMPS, toapprox[2])), algorithm, envs)
     ψ = convert(InfiniteMPS, multi)
     return ψ, envs
 end
 
-Base.@deprecate(approximate(ψ::MPSMultiline, toapprox::Tuple{<:MPOMultiline,<:MPSMultiline},
+Base.@deprecate(approximate(ψ::MultilineMPS, toapprox::Tuple{<:MultilineMPO,<:MultilineMPS},
                             alg::VUMPS, envs...; kwargs...),
                 approximate(ψ, toapprox,
                             VOMPS(; alg.tol, alg.maxiter, alg.finalize,
                                   alg.verbosity, alg.alg_gauge, alg.alg_environments),
                             envs...; kwargs...))
 
-function approximate(ψ::MPSMultiline, toapprox::Tuple{<:MPOMultiline,<:MPSMultiline},
+function approximate(ψ::MultilineMPS, toapprox::Tuple{<:MultilineMPO,<:MultilineMPS},
                      alg::VOMPS, envs=environments(ψ, toapprox))
     ϵ::Float64 = calc_galerkin(ψ, envs)
     temp_ACs = similar.(ψ.AC)
@@ -38,7 +38,7 @@ function approximate(ψ::MPSMultiline, toapprox::Tuple{<:MPOMultiline,<:MPSMulti
             end
 
             alg_gauge = updatetol(alg.alg_gauge, iter, ϵ)
-            ψ = MPSMultiline(temp_ACs, ψ.CR[:, end]; alg_gauge.tol, alg_gauge.maxiter)
+            ψ = MultilineMPS(temp_ACs, ψ.CR[:, end]; alg_gauge.tol, alg_gauge.maxiter)
 
             alg_environments = updatetol(alg.alg_environments, iter, ϵ)
             recalculate!(envs, ψ; alg_environments.tol)
diff --git a/src/algorithms/changebonds/changebonds.jl b/src/algorithms/changebonds/changebonds.jl
index 0f06d21c7..0c35bbc88 100644
--- a/src/algorithms/changebonds/changebonds.jl
+++ b/src/algorithms/changebonds/changebonds.jl
@@ -36,7 +36,7 @@ function _expand!(ψ::InfiniteMPS, AL′::PeriodicVector, AR′::PeriodicVector)
     end
     return normalize!(ψ)
 end
-function _expand!(ψ::MPSMultiline, AL′::PeriodicMatrix, AR′::PeriodicMatrix)
+function _expand!(ψ::MultilineMPS, AL′::PeriodicMatrix, AR′::PeriodicMatrix)
     for i in 1:size(ψ, 1)
         _expand!(ψ[i], AL′[i, :], AR′[i, :])
     end
diff --git a/src/algorithms/changebonds/optimalexpand.jl b/src/algorithms/changebonds/optimalexpand.jl
index e8086c8e2..492e30f4c 100644
--- a/src/algorithms/changebonds/optimalexpand.jl
+++ b/src/algorithms/changebonds/optimalexpand.jl
@@ -38,11 +38,11 @@ end
 
 function changebonds(ψ::InfiniteMPS, H::DenseMPO, alg::OptimalExpand,
                      envs=environments(ψ, H))
-    (nmψ, envs) = changebonds(convert(MPSMultiline, ψ), convert(MPOMultiline, H), alg, envs)
+    (nmψ, envs) = changebonds(convert(MultilineMPS, ψ), convert(MultilineMPO, H), alg, envs)
     return (convert(InfiniteMPS, nmψ), envs)
 end
 
-function changebonds(ψ::MPSMultiline, H, alg::OptimalExpand, envs=environments(ψ, H))
+function changebonds(ψ::MultilineMPS, H, alg::OptimalExpand, envs=environments(ψ, H))
     TL = eltype(ψ.AL)
     AL′ = PeriodicMatrix{TL}(undef, size(ψ.AL))
     TR = tensormaptype(spacetype(TL), 1, numind(TL) - 1, storagetype(TL))
diff --git a/src/algorithms/changebonds/randexpand.jl b/src/algorithms/changebonds/randexpand.jl
index f5e54d46a..28c128288 100644
--- a/src/algorithms/changebonds/randexpand.jl
+++ b/src/algorithms/changebonds/randexpand.jl
@@ -33,7 +33,7 @@ function changebonds(ψ::InfiniteMPS, alg::RandExpand)
     return _expand(ψ, AL′, AR′)
 end
 
-function changebonds(ψ::MPSMultiline, alg::RandExpand)
+function changebonds(ψ::MultilineMPS, alg::RandExpand)
     return Multiline(map(x -> changebonds(x, alg), ψ.data))
 end
 
diff --git a/src/algorithms/changebonds/svdcut.jl b/src/algorithms/changebonds/svdcut.jl
index 145e417bc..193248113 100644
--- a/src/algorithms/changebonds/svdcut.jl
+++ b/src/algorithms/changebonds/svdcut.jl
@@ -68,10 +68,10 @@ end
 function changebonds(ψ::InfiniteMPO, alg::SvdCut)
     return convert(InfiniteMPO, changebonds(convert(InfiniteMPS, ψ), alg))
 end
-function changebonds(ψ::MPOMultiline, alg::SvdCut)
-    return convert(MPOMultiline, changebonds(convert(MPSMultiline, ψ), alg))
+function changebonds(ψ::MultilineMPO, alg::SvdCut)
+    return convert(MultilineMPO, changebonds(convert(MultilineMPS, ψ), alg))
 end
-function changebonds(ψ::MPSMultiline, alg::SvdCut)
+function changebonds(ψ::MultilineMPS, alg::SvdCut)
     return Multiline(map(x -> changebonds(x, alg), ψ.data))
 end
 function changebonds(ψ::InfiniteMPS, alg::SvdCut)
diff --git a/src/algorithms/derivatives.jl b/src/algorithms/derivatives.jl
index a0676b931..4aa5dd46e 100644
--- a/src/algorithms/derivatives.jl
+++ b/src/algorithms/derivatives.jl
@@ -34,21 +34,21 @@ Base.:*(h::Union{MPO_∂∂C,MPO_∂∂AC,MPO_∂∂AC2}, v) = h(v);
 function ∂∂C(pos::Int, mps, operator::AbstractMPO, cache)
     return MPO_∂∂C(leftenv(cache, pos + 1, mps), rightenv(cache, pos, mps))
 end
-function ∂∂C(col::Int, mps, operator::MPOMultiline, envs)
+function ∂∂C(col::Int, mps, operator::MultilineMPO, envs)
     return MPO_∂∂C(leftenv(envs, col + 1, mps), rightenv(envs, col, mps))
 end
-function ∂∂C(row::Int, col::Int, mps, operator::MPOMultiline, envs)
+function ∂∂C(row::Int, col::Int, mps, operator::MultilineMPO, envs)
     return MPO_∂∂C(leftenv(envs, row, col + 1, mps), rightenv(envs, row, col, mps))
 end
 
 function ∂∂AC(pos::Int, mps, operator::AbstractMPO, cache)
     return MPO_∂∂AC(operator[pos], leftenv(cache, pos, mps), rightenv(cache, pos, mps))
 end
-function ∂∂AC(row::Int, col::Int, mps, operator::MPOMultiline, envs)
+function ∂∂AC(row::Int, col::Int, mps, operator::MultilineMPO, envs)
     return MPO_∂∂AC(operator[row, col], leftenv(envs, row, col, mps),
                     rightenv(envs, row, col, mps))
 end
-function ∂∂AC(col::Int, mps, operator::MPOMultiline, envs)
+function ∂∂AC(col::Int, mps, operator::MultilineMPO, envs)
     return MPO_∂∂AC(envs.operator[:, col], leftenv(envs, col, mps),
                     rightenv(envs, col, mps))
 end;
@@ -57,11 +57,11 @@ function ∂∂AC2(pos::Int, mps, operator::AbstractMPO, cache)
     return MPO_∂∂AC2(operator[pos], operator[pos + 1], leftenv(cache, pos, mps),
                      rightenv(cache, pos + 1, mps))
 end;
-function ∂∂AC2(col::Int, mps, operator::MPOMultiline, envs)
+function ∂∂AC2(col::Int, mps, operator::MultilineMPO, envs)
     return MPO_∂∂AC2(operator[:, col], operator[:, col + 1], leftenv(envs, col, mps),
                      rightenv(envs, col + 1, mps))
 end
-function ∂∂AC2(row::Int, col::Int, mps, operator::MPOMultiline, envs)
+function ∂∂AC2(row::Int, col::Int, mps, operator::MultilineMPO, envs)
     return MPO_∂∂AC2(operator[row, col], operator[row, col + 1],
                      leftenv(envs, row, col, mps), rightenv(envs, row, col + 1, mps))
 end
diff --git a/src/algorithms/excitation/quasiparticleexcitation.jl b/src/algorithms/excitation/quasiparticleexcitation.jl
index 920ce67e5..a6158dab7 100644
--- a/src/algorithms/excitation/quasiparticleexcitation.jl
+++ b/src/algorithms/excitation/quasiparticleexcitation.jl
@@ -167,7 +167,7 @@ end
 #                           Statmech Excitations                               #
 ################################################################################
 
-function excitations(H::MPOMultiline, alg::QuasiparticleAnsatz, ϕ₀::Multiline{<:InfiniteQP},
+function excitations(H::MultilineMPO, alg::QuasiparticleAnsatz, ϕ₀::Multiline{<:InfiniteQP},
                      lenvs, renvs; num=1, solver=Defaults.linearsolver)
     qp_envs(ϕ) = environments(ϕ, H, lenvs, renvs; solver)
     function H_eff(ϕ′)
@@ -194,13 +194,13 @@ function excitations(H::InfiniteMPO, alg::QuasiparticleAnsatz, ϕ₀::InfiniteQP
     return Es, ϕs
 end
 
-function excitations(H::MPOMultiline, alg::QuasiparticleAnsatz, ϕ₀::Multiline{<:InfiniteQP},
+function excitations(H::MultilineMPO, alg::QuasiparticleAnsatz, ϕ₀::Multiline{<:InfiniteQP},
                      lenvs; num=1, solver=Defaults.linearsolver)
     # Infer `renvs` in function body as it depends on `solver`.
     renvs = ϕ₀.trivial ? lenvs : environments(ϕ₀.right_gs, H; solver)
     return excitations(H, alg, ϕ₀, lenvs, renvs; num, solver)
 end
-function excitations(H::MPOMultiline, alg::QuasiparticleAnsatz, ϕ₀::Multiline{<:InfiniteQP};
+function excitations(H::MultilineMPO, alg::QuasiparticleAnsatz, ϕ₀::Multiline{<:InfiniteQP};
                      num=1, solver=Defaults.linearsolver)
     # Infer `lenvs` in function body as it depends on `solver`.
     lenvs = environments(ϕ₀.left_gs, H; solver)
@@ -212,19 +212,19 @@ function excitations(H::DenseMPO, alg::QuasiparticleAnsatz, momentum::Real,
                      lenvs=environments(lmps, H), rmps::InfiniteMPS=lmps,
                      renvs=lmps === rmps ? lenvs : environments(rmps, H);
                      sector=one(sectortype(lmps)), num=1, solver=Defaults.linearsolver)
-    multiline_lmps = convert(MPSMultiline, lmps)
+    multiline_lmps = convert(MultilineMPS, lmps)
     if lmps === rmps
-        excitations(convert(MPOMultiline, H), alg, momentum, multiline_lmps, lenvs,
+        excitations(convert(MultilineMPO, H), alg, momentum, multiline_lmps, lenvs,
                     multiline_lmps,
                     lenvs; sector, num, solver)
     else
-        excitations(convert(MPOMultiline, H), alg, momentum, multiline_lmps, lenvs,
-                    convert(MPSMultiline, rmps), renvs; sector, num, solver)
+        excitations(convert(MultilineMPO, H), alg, momentum, multiline_lmps, lenvs,
+                    convert(MultilineMPS, rmps), renvs; sector, num, solver)
     end
 end
 
-function excitations(H::MPOMultiline, alg::QuasiparticleAnsatz, momentum::Real,
-                     lmps::MPSMultiline,
+function excitations(H::MultilineMPO, alg::QuasiparticleAnsatz, momentum::Real,
+                     lmps::MultilineMPS,
                      lenvs=environments(lmps, H), rmps=lmps,
                      renvs=lmps === rmps ? lenvs : environments(rmps, H);
                      sector=one(sectortype(lmps)), num=1, solver=Defaults.linearsolver)
@@ -263,7 +263,7 @@ function effective_excitation_hamiltonian(H::Union{InfiniteMPOHamiltonian,
     return ϕ′
 end
 
-function effective_excitation_hamiltonian(H::MPOMultiline, ϕ::Multiline{<:InfiniteQP},
+function effective_excitation_hamiltonian(H::MultilineMPO, ϕ::Multiline{<:InfiniteQP},
                                           envs=environments(ϕ, H))
     ϕ′ = Multiline(similar.(ϕ.data))
     left_gs = ϕ.left_gs
diff --git a/src/algorithms/expval.jl b/src/algorithms/expval.jl
index 0f4caf52d..dd866fcb8 100644
--- a/src/algorithms/expval.jl
+++ b/src/algorithms/expval.jl
@@ -118,9 +118,9 @@ function expectation_value(ψ::FiniteQP, mpo::FiniteMPO)
     return expectation_value(convert(FiniteMPS, ψ), mpo)
 end
 function expectation_value(ψ::InfiniteMPS, mpo::InfiniteMPO, envs...)
-    return expectation_value(convert(MPSMultiline, ψ), convert(MPOMultiline, mpo), envs...)
+    return expectation_value(convert(MultilineMPS, ψ), convert(MultilineMPO, mpo), envs...)
 end
-function expectation_value(ψ::MPSMultiline, O::MPOMultiline{<:Union{DenseMPO,SparseMPO}},
+function expectation_value(ψ::MultilineMPS, O::MultilineMPO{<:Union{DenseMPO,SparseMPO}},
                            envs::InfiniteMPOEnvironments=environments(ψ, O))
     return prod(product(1:size(ψ, 1), 1:size(ψ, 2))) do (i, j)
         GL = leftenv(envs, i, j, ψ)
@@ -130,7 +130,7 @@ function expectation_value(ψ::MPSMultiline, O::MPOMultiline{<:Union{DenseMPO,Sp
                  conj(ψ.AC[i + 1, j][1 4; 8])
     end
 end
-function expectation_value(ψ::MPSMultiline, mpo::MPOMultiline, envs...)
+function expectation_value(ψ::MultilineMPS, mpo::MultilineMPO, envs...)
     # TODO: fix environments
     return prod(x -> expectation_value(x...), zip(parent(ψ), parent(mpo)))
 end
diff --git a/src/algorithms/grassmann.jl b/src/algorithms/grassmann.jl
index 04b714971..9e6ab5476 100644
--- a/src/algorithms/grassmann.jl
+++ b/src/algorithms/grassmann.jl
@@ -85,9 +85,9 @@ function ManifoldPoint(state::Union{InfiniteMPS,FiniteMPS}, envs)
     return ManifoldPoint(state, envs, g, Rhoreg)
 end
 
-function ManifoldPoint(state::MPSMultiline, envs)
+function ManifoldPoint(state::MultilineMPS, envs)
     # FIXME: add support for unitcells
-    @assert length(state.AL) == 1 "GradientGrassmann only supports MPSMultiline without unitcells for now"
+    @assert length(state.AL) == 1 "GradientGrassmann only supports MultilineMPS without unitcells for now"
 
     # TODO: this really should not use the operator from the environment
     f = expectation_value(state, envs.operator, envs)
@@ -128,8 +128,8 @@ function fg(x::ManifoldPoint{T}) where {T<:Union{InfiniteMPS,FiniteMPS}}
 
     return real(f), g_prec
 end
-function fg(x::ManifoldPoint{<:MPSMultiline})
-    @assert length(x.state) == 1 "GradientGrassmann only supports MPSMultiline without unitcells for now"
+function fg(x::ManifoldPoint{<:MultilineMPS})
+    @assert length(x.state) == 1 "GradientGrassmann only supports MultilineMPS without unitcells for now"
     # the gradient I want to return is the preconditioned gradient!
     g_prec = map(enumerate(x.g)) do (i, cg)
         return PrecGrad(rmul!(copy(cg), x.state.CR[i]'), x.Rhoreg[i])
@@ -145,9 +145,9 @@ function fg(x::ManifoldPoint{<:MPSMultiline})
 end
 
 """
-Retract a left-canonical MPSMultiline along Grassmann tangent `g` by distance `alpha`.
+Retract a left-canonical MultilineMPS along Grassmann tangent `g` by distance `alpha`.
 """
-function retract(x::ManifoldPoint{<:MPSMultiline}, tg, alpha)
+function retract(x::ManifoldPoint{<:MultilineMPS}, tg, alpha)
     g = reshape(tg, size(x.state))
 
     nal = similar(x.state.AL)
@@ -157,7 +157,7 @@ function retract(x::ManifoldPoint{<:MPSMultiline}, tg, alpha)
         h[i] = PrecGrad(th)
     end
 
-    nstate = MPSKit.MPSMultiline(nal, x.state.CR[:, end])
+    nstate = MPSKit.MultilineMPS(nal, x.state.CR[:, end])
     newpoint = ManifoldPoint(nstate, x.envs)
 
     return newpoint, h[:]
diff --git a/src/algorithms/statmech/gradient_grassmann.jl b/src/algorithms/statmech/gradient_grassmann.jl
index 70335a9c9..5712b7696 100644
--- a/src/algorithms/statmech/gradient_grassmann.jl
+++ b/src/algorithms/statmech/gradient_grassmann.jl
@@ -1,12 +1,12 @@
 function leading_boundary(state::InfiniteMPS, H::DenseMPO, alg::GradientGrassmann,
                           envs=environments(state, H))
-    (multi, envs, err) = leading_boundary(convert(MPSMultiline, state),
-                                          convert(MPOMultiline, H), alg, envs)
+    (multi, envs, err) = leading_boundary(convert(MultilineMPS, state),
+                                          convert(MultilineMPO, H), alg, envs)
     state = convert(InfiniteMPS, multi)
     return (state, envs, err)
 end
 
-function leading_boundary(state::MPSMultiline, H, alg::GradientGrassmann,
+function leading_boundary(state::MultilineMPS, H, alg::GradientGrassmann,
                           envs=environments(state, H))
     res = optimize(GrassmannMPS.fg,
                    GrassmannMPS.ManifoldPoint(state, envs),
diff --git a/src/algorithms/statmech/vomps.jl b/src/algorithms/statmech/vomps.jl
index fd4a4f639..2cd5cb412 100644
--- a/src/algorithms/statmech/vomps.jl
+++ b/src/algorithms/statmech/vomps.jl
@@ -24,7 +24,7 @@ Power method algorithm for infinite MPS.
     alg_environments = Defaults.alg_environments()
 end
 
-function leading_boundary(ψ::MPSMultiline, O::MPOMultiline, alg::VOMPS,
+function leading_boundary(ψ::MultilineMPS, O::MultilineMPO, alg::VOMPS,
                           envs=environments(ψ, O))
     ϵ::Float64 = calc_galerkin(ψ, envs)
     temp_ACs = similar.(ψ.AC)
@@ -62,7 +62,7 @@ function leading_boundary(ψ::MPSMultiline, O::MPOMultiline, alg::VOMPS,
 
             regauge!.(temp_ACs, temp_Cs; alg=TensorKit.QRpos())
             alg_gauge = updatetol(alg.alg_gauge, iter, ϵ)
-            ψ = MPSMultiline(temp_ACs, ψ.CR[:, end]; alg_gauge.tol, alg_gauge.maxiter)
+            ψ = MultilineMPS(temp_ACs, ψ.CR[:, end]; alg_gauge.tol, alg_gauge.maxiter)
 
             alg_environments = updatetol(alg.alg_environments, iter, ϵ)
             recalculate!(envs, ψ; alg_environments.tol)
diff --git a/src/algorithms/statmech/vumps.jl b/src/algorithms/statmech/vumps.jl
index 3d5d5994e..a5d77acd1 100644
--- a/src/algorithms/statmech/vumps.jl
+++ b/src/algorithms/statmech/vumps.jl
@@ -1,6 +1,6 @@
 #the statmech VUMPS
 #it made sense to seperate both vumpses as
-# - leading_boundary primarily works on MPSMultiline
+# - leading_boundary primarily works on MultilineMPS
 # - they search for different eigenvalues
 # - Hamiltonian vumps should use Lanczos, this has to use arnoldi
 # - this vumps updates entire collumns (ψ[:,i]); incompatible with InfiniteMPS
@@ -13,11 +13,11 @@
 Approximate the leading eigenvector for opp.
 """
 function leading_boundary(ψ::InfiniteMPS, H, alg, envs=environments(ψ, H))
-    (st, pr, de) = leading_boundary(convert(MPSMultiline, ψ), Multiline([H]), alg, envs)
+    (st, pr, de) = leading_boundary(convert(MultilineMPS, ψ), Multiline([H]), alg, envs)
     return convert(InfiniteMPS, st), pr, de
 end
 
-function leading_boundary(ψ::MPSMultiline, H, alg::VUMPS, envs=environments(ψ, H))
+function leading_boundary(ψ::MultilineMPS, H, alg::VUMPS, envs=environments(ψ, H))
     ϵ::Float64 = calc_galerkin(ψ, envs)
     temp_ACs = similar.(ψ.AC)
     temp_Cs = similar.(ψ.CR)
@@ -59,7 +59,7 @@ function leading_boundary(ψ::MPSMultiline, H, alg::VUMPS, envs=environments(ψ,
 
             regauge!.(temp_ACs, temp_Cs; alg=TensorKit.QRpos())
             alg_gauge = updatetol(alg.alg_gauge, iter, ϵ)
-            ψ = MPSMultiline(temp_ACs, ψ.CR[:, end]; alg_gauge.tol, alg_gauge.maxiter)
+            ψ = MultilineMPS(temp_ACs, ψ.CR[:, end]; alg_gauge.tol, alg_gauge.maxiter)
 
             alg_environments = updatetol(alg.alg_environments, iter, ϵ)
             recalculate!(envs, ψ; alg_environments.tol)
diff --git a/src/algorithms/toolbox.jl b/src/algorithms/toolbox.jl
index 05a724e20..737196bfd 100644
--- a/src/algorithms/toolbox.jl
+++ b/src/algorithms/toolbox.jl
@@ -29,7 +29,7 @@ end
 function calc_galerkin(state::Union{InfiniteMPS,FiniteMPS,WindowMPS}, envs)::Float64
     return maximum([calc_galerkin(state, loc, envs) for loc in 1:length(state)])
 end
-function calc_galerkin(state::MPSMultiline, envs::InfiniteMPOEnvironments)::Float64
+function calc_galerkin(state::MultilineMPS, envs::InfiniteMPOEnvironments)::Float64
     above = isnothing(envs.above) ? state : envs.above
 
     εs = zeros(Float64, size(state, 1), size(state, 2))
diff --git a/src/environments/idmrg_envs.jl b/src/environments/idmrg_envs.jl
index 15e04c65f..9a3682832 100644
--- a/src/environments/idmrg_envs.jl
+++ b/src/environments/idmrg_envs.jl
@@ -20,7 +20,7 @@ function IDMRGEnvironments(ψ::InfiniteMPS, envs::InfiniteMPOHamiltonianEnvironm
     rightenvs = PeriodicMatrix(reshape(deepcopy(envs.rightenvs), (1, L)))
     return IDMRGEnvironments(envs.operator, leftenvs, rightenvs)
 end
-function IDMRGEnvironments(ψ::Union{InfiniteMPS,MPSMultiline},
+function IDMRGEnvironments(ψ::Union{InfiniteMPS,MultilineMPS},
                            envs::InfiniteMPOEnvironments)
     check_recalculate!(envs, ψ)
     return IDMRGEnvironments(envs.operator, deepcopy(envs.leftenvs),
diff --git a/src/environments/infinitempo_envs.jl b/src/environments/infinitempo_envs.jl
index 6ccf077ae..1497069ab 100644
--- a/src/environments/infinitempo_envs.jl
+++ b/src/environments/infinitempo_envs.jl
@@ -1,9 +1,9 @@
 """
-    InfiniteMPOEnvironments{O<:MPOMultiline,V,S<:MPSMultiline,A} <: AbstractMPSEnvironments
+    InfiniteMPOEnvironments{O<:MultilineMPO,V,S<:MultilineMPS,A} <: AbstractMPSEnvironments
 
 Environment manager for `InfiniteMPO` and its `Multiline` version.
 """
-mutable struct InfiniteMPOEnvironments{O,V,S<:MPSMultiline,A} <:
+mutable struct InfiniteMPOEnvironments{O,V,S<:MultilineMPS,A} <:
                AbstractInfiniteEnvironments
     above::Union{S,Nothing}
     operator::O
@@ -23,31 +23,31 @@ end
 # Constructors
 # ------------
 function environments(state::InfiniteMPS, O::InfiniteMPO; kwargs...)
-    return environments(convert(MPSMultiline, state), convert(MPOMultiline, O); kwargs...)
+    return environments(convert(MultilineMPS, state), convert(MultilineMPO, O); kwargs...)
 end
 function environments(below::InfiniteMPS,
                       (mpo, above)::Tuple{<:InfiniteMPO,<:InfiniteMPS}; kwargs...)
-    return environments(convert(MPSMultiline, below),
-                        (convert(MPOMultiline, mpo), convert(MPSMultiline, above));
+    return environments(convert(MultilineMPS, below),
+                        (convert(MultilineMPO, mpo), convert(MultilineMPS, above));
                         kwargs...)
 end
 
-function environments(state::MPSMultiline, mpo::MPOMultiline; solver=Defaults.eigsolver)
+function environments(state::MultilineMPS, mpo::MultilineMPO; solver=Defaults.eigsolver)
     GL, GR = initialize_environments(state, mpo, state)
     envs = InfiniteMPOEnvironments(nothing, mpo, state, solver, GL, GR)
     return recalculate!(envs, state)
 end
 
-function environments(below::MPSMultiline,
-                      (mpo, above)::Tuple{<:MPOMultiline,<:MPSMultiline};
+function environments(below::MultilineMPS,
+                      (mpo, above)::Tuple{<:MultilineMPO,<:MultilineMPS};
                       solver=Defaults.eigsolver)
     GL, GR = initialize_environments(above, mpo, below)
     envs = InfiniteMPOEnvironments(above, mpo, below, solver, GL, GR)
     return recalculate!(envs, below)
 end
 
-function initialize_environments(ket::MPSMultiline, operator::MPOMultiline,
-                                 bra::MPSMultiline=ket)
+function initialize_environments(ket::MultilineMPS, operator::MultilineMPO,
+                                 bra::MultilineMPS=ket)
     # allocate
     GL = PeriodicArray([allocate_GL(bra[row], operator[row], ket[row], col)
                         for row in 1:size(ket, 1), col in 1:size(ket, 2)])
@@ -67,7 +67,7 @@ function leftenv(envs::InfiniteMPOEnvironments, pos::Int, state::InfiniteMPS)
     check_recalculate!(envs, state)
     return envs.leftenvs[1, pos]
 end
-function leftenv(envs::InfiniteMPOEnvironments, pos::Int, state::MPSMultiline)
+function leftenv(envs::InfiniteMPOEnvironments, pos::Int, state::MultilineMPS)
     check_recalculate!(envs, state)
     return envs.leftenvs[:, pos]
 end
@@ -80,7 +80,7 @@ function rightenv(envs::InfiniteMPOEnvironments, pos::Int, state::InfiniteMPS)
     check_recalculate!(envs, state)
     return envs.rightenvs[1, pos]
 end
-function rightenv(envs::InfiniteMPOEnvironments, pos::Int, state::MPSMultiline)
+function rightenv(envs::InfiniteMPOEnvironments, pos::Int, state::MultilineMPS)
     check_recalculate!(envs, state)
     return envs.rightenvs[:, pos]
 end
@@ -91,11 +91,11 @@ end
 
 # Utility
 # -------
-function check_dependency(envs::InfiniteMPOEnvironments, state::MPSMultiline)
+function check_dependency(envs::InfiniteMPOEnvironments, state::MultilineMPS)
     return all(x -> ===(x...), zip(envs.dependency, state))
 end
 
-function issamespace(envs::InfiniteMPOEnvironments, state::MPSMultiline)
+function issamespace(envs::InfiniteMPOEnvironments, state::MultilineMPS)
     for row in 1:size(state, 1)
         newstate = state[row]
         oldstate = envs.dependency[row]
@@ -114,7 +114,7 @@ end
 # Calculation
 # -----------
 function recalculate!(envs::InfiniteMPOEnvironments, nstate::InfiniteMPS; kwargs...)
-    return recalculate!(envs, convert(MPSMultiline, nstate); kwargs...)
+    return recalculate!(envs, convert(MultilineMPS, nstate); kwargs...)
 end
 
 function compute_leftenv!(envs::InfiniteMPOEnvironments)
diff --git a/src/environments/multiple_envs.jl b/src/environments/multiple_envs.jl
index 452182102..ac4f8a4d4 100644
--- a/src/environments/multiple_envs.jl
+++ b/src/environments/multiple_envs.jl
@@ -15,7 +15,7 @@ function environments(st, H::LazySum)
     return MultipleEnvironments(H, map(op -> environments(st, op), H.ops))
 end
 
-function environments(st::Union{InfiniteMPS,MPSMultiline}, H::LazySum;
+function environments(st::Union{InfiniteMPS,MultilineMPS}, H::LazySum;
                       solver=Defaults.linearsolver)
     if !(solver isa Vector)
         solver = repeat([solver], length(H))
@@ -26,7 +26,7 @@ function environments(st::Union{InfiniteMPS,MPSMultiline}, H::LazySum;
 end
 
 # TODO: fix this such that `T(...) isa T`
-function IDMRGEnvironments(ψ::Union{MPSMultiline,InfiniteMPS}, env::MultipleEnvironments)
+function IDMRGEnvironments(ψ::Union{MultilineMPS,InfiniteMPS}, env::MultipleEnvironments)
     envs = IDMRGEnvironments.(Ref(ψ), env.envs)
     Hs = getproperty.(env.envs, :operator)
     return MultipleEnvironments(LazySum(Hs), envs)
diff --git a/src/environments/qp_envs.jl b/src/environments/qp_envs.jl
index e56fc4099..84214f34e 100644
--- a/src/environments/qp_envs.jl
+++ b/src/environments/qp_envs.jl
@@ -192,7 +192,7 @@ function environments(exci::FiniteQP,
 end
 
 function environments(exci::Multiline{<:InfiniteQP},
-                      ham::MPOMultiline,
+                      ham::MultilineMPO,
                       lenvs,
                       renvs;
                       solver=Defaults.linearsolver)
diff --git a/src/operators/mpomultiline.jl b/src/operators/mpomultiline.jl
deleted file mode 100644
index f674789b7..000000000
--- a/src/operators/mpomultiline.jl
+++ /dev/null
@@ -1,45 +0,0 @@
-# MPOMultiline
-# ------------
-"""
-    const MPOMultiline = Multiline{<:Union{SparseMPO,DenseMPO}}
-
-Type that represents multiple lines of `MPO` objects.
-
-# Constructors
-    MPOMultiline(mpos::AbstractVector{<:Union{SparseMPO,DenseMPO}})
-    MPOMultiline(Os::AbstractMatrix{<:MPOTensor})
-
-See also: [`Multiline`](@ref), [`SparseMPO`](@ref), [`DenseMPO`](@ref)
-"""
-const MPOMultiline = Multiline{<:AbstractMPO}
-
-function MPOMultiline(Os::AbstractMatrix{T}) where {T<:MPOTensor}
-    return MPOMultiline(map(FiniteMPO, eachrow(Os)))
-end
-function MPOMultiline(Os::PeriodicMatrix{T}) where {T<:MPOTensor}
-    return MPOMultiline(map(InfiniteMPO, eachrow(Os)))
-end
-MPOMultiline(mpos::AbstractVector{<:AbstractMPO}) = Multiline(mpos)
-MPOMultiline(t::MPOTensor) = MPOMultiline(PeriodicMatrix(fill(t, 1, 1)))
-
-# allow indexing with two indices
-Base.getindex(t::MPOMultiline, ::Colon, j::Int) = Base.getindex.(t.data, j)
-Base.getindex(t::MPOMultiline, i::Int, j) = Base.getindex(t[i], j)
-Base.getindex(t::MPOMultiline, I::CartesianIndex{2}) = t[I.I...]
-
-# converters
-Base.convert(::Type{MPOMultiline}, t::AbstractMPO) = Multiline([t])
-Base.convert(::Type{DenseMPO}, t::MPOMultiline{<:DenseMPO}) = only(t)
-Base.convert(::Type{SparseMPO}, t::MPOMultiline{<:SparseMPO}) = only(t)
-Base.convert(::Type{FiniteMPO}, t::MPOMultiline{<:FiniteMPO}) = only(t)
-Base.convert(::Type{InfiniteMPO}, t::MPOMultiline{<:InfiniteMPO}) = only(t)
-
-function Base.:*(mpo::MPOMultiline, st::MPSMultiline)
-    size(mpo) == size(st) || throw(ArgumentError("dimension mismatch"))
-    return Multiline(map(*, zip(mpo, st)))
-end
-
-function Base.:*(mpo1::MPOMultiline, mpo2::MPOMultiline)
-    size(mpo1) == size(mpo2) || throw(ArgumentError("dimension mismatch"))
-    return Multiline(map(*, zip(mpo1, mpo2)))
-end
diff --git a/src/operators/multilinempo.jl b/src/operators/multilinempo.jl
new file mode 100644
index 000000000..938281062
--- /dev/null
+++ b/src/operators/multilinempo.jl
@@ -0,0 +1,45 @@
+# MultilineMPO
+# ------------
+"""
+    const MultilineMPO = Multiline{<:Union{SparseMPO,DenseMPO}}
+
+Type that represents multiple lines of `MPO` objects.
+
+# Constructors
+    MultilineMPO(mpos::AbstractVector{<:Union{SparseMPO,DenseMPO}})
+    MultilineMPO(Os::AbstractMatrix{<:MPOTensor})
+
+See also: [`Multiline`](@ref), [`SparseMPO`](@ref), [`DenseMPO`](@ref)
+"""
+const MultilineMPO = Multiline{<:AbstractMPO}
+
+function MultilineMPO(Os::AbstractMatrix{T}) where {T<:MPOTensor}
+    return MultilineMPO(map(FiniteMPO, eachrow(Os)))
+end
+function MultilineMPO(Os::PeriodicMatrix{T}) where {T<:MPOTensor}
+    return MultilineMPO(map(InfiniteMPO, eachrow(Os)))
+end
+MultilineMPO(mpos::AbstractVector{<:AbstractMPO}) = Multiline(mpos)
+MultilineMPO(t::MPOTensor) = MultilineMPO(PeriodicMatrix(fill(t, 1, 1)))
+
+# allow indexing with two indices
+Base.getindex(t::MultilineMPO, ::Colon, j::Int) = Base.getindex.(t.data, j)
+Base.getindex(t::MultilineMPO, i::Int, j) = Base.getindex(t[i], j)
+Base.getindex(t::MultilineMPO, I::CartesianIndex{2}) = t[I.I...]
+
+# converters
+Base.convert(::Type{MultilineMPO}, t::AbstractMPO) = Multiline([t])
+Base.convert(::Type{DenseMPO}, t::MultilineMPO{<:DenseMPO}) = only(t)
+Base.convert(::Type{SparseMPO}, t::MultilineMPO{<:SparseMPO}) = only(t)
+Base.convert(::Type{FiniteMPO}, t::MultilineMPO{<:FiniteMPO}) = only(t)
+Base.convert(::Type{InfiniteMPO}, t::MultilineMPO{<:InfiniteMPO}) = only(t)
+
+function Base.:*(mpo::MultilineMPO, st::MultilineMPS)
+    size(mpo) == size(st) || throw(ArgumentError("dimension mismatch"))
+    return Multiline(map(*, zip(mpo, st)))
+end
+
+function Base.:*(mpo1::MultilineMPO, mpo2::MultilineMPO)
+    size(mpo1) == size(mpo2) || throw(ArgumentError("dimension mismatch"))
+    return Multiline(map(*, zip(mpo1, mpo2)))
+end
diff --git a/src/states/mpsmultiline.jl b/src/states/multilinemps.jl
similarity index 54%
rename from src/states/mpsmultiline.jl
rename to src/states/multilinemps.jl
index 28fcabde3..ee12c8303 100644
--- a/src/states/mpsmultiline.jl
+++ b/src/states/multilinemps.jl
@@ -1,49 +1,49 @@
-# MPSMultiline
+# MultilineMPS
 # ------------
-const MPSMultiline = Multiline{<:InfiniteMPS}
+const MultilineMPS = Multiline{<:InfiniteMPS}
 
 @doc """
-    const MPSMultiline = Multiline{<:InfiniteMPS}
+    const MultilineMPS = Multiline{<:InfiniteMPS}
 
 Type that represents multiple lines of `InfiniteMPS` objects.
 
 # Constructors
-    MPSMultiline(mpss::AbstractVector{<:InfiniteMPS})
-    MPSMultiline([f, eltype], physicalspaces::Matrix{<:Union{S, CompositeSpace{S}},
+    MultilineMPS(mpss::AbstractVector{<:InfiniteMPS})
+    MultilineMPS([f, eltype], physicalspaces::Matrix{<:Union{S, CompositeSpace{S}},
                  virtualspaces::Matrix{<:Union{S, CompositeSpace{S}}) where
                  {S<:ElementarySpace}
-    MPSMultiline(As::AbstractMatrix{<:GenericMPSTensor}; kwargs...)
-    MPSMultiline(ALs::AbstractMatrix{<:GenericMPSTensor}, 
+    MultilineMPS(As::AbstractMatrix{<:GenericMPSTensor}; kwargs...)
+    MultilineMPS(ALs::AbstractMatrix{<:GenericMPSTensor}, 
                  C₀::AbstractVector{<:MPSBondTensor}; kwargs...)
 
 See also: [`Multiline`](@ref)
 """
-function MPSMultiline end
+function MultilineMPS end
 
-MPSMultiline(mpss::AbstractVector{<:InfiniteMPS}) = Multiline(mpss)
-function MPSMultiline(pspaces::AbstractMatrix{S}, Dspaces::AbstractMatrix{S};
+MultilineMPS(mpss::AbstractVector{<:InfiniteMPS}) = Multiline(mpss)
+function MultilineMPS(pspaces::AbstractMatrix{S}, Dspaces::AbstractMatrix{S};
                       kwargs...) where {S<:VectorSpace}
     data = map(eachrow(pspaces), eachrow(Dspaces)) do p, D
         return InfiniteMPS(p, D; kwargs...)
     end
-    return MPSMultiline(data)
+    return MultilineMPS(data)
 end
-function MPSMultiline(As::AbstractMatrix{T}; kwargs...) where {T<:GenericMPSTensor}
+function MultilineMPS(As::AbstractMatrix{T}; kwargs...) where {T<:GenericMPSTensor}
     data = map(eachrow(As)) do Arow
         return InfiniteMPS(Arow; kwargs...)
     end
-    return MPSMultiline(data)
+    return MultilineMPS(data)
 end
-function MPSMultiline(ALs::AbstractMatrix{<:GenericMPSTensor},
+function MultilineMPS(ALs::AbstractMatrix{<:GenericMPSTensor},
                       C₀::AbstractVector{<:MPSBondTensor}; kwargs...)
     data = map(eachrow(ALs), C₀) do ALrow, C₀row
         return InfiniteMPS(ALrow, C₀row; kwargs...)
     end
-    return MPSMultiline(data)
+    return MultilineMPS(data)
 end
 
 # TODO: properly rewrite these properties
-function Base.getproperty(psi::MPSMultiline, prop::Symbol)
+function Base.getproperty(psi::MultilineMPS, prop::Symbol)
     if prop == :AL
         return ALView(psi)
     elseif prop == :AR
@@ -58,11 +58,11 @@ function Base.getproperty(psi::MPSMultiline, prop::Symbol)
 end
 
 for f in (:l_RR, :l_RL, :l_LL, :l_LR)
-    @eval $f(t::MPSMultiline, i, j=1) = $f(t[i], j)
+    @eval $f(t::MultilineMPS, i, j=1) = $f(t[i], j)
 end
 
 for f in (:r_RR, :r_RL, :r_LR, :r_LL)
-    @eval $f(t::MPSMultiline, i, j=size(t, 2)) = $f(t[i], j)
+    @eval $f(t::MultilineMPS, i, j=size(t, 2)) = $f(t[i], j)
 end
 
 site_type(::Type{Multiline{S}}) where {S} = site_type(S)
@@ -71,13 +71,13 @@ site_type(st::Multiline) = site_type(typeof(st))
 bond_type(st::Multiline) = bond_type(typeof(st))
 VectorInterface.scalartype(::Multiline{T}) where {T} = scalartype(T)
 
-function TensorKit.dot(a::MPSMultiline, b::MPSMultiline; kwargs...)
+function TensorKit.dot(a::MultilineMPS, b::MultilineMPS; kwargs...)
     return sum(dot.(parent(a), parent(b); kwargs...))
 end
-TensorKit.normalize!(a::MPSMultiline) = (normalize!.(parent(a)); return a)
+TensorKit.normalize!(a::MultilineMPS) = (normalize!.(parent(a)); return a)
 
-Base.convert(::Type{MPSMultiline}, st::InfiniteMPS) = Multiline([st])
-Base.convert(::Type{InfiniteMPS}, st::MPSMultiline) = only(st)
-Base.eltype(t::MPSMultiline) = eltype(t[1])
-left_virtualspace(t::MPSMultiline, i::Int, j::Int) = left_virtualspace(t[i], j)
-right_virtualspace(t::MPSMultiline, i::Int, j::Int) = right_virtualspace(t[i], j)
+Base.convert(::Type{MultilineMPS}, st::InfiniteMPS) = Multiline([st])
+Base.convert(::Type{InfiniteMPS}, st::MultilineMPS) = only(st)
+Base.eltype(t::MultilineMPS) = eltype(t[1])
+left_virtualspace(t::MultilineMPS, i::Int, j::Int) = left_virtualspace(t[i], j)
+right_virtualspace(t::MultilineMPS, i::Int, j::Int) = right_virtualspace(t[i], j)
diff --git a/src/utility/multiline.jl b/src/utility/multiline.jl
index 9d77e2ec6..281bfe666 100644
--- a/src/utility/multiline.jl
+++ b/src/utility/multiline.jl
@@ -2,12 +2,12 @@
     struct Multiline{T}
 
 Object that represents multiple lines of objects of type `T`. Typically used to represent
-multiple lines of `InfiniteMPS` (`MPSMultiline`) or MPO (`Multiline{<:AbstractMPO}`).
+multiple lines of `InfiniteMPS` (`MultilineMPS`) or MPO (`Multiline{<:AbstractMPO}`).
 
 # Fields
 - `data::PeriodicArray{T,1}`: the data of the multiline object
 
-See also: [`MPSMultiline`](@ref) and [`MPOMultiline`](@ref)
+See also: [`MultilineMPS`](@ref) and [`MultilineMPO`](@ref)
 """
 struct Multiline{T}
     data::PeriodicArray{T,1}
diff --git a/test/algorithms.jl b/test/algorithms.jl
index 6534fbea6..a596a093a 100644
--- a/test/algorithms.jl
+++ b/test/algorithms.jl
@@ -564,12 +564,12 @@ end
         @test dim(left_virtualspace(state_tr, 5)) < dim(left_virtualspace(state_oe, 5))
     end
 
-    @testset "MPSMultiline" begin
+    @testset "MultilineMPS" begin
         o = rand(ComplexF64, pspace * pspace, pspace * pspace)
-        mpo = MPOMultiline(o)
+        mpo = MultilineMPO(o)
 
         t = rand(ComplexF64, Dspace * pspace, Dspace)
-        state = MPSMultiline(fill(t, 1, 1))
+        state = MultilineMPS(fill(t, 1, 1))
 
         state_re = changebonds(state,
                                RandExpand(; trscheme=truncdim(dim(Dspace) * dim(Dspace))))
diff --git a/test/states.jl b/test/states.jl
index f94cae7ec..f80406b2c 100644
--- a/test/states.jl
+++ b/test/states.jl
@@ -71,12 +71,12 @@ end
     end
 end
 
-@testset "MPSMultiline ($(sectortype(D)), $elt)" for (D, d, elt) in
+@testset "MultilineMPS ($(sectortype(D)), $elt)" for (D, d, elt) in
                                                      [(ℙ^10, ℙ^2, ComplexF64),
                                                       (Rep[U₁](1 => 3), Rep[U₁](0 => 1),
                                                        ComplexF32)]
     tol = Float64(eps(real(elt)) * 100)
-    ψ = MPSMultiline([rand(elt, D * d, D) rand(elt, D * d, D)
+    ψ = MultilineMPS([rand(elt, D * d, D) rand(elt, D * d, D)
                       rand(elt, D * d, D) rand(elt, D * d, D)]; tol)
 
     for i in 1:size(ψ, 1), j in 1:size(ψ, 2)