diff --git a/README.md b/README.md
index 50aa4b2d..2eb68cee 100644
--- a/README.md
+++ b/README.md
@@ -17,7 +17,7 @@ pkg> add MadNLPHSL, MadNLPPardiso, MadNLPMumps, MadNLPGPU, MadNLPGraph, MadNLPIt
 These packages are stored in the `lib` subdirectory within the main MadNLP repository. Some extension packages may require additional dependencies or specific hardware. For the instructions for the build procedure, see the following links: [MadNLPHSL](https://github.com/sshin23/MadNLP.jl/tree/master/lib/MadNLPHSL), [MadNLPPardiso](https://github.com/sshin23/MadNLP.jl/tree/master/lib/MadNLPHSL), [MadNLPGPU](https://github.com/sshin23/MadNLP.jl/tree/master/lib/MadNLPGPU).
 
 
-## Usage
+## Usage 
 ### Interfaces
 MadNLP is interfaced with modeling packages: 
 - [JuMP](https://github.com/jump-dev/JuMP.jl)
diff --git a/lib/MadNLPGPU/src/kernels.jl b/lib/MadNLPGPU/src/kernels.jl
index 9a903ce4..da447d2d 100644
--- a/lib/MadNLPGPU/src/kernels.jl
+++ b/lib/MadNLPGPU/src/kernels.jl
@@ -69,7 +69,7 @@ end
     end
 end
 
-function MadNLP.treat_fixed_variable!(kkt::MadNLP.AbstractKKTSystem{T, MT}) where {T, MT<:CuMatrix{T}}
+function MadNLP.treat_fixed_variable!(kkt::MadNLP.AbstractKKTSystem{T, VT, MT}) where {T, VT, MT<:CuMatrix{T}}
     length(kkt.ind_fixed) == 0 && return
     aug = kkt.aug_com
     d_ind_fixed = kkt.ind_fixed |> CuVector # TODO: allocate ind_fixed directly on the GPU
diff --git a/lib/MadNLPGraph/src/MadNLPGraph.jl b/lib/MadNLPGraph/src/MadNLPGraph.jl
index bdc7f60a..8898b965 100644
--- a/lib/MadNLPGraph/src/MadNLPGraph.jl
+++ b/lib/MadNLPGraph/src/MadNLPGraph.jl
@@ -7,7 +7,7 @@ import MadNLP:
     eval_objective_gradient, eval_function, eval_constraint, eval_hessian_lagrangian, eval_constraint_jacobian,
     @kwdef, Logger, @debug, @warn, @error, @sprintf,
     AbstractOptions, AbstractLinearSolver, EmptyLinearSolver, set_options!,
-    SparseMatrixCSC, SubVector, StrideOneVector,
+    SparseMatrixCSC, SubVector,
     SymbolicException,FactorizationException,SolveException,InertiaException,
     introduce, factorize!, solve!, improve!, is_inertia, inertia,
     default_linear_solver, default_dense_solver, get_csc_view, get_cscsy_view, nnz, mul!,
diff --git a/lib/MadNLPGraph/src/schur.jl b/lib/MadNLPGraph/src/schur.jl
index 1c28f23c..9876f382 100644
--- a/lib/MadNLPGraph/src/schur.jl
+++ b/lib/MadNLPGraph/src/schur.jl
@@ -2,7 +2,7 @@ module MadNLPSchur
 
 import ..MadNLPGraph:
     @kwdef, Logger, @debug, @warn, @error,
-    AbstractOptions, AbstractLinearSolver, EmptyLinearSolver, set_options!, SparseMatrixCSC, SubVector, StrideOneVector,
+    AbstractOptions, AbstractLinearSolver, EmptyLinearSolver, set_options!, SparseMatrixCSC, SubVector, 
     SymbolicException,FactorizationException,SolveException,InertiaException,
     introduce, factorize!, solve!, improve!, is_inertia, inertia,
     default_linear_solver, default_dense_solver, get_csc_view, get_cscsy_view, nnz, mul!,
@@ -92,7 +92,7 @@ function SolverWorker(tsp,V_0,csc::SparseMatrixCSC{Float64},inds::Vector{Int},k,
                       SubproblemSolverModule::Module,logger::Logger,option_dict::Dict{Symbol,Any})
 
     V    = findall(tsp.part.==k)
-    
+
     csc_k,csc_k_view = get_cscsy_view(csc,V,inds=inds)
     compl,compl_view = get_csc_view(csc,V,V_0,inds=inds)
     V_0_nz = findnz(compl.colptr)
diff --git a/lib/MadNLPGraph/src/schwarz.jl b/lib/MadNLPGraph/src/schwarz.jl
index c4160fa8..e2d40ad4 100644
--- a/lib/MadNLPGraph/src/schwarz.jl
+++ b/lib/MadNLPGraph/src/schwarz.jl
@@ -2,7 +2,7 @@ module MadNLPSchwarz
 
 import ..MadNLPGraph:
     @kwdef, Logger, @debug, @warn, @error,
-    default_linear_solver,SparseMatrixCSC, SubVector, StrideOneVector, get_cscsy_view, nnz,
+    default_linear_solver,SparseMatrixCSC, SubVector, get_cscsy_view, nnz,
     SymbolicException,FactorizationException,SolveException,InertiaException,
     AbstractOptions, AbstractLinearSolver, set_options!,
     MonolevelPartition, MonolevelStruc, BilevelPartition, BilevelStruc,
diff --git a/lib/MadNLPHSL/src/MadNLPHSL.jl b/lib/MadNLPHSL/src/MadNLPHSL.jl
index 01bb797c..890fa855 100644
--- a/lib/MadNLPHSL/src/MadNLPHSL.jl
+++ b/lib/MadNLPHSL/src/MadNLPHSL.jl
@@ -2,10 +2,10 @@ module MadNLPHSL
 
 import Libdl: dlopen, RTLD_DEEPBIND
 import MadNLP: @kwdef, Logger, @debug, @warn, @error,
-    AbstractOptions, AbstractLinearSolver, set_options!, SparseMatrixCSC, SubVector, StrideOneVector,
+    AbstractOptions, AbstractLinearSolver, set_options!, SparseMatrixCSC, SubVector,
     SymbolicException,FactorizationException,SolveException,InertiaException,
     introduce, factorize!, solve!, improve!, is_inertia, inertia, findIJ, nnz,
-    get_tril_to_full, transfer!, input_type
+    get_tril_to_full, transfer!, input_type, _madnlp_unsafe_wrap
 
 include(joinpath("..","deps","deps.jl"))
 
diff --git a/lib/MadNLPHSL/src/ma27.jl b/lib/MadNLPHSL/src/ma27.jl
index f52231a9..418b98a2 100644
--- a/lib/MadNLPHSL/src/ma27.jl
+++ b/lib/MadNLPHSL/src/ma27.jl
@@ -1,6 +1,3 @@
-# MadNLP.jl
-# Created by Sungho Shin (sungho.shin@wisc.edu)
-
 const ma27_default_icntl = Int32[
     6,6,0,2139062143,1,32639,32639,32639,32639,14,9,8,8,9,10,32639,32639,32639,32689,24,11,9,8,9,10,0,0,0,0,0]
 const ma27_default_cntl  = [.1,1.0,0.,0.,0.]
@@ -24,7 +21,7 @@ mutable struct Ma27Solver <: AbstractLinearSolver
     info::Vector{Int32}
 
     a::Vector{Float64}
-    a_view::StrideOneVector{Float64}
+    a_view::Vector{Float64}
     la::Int32
     ikeep::Vector{Int32}
 
@@ -39,7 +36,7 @@ mutable struct Ma27Solver <: AbstractLinearSolver
     logger::Logger
 end
 
-ma27ad!(n::Cint,nz::Cint,I::StrideOneVector{Cint},J::StrideOneVector{Cint},
+ma27ad!(n::Cint,nz::Cint,I::Vector{Cint},J::Vector{Cint},
         iw::Vector{Cint},liw::Cint,ikeep::Vector{Cint},iw1::Vector{Cint},
         nsteps::Vector{Cint},iflag::Cint,icntl::Vector{Cint},cntl::Vector{Cdouble},
         info::Vector{Cint},ops::Cdouble) = ccall(
@@ -51,8 +48,8 @@ ma27ad!(n::Cint,nz::Cint,I::StrideOneVector{Cint},J::StrideOneVector{Cint},
              Ptr{Cint},Ref{Cdouble}),
             n,nz,I,J,iw,liw,ikeep,iw1,nsteps,iflag,icntl,cntl,info,ops)
 
-ma27bd!(n::Cint,nz::Cint,I::StrideOneVector{Cint},J::StrideOneVector{Cint},
-        a::StrideOneVector{Cdouble},la::Cint,iw::Vector{Cint},liw::Cint,
+ma27bd!(n::Cint,nz::Cint,I::Vector{Cint},J::Vector{Cint},
+        a::Vector{Cdouble},la::Cint,iw::Vector{Cint},liw::Cint,
         ikeep::Vector{Cint},nsteps::Vector{Cint},maxfrt::Vector{Cint},iw1::Vector{Cint},
         icntl::Vector{Cint},cntl::Vector{Cdouble},info::Vector{Cint}) = ccall(
             (:ma27bd_,libhsl),
@@ -101,7 +98,7 @@ function Ma27Solver(csc::SparseMatrixCSC;
 
     la = ceil(Int32,max(nz,opt.ma27_la_init_factor*info[5]))
     a = Vector{Float64}(undef,la)
-    a_view = view(a,1:nnz(csc))
+    a_view = _madnlp_unsafe_wrap(a,nnz(csc))
     liw= ceil(Int32,opt.ma27_liw_init_factor*info[6])
     resize!(iw,liw)
     maxfrt=Int32[1]
@@ -134,7 +131,7 @@ function factorize!(M::Ma27Solver)
     return M
 end
 
-function solve!(M::Ma27Solver,rhs::StrideOneVector{Float64})
+function solve!(M::Ma27Solver,rhs::Vector{Float64})
     length(M.w)<M.maxfrt[1] && resize!(M.w,M.maxfrt[1])
     length(M.iw1)<M.nsteps[1] && resize!(M.iw1,M.nsteps[1])
     ma27cd!(Int32(M.csc.n),M.a,M.la,M.iw,M.liw,M.w,M.maxfrt,rhs,
diff --git a/lib/MadNLPHSL/src/ma57.jl b/lib/MadNLPHSL/src/ma57.jl
index 23def20a..e2a62dec 100644
--- a/lib/MadNLPHSL/src/ma57.jl
+++ b/lib/MadNLPHSL/src/ma57.jl
@@ -1,6 +1,3 @@
-# MadNLP.jl
-# Created by Sungho Shin (sungho.shin@wisc.edu)
-
 const ma57_default_icntl = Int32[0,0,6,1,0,5,1,0,10,0,16,16,10,100,0,0,0,0,0,0]
 const ma57_default_cntl  = Float64[1e-8,1.0e-20,0.5,0.0,0.0]
 
@@ -45,7 +42,7 @@ mutable struct Ma57Solver <: AbstractLinearSolver
 end
 
 
-ma57ad!(n::Cint,nz::Cint,I::StrideOneVector{Cint},J::StrideOneVector{Cint},lkeep::Cint,
+ma57ad!(n::Cint,nz::Cint,I::Vector{Cint},J::Vector{Cint},lkeep::Cint,
         keep::Vector{Cint},iwork::Vector{Cint},icntl::Vector{Cint},
         info::Vector{Cint},rinfo::Vector{Cdouble}) = ccall(
             (:ma57ad_,libhsl),
@@ -55,7 +52,7 @@ ma57ad!(n::Cint,nz::Cint,I::StrideOneVector{Cint},J::StrideOneVector{Cint},lkeep
              Ptr{Cint},Ptr{Cdouble}),
             n,nz,I,J,lkeep,keep,iwork,icntl,info,rinfo)
 
-ma57bd!(n::Cint,nz::Cint,V::StrideOneVector{Cdouble},fact::Vector{Cdouble},
+ma57bd!(n::Cint,nz::Cint,V::Vector{Cdouble},fact::Vector{Cdouble},
         lfact::Cint,ifact::Vector{Cint},lifact::Cint,lkeep::Cint,
         keep::Vector{Cint},iwork::Vector{Cint},icntl::Vector{Cint},cntl::Vector{Cdouble},
         info::Vector{Cint},rinfo::Vector{Cdouble}) = ccall(
@@ -68,7 +65,7 @@ ma57bd!(n::Cint,nz::Cint,V::StrideOneVector{Cdouble},fact::Vector{Cdouble},
             n,nz,V,fact,lfact,ifact,lifact,lkeep,keep,iwork,icntl,cntl,info,rinfo)
 
 ma57cd!(job::Cint,n::Cint,fact::Vector{Cdouble},lfact::Cint,
-        ifact::Vector{Cint},lifact::Cint,nrhs::Cint,rhs::StrideOneVector{Cdouble},
+        ifact::Vector{Cint},lifact::Cint,nrhs::Cint,rhs::Vector{Cdouble},
         lrhs::Cint,work::Vector{Cdouble},lwork::Cint,iwork::Vector{Cint},
         icntl::Vector{Cint},info::Vector{Cint}) = ccall(
             (:ma57cd_,libhsl),
@@ -146,7 +143,7 @@ function factorize!(M::Ma57Solver)
     return M
 end
 
-function solve!(M::Ma57Solver,rhs::StrideOneVector{Float64})
+function solve!(M::Ma57Solver,rhs::Vector{Float64})
     ma57cd!(one(Int32),Int32(M.csc.n),M.fact,M.lfact,M.ifact,
             M.lifact,one(Int32),rhs,Int32(M.csc.n),M.work,M.lwork,M.iwork,M.icntl,M.info)
     M.info[1]<0 && throw(SolveException())
diff --git a/lib/MadNLPHSL/src/ma77.jl b/lib/MadNLPHSL/src/ma77.jl
index cc61e4a8..83c1a000 100644
--- a/lib/MadNLPHSL/src/ma77.jl
+++ b/lib/MadNLPHSL/src/ma77.jl
@@ -1,8 +1,3 @@
-# MadNLP.jl
-# Created by Sungho Shin (sungho.shin@wisc.edu)
-
-
-
 @kwdef mutable struct Ma77Options <: AbstractOptions
     ma77_buffer_lpage::Int = 4096
     ma77_buffer_npage::Int = 1600
@@ -175,14 +170,14 @@ ma77_open_d(n::Cint,fname1::String,fname2::String,fname3::String,fname4::String,
                 (Cint,Ptr{Cchar},Ptr{Cchar},Ptr{Cchar},Ptr{Cchar},
                  Ptr{Ptr{Cvoid}},Ref{Ma77Control},Ref{Ma77Info}),
                 n,fname1,fname2,fname3,fname4,keep,control,info)
-ma77_input_vars_d(idx::Cint,nvar::Cint,list::StrideOneVector{Cint},
+ma77_input_vars_d(idx::Cint,nvar::Cint,list::Vector{Cint},
                   keep::Vector{Ptr{Cvoid}},control::Ma77Control,info::Ma77Info) = ccall(
                       (:ma77_input_vars_d,libhsl),
                       Cvoid,
                       (Cint,Cint,Ptr{Cint},
                        Ptr{Ptr{Cvoid}},Ref{Ma77Control},Ref{Ma77Info}),
                       idx,nvar,list,keep,control,info)
-ma77_input_reals_d(idx::Cint,length::Cint,reals::StrideOneVector{Cdouble},
+ma77_input_reals_d(idx::Cint,length::Cint,reals::Vector{Cdouble},
                    keep::Vector{Ptr{Cvoid}},control::Ma77Control,info::Ma77Info) = ccall(
                        (:ma77_input_reals_d,libhsl),
                        Cvoid,
@@ -271,9 +266,14 @@ function Ma77Solver(csc::SparseMatrixCSC{Float64,Int32};
     info.flag < 0 && throw(SymbolicException())
 
     for i=1:full.n
-        ma77_input_vars_d(Int32(i),full.colptr[i+1]-full.colptr[i],
-                          view(full.rowval,full.colptr[i]:full.colptr[i+1]-1),
-                          keep,control,info);
+        ma77_input_vars_d(
+            Int32(i),full.colptr[i+1]-full.colptr[i],
+            _madnlp_unsafe_wrap(
+                full.rowval,
+                full.colptr[i+1]-full.colptr[i],
+                full.colptr[i]
+            ),
+            keep,control,info);
         info.flag < 0 && throw(LinearSymbolicException())
     end
 
@@ -281,7 +281,7 @@ function Ma77Solver(csc::SparseMatrixCSC{Float64,Int32};
     info.flag<0 && throw(SymbolicException())
 
     M = Ma77Solver(csc,full,tril_to_full_view,
-               control,info,mc68_control,mc68_info,order,keep,opt,logger)
+                   control,info,mc68_control,mc68_info,order,keep,opt,logger)
     finalizer(finalize,M)
     return M
 end
@@ -289,16 +289,22 @@ end
 function factorize!(M::Ma77Solver)
     M.full.nzval.=M.tril_to_full_view
     for i=1:M.full.n
-        ma77_input_reals_d(Int32(i),M.full.colptr[i+1]-M.full.colptr[i],
-                           view(M.full.nzval,M.full.colptr[i]:M.full.colptr[i+1]-1),
-                           M.keep,M.control,M.info)
+        ma77_input_reals_d(
+            Int32(i),M.full.colptr[i+1]-M.full.colptr[i],
+            _madnlp_unsafe_wrap(
+                M.full.nzval,
+                M.full.colptr[i+1]-M.full.colptr[i],
+                M.full.colptr[i]
+            ),
+            M.keep,M.control,M.info
+        )
         M.info.flag < 0 && throw(FactorizationException())
     end
     ma77_factor_d(Int32(0),M.keep,M.control,M.info,C_NULL)
     M.info.flag < 0 && throw(FactorizationException())
     return M
 end
-function solve!(M::Ma77Solver,rhs::StrideOneVector{Float64})
+function solve!(M::Ma77Solver,rhs::Vector{Float64})
     ma77_solve_d(Int32(0),Int32(1),Int32(M.full.n),rhs,M.keep,M.control,M.info,C_NULL);
     M.info.flag < 0 && throw(SolveException())
     return rhs
diff --git a/lib/MadNLPHSL/src/ma86.jl b/lib/MadNLPHSL/src/ma86.jl
index 2c203064..6020b7bd 100644
--- a/lib/MadNLPHSL/src/ma86.jl
+++ b/lib/MadNLPHSL/src/ma86.jl
@@ -1,6 +1,3 @@
-# MadNLP.jl
-# Created by Sungho Shin (sungho.shin@wisc.edu)
-
 @kwdef mutable struct Ma86Options <: AbstractOptions
     ma86_num_threads::Int = 1
     ma86_print_level::Float64 = -1
@@ -72,16 +69,16 @@ ma86_default_control_d(control::Ma86Control) = ccall(
     Nothing,
     (Ref{Ma86Control},),
     control)
-ma86_analyse_d(n::Cint,colptr::StrideOneVector{Cint},rowval::StrideOneVector{Cint},
-               order::StrideOneVector{Cint},keep::Vector{Ptr{Nothing}},
+ma86_analyse_d(n::Cint,colptr::Vector{Cint},rowval::Vector{Cint},
+               order::Vector{Cint},keep::Vector{Ptr{Nothing}},
                control::Ma86Control,info::Ma86Info) = ccall(
                    (:ma86_analyse_d,libhsl),
                    Nothing,
                    (Cint,Ptr{Cint},Ptr{Cint},Ptr{Cdouble},
                     Ptr{Ptr{Nothing}},Ref{Ma86Control},Ref{Ma86Info}),
                    n,colptr,rowval,order,keep,control,info)
-ma86_factor_d(n::Cint,colptr::StrideOneVector{Cint},rowval::StrideOneVector{Cint},
-              nzval::StrideOneVector{Cdouble},order::StrideOneVector{Cint},
+ma86_factor_d(n::Cint,colptr::Vector{Cint},rowval::Vector{Cint},
+              nzval::Vector{Cdouble},order::Vector{Cint},
               keep::Vector{Ptr{Nothing}},control::Ma86Control,info::Ma86Info,
               scale::Ptr{Nothing}) = ccall(
                   (:ma86_factor_d,libhsl),
@@ -152,7 +149,7 @@ function factorize!(M::Ma86Solver)
     M.info.flag<0 && throw(FactorizationException())
     return M
 end
-function solve!(M::Ma86Solver,rhs::StrideOneVector{Float64})
+function solve!(M::Ma86Solver,rhs::Vector{Float64})
     ma86_solve_d(Int32(0),Int32(1),Int32(M.csc.n),rhs,
                  M.order,M.keep,M.control,M.info,C_NULL)
     M.info.flag<0 && throw(SolveException())
diff --git a/lib/MadNLPHSL/src/ma97.jl b/lib/MadNLPHSL/src/ma97.jl
index e3c2c21e..dcb8986f 100644
--- a/lib/MadNLPHSL/src/ma97.jl
+++ b/lib/MadNLPHSL/src/ma97.jl
@@ -1,7 +1,3 @@
-# MadNLP.jl
-# Created by Sungho Shin (sungho.shin@wisc.edu)
-
-
 @kwdef mutable struct Ma97Options <: AbstractOptions
     ma97_num_threads::Int = 1
     ma97_print_level::Int = -1
@@ -78,7 +74,7 @@ ma97_default_control_d(control::Ma97Control) = ccall(
     (Ref{Ma97Control},),
     control)
 
-ma97_analyse_d(check::Cint,n::Cint,ptr::StrideOneVector{Cint},row::StrideOneVector{Cint},
+ma97_analyse_d(check::Cint,n::Cint,ptr::Vector{Cint},row::Vector{Cint},
                val::Ptr{Nothing},akeep::Vector{Ptr{Nothing}},
                control::Ma97Control,info::Ma97Info,
                order::Ptr{Nothing}) = ccall(
@@ -88,14 +84,14 @@ ma97_analyse_d(check::Cint,n::Cint,ptr::StrideOneVector{Cint},row::StrideOneVect
                           Ptr{Ptr{Nothing}},Ref{Ma97Control},Ref{Ma97Info},Ptr{Cint}),
                          check,n,ptr,row,val,akeep,control,info,order)
 ma97_factor_d(matrix_type::Cint,ptr::Ptr{Nothing},row::Ptr{Nothing},
-              val::StrideOneVector{Cdouble},akeep::Vector{Ptr{Nothing}},fkeep::Vector{Ptr{Nothing}},
+              val::Vector{Cdouble},akeep::Vector{Ptr{Nothing}},fkeep::Vector{Ptr{Nothing}},
               control::Ma97Control,info::Ma97Info,scale::Ptr{Nothing}) = ccall(
                   (:ma97_factor_d,libhsl),
                   Nothing,
                   (Cint,Ptr{Cint},Ptr{Cint},Ptr{Cdouble},Ptr{Ptr{Nothing}},
                    Ptr{Ptr{Nothing}},Ref{Ma97Control},Ref{Ma97Info},Ptr{Cdouble}),
                   matrix_type,ptr,row,val,akeep,fkeep,control,info,scale)
-ma97_solve_d(job::Cint,nrhs::Cint,x::StrideOneVector{Cdouble},ldx::Cint,
+ma97_solve_d(job::Cint,nrhs::Cint,x::Vector{Cdouble},ldx::Cint,
              akeep::Vector{Ptr{Nothing}},fkeep::Vector{Ptr{Nothing}},
              control::Ma97Control,info::Ma97Info) = ccall(
                  (:ma97_solve_d,libhsl),
@@ -151,7 +147,7 @@ function factorize!(M::Ma97Solver)
     M.info.flag<0 && throw(FactorizationException())
     return M
 end
-function solve!(M::Ma97Solver,rhs::StrideOneVector{Float64})
+function solve!(M::Ma97Solver,rhs::Vector{Float64})
     ma97_solve_d(Int32(0),Int32(1),rhs,M.n,M.akeep,M.fkeep,M.control,M.info)
     M.info.flag<0 && throw(SolveException())
     return rhs
diff --git a/lib/MadNLPKrylov/src/MadNLPKrylov.jl b/lib/MadNLPKrylov/src/MadNLPKrylov.jl
index c8de7029..3d0b2c30 100644
--- a/lib/MadNLPKrylov/src/MadNLPKrylov.jl
+++ b/lib/MadNLPKrylov/src/MadNLPKrylov.jl
@@ -3,7 +3,7 @@ module MadNLPKrylov
 import MadNLP:
     @kwdef, Logger, @debug, @warn, @error,
     AbstractOptions, AbstractIterator, set_options!, @sprintf,
-    solve_refine!, mul!, ldiv!, size, StrideOneVector
+    solve_refine!, mul!, ldiv!, size
 import IterativeSolvers:
     FastHessenberg, ArnoldiDecomp, Residual, init!, init_residual!, expand!, Identity,
     orthogonalize_and_normalize!, update_residual!, gmres_iterable!, GMRESIterable, converged,
@@ -28,7 +28,7 @@ size(A::VirtualMatrix,i) = (A.m,A.n)[i]
 struct VirtualPreconditioner
     ldiv!::Function
 end
-ldiv!(Pl::VirtualPreconditioner,x::StrideOneVector{Float64}) = Pl.ldiv!(x)
+ldiv!(Pl::VirtualPreconditioner,x::Vector{Float64}) = Pl.ldiv!(x)
 
 mutable struct KrylovIterator <: AbstractIterator
     g::Union{Nothing,GMRESIterable}
diff --git a/lib/MadNLPMumps/src/MadNLPMumps.jl b/lib/MadNLPMumps/src/MadNLPMumps.jl
index 80288bec..1a99d802 100644
--- a/lib/MadNLPMumps/src/MadNLPMumps.jl
+++ b/lib/MadNLPMumps/src/MadNLPMumps.jl
@@ -5,7 +5,7 @@ import MUMPS_seq_jll
 import MadNLP:
     parsefile, dlopen,
     @kwdef, Logger, @debug, @warn, @error,
-    SparseMatrixCSC, SubVector, StrideOneVector,
+    SparseMatrixCSC, SubVector,
     SymbolicException,FactorizationException,SolveException,InertiaException,
     AbstractOptions, AbstractLinearSolver, set_options!, input_type,
     introduce, factorize!, solve!, improve!, is_inertia, inertia, findIJ, nnz
@@ -425,7 +425,7 @@ function factorize!(M::MumpsSolver)
     return M
 end
 
-function solve!(M::MumpsSolver, rhs::StrideOneVector{Float64})
+function solve!(M::MumpsSolver,rhs::Vector{Float64})
     M.is_singular && return rhs
     M.mumps_struc.rhs = pointer(rhs)
     M.mumps_struc.job = 3
diff --git a/lib/MadNLPPardiso/src/MadNLPPardiso.jl b/lib/MadNLPPardiso/src/MadNLPPardiso.jl
index 9d360f6a..f6b67c26 100644
--- a/lib/MadNLPPardiso/src/MadNLPPardiso.jl
+++ b/lib/MadNLPPardiso/src/MadNLPPardiso.jl
@@ -6,7 +6,7 @@ include(joinpath("..","deps","deps.jl"))
 import Libdl: dlopen, RTLD_DEEPBIND
 import MadNLP:
     MadNLP, @kwdef, Logger, @debug, @warn, @error,
-    SubVector, StrideOneVector, SparseMatrixCSC,
+    SubVector, SparseMatrixCSC, 
     SymbolicException,FactorizationException,SolveException,InertiaException,
     AbstractOptions, AbstractLinearSolver, set_options!,
     introduce, factorize!, solve!, improve!, is_inertia, inertia, input_type,
diff --git a/lib/MadNLPPardiso/src/pardiso.jl b/lib/MadNLPPardiso/src/pardiso.jl
index d4cb2d81..a4a5571a 100644
--- a/lib/MadNLPPardiso/src/pardiso.jl
+++ b/lib/MadNLPPardiso/src/pardiso.jl
@@ -33,7 +33,7 @@ _pardiso(
     pt::Vector{Int},maxfct::Ref{Cint},mnum::Ref{Cint},mtype::Ref{Cint},
     phase::Ref{Cint},n::Ref{Cint},a::Vector{Cdouble},ia::Vector{Cint},ja::Vector{Cint},
     perm::Vector{Cint},nrhs::Ref{Cint},iparm::Vector{Cint},msglvl::Ref{Cint},
-    b::StrideOneVector{Cdouble},x::StrideOneVector{Cdouble},err::Ref{Cint},dparm::Vector{Cdouble}) =
+    b::Vector{Cdouble},x::Vector{Cdouble},err::Ref{Cint},dparm::Vector{Cdouble}) =
         ccall(
             (:pardiso,libpardiso),
             Cvoid,
@@ -98,7 +98,7 @@ function factorize!(M::PardisoSolver)
     M.err.x < 0  && throw(FactorizationException())
     return M
 end
-function solve!(M::PardisoSolver,rhs::StrideOneVector{Float64})
+function solve!(M::PardisoSolver,rhs::Vector{Float64})
     _pardiso(M.pt,Ref{Int32}(1),Ref{Int32}(1),Ref{Int32}(-2),Ref{Int32}(33),
              Ref{Int32}(M.csc.n),M.csc.nzval,M.csc.colptr,M.csc.rowval,M.perm,
              Ref{Int32}(1),M.iparm,M.msglvl,rhs,M.w,M.err,M.dparm)
diff --git a/lib/MadNLPPardiso/src/pardisomkl.jl b/lib/MadNLPPardiso/src/pardisomkl.jl
index 2de223d8..c57ecb76 100644
--- a/lib/MadNLPPardiso/src/pardisomkl.jl
+++ b/lib/MadNLPPardiso/src/pardisomkl.jl
@@ -1,5 +1,3 @@
-
-
 @enum(MatchingStrategy::Int,COMPLETE=1,COMPLETE2x2=2,CONSTRAINTS=3)
 
 @kwdef mutable struct PardisoMKLOptions <: AbstractOptions
@@ -31,7 +29,7 @@ pardisomkl_pardisoinit(pt,mtype::Ref{Cint},iparm::Vector{Cint}) =
 pardisomkl_pardiso(pt,maxfct::Ref{Cint},mnum::Ref{Cint},mtype::Ref{Cint},
                    phase::Ref{Cint},n::Ref{Cint},a::Vector{Cdouble},ia::Vector{Cint},ja::Vector{Cint},
                    perm::Vector{Cint},nrhs::Ref{Cint},iparm::Vector{Cint},msglvl::Ref{Cint},
-                   b::StrideOneVector{Cdouble},x::StrideOneVector{Cdouble},err::Ref{Cint}) =
+                   b::Vector{Cdouble},x::Vector{Cdouble},err::Ref{Cint}) =
                        ccall(
                            (:pardiso,libmkl_rt),
                            Cvoid,
@@ -116,7 +114,7 @@ function factorize!(M::PardisoMKLSolver)
     M.err.x < 0  && throw(FactorizationException())
     return M
 end
-function solve!(M::PardisoMKLSolver,rhs::StrideOneVector{Float64})
+function solve!(M::PardisoMKLSolver,rhs::Vector{Float64})
     pardisomkl_set_num_threads!(M.opt.pardisomkl_num_threads)
     pardisomkl_pardiso(M.pt,Ref{Int32}(1),Ref{Int32}(1),Ref{Int32}(-2),Ref{Int32}(33),
                      Ref{Int32}(M.csc.n),M.csc.nzval,M.csc.colptr,M.csc.rowval,M.perm,
diff --git a/src/IPM/IPM.jl b/src/IPM/IPM.jl
index 9c54e6da..e046f14a 100644
--- a/src/IPM/IPM.jl
+++ b/src/IPM/IPM.jl
@@ -31,8 +31,8 @@ mutable struct InteriorPointSolver{KKTSystem} <: AbstractInteriorPointSolver
 
     jacl::Vector{Float64}
 
-    d::AbstractKKTVector{Float64, Vector{Float64}}
-    p::AbstractKKTVector{Float64, Vector{Float64}}
+    d::UnreducedKKTVector{Float64, Vector{Float64}}
+    p::UnreducedKKTVector{Float64, Vector{Float64}}
 
     _w1::AbstractKKTVector{Float64, Vector{Float64}}
     _w2::AbstractKKTVector{Float64, Vector{Float64}}
@@ -44,7 +44,7 @@ mutable struct InteriorPointSolver{KKTSystem} <: AbstractInteriorPointSolver
     c_trial::Vector{Float64}
     obj_val_trial::Float64
 
-    x_slk::StrideOneVector{Float64}
+    x_slk::Vector{Float64}
     c_slk::SubVector{Float64}
     rhs::Vector{Float64}
 
@@ -102,19 +102,18 @@ function InteriorPointSolver(nlp::AbstractNLPModel;
     set_options!(opt,option_dict,kwargs)
     check_option_sanity(opt)
 
+    VT = Vector{Float64}
     KKTSystem = if opt.kkt_system == SPARSE_KKT_SYSTEM
         MT = (input_type(opt.linear_solver) == :csc) ? SparseMatrixCSC{Float64, Int32} : Matrix{Float64}
-        SparseKKTSystem{Float64, MT}
+        SparseKKTSystem{Float64, VT, MT}
     elseif opt.kkt_system == SPARSE_UNREDUCED_KKT_SYSTEM
         MT = (input_type(opt.linear_solver) == :csc) ? SparseMatrixCSC{Float64, Int32} : Matrix{Float64}
-        SparseUnreducedKKTSystem{Float64, MT}
+        SparseUnreducedKKTSystem{Float64, VT, MT}
     elseif opt.kkt_system == DENSE_KKT_SYSTEM
         MT = Matrix{Float64}
-        VT = Vector{Float64}
         DenseKKTSystem{Float64, VT, MT}
     elseif opt.kkt_system == DENSE_CONDENSED_KKT_SYSTEM
         MT = Matrix{Float64}
-        VT = Vector{Float64}
         DenseCondensedKKTSystem{Float64, VT, MT}
     end
     return InteriorPointSolver{KKTSystem}(nlp, opt; option_linear_solver=option_dict)
@@ -162,7 +161,7 @@ function InteriorPointSolver{KKTSystem}(nlp::AbstractNLPModel, opt::Options;
     x_trial=Vector{Float64}(undef,n)
     c_trial=Vector{Float64}(undef,m)
 
-    x_slk= view(x,get_nvar(nlp)+1:n)
+    x_slk= _madnlp_unsafe_wrap(x,ns, get_nvar(nlp)+1)
     c_slk= view(c,ind_cons.ind_ineq)
     rhs = (get_lcon(nlp).==get_ucon(nlp)).*get_lcon(nlp)
 
diff --git a/src/IPM/callbacks.jl b/src/IPM/callbacks.jl
index e2043336..f742388d 100644
--- a/src/IPM/callbacks.jl
+++ b/src/IPM/callbacks.jl
@@ -1,9 +1,9 @@
-
 function eval_f_wrapper(ips::InteriorPointSolver, x::Vector{Float64})
     nlp = ips.nlp
     cnt = ips.cnt
     @trace(ips.logger,"Evaluating objective.")
-    cnt.eval_function_time += @elapsed obj_val = (get_minimize(nlp) ? 1. : -1.) * obj(nlp,view(x,1:get_nvar(nlp)))
+    x_nlpmodel = _madnlp_unsafe_wrap(x, get_nvar(nlp))
+    cnt.eval_function_time += @elapsed obj_val = (get_minimize(nlp) ? 1. : -1.) * obj(nlp,x_nlpmodel)
     cnt.obj_cnt+=1
     cnt.obj_cnt==1 && (is_valid(obj_val) || throw(InvalidNumberException()))
     return obj_val*ips.obj_scale[]
@@ -13,7 +13,13 @@ function eval_grad_f_wrapper!(ips::InteriorPointSolver, f::Vector{Float64},x::Ve
     nlp = ips.nlp
     cnt = ips.cnt
     @trace(ips.logger,"Evaluating objective gradient.")
-    cnt.eval_function_time += @elapsed grad!(nlp,view(x,1:get_nvar(nlp)),view(f,1:get_nvar(nlp)))
+    x_nlpmodel = _madnlp_unsafe_wrap(x, get_nvar(nlp))
+    f_nlpmodel = _madnlp_unsafe_wrap(f, get_nvar(nlp))
+    cnt.eval_function_time += @elapsed grad!(
+        nlp,
+        x_nlpmodel,
+        f_nlpmodel
+    )
     f.*=ips.obj_scale[] * (get_minimize(nlp) ? 1. : -1.)
     cnt.obj_grad_cnt+=1
     cnt.obj_grad_cnt==1 && (is_valid(f)  || throw(InvalidNumberException()))
@@ -24,7 +30,13 @@ function eval_cons_wrapper!(ips::InteriorPointSolver, c::Vector{Float64},x::Vect
     nlp = ips.nlp
     cnt = ips.cnt
     @trace(ips.logger, "Evaluating constraints.")
-    cnt.eval_function_time += @elapsed cons!(nlp,view(x,1:get_nvar(nlp)),view(c,1:get_ncon(nlp)))
+    x_nlpmodel = _madnlp_unsafe_wrap(x, get_nvar(nlp))
+    c_nlpmodel = _madnlp_unsafe_wrap(c, get_ncon(nlp))
+    cnt.eval_function_time += @elapsed cons!(
+        nlp,
+        x_nlpmodel,
+        c_nlpmodel
+    )
     view(c,ips.ind_ineq).-=view(x,get_nvar(nlp)+1:ips.n)
     c.-=ips.rhs
     c.*=ips.con_scale
@@ -39,7 +51,13 @@ function eval_jac_wrapper!(ipp::InteriorPointSolver, kkt::AbstractKKTSystem, x::
     ns = length(ipp.ind_ineq)
     @trace(ipp.logger, "Evaluating constraint Jacobian.")
     jac = get_jacobian(kkt)
-    cnt.eval_function_time += @elapsed jac_coord!(nlp,view(x,1:get_nvar(nlp)),view(jac,1:get_nnzj(nlp)))
+    x_nlpmodel = _madnlp_unsafe_wrap(x, get_nvar(nlp))
+    jac_nlpmodel = _madnlp_unsafe_wrap(jac, get_nnzj(nlp))
+    cnt.eval_function_time += @elapsed jac_coord!(
+        nlp,
+        x_nlpmodel, 
+        jac_nlpmodel
+    )
     compress_jacobian!(kkt)
     cnt.con_jac_cnt+=1
     cnt.con_jac_cnt==1 && (is_valid(jac) || throw(InvalidNumberException()))
@@ -53,9 +71,15 @@ function eval_lag_hess_wrapper!(ipp::InteriorPointSolver, kkt::AbstractKKTSystem
     @trace(ipp.logger,"Evaluating Lagrangian Hessian.")
     dual(ipp._w1) .= l.*ipp.con_scale
     hess = get_hessian(kkt)
+    x_nlpmodel = _madnlp_unsafe_wrap(x, get_nvar(nlp))
+    hess_nlpmodel = _madnlp_unsafe_wrap(hess, get_nnzh(nlp))
     cnt.eval_function_time += @elapsed hess_coord!(
-        nlp, view(x,1:get_nvar(nlp)), dual(ipp._w1), view(hess, 1:get_nnzh(nlp));
-        obj_weight = (get_minimize(nlp) ? 1. : -1.) * (is_resto ? 0.0 : ipp.obj_scale[]))
+        nlp,
+        x_nlpmodel,
+        dual(ipp._w1),
+        hess_nlpmodel;
+        obj_weight = (get_minimize(nlp) ? 1. : -1.) * (is_resto ? 0.0 : ipp.obj_scale[])
+    )
     compress_hessian!(kkt)
     cnt.lag_hess_cnt+=1
     cnt.lag_hess_cnt==1 && (is_valid(hess) || throw(InvalidNumberException()))
@@ -68,7 +92,12 @@ function eval_jac_wrapper!(ipp::InteriorPointSolver, kkt::AbstractDenseKKTSystem
     ns = length(ipp.ind_ineq)
     @trace(ipp.logger, "Evaluating constraint Jacobian.")
     jac = get_jacobian(kkt)
-    cnt.eval_function_time += @elapsed jac_dense!(nlp,view(x,1:get_nvar(nlp)),jac)
+    x_nlpmodel = _madnlp_unsafe_wrap(x, get_nvar(nlp))
+    cnt.eval_function_time += @elapsed jac_dense!(
+        nlp,
+        x_nlpmodel,
+        jac
+    )
     compress_jacobian!(kkt)
     cnt.con_jac_cnt+=1
     cnt.con_jac_cnt==1 && (is_valid(jac) || throw(InvalidNumberException()))
@@ -82,9 +111,14 @@ function eval_lag_hess_wrapper!(ipp::InteriorPointSolver, kkt::AbstractDenseKKTS
     @trace(ipp.logger,"Evaluating Lagrangian Hessian.")
     dual(ipp._w1) .= l.*ipp.con_scale
     hess = get_hessian(kkt)
+    x_nlpmodel = _madnlp_unsafe_wrap(x, get_nvar(nlp))
     cnt.eval_function_time += @elapsed hess_dense!(
-        nlp, view(x,1:get_nvar(nlp)), dual(ipp._w1), hess;
-        obj_weight = (get_minimize(nlp) ? 1. : -1.) * (is_resto ? 0.0 : ipp.obj_scale[]))
+        nlp,
+        x_nlpmodel,
+        dual(ipp._w1),
+        hess;
+        obj_weight = (get_minimize(nlp) ? 1. : -1.) * (is_resto ? 0.0 : ipp.obj_scale[])
+    )
     compress_hessian!(kkt)
     cnt.lag_hess_cnt+=1
     cnt.lag_hess_cnt==1 && (is_valid(hess) || throw(InvalidNumberException()))
diff --git a/src/IPM/solver.jl b/src/IPM/solver.jl
index 17428d49..fc205659 100644
--- a/src/IPM/solver.jl
+++ b/src/IPM/solver.jl
@@ -1,8 +1,7 @@
-
 function initialize!(ips::AbstractInteriorPointSolver)
     # initializing slack variables
     @trace(ips.logger,"Initializing slack variables.")
-    cons!(ips.nlp,get_x0(ips.nlp),view(ips.c,1:get_ncon(ips.nlp)))
+    cons!(ips.nlp,get_x0(ips.nlp),_madnlp_unsafe_wrap(ips.c,get_ncon(ips.nlp)))
     ips.cnt.con_cnt += 1
     ips.x_slk.=ips.c_slk
 
diff --git a/src/IPM/utils.jl b/src/IPM/utils.jl
index 7fb48d55..3e307892 100644
--- a/src/IPM/utils.jl
+++ b/src/IPM/utils.jl
@@ -1,13 +1,13 @@
 struct MadNLPExecutionStats{T} <: AbstractExecutionStats
     status::Status
-    solution::StrideOneVector{T}
+    solution::Vector{T}
     objective::T
-    constraints::StrideOneVector{T}
+    constraints::Vector{T}
     dual_feas::T
     primal_feas::T
-    multipliers::StrideOneVector{T}
-    multipliers_L::StrideOneVector{T}
-    multipliers_U::StrideOneVector{T}
+    multipliers::Vector{T}
+    multipliers_L::Vector{T}
+    multipliers_U::Vector{T}
     iter::Int
     counters::NLPModelsCounters
     elapsed_time::Real
@@ -17,10 +17,15 @@ struct InvalidNumberException <: Exception end
 struct NotEnoughDegreesOfFreedomException <: Exception end
 
 MadNLPExecutionStats(ips::InteriorPointSolver) =MadNLPExecutionStats(
-    ips.status,view(ips.x,1:get_nvar(ips.nlp)),ips.obj_val,ips.c,
+    ips.status,
+    _madnlp_unsafe_wrap(ips.x, get_nvar(ips.nlp)),
+    ips.obj_val,ips.c,
     ips.inf_du, ips.inf_pr,
-    ips.l,view(ips.zl,1:get_nvar(ips.nlp)),view(ips.zu,1:get_nvar(ips.nlp)),
-    ips.cnt.k, ips.nlp.counters,ips.cnt.total_time)
+    ips.l,
+    _madnlp_unsafe_wrap(ips.zl, get_nvar(ips.nlp)),
+    _madnlp_unsafe_wrap(ips.zu, get_nvar(ips.nlp)),
+    ips.cnt.k, ips.nlp.counters,ips.cnt.total_time
+)
 getStatus(result::MadNLPExecutionStats) = STATUS_OUTPUT_DICT[result.status]
 
 # Utilities
diff --git a/src/Interfaces/MOI_interface.jl b/src/Interfaces/MOI_interface.jl
index 8a4f46f3..a18ac7f3 100644
--- a/src/Interfaces/MOI_interface.jl
+++ b/src/Interfaces/MOI_interface.jl
@@ -1105,14 +1105,14 @@ struct MOIModel{T} <: AbstractNLPModel{T,Vector{T}}
     counters::NLPModelsCounters
 end
 
-obj(nlp::MOIModel,x::StrideOneVector{Float64}) = eval_objective(nlp.model,x)
-grad!(nlp::MOIModel,x::StrideOneVector{Float64},f::StrideOneVector{Float64}) =
+obj(nlp::MOIModel,x::Vector{Float64}) = eval_objective(nlp.model,x)
+grad!(nlp::MOIModel,x::Vector{Float64},f::Vector{Float64}) =
     eval_objective_gradient(nlp.model,f,x)
-cons!(nlp::MOIModel,x::StrideOneVector{Float64},c::StrideOneVector{Float64}) =
+cons!(nlp::MOIModel,x::Vector{Float64},c::Vector{Float64}) =
     eval_constraint(nlp.model,c,x)
-jac_coord!(nlp::MOIModel,x::StrideOneVector{Float64},jac::StrideOneVector{Float64})=
+jac_coord!(nlp::MOIModel,x::Vector{Float64},jac::Vector{Float64})=
     eval_constraint_jacobian(nlp.model,jac,x)
-hess_coord!(nlp::MOIModel,x::StrideOneVector{Float64},l::StrideOneVector{Float64},hess::StrideOneVector{Float64};
+hess_coord!(nlp::MOIModel,x::Vector{Float64},l::Vector{Float64},hess::Vector{Float64};
             obj_weight::Float64=1.) = eval_hessian_lagrangian(nlp.model,hess,x,obj_weight,l)
 function hess_structure!(nlp::MOIModel, I::AbstractVector{T}, J::AbstractVector{T}) where T
     return hessian_lagrangian_structure(nlp.model,I,J)
diff --git a/src/KKT/KKTsystem.jl b/src/KKT/KKTsystem.jl
index d4a2923c..6f980acc 100644
--- a/src/KKT/KKTsystem.jl
+++ b/src/KKT/KKTsystem.jl
@@ -1,13 +1,13 @@
 
 """
-    AbstractKKTSystem{T, MT<:AbstractMatrix{T}}
+    AbstractKKTSystem{T, VT<:AbstractVector{T}, MT<:AbstractMatrix{T}}
 
 Abstract type for KKT system.
 """
-abstract type AbstractKKTSystem{T, MT<:AbstractMatrix{T}} end
+abstract type AbstractKKTSystem{T, VT, MT<:AbstractMatrix{T}} end
 
 """
-    AbstractUnreducedKKTSystem{T, MT} <: AbstractKKTSystem{T, MT}
+    AbstractUnreducedKKTSystem{T, VT, MT} <: AbstractKKTSystem{T, VT, MT}
 
 Augmented KKT system associated to the linearization of the KKT
 conditions at the current primal-dual iterate ``(x, s, y, z, ν, w)``.
@@ -30,10 +30,10 @@ with
 * ``V = diag(ν)``
 * ``W = diag(w)``
 """
-abstract type AbstractUnreducedKKTSystem{T, MT} <: AbstractKKTSystem{T, MT} end
+abstract type AbstractUnreducedKKTSystem{T, VT, MT} <: AbstractKKTSystem{T, VT, MT} end
 
 """
-    AbstractReducedKKTSystem{T, MT} <: AbstractKKTSystem{T, MT}
+    AbstractReducedKKTSystem{T, VT, MT} <: AbstractKKTSystem{T, VT, MT}
 
 The reduced KKT system is a simplification of the original Augmented KKT system.
 Comparing to [`AbstractUnreducedKKTSystem`](@ref)), `AbstractReducedKKTSystem` removes
@@ -54,10 +54,10 @@ with
 * ``Σₛ = S⁻¹ W``
 
 """
-abstract type AbstractReducedKKTSystem{T, MT} <: AbstractKKTSystem{T, MT} end
+abstract type AbstractReducedKKTSystem{T, VT, MT} <: AbstractKKTSystem{T, VT, MT} end
 
 """
-    AbstractCondensedKKTSystem{T, MT} <: AbstractKKTSystem{T, MT}
+    AbstractCondensedKKTSystem{T, VT, MT} <: AbstractKKTSystem{T, VT, MT}
 
 The condensed KKT system simplifies further the [`AbstractReducedKKTSystem`](@ref)
 by removing the rows associated to the slack variables ``s`` and the inequalities.
@@ -74,7 +74,7 @@ with
 * ``Σₓ = X⁻¹ V``
 * ``Σₛ = S⁻¹ W``
 """
-abstract type AbstractCondensedKKTSystem{T, MT} <: AbstractKKTSystem{T, MT} end
+abstract type AbstractCondensedKKTSystem{T, VT, MT} <: AbstractKKTSystem{T, VT, MT} end
 
 #=
     Templates
@@ -210,7 +210,7 @@ get_raw_jacobian(kkt::AbstractKKTSystem) = kkt.jac_raw
 
 
 # Fix variable treatment
-function treat_fixed_variable!(kkt::AbstractKKTSystem{T, MT}) where {T, MT<:SparseMatrixCSC{T, Int32}}
+function treat_fixed_variable!(kkt::AbstractKKTSystem{T, VT, MT}) where {T, VT, MT<:SparseMatrixCSC{T, Int32}}
     length(kkt.ind_fixed) == 0 && return
     aug = kkt.aug_com
 
@@ -220,7 +220,7 @@ function treat_fixed_variable!(kkt::AbstractKKTSystem{T, MT}) where {T, MT<:Spar
     fixed_aug .= 0.0
     return
 end
-function treat_fixed_variable!(kkt::AbstractKKTSystem{T, MT}) where {T, MT<:Matrix{T}}
+function treat_fixed_variable!(kkt::AbstractKKTSystem{T, VT, MT}) where {T, VT, MT<:Matrix{T}}
     length(kkt.ind_fixed) == 0 && return
     aug = kkt.aug_com
     @inbounds for i in kkt.ind_fixed
@@ -234,12 +234,12 @@ function is_inertia_correct(kkt::AbstractKKTSystem, num_pos, num_zero, num_neg)
     return (num_zero == 0) && (num_pos == num_variables(kkt))
 end
 
-function build_kkt!(kkt::AbstractKKTSystem{T, MT}) where {T, MT<:Matrix{T}}
+function build_kkt!(kkt::AbstractKKTSystem{T, VT, MT}) where {T, VT, MT<:Matrix{T}}
     copyto!(kkt.aug_com, kkt.aug_raw)
     treat_fixed_variable!(kkt)
 end
 
-function build_kkt!(kkt::AbstractKKTSystem{T, MT}) where {T, MT<:SparseMatrixCSC{T, Int32}}
+function build_kkt!(kkt::AbstractKKTSystem{T, VT, MT}) where {T, VT, MT<:SparseMatrixCSC{T, Int32}}
     transfer!(kkt.aug_com, kkt.aug_raw, kkt.aug_csc_map)
     treat_fixed_variable!(kkt)
 end
diff --git a/src/KKT/dense.jl b/src/KKT/dense.jl
index 0f8d5482..d1f73789 100644
--- a/src/KKT/dense.jl
+++ b/src/KKT/dense.jl
@@ -4,14 +4,14 @@
 =#
 
 """
-    DenseKKTSystem{T, VT, MT} <: AbstractReducedKKTSystem{T, MT}
+    DenseKKTSystem{T, VT, MT} <: AbstractReducedKKTSystem{T, VT, MT}
 
 Implement [`AbstractReducedKKTSystem`](@ref) with dense matrices.
 
 Requires a dense linear solver to be factorized (otherwise an error is returned).
 
 """
-struct DenseKKTSystem{T, VT, MT} <: AbstractReducedKKTSystem{T, MT}
+struct DenseKKTSystem{T, VT, MT} <: AbstractReducedKKTSystem{T, VT, MT}
     hess::MT
     jac::MT
     pr_diag::VT
@@ -29,14 +29,14 @@ struct DenseKKTSystem{T, VT, MT} <: AbstractReducedKKTSystem{T, MT}
 end
 
 """
-    DenseCondensedKKTSystem{T, VT, MT} <: AbstractCondensedKKTSystem{T, MT}
+    DenseCondensedKKTSystem{T, VT, MT} <: AbstractCondensedKKTSystem{T, VT, MT}
 
 Implement [`AbstractCondensedKKTSystem`](@ref) with dense matrices.
 
 Requires a dense linear solver to factorize the associated KKT system (otherwise an error is returned).
 
 """
-struct DenseCondensedKKTSystem{T, VT, MT} <: AbstractCondensedKKTSystem{T, MT}
+struct DenseCondensedKKTSystem{T, VT, MT} <: AbstractCondensedKKTSystem{T, VT, MT}
     hess::MT
     jac::MT
     jac_ineq::MT
diff --git a/src/KKT/rhs.jl b/src/KKT/rhs.jl
index c6e27c11..95a12c2e 100644
--- a/src/KKT/rhs.jl
+++ b/src/KKT/rhs.jl
@@ -100,10 +100,8 @@ function ReducedKKTVector(n::Int, m::Int)
     x = Vector{Float64}(undef, n + m)
     fill!(x, 0.0)
     # Wrap directly array x to avoid dealing with views
-    pp = pointer(x)
-    xp = unsafe_wrap(Vector{Float64}, pp, n)
-    pd = pointer(x, n + 1)
-    xl = unsafe_wrap(Vector{Float64}, pd, m)
+    xp = _madnlp_unsafe_wrap(x, n)
+    xl = _madnlp_unsafe_wrap(x, m, n+1)
     return ReducedKKTVector{Float64, Vector{Float64}}(x, xp, xl)
 end
 function ReducedKKTVector(rhs::AbstractKKTVector)
@@ -139,15 +137,11 @@ function UnreducedKKTVector(n::Int, m::Int, nlb::Int, nub::Int)
     values = Vector{Float64}(undef, n + m + nlb + nub)
     fill!(values, 0.0)
     # Wrap directly array x to avoid dealing with views
-    pp = pointer(values)
-    x = unsafe_wrap(Vector{Float64}, pp, n + m) # Primal-Dual
-    xp = unsafe_wrap(Vector{Float64}, pp, n) # Primal
-    pd = pointer(values, n + 1)
-    xl = unsafe_wrap(Vector{Float64}, pd, m) # Dual
-    pzl = pointer(values, n + m + 1)
-    xzl = unsafe_wrap(Vector{Float64}, pzl, nlb) # Lower bound
-    pzu = pointer(values, n + m + nlb + 1)
-    xzu = unsafe_wrap(Vector{Float64}, pzu, nub) # Upper bound
+    x = _madnlp_unsafe_wrap(values, n + m) # Primal-Dual
+    xp = _madnlp_unsafe_wrap(values, n) # Primal
+    xl = _madnlp_unsafe_wrap(values, m, n+1) # Dual
+    xzl = _madnlp_unsafe_wrap(values, nlb, n + m + 1) # Lower bound
+    xzu = _madnlp_unsafe_wrap(values, nub, n + m + nlb + 1) # Upper bound
     return UnreducedKKTVector{Float64, Vector{Float64}}(values, x, xp, xl, xzl, xzu)
 end
 
diff --git a/src/KKT/sparse.jl b/src/KKT/sparse.jl
index 2ccbe676..5c089c98 100644
--- a/src/KKT/sparse.jl
+++ b/src/KKT/sparse.jl
@@ -1,62 +1,61 @@
 
 """
-    SparseKKTSystem{T, MT} <: AbstractReducedKKTSystem{T, MT}
+    SparseKKTSystem{T, VT, MT} <: AbstractReducedKKTSystem{T, VT, MT}
 
 Implement the [`AbstractReducedKKTSystem`](@ref) in sparse COO format.
 
 """
-struct SparseKKTSystem{T, MT} <: AbstractReducedKKTSystem{T, MT}
-    hess::StrideOneVector{T}
-    jac::StrideOneVector{T}
-    pr_diag::StrideOneVector{T}
-    du_diag::StrideOneVector{T}
+struct SparseKKTSystem{T, VT, MT} <: AbstractReducedKKTSystem{T, VT, MT}
+    hess::VT
+    jac::VT
+    pr_diag::VT
+    du_diag::VT
     # Augmented system
-    aug_raw::SparseMatrixCOO{T,Int32}
+    aug_raw::SparseMatrixCOO{T,Int32,VT}
     aug_com::MT
     aug_csc_map::Union{Nothing, Vector{Int}}
     # Jacobian
-    jac_raw::SparseMatrixCOO{T,Int32}
+    jac_raw::SparseMatrixCOO{T,Int32,VT}
     jac_com::MT
     jac_csc_map::Union{Nothing, Vector{Int}}
     # Info
     ind_ineq::Vector{Int}
     ind_fixed::Vector{Int}
     ind_aug_fixed::Vector{Int}
-    jacobian_scaling::Vector{T}
+    jacobian_scaling::VT
 end
 
 """
-    SparseUnreducedKKTSystem{T, MT} <: AbstractUnreducedKKTSystem{T, MT}
+    SparseUnreducedKKTSystem{T, VT, MT} <: AbstractUnreducedKKTSystem{T, VT, MT}
 
 Implement the [`AbstractUnreducedKKTSystem`](@ref) in sparse COO format.
 
 """
-struct SparseUnreducedKKTSystem{T, MT} <: AbstractUnreducedKKTSystem{T, MT}
-    hess::StrideOneVector{T}
-    jac::StrideOneVector{T}
-    pr_diag::StrideOneVector{T}
-    du_diag::StrideOneVector{T}
-
-    l_diag::StrideOneVector{T}
-    u_diag::StrideOneVector{T}
-    l_lower::StrideOneVector{T}
-    u_lower::StrideOneVector{T}
-
-    aug_raw::SparseMatrixCOO{T,Int32}
+struct SparseUnreducedKKTSystem{T, VT, MT} <: AbstractUnreducedKKTSystem{T, VT, MT}
+    hess::VT
+    jac::VT
+    pr_diag::VT
+    du_diag::VT
+
+    l_diag::VT
+    u_diag::VT
+    l_lower::VT
+    u_lower::VT
+    aug_raw::SparseMatrixCOO{T,Int32,VT}
     aug_com::MT
     aug_csc_map::Union{Nothing, Vector{Int}}
 
-    jac_raw::SparseMatrixCOO{T,Int32}
+    jac_raw::SparseMatrixCOO{T,Int32,VT}
     jac_com::MT
     jac_csc_map::Union{Nothing, Vector{Int}}
     ind_ineq::Vector{Int}
     ind_fixed::Vector{Int}
     ind_aug_fixed::Vector{Int}
-    jacobian_scaling::Vector{T}
+    jacobian_scaling::VT
 end
 
 # Template to dispatch on sparse representation
-const AbstractSparseKKTSystem{T, MT} = Union{SparseKKTSystem{T, MT}, SparseUnreducedKKTSystem{T, MT}}
+const AbstractSparseKKTSystem{T, VT, MT} = Union{SparseKKTSystem{T, VT, MT}, SparseUnreducedKKTSystem{T, VT, MT}}
 
 #=
     Generic sparse methods
@@ -75,21 +74,21 @@ end
 
 nnz_jacobian(kkt::AbstractSparseKKTSystem) = nnz(kkt.jac_raw)
 
-function compress_jacobian!(kkt::AbstractSparseKKTSystem{T, MT}) where {T, MT<:SparseMatrixCSC{T, Int32}}
+function compress_jacobian!(kkt::AbstractSparseKKTSystem{T, VT, MT}) where {T, VT, MT<:SparseMatrixCSC{T, Int32}}
     ns = length(kkt.ind_ineq)
     kkt.jac[end-ns+1:end] .= -1.0
     kkt.jac .*= kkt.jacobian_scaling # scaling
     transfer!(kkt.jac_com, kkt.jac_raw, kkt.jac_csc_map)
 end
 
-function compress_jacobian!(kkt::AbstractSparseKKTSystem{T, MT}) where {T, MT<:Matrix{T}}
+function compress_jacobian!(kkt::AbstractSparseKKTSystem{T, VT, MT}) where {T, VT, MT<:Matrix{T}}
     ns = length(kkt.ind_ineq)
     kkt.jac[end-ns+1:end] .= -1.0
     kkt.jac .*= kkt.jacobian_scaling # scaling
     copyto!(kkt.jac_com, kkt.jac_raw)
 end
 
-function set_jacobian_scaling!(kkt::AbstractSparseKKTSystem{T, MT}, constraint_scaling::AbstractVector) where {T, MT}
+function set_jacobian_scaling!(kkt::AbstractSparseKKTSystem{T, VT, MT}, constraint_scaling::AbstractVector) where {T, VT, MT}
     nnzJ = length(kkt.jac)::Int
     @inbounds for i in 1:nnzJ
         index = kkt.jac_raw.I[i]
@@ -102,11 +101,11 @@ end
     SparseKKTSystem
 =#
 
-function SparseKKTSystem{T, MT}(
+function SparseKKTSystem{T, VT, MT}(
     n::Int, m::Int, ind_ineq::Vector{Int}, ind_fixed::Vector{Int},
     hess_sparsity_I, hess_sparsity_J,
     jac_sparsity_I, jac_sparsity_J,
-) where {T, MT}
+) where {T, VT, MT}
     n_jac = length(jac_sparsity_I)
     n_hess = length(hess_sparsity_I)
 
@@ -115,7 +114,7 @@ function SparseKKTSystem{T, MT}(
 
     I = Vector{Int32}(undef, aug_mat_length)
     J = Vector{Int32}(undef, aug_mat_length)
-    V = Vector{T}(undef, aug_mat_length)
+    V = VT(undef, aug_mat_length)
     fill!(V, 0.0)  # Need to initiate V to avoid NaN
 
     offset = n+n_jac+n_hess+m
@@ -130,11 +129,11 @@ function SparseKKTSystem{T, MT}(
     J[n+n_hess+1:n+n_hess+n_jac] .= jac_sparsity_J
     J[n+n_hess+n_jac+1:offset] .= (n+1:n+m)
 
-    pr_diag = view(V, 1:n)
-    du_diag = view(V, n_jac+n_hess+n+1:n_jac+n_hess+n+m)
+    pr_diag = _madnlp_unsafe_wrap(V, n)
+    du_diag = _madnlp_unsafe_wrap(V, m, n_jac+n_hess+n+1)
 
-    hess = view(V, n+1:n+n_hess)
-    jac = view(V, n_hess+n+1:n_hess+n+n_jac)
+    hess = _madnlp_unsafe_wrap(V, n_hess, n+1)
+    jac = _madnlp_unsafe_wrap(V, n_jac, n_hess+n+1)
 
     aug_raw = SparseMatrixCOO(aug_vec_length,aug_vec_length,I,J,V)
     jac_raw = SparseMatrixCOO(m,n,jac_sparsity_I,jac_sparsity_J,jac)
@@ -152,7 +151,7 @@ function SparseKKTSystem{T, MT}(
     end
     jac_scaling = ones(T, n_jac)
 
-    return SparseKKTSystem{T, MT}(
+    return SparseKKTSystem{T, VT, MT}(
         hess, jac, pr_diag, du_diag,
         aug_raw, aug_com, aug_csc_map,
         jac_raw, jac_com, jac_csc_map,
@@ -161,7 +160,7 @@ function SparseKKTSystem{T, MT}(
 end
 
 # Build KKT system directly from AbstractNLPModel
-function SparseKKTSystem{T, MT}(nlp::AbstractNLPModel, ind_cons=get_index_constraints(nlp)) where {T, MT}
+function SparseKKTSystem{T, VT, MT}(nlp::AbstractNLPModel, ind_cons=get_index_constraints(nlp)) where {T, VT, MT}
     n_slack = length(ind_cons.ind_ineq)
     # Deduce KKT size.
     n = get_nvar(nlp) + n_slack
@@ -180,7 +179,7 @@ function SparseKKTSystem{T, MT}(nlp::AbstractNLPModel, ind_cons=get_index_constr
     append!(jac_I, ind_cons.ind_ineq)
     append!(jac_J, get_nvar(nlp)+1:get_nvar(nlp)+n_slack)
 
-    return SparseKKTSystem{T, MT}(
+    return SparseKKTSystem{T, VT, MT}(
         n, m, ind_cons.ind_ineq, ind_cons.ind_fixed,
         hess_I, hess_J, jac_I, jac_J,
     )
@@ -194,12 +193,12 @@ num_variables(kkt::SparseKKTSystem) = length(kkt.pr_diag)
     SparseUnreducedKKTSystem
 =#
 
-function SparseUnreducedKKTSystem{T, MT}(
+function SparseUnreducedKKTSystem{T, VT, MT}(
     n::Int, m::Int, nlb::Int, nub::Int, ind_ineq, ind_fixed,
     hess_sparsity_I, hess_sparsity_J,
     jac_sparsity_I, jac_sparsity_J,
     ind_lb, ind_ub,
-) where {T, MT}
+) where {T, VT, MT}
     n_jac = length(jac_sparsity_I)
     n_hess = length(hess_sparsity_I)
 
@@ -231,16 +230,16 @@ function SparseUnreducedKKTSystem{T, MT}(
     J[offset+2nlb+1:offset+2nlb+nub] .= (1:nub).+(n+m+nlb)
     J[offset+2nlb+nub+1:offset+2nlb+2nub] .= ind_ub
 
-    pr_diag = view(V,1:n)
-    du_diag = view(V,n_jac+n_hess+n+1:n_jac+n_hess+n+m)
+    pr_diag = _madnlp_unsafe_wrap(V,n)
+    du_diag = _madnlp_unsafe_wrap(V,m, n_jac+n_hess+n+1)
 
-    l_diag = view(V,offset+1:offset+nlb)
-    l_lower= view(V,offset+nlb+1:offset+2nlb)
-    u_diag = view(V,offset+2nlb+1:offset+2nlb+nub)
-    u_lower= view(V,offset+2nlb+nub+1:offset+2nlb+2nub)
+    l_diag = _madnlp_unsafe_wrap(V, nlb, offset+1)
+    l_lower= _madnlp_unsafe_wrap(V, nlb, offset+nlb+1)
+    u_diag = _madnlp_unsafe_wrap(V, nub, offset+2nlb+1)
+    u_lower= _madnlp_unsafe_wrap(V, nub, offset+2nlb+nub+1)
 
-    hess = view(V, n+1:n+n_hess)
-    jac = view(V, n_hess+n+1:n_hess+n+n_jac)
+    hess = _madnlp_unsafe_wrap(V, n_hess, n+1)
+    jac = _madnlp_unsafe_wrap(V, n_jac, n_hess+n+1)
 
     aug_raw = SparseMatrixCOO(aug_vec_length,aug_vec_length,I,J,V)
     jac_raw = SparseMatrixCOO(m,n,jac_sparsity_I,jac_sparsity_J,jac)
@@ -259,7 +258,7 @@ function SparseUnreducedKKTSystem{T, MT}(
         zeros(Int, 0)
     end
 
-    return SparseUnreducedKKTSystem{T, MT}(
+    return SparseUnreducedKKTSystem{T, VT, MT}(
         hess, jac, pr_diag, du_diag,
         l_diag, u_diag, l_lower, u_lower,
         aug_raw, aug_com, aug_csc_map,
@@ -268,7 +267,7 @@ function SparseUnreducedKKTSystem{T, MT}(
     )
 end
 
-function SparseUnreducedKKTSystem{T, MT}(nlp::AbstractNLPModel, ind_cons=get_index_constraints(nlp)) where {T, MT}
+function SparseUnreducedKKTSystem{T, VT, MT}(nlp::AbstractNLPModel, ind_cons=get_index_constraints(nlp)) where {T, VT, MT}
     n_slack = length(ind_cons.ind_ineq)
     nlb = length(ind_cons.ind_lb)
     nub = length(ind_cons.ind_ub)
@@ -289,7 +288,7 @@ function SparseUnreducedKKTSystem{T, MT}(nlp::AbstractNLPModel, ind_cons=get_ind
     append!(jac_I, ind_cons.ind_ineq)
     append!(jac_J, get_nvar(nlp)+1:get_nvar(nlp)+n_slack)
 
-    return SparseUnreducedKKTSystem{T, MT}(
+    return SparseUnreducedKKTSystem{T, VT, MT}(
         n, m, nlb, nub, ind_cons.ind_ineq, ind_cons.ind_fixed,
         hess_I, hess_J, jac_I, jac_J, ind_cons.ind_lb, ind_cons.ind_ub,
     )
diff --git a/src/LinearSolvers/lapack.jl b/src/LinearSolvers/lapack.jl
index 9da3ed8c..ab526337 100644
--- a/src/LinearSolvers/lapack.jl
+++ b/src/LinearSolvers/lapack.jl
@@ -1,4 +1,3 @@
-
 @kwdef mutable struct LapackOptions <: AbstractOptions
     lapack_algorithm::LinearFactorization = BUNCHKAUFMAN
 end
@@ -88,7 +87,7 @@ function factorize!(M::LapackCPUSolver)
         error(LOGGER,"Invalid lapack_algorithm")
     end
 end
-function solve!(M::LapackCPUSolver, x::StrideOneVector{Float64})
+function solve!(M::LapackCPUSolver, x::Vector{Float64})
     if M.opt.lapack_algorithm == BUNCHKAUFMAN
         solve_bunchkaufman!(M,x)
     elseif M.opt.lapack_algorithm == LU
diff --git a/src/LinearSolvers/umfpack.jl b/src/LinearSolvers/umfpack.jl
index cd80f44f..f1d533de 100644
--- a/src/LinearSolvers/umfpack.jl
+++ b/src/LinearSolvers/umfpack.jl
@@ -1,4 +1,3 @@
-
 const umfpack_default_ctrl = copy(UMFPACK.umf_ctrl)
 const umfpack_default_info = copy(UMFPACK.umf_info)
 
@@ -26,8 +25,8 @@ mutable struct UmfpackSolver <: AbstractLinearSolver
     logger::Logger
 end
 
-umfpack_di_numeric(colptr::StrideOneVector{Int32},rowval::StrideOneVector{Int32},
-                   nzval::StrideOneVector{Float64},symbolic::Ptr{Nothing},
+umfpack_di_numeric(colptr::Vector{Int32},rowval::Vector{Int32},
+                   nzval::Vector{Float64},symbolic::Ptr{Nothing},
                    tmp::Vector{Ptr{Nothing}},ctrl::Vector{Float64},
                    info::Vector{Float64}) = ccall(
                        (:umfpack_di_numeric,:libumfpack),
@@ -80,7 +79,7 @@ function factorize!(M::UmfpackSolver)
     M.inner.status = status
     return M
 end
-function solve!(M::UmfpackSolver,rhs::StrideOneVector{Float64})
+function solve!(M::UmfpackSolver,rhs::Vector{Float64})
     status = umfpack_di_solve(1,M.inner.colptr,M.inner.rowval,M.inner.nzval,M.p,rhs,M.inner.numeric,M.ctrl,M.info)
     rhs .= M.p
     return rhs
diff --git a/src/matrixtools.jl b/src/matrixtools.jl
index 125975db..df12d459 100644
--- a/src/matrixtools.jl
+++ b/src/matrixtools.jl
@@ -3,12 +3,12 @@
 
 abstract type AbstractSparseMatrixCOO{Tv,Ti<:Integer} <: AbstractSparseMatrix{Tv,Ti} end
 
-mutable struct SparseMatrixCOO{Tv,Ti<:Integer} <: AbstractSparseMatrixCOO{Tv,Ti}
+mutable struct SparseMatrixCOO{Tv,Ti<:Integer, VTv<:AbstractVector{Tv}} <: AbstractSparseMatrixCOO{Tv,Ti}
     m::Int
     n::Int
-    I::StrideOneVector{Ti}
-    J::StrideOneVector{Ti}
-    V::StrideOneVector{Tv}
+    I::Vector{Ti}
+    J::Vector{Ti}
+    V::VTv
 end
 size(A::SparseMatrixCOO) = (A.m,A.n)
 getindex(A::SparseMatrixCOO{Float64,Ti},i::Int,j::Int) where Ti <: Integer = sum(A.V[(A.I.==i) .* (A.J.==j)])
diff --git a/src/utils.jl b/src/utils.jl
index 248dcb8a..9e56b46c 100644
--- a/src/utils.jl
+++ b/src/utils.jl
@@ -1,12 +1,9 @@
-# MadNLP.jl.
-# Created by Sungho Shin (sungho.shin@wisc.edu)
 abstract type AbstractOptions end
 
 # Build info
 default_linear_solver() = UmfpackSolver
 default_dense_solver() = LapackCPUSolver
 
-
 # Logger
 @kwdef mutable struct Logger
     print_level::LogLevels = INFO
@@ -59,14 +56,13 @@ macro blas_safe_threads(args...)
     return esc(code)
 end
 
-# Type definitions
-SubVector{Tv}=SubArray{Tv, 1, Vector{Tv}, Tuple{Vector{Int}}, false}
-StrideOneVector{Tv}=Union{
-    Vector{Tv},
-    SubArray{Tv,1,Vector{Tv},Tuple{UnitRange{Int}},true},
-    SubArray{Tv, 1, Matrix{Tv}, Tuple{Base.Slice{Base.OneTo{Int}}, Int}, true}
-}
+# unsafe wrap
+function _madnlp_unsafe_wrap(vec::VT, n, shift=1) where VT
+    return unsafe_wrap(VT, pointer(vec,shift), n)
+end
 
+# Type definitions for noncontiguous views
+const SubVector{Tv} = SubArray{Tv, 1, Vector{Tv}, Tuple{Vector{Int}}, false}
 
 @kwdef mutable struct Counters
     k::Int = 0 # total iteration counter