diff --git a/src/SoftRobots.Inverse/binding/Binding_QPInverseProblemSolver.cpp b/src/SoftRobots.Inverse/binding/Binding_QPInverseProblemSolver.cpp
index 8424c8d..b386103 100644
--- a/src/SoftRobots.Inverse/binding/Binding_QPInverseProblemSolver.cpp
+++ b/src/SoftRobots.Inverse/binding/Binding_QPInverseProblemSolver.cpp
@@ -117,6 +117,12 @@ void moduleAddQPInverseProblemSolver(py::module &m)
 
     s.def(py::init<>());
     s.def("solveSystem", &softrobotsinverse::solver::QPInverseProblemSolver::solveSystem);
+
+    /// register the binding in the downcasting subsystem
+    sofapython3::PythonFactory::registerType<softrobotsinverse::solver::QPInverseProblemSolver>([](sofa::core::objectmodel::Base* object)
+                                                      {
+                                                          return py::cast(dynamic_cast<softrobotsinverse::solver::QPInverseProblemSolver*>(object));
+                                                      });
 }
 
 }
diff --git a/src/SoftRobots.Inverse/component/constraint/BarycentricCenterEffector.h b/src/SoftRobots.Inverse/component/constraint/BarycentricCenterEffector.h
index 775de99..b9b7fa5 100644
--- a/src/SoftRobots.Inverse/component/constraint/BarycentricCenterEffector.h
+++ b/src/SoftRobots.Inverse/component/constraint/BarycentricCenterEffector.h
@@ -113,12 +113,6 @@ class SOFA_SOFTROBOTS_INVERSE_API BarycentricCenterEffector : public PositionEff
     using PositionEffector<DataTypes>::d_indices ;
     using PositionEffector<DataTypes>::d_componentState ;
 
-    SOFA_ATTRIBUTE_DEPRECATED("v24.12", "v25.06", "Use d_useDirections instead.")
-    sofa::Data<Vec<3,bool> > d_axis;
-
-    SOFA_ATTRIBUTE_DEPRECATED("v24.12", "v25.06", "Use d_effectorGoal instead.")
-    sofa::Data<Coord >       d_effectorGoalPosition;
-
     sofa::Data<bool>         d_drawBarycenter;
     sofa::Data<Coord >       d_barycenter;
 
diff --git a/src/SoftRobots.Inverse/component/constraint/BarycentricCenterEffector.inl b/src/SoftRobots.Inverse/component/constraint/BarycentricCenterEffector.inl
index a219be8..4a900ff 100644
--- a/src/SoftRobots.Inverse/component/constraint/BarycentricCenterEffector.inl
+++ b/src/SoftRobots.Inverse/component/constraint/BarycentricCenterEffector.inl
@@ -51,10 +51,6 @@ using sofa::core::objectmodel::ComponentState;
 template<class DataTypes>
 BarycentricCenterEffector<DataTypes>::BarycentricCenterEffector(MechanicalState* object)
     : Inherit1(object)
-    , d_axis(initData(&d_axis, sofa::type::Vec<3,bool>(true,true,true), "axis",
-                      "The parameter axis is of type Vec3<bool> and allows to specify the directions in \n"
-                      "which you want to solve the effector. If unspecified, the default    \n"
-                      "values are {true, true, true})."))
 
     , d_drawBarycenter(initData(&d_drawBarycenter,false,"drawBarycenter",
                                 "If true, draw the barycenter" ))
@@ -62,7 +58,6 @@ BarycentricCenterEffector<DataTypes>::BarycentricCenterEffector(MechanicalState*
     , d_barycenter(initData(&d_barycenter,"barycenter",
                             "Position of barycenter." ))
 {
-    d_axis.setDisplayed(false);
     d_indices.setDisplayed(false); // inherited from PositionModel but not used here
     d_barycenter.setReadOnly(true);
 }
@@ -81,16 +76,6 @@ void BarycentricCenterEffector<DataTypes>::init()
     indices.resize(1);
 
     Inherit1::init();
-
-    if (d_axis.isSet())
-    {
-        msg_deprecated() << "The data axis is deprecated. To fix your scene please use useDirections instead. It will be remove in v25.06.";
-        auto useDirections = sofa::helper::getWriteAccessor(d_useDirections);
-        const auto& axis = sofa::helper::getReadAccessor(d_axis);
-        useDirections[0] = axis[0];
-        useDirections[1] = axis[1];
-        useDirections[2] = axis[2];
-    }
 }
 
 template<class DataTypes>
diff --git a/src/SoftRobots.Inverse/component/constraint/CableActuator.inl b/src/SoftRobots.Inverse/component/constraint/CableActuator.inl
index 8c092be..948e8a4 100644
--- a/src/SoftRobots.Inverse/component/constraint/CableActuator.inl
+++ b/src/SoftRobots.Inverse/component/constraint/CableActuator.inl
@@ -61,13 +61,6 @@ CableActuator<DataTypes>::CableActuator(MechanicalState* object)
     // These data from CableModel have no sense for actuator
     d_eqForce.setDisplayed(false);
     d_eqDisplacement.setDisplayed(false);
-
-    // QP on only one value, we set dimension to one
-    m_lambdaInit.resize(1);
-    m_deltaMax.resize(1);
-    m_deltaMin.resize(1);
-    m_lambdaMax.resize(1);
-    m_lambdaMin.resize(1);
 }
 
 
@@ -103,8 +96,10 @@ void CableActuator<DataTypes>::reset()
 template<class DataTypes>
 void CableActuator<DataTypes>::initData()
 {
-    d_displacement.setValue(0.0);
+    auto l = sofa::helper::getWriteAccessor(this->d_lambda);
+    l[0] = d_initForce.getValue();
     d_force.setValue(d_initForce.getValue());
+
     if(d_initForce.isSet())
     {
         m_hasLambdaInit = true;
@@ -119,7 +114,7 @@ void CableActuator<DataTypes>::initLimit()
     if(time < d_constrainAtTime.getValue())
         return;
 
-    ReadAccessor<sofa::Data<double>> displacement = d_displacement;
+    ReadAccessor<sofa::Data<sofa::type::vector<double>>> displacement = this->d_delta;
     ReadAccessor<sofa::Data<Real>> maxDispVariation = d_maxDispVariation;
     ReadAccessor<sofa::Data<Real>> maxPositiveDisplacement = d_maxPositiveDisplacement;
     ReadAccessor<sofa::Data<Real>> maxNegativeDisplacement = d_maxNegativeDisplacement;
@@ -157,10 +152,10 @@ void CableActuator<DataTypes>::initLimit()
     {
         m_hasDeltaMax = true;
         m_hasDeltaMin = true;
-        if(rabs(m_deltaMin[0] - displacement) >= maxDispVariation || !d_maxNegativeDisplacement.isSet())
-            m_deltaMin[0] = displacement - maxDispVariation;
-        if(rabs(m_deltaMax[0] - displacement) >= maxDispVariation || !d_maxPositiveDisplacement.isSet())
-            m_deltaMax[0] = displacement + maxDispVariation;
+        if(rabs(m_deltaMin[0] - displacement[0]) >= maxDispVariation || !d_maxNegativeDisplacement.isSet())
+            m_deltaMin[0] = displacement[0] - maxDispVariation;
+        if(rabs(m_deltaMax[0] - displacement[0]) >= maxDispVariation || !d_maxPositiveDisplacement.isSet())
+            m_deltaMax[0] = displacement[0] + maxDispVariation;
     }
 }
 
@@ -178,7 +173,7 @@ void CableActuator<DataTypes>::updateLimit()
         return;
     }
 
-    ReadAccessor<sofa::Data<double>> displacement = d_displacement;
+    ReadAccessor<sofa::Data<sofa::type::vector<double>>> displacement = this->d_delta;
     ReadAccessor<sofa::Data<Real>> maxDispVariation = d_maxDispVariation;
     ReadAccessor<sofa::Data<Real>> maxPositiveDisplacement = d_maxPositiveDisplacement;
     ReadAccessor<sofa::Data<Real>> maxNegativeDisplacement = d_maxNegativeDisplacement;
@@ -191,10 +186,10 @@ void CableActuator<DataTypes>::updateLimit()
 
     if(d_maxDispVariation.isSet())
     {
-        if(rabs(m_deltaMin[0] - displacement) >= maxDispVariation || !d_maxNegativeDisplacement.isSet())
-            m_deltaMin[0] = displacement - maxDispVariation;
-        if(rabs(m_deltaMax[0] - displacement) >= maxDispVariation || !d_maxPositiveDisplacement.isSet())
-            m_deltaMax[0] = displacement + maxDispVariation;
+        if(rabs(m_deltaMin[0] - displacement[0]) >= maxDispVariation || !d_maxNegativeDisplacement.isSet())
+            m_deltaMin[0] = displacement[0] - maxDispVariation;
+        if(rabs(m_deltaMax[0] - displacement[0]) >= maxDispVariation || !d_maxPositiveDisplacement.isSet())
+            m_deltaMax[0] = displacement[0] + maxDispVariation;
     }
 }
 
@@ -202,14 +197,14 @@ void CableActuator<DataTypes>::updateLimit()
 template<class DataTypes>
 void CableActuator<DataTypes>::updateVisualization()
 {
-    ReadAccessor<sofa::Data<double>> displacement = d_displacement;
-    ReadAccessor<sofa::Data<double>> force = d_force;
+    ReadAccessor<sofa::Data<sofa::type::vector<double>>> displacement = this->d_delta;
+    ReadAccessor<sofa::Data<sofa::type::vector<double>>> force = this->d_lambda;
     ReadAccessor<sofa::Data<Real>> maxPositiveDisplacement = d_maxPositiveDisplacement;
     ReadAccessor<sofa::Data<Real>> maxForce = d_maxForce;
 
     if(d_maxPositiveDisplacement.isSet())
     {
-        if(rabs(displacement-maxPositiveDisplacement) < 1e-5)
+        if(rabs(displacement[0]-maxPositiveDisplacement) < 1e-5)
             d_color.setValue(sofa::type::RGBAColor::red());
         else
             d_color.setValue(m_color);
@@ -217,7 +212,7 @@ void CableActuator<DataTypes>::updateVisualization()
 
     if(d_maxForce.isSet())
     {
-        if(rabs(force-maxForce) < 1e-5)
+        if(rabs(force[0]-maxForce) < 1e-5)
             d_color.setValue(sofa::type::RGBAColor::red());
         else
             d_color.setValue(m_color);
@@ -228,7 +223,13 @@ template<class DataTypes>
 void CableActuator<DataTypes>::storeResults(sofa::type::vector<double> &lambda,
                                             sofa::type::vector<double> &delta)
 {
+    auto l = sofa::helper::getWriteAccessor(this->d_lambda);
+    auto d = sofa::helper::getWriteAccessor(this->d_delta);
+
+    l[0] = lambda[0];
     d_force.setValue(lambda[0]);
+
+    d[0] = delta[0];
     d_displacement.setValue(delta[0]);
 
     updateLimit();
diff --git a/src/SoftRobots.Inverse/component/constraint/CableEquality.inl b/src/SoftRobots.Inverse/component/constraint/CableEquality.inl
index 16a1047..e9f667d 100644
--- a/src/SoftRobots.Inverse/component/constraint/CableEquality.inl
+++ b/src/SoftRobots.Inverse/component/constraint/CableEquality.inl
@@ -55,10 +55,6 @@ CableEquality<DataTypes>::CableEquality(MechanicalState* object)
     d_maxPositiveDisplacement.setDisplayed(false);
     d_maxNegativeDisplacement.setDisplayed(false);
     d_maxDispVariation.setDisplayed(false);
-
-    // QP on only one value, we set dimension to one
-    m_lambdaEqual.resize(1);
-    m_deltaEqual.resize(1);
 }
 
 
@@ -85,8 +81,6 @@ void CableEquality<DataTypes>::reinit()
 template<class DataTypes>
 void CableEquality<DataTypes>::reset()
 {
-    d_displacement.setValue(0.0);
-    d_force.setValue(0.0);
     updateConstraint();
 }
 
diff --git a/src/SoftRobots.Inverse/component/constraint/CableSensor.inl b/src/SoftRobots.Inverse/component/constraint/CableSensor.inl
index 185a30a..41e7f82 100644
--- a/src/SoftRobots.Inverse/component/constraint/CableSensor.inl
+++ b/src/SoftRobots.Inverse/component/constraint/CableSensor.inl
@@ -61,12 +61,12 @@ void CableSensor<DataTypes>::setUpData()
     d_maxForce.setDisplayed(false);
     d_minForce.setDisplayed(false);
     d_eqForce.setDisplayed(false);
-    d_force.setDisplayed(false);
+    this->d_lambda.setDisplayed(false);
     d_maxPositiveDisplacement.setDisplayed(false);
     d_maxNegativeDisplacement.setDisplayed(false);
     d_maxDispVariation.setDisplayed(false);
     d_eqDisplacement.setDisplayed(false);
-    d_displacement.setDisplayed(false);
+    this->d_delta.setDisplayed(false);
 }
 
 
diff --git a/src/SoftRobots.Inverse/component/constraint/ForcePointActuator.h b/src/SoftRobots.Inverse/component/constraint/ForcePointActuator.h
index 400b110..df3d327 100644
--- a/src/SoftRobots.Inverse/component/constraint/ForcePointActuator.h
+++ b/src/SoftRobots.Inverse/component/constraint/ForcePointActuator.h
@@ -104,7 +104,9 @@ class ForcePointActuator : public Actuator<DataTypes>
     sofa::Data<Real>                             d_minForce;
     sofa::Data<Real>                             d_initForce;
     sofa::Data<Real>                             d_maxForceVariation;
+    SOFA_ATTRIBUTE_DEPRECATED("v26.06", "v27.06", "Use d_lambda instead.")
     sofa::Data<sofa::type::vector<Real>>         d_force;
+    SOFA_ATTRIBUTE_DEPRECATED("v26.06", "v27.06", "Use d_delta instead.")
     sofa::Data<Real>                             d_displacement;
     sofa::Data<Deriv>                            d_direction;
     sofa::Data<Real>                             d_energyWeight;
diff --git a/src/SoftRobots.Inverse/component/constraint/ForcePointActuator.inl b/src/SoftRobots.Inverse/component/constraint/ForcePointActuator.inl
index 33dfc69..13814ee 100644
--- a/src/SoftRobots.Inverse/component/constraint/ForcePointActuator.inl
+++ b/src/SoftRobots.Inverse/component/constraint/ForcePointActuator.inl
@@ -51,10 +51,10 @@ ForcePointActuator<DataTypes>::ForcePointActuator(MechanicalState* object)
                        "Index of the point of the model on which we want to apply the force"))
 
     , d_maxForce(initData(&d_maxForce, "maxForce",
-                       ""))
+                       "Maximum force."))
 
     , d_minForce(initData(&d_minForce, "minForce",
-                       ""))
+                       "Minimum force."))
 
     , d_initForce(initData(&d_initForce, Real(0.0), "initForce",
                        "Initial force if any. Default is 0."))
@@ -62,12 +62,6 @@ ForcePointActuator<DataTypes>::ForcePointActuator(MechanicalState* object)
     , d_maxForceVariation(initData(&d_maxForceVariation, "maxForceVariation",
                        "Only available if the direction is set."))
 
-    , d_force(initData(&d_force, "force",
-                       "Warning: to get the actual force you should divide this value by dt."))
-
-    , d_displacement(initData(&d_displacement, Real(0.0), "displacement",
-                       ""))
-
     , d_direction(initData(&d_direction, "direction",
                            "Direction of the force we want to apply. If d=[0,0,0], the direction \n"
                            "will be optimized."))
@@ -78,10 +72,10 @@ ForcePointActuator<DataTypes>::ForcePointActuator(MechanicalState* object)
                               "transfered by this actuator. The default value used is the energyWeight defined in the inverse problem solver."))
 
     , d_showForce(initData(&d_showForce, false, "showForce",
-                           ""))
+                           "Either to show the force or not."))
 
     , d_visuScale(initData(&d_visuScale, Real(0.1), "visuScale",
-                           ""))
+                           "Visualization scale."))
 
 {
     setUpData();
@@ -94,9 +88,6 @@ void ForcePointActuator<DataTypes>::setUpData()
     d_epsilon.setOriginalData(&d_energyWeight);
     this->addAlias(&d_energyWeight, "penalty");
 
-    d_force.setReadOnly(true);
-    d_displacement.setReadOnly(true);
-
     d_showForce.setGroup("Visualization");
     d_visuScale.setGroup("Visualization");
 }
@@ -135,6 +126,7 @@ template<class DataTypes>
 void ForcePointActuator<DataTypes>::initData()
 {
     m_dim = (d_direction.getValue().norm()<1e-10)? Deriv::total_size: 1;
+    this->resizeConstraints(m_dim);
 
     if(d_energyWeight.isSet())
     {
@@ -150,12 +142,8 @@ void ForcePointActuator<DataTypes>::initData()
 
     sofa::type::vector<Real> force;
     force.resize(m_dim, d_initForce.getValue());
+    this->d_lambda.setValue(force);
     d_force.setValue(force);
-
-    // QP on only one value, we set dimension to one
-    m_lambdaInit.resize(m_dim);
-    m_lambdaMax.resize(m_dim);
-    m_lambdaMin.resize(m_dim);
 }
 
 
@@ -193,24 +181,26 @@ void ForcePointActuator<DataTypes>::updateLimit()
             lambda = d_minForce.getValue();
     }
 
+    auto lambda = sofa::helper::getReadAccessor(this->d_lambda);
+
     if(d_maxForceVariation.isSet())
     {
         if (m_dim>1)
         {
             for(unsigned int j=0; j<Deriv::total_size; j++)
             {
-                if(rabs(m_lambdaMin[j] - d_force.getValue()[j]) >= d_maxForceVariation.getValue() || !d_minForce.isSet())
-                    m_lambdaMin[j] = d_force.getValue()[j] - d_maxForceVariation.getValue();
-                if(rabs(m_lambdaMax[j] - d_force.getValue()[j]) >= d_maxForceVariation.getValue() || !d_maxForce.isSet())
-                    m_lambdaMax[j] = d_force.getValue()[j] + d_maxForceVariation.getValue();
+                if(rabs(m_lambdaMin[j] - lambda[j]) >= d_maxForceVariation.getValue() || !d_minForce.isSet())
+                    m_lambdaMin[j] = lambda[j] - d_maxForceVariation.getValue();
+                if(rabs(m_lambdaMax[j] - lambda[j]) >= d_maxForceVariation.getValue() || !d_maxForce.isSet())
+                    m_lambdaMax[j] = lambda[j] + d_maxForceVariation.getValue();
             }
         }
         else
         {
-            if(rabs(m_lambdaMin[0] - d_force.getValue()[0]) >= d_maxForceVariation.getValue() || !d_minForce.isSet())
-                m_lambdaMin[0] = d_force.getValue()[0] - d_maxForceVariation.getValue();
-            if(rabs(m_lambdaMax[0] - d_force.getValue()[0]) >= d_maxForceVariation.getValue() || !d_maxForce.isSet())
-                m_lambdaMax[0] = d_force.getValue()[0] + d_maxForceVariation.getValue();
+            if(rabs(m_lambdaMin[0] - lambda[0]) >= d_maxForceVariation.getValue() || !d_minForce.isSet())
+                m_lambdaMin[0] = lambda[0] - d_maxForceVariation.getValue();
+            if(rabs(m_lambdaMax[0] - lambda[0]) >= d_maxForceVariation.getValue() || !d_maxForce.isSet())
+                m_lambdaMax[0] = lambda[0] + d_maxForceVariation.getValue();
         }
     }
 }
@@ -287,17 +277,27 @@ void ForcePointActuator<DataTypes>::getConstraintViolation(const ConstraintParam
 template<class DataTypes>
 void ForcePointActuator<DataTypes>::storeResults(vector<double> &lambda, vector<double> &delta)
 {
+    auto l = sofa::helper::getWriteAccessor(this->d_lambda);
+    auto d = sofa::helper::getWriteAccessor(this->d_delta);
+
     WriteAccessor<sofa::Data<vector<Real>>> force = d_force;
 
+    d[0] = delta[0];
     d_displacement.setValue(delta[0]);
 
     if(m_dim > 1) // No fixed direction
     {
         for(unsigned int j=0; j<Deriv::total_size; j++)
+        {
+            l[j] = lambda[j];
             force[j]=lambda[j];
+        }
     }
     else
+    {
+        l[0] = lambda[0];
         force[0] = lambda[0];
+    }
 
     updateLimit();
 
@@ -316,7 +316,7 @@ void ForcePointActuator<DataTypes>::draw(const VisualParams* vparams)
     ReadAccessor<sofa::Data<sofa::type::vector<sofa::Index>>> indices = sofa::helper::getReadAccessor(d_indices);
     ReadAccessor<sofa::Data<Real>> visuScale = sofa::helper::getReadAccessor(d_visuScale);
     ReadAccessor<sofa::Data<VecCoord> > positions = m_state->readPositions();
-    ReadAccessor<sofa::Data<vector<Real>>> force = d_force;
+    ReadAccessor<sofa::Data<vector<Real>>> force = this->d_lambda;
     Deriv direction = d_direction.getValue();
 
     static const sofa::type::RGBAColor color(0,0,0.8,1);
diff --git a/src/SoftRobots.Inverse/component/constraint/ForceSurfaceActuator.h b/src/SoftRobots.Inverse/component/constraint/ForceSurfaceActuator.h
index dc4f09b..1b78afe 100644
--- a/src/SoftRobots.Inverse/component/constraint/ForceSurfaceActuator.h
+++ b/src/SoftRobots.Inverse/component/constraint/ForceSurfaceActuator.h
@@ -108,10 +108,10 @@ class ForceSurfaceActuator : public Actuator<DataTypes>
     sofa::Data<VecDeriv>                      d_directions;
     sofa::Data<bool>                          d_updateNormals;
 
-    sofa::Data<sofa::type::vector<Triangle>>      d_triangles;
-    sofa::Data<sofa::type::vector<Quad>>          d_quads;
-    sofa::Data<sofa::type::vector<Coord>>         d_positions;
-    sofa::type::vector<Edge>                m_edges;
+    sofa::Data<sofa::type::vector<Triangle>>  d_triangles;
+    sofa::Data<sofa::type::vector<Quad>>      d_quads;
+    sofa::Data<sofa::type::vector<Coord>>     d_positions;
+    sofa::type::vector<Edge>                  m_edges;
 
     sofa::Data<Real>                          d_maxForce;
     sofa::Data<Real>                          d_minForce;
@@ -120,15 +120,17 @@ class ForceSurfaceActuator : public Actuator<DataTypes>
     sofa::Data<Real>                          d_maxDisplacement;
     sofa::Data<Real>                          d_minDisplacement;
 
-    sofa::Data<sofa::type::vector<Real>>          d_force;
-    sofa::Data<sofa::type::vector<Real>>          d_displacement;
+    SOFA_ATTRIBUTE_DEPRECATED("v26.06", "v27.06", "Use d_lambda instead.")
+    sofa::Data<sofa::type::vector<Real>>      d_force;
+    SOFA_ATTRIBUTE_DEPRECATED("v26.06", "v27.06", "Use d_delta instead.")
+    sofa::Data<sofa::type::vector<Real>>      d_displacement;
 
     sofa::Data<bool>                          d_drawForce;
     sofa::Data<bool>                          d_drawSphere;
     sofa::Data<bool>                          d_drawSurface;
     sofa::Data<Real>                          d_visuScale;
 
-    bool                                m_useNormals{false};
+    bool                                      m_useNormals{false};
 
     sofa::type::vector<sofa::type::vector<unsigned int>>        m_pointsInSphereId;
     sofa::type::vector<sofa::type::vector<unsigned int>>        m_trianglesInSpheresId;
@@ -148,7 +150,6 @@ class ForceSurfaceActuator : public Actuator<DataTypes>
     using Actuator<DataTypes>::d_constraintIndex ;
     ////////////////////////////////////////////////////////////////////////////
 
-
     void initLimit();
     void initData();
     void updateLimit();
diff --git a/src/SoftRobots.Inverse/component/constraint/ForceSurfaceActuator.inl b/src/SoftRobots.Inverse/component/constraint/ForceSurfaceActuator.inl
index b09d57f..3ccdf33 100644
--- a/src/SoftRobots.Inverse/component/constraint/ForceSurfaceActuator.inl
+++ b/src/SoftRobots.Inverse/component/constraint/ForceSurfaceActuator.inl
@@ -91,12 +91,6 @@ ForceSurfaceActuator<DataTypes>::ForceSurfaceActuator(MechanicalState* object)
     , d_minDisplacement(initData(&d_minDisplacement, "minDisplacement",
                                  ""))
 
-    , d_force(initData(&d_force, vector<Real>(0), "force",
-                       "Warning: to get the actual force you should divide this value by dt."))
-
-    , d_displacement(initData(&d_displacement, vector<Real>(0), "displacement",
-                              ""))
-
     , d_drawForce(initData(&d_drawForce, false, "drawForces",
                            ""))
 
@@ -110,21 +104,10 @@ ForceSurfaceActuator<DataTypes>::ForceSurfaceActuator(MechanicalState* object)
                            ""))
 
 {
-    d_force.setReadOnly(true);
-    WriteAccessor<sofa::Data<vector<Real>>> force = d_force;
-    force.resize(1);
-    d_displacement.setReadOnly(true);
-
     d_drawForce.setGroup("Visualization");
     d_drawSphere.setGroup("Visualization");
     d_drawSurface.setGroup("Visualization");
     d_visuScale.setGroup("Visualization");
-
-    // QP on only one value, we set dimension to one
-    m_deltaMax.resize(1);
-    m_deltaMin.resize(1);
-    m_lambdaMax.resize(1);
-    m_lambdaMin.resize(1);
 }
 
 
@@ -283,14 +266,15 @@ void ForceSurfaceActuator<DataTypes>::initLimit()
         m_lambdaMin[0] = d_minForce.getValue();
     }
 
+    auto force = sofa::helper::getReadAccessor(this->d_lambda);
     if(d_maxForceVariation.isSet())
     {
         m_hasLambdaMax = true;
         m_hasLambdaMin = true;
-        if(rabs(m_lambdaMin[0] - d_force.getValue()[0]) >= d_maxForceVariation.getValue() || !d_minForce.isSet())
-            m_lambdaMin[0] = d_force.getValue()[0] - d_maxForceVariation.getValue();
-        if(rabs(m_lambdaMax[0] - d_force.getValue()[0]) >= d_maxForceVariation.getValue() || !d_maxForce.isSet())
-            m_lambdaMax[0] = d_force.getValue()[0] + d_maxForceVariation.getValue();
+        if(rabs(m_lambdaMin[0] - force[0]) >= d_maxForceVariation.getValue() || !d_minForce.isSet())
+            m_lambdaMin[0] = force[0] - d_maxForceVariation.getValue();
+        if(rabs(m_lambdaMax[0] - force[0]) >= d_maxForceVariation.getValue() || !d_maxForce.isSet())
+            m_lambdaMax[0] = force[0] + d_maxForceVariation.getValue();
     }
 
     if(d_maxDisplacement.isSet())
@@ -316,12 +300,13 @@ void ForceSurfaceActuator<DataTypes>::updateLimit()
     if(d_minForce.isSet())
         m_lambdaMin[0] = d_minForce.getValue();
 
+    auto force = sofa::helper::getReadAccessor(this->d_lambda);
     if(d_maxForceVariation.isSet())
     {
-        if(rabs(m_lambdaMin[0] - d_force.getValue()[0]) >= d_maxForceVariation.getValue() || !d_minForce.isSet())
-            m_lambdaMin[0] = d_force.getValue()[0] - d_maxForceVariation.getValue();
-        if(rabs(m_lambdaMax[0] - d_force.getValue()[0]) >= d_maxForceVariation.getValue() || !d_maxForce.isSet())
-            m_lambdaMax[0] = d_force.getValue()[0] + d_maxForceVariation.getValue();
+        if(rabs(m_lambdaMin[0] - force[0]) >= d_maxForceVariation.getValue() || !d_minForce.isSet())
+            m_lambdaMin[0] = force[0] - d_maxForceVariation.getValue();
+        if(rabs(m_lambdaMax[0] - force[0]) >= d_maxForceVariation.getValue() || !d_maxForce.isSet())
+            m_lambdaMax[0] = force[0] + d_maxForceVariation.getValue();
     }
 
     if(d_maxDisplacement.isSet())
@@ -338,7 +323,7 @@ void ForceSurfaceActuator<DataTypes>::computeSurfaces()
 {
     ReadAccessor<sofa::Data<vector<Triangle> > >  triangles = d_triangles;
     ReadAccessor<sofa::Data<vector<Quad> > >      quads     = d_quads;
-    ReadAccessor<sofa::Data<VecCoord> >      centers     = d_centers;
+    ReadAccessor<sofa::Data<VecCoord> >           centers   = d_centers;
 
     computePointsInSpheres();
 
@@ -661,14 +646,20 @@ void ForceSurfaceActuator<DataTypes>::storeResults(vector<double> &lambda, vecto
 {
     WriteAccessor<sofa::Data<vector<Real>>> force = d_force;
     WriteAccessor<sofa::Data<vector<Real>>> displacement = d_displacement;
+    WriteAccessor<sofa::Data<vector<Real>>> l = this->d_lambda;
+    WriteAccessor<sofa::Data<vector<Real>>> d = this->d_delta;
 
     unsigned int nbForces = d_centers.getValue().size();
     force.resize(nbForces);
+    l.resize(nbForces);
     displacement.resize(nbForces);
+    d.resize(nbForces);
     for(unsigned int i=0; i<nbForces; i++)
     {
         force[i] = lambda[i];
+        l[i] = lambda[i];
         displacement[i] = delta[i];
+        d[i] = delta[i];
     }
 
     updateCenter();
@@ -682,13 +673,13 @@ template<class DataTypes>
 void ForceSurfaceActuator<DataTypes>::updateCenter()
 {
     WriteAccessor<sofa::Data<vector<Coord>>> centers = d_centers;
-    ReadAccessor<sofa::Data<vector<Real>>> displacement = d_displacement;
+    ReadAccessor<sofa::Data<vector<Real>>> displacement = this->d_delta;
     ReadAccessor<sofa::Data<vector<Deriv>>> directions = d_directions;
 
     int nbCenters = centers.size();
 
     for(int i=0; i<nbCenters; i++)
-        centers[i] = m_initialCenters[i] + directions[i]*displacement[i];
+        centers[i] = m_initialCenters[i] + directions[i] * displacement[i];
 }
 
 
@@ -714,13 +705,14 @@ void ForceSurfaceActuator<DataTypes>::draw(const VisualParams* vparams)
 template<class DataTypes>
 void ForceSurfaceActuator<DataTypes>::drawForces(const VisualParams* vparams)
 {
-    if(m_state == nullptr || d_force.getValue().size()==0)
+    ReadAccessor<sofa::Data<vector<Real>>> force = this->d_lambda;
+
+    if(m_state == nullptr || force.size() == 0)
         return;
 
     VecDeriv directions = d_directions.getValue();
 
     ReadAccessor<sofa::Data<VecCoord> > positions = m_state->readPositions();
-    ReadAccessor<sofa::Data<vector<Real>>> force = d_force;
 
     RGBAColor color(0,1,0,1);
     for(unsigned int i=0; i<directions.size(); i++)
@@ -744,7 +736,6 @@ void ForceSurfaceActuator<DataTypes>::drawSpheres(const VisualParams* vparams)
 template<class DataTypes>
 void ForceSurfaceActuator<DataTypes>::drawSurfaces(const VisualParams* vparams)
 {
-
     if(m_state == nullptr)
         return;
 
diff --git a/src/SoftRobots.Inverse/component/constraint/JointActuator.h b/src/SoftRobots.Inverse/component/constraint/JointActuator.h
index 02da0d9..89b15d2 100644
--- a/src/SoftRobots.Inverse/component/constraint/JointActuator.h
+++ b/src/SoftRobots.Inverse/component/constraint/JointActuator.h
@@ -106,7 +106,9 @@ class JointActuator : public Actuator<DataTypes>
     sofa::Data<Real>          d_maxAngle;
     sofa::Data<Real>          d_minAngle;
     sofa::Data<Real>          d_maxAngleVariation;
+    SOFA_ATTRIBUTE_DEPRECATED("v26.06", "v27.06", "Use d_lambda instead.")
     sofa::Data<Real>          d_effort;
+    SOFA_ATTRIBUTE_DEPRECATED("v26.06", "v27.06", "Use d_delta instead.")
     sofa::Data<Real>          d_angle;
 
 
@@ -129,10 +131,12 @@ class JointActuator : public Actuator<DataTypes>
     /// Bring inherited attributes and function in the current lookup context.
     /// otherwise any access to the base::attribute would require
     /// the "this->" approach.
+    using Actuator<DataTypes>::d_lambda ;
     using Actuator<DataTypes>::m_lambdaMax ;
     using Actuator<DataTypes>::m_lambdaMin ;
     using Actuator<DataTypes>::m_hasLambdaMax ;
     using Actuator<DataTypes>::m_hasLambdaMin ;
+    using Actuator<DataTypes>::d_delta ;
     using Actuator<DataTypes>::m_deltaMax ;
     using Actuator<DataTypes>::m_deltaMin ;
     using Actuator<DataTypes>::m_hasDeltaMax ;
@@ -141,11 +145,6 @@ class JointActuator : public Actuator<DataTypes>
     using Actuator<DataTypes>::d_componentState ;
     ////////////////////////////////////////////////////////////////////////////
 
-
-private:
-
-    void setUpData();
-
 };
 
 // Declares template as extern to avoid the code generation of the template for
diff --git a/src/SoftRobots.Inverse/component/constraint/JointActuator.inl b/src/SoftRobots.Inverse/component/constraint/JointActuator.inl
index b24f23f..9244c09 100644
--- a/src/SoftRobots.Inverse/component/constraint/JointActuator.inl
+++ b/src/SoftRobots.Inverse/component/constraint/JointActuator.inl
@@ -64,26 +64,9 @@ JointActuator<DataTypes>::JointActuator(MechanicalState* object)
     , d_minAngle(initData(&d_minAngle, "minAngle", "In radian"))
 
     , d_maxAngleVariation(initData(&d_maxAngleVariation, "maxAngleVariation", "In radian"))
-
-    , d_effort(initData(&d_effort, "effort", "Warning: to get the actual effort you should divide this value by dt."))
-
-    , d_angle(initData(&d_angle, "angle", ""))
 {
-    setUpData();
-
-    // QP on only one value, we set dimension to one
-    m_deltaMax.resize(1);
-    m_deltaMin.resize(1);
-    m_lambdaMax.resize(1);
-    m_lambdaMin.resize(1);
-}
-
-
-template<class DataTypes>
-void JointActuator<DataTypes>::setUpData()
-{
-    d_effort.setReadOnly(true);
-    d_angle.setReadOnly(true);
+    this->setLambdaName("effort");
+    this->setDeltaName("angle");
 }
 
 
@@ -148,24 +131,27 @@ void JointActuator<DataTypes>::initLimit()
         m_deltaMin[0] = d_minAngle.getValue();
     }
 
+    auto effort = sofa::helper::getReadAccessor(d_lambda);
+    auto angle = sofa::helper::getReadAccessor(d_delta);
+
     if(d_maxEffortVariation.isSet())
     {
         m_hasLambdaMax = true;
         m_hasLambdaMin = true;
-        if(rabs(m_lambdaMin[0] - d_effort.getValue()) >= d_maxEffortVariation.getValue() || !d_minEffort.isSet())
-            m_lambdaMin[0] = d_effort.getValue() - d_maxEffortVariation.getValue();
-        if(rabs(m_lambdaMax[0] - d_effort.getValue()) >= d_maxEffortVariation.getValue() || !d_maxEffort.isSet())
-            m_lambdaMax[0] = d_effort.getValue() + d_maxEffortVariation.getValue();
+        if(rabs(m_lambdaMin[0] - effort[0]) >= d_maxEffortVariation.getValue() || !d_minEffort.isSet())
+            m_lambdaMin[0] = effort[0] - d_maxEffortVariation.getValue();
+        if(rabs(m_lambdaMax[0] - effort[0]) >= d_maxEffortVariation.getValue() || !d_maxEffort.isSet())
+            m_lambdaMax[0] = effort[0] + d_maxEffortVariation.getValue();
     }
 
     if(d_maxAngleVariation.isSet())
     {
         m_hasDeltaMax = true;
         m_hasDeltaMin = true;
-        if(rabs(m_deltaMin[0] - d_angle.getValue()) >= d_maxAngleVariation.getValue() || !d_minAngle.isSet())
-            m_deltaMin[0] = d_angle.getValue() - d_maxAngleVariation.getValue();
-        if(rabs(m_deltaMax[0] - d_angle.getValue()) >= d_maxAngleVariation.getValue() || !d_maxAngle.isSet())
-            m_deltaMax[0] = d_angle.getValue() + d_maxAngleVariation.getValue();
+        if(rabs(m_deltaMin[0] - angle[0]) >= d_maxAngleVariation.getValue() || !d_minAngle.isSet())
+            m_deltaMin[0] = angle[0] - d_maxAngleVariation.getValue();
+        if(rabs(m_deltaMax[0] - angle[0]) >= d_maxAngleVariation.getValue() || !d_maxAngle.isSet())
+            m_deltaMax[0] = angle[0] + d_maxAngleVariation.getValue();
     }
 }
 
@@ -173,6 +159,10 @@ void JointActuator<DataTypes>::initLimit()
 template<class DataTypes>
 void JointActuator<DataTypes>::initData()
 {
+    auto effort = sofa::helper::getWriteAccessor(d_lambda);
+    auto angle = sofa::helper::getWriteAccessor(d_delta);
+    effort[0] = d_initEffort.getValue();
+    angle[0] = d_initAngle.getValue();
     d_effort.setValue(d_initEffort.getValue());
     d_angle.setValue(d_initAngle.getValue());
 }
@@ -193,20 +183,23 @@ void JointActuator<DataTypes>::updateLimit()
     if(d_minAngle.isSet())
         m_deltaMin[0] = d_minAngle.getValue();
 
+    auto effort = sofa::helper::getReadAccessor(d_lambda);
+    auto angle = sofa::helper::getReadAccessor(d_delta);
+
     if(d_maxEffortVariation.isSet())
     {
-        if(rabs(m_lambdaMin[0] - d_effort.getValue()) >= d_maxEffortVariation.getValue() || !d_minEffort.isSet())
-            m_lambdaMin[0] = d_effort.getValue() - d_maxEffortVariation.getValue();
-        if(rabs(m_lambdaMax[0] - d_effort.getValue()) >= d_maxEffortVariation.getValue() || !d_maxEffort.isSet())
-            m_lambdaMax[0] = d_effort.getValue() + d_maxEffortVariation.getValue();
+        if(rabs(m_lambdaMin[0] - effort[0]) >= d_maxEffortVariation.getValue() || !d_minEffort.isSet())
+            m_lambdaMin[0] = effort[0] - d_maxEffortVariation.getValue();
+        if(rabs(m_lambdaMax[0] - effort[0]) >= d_maxEffortVariation.getValue() || !d_maxEffort.isSet())
+            m_lambdaMax[0] = effort[0] + d_maxEffortVariation.getValue();
     }
 
     if(d_maxAngleVariation.isSet())
     {
-        if(rabs(m_deltaMin[0] - d_angle.getValue()) >= d_maxAngleVariation.getValue() || !d_minAngle.isSet())
-            m_deltaMin[0] = d_angle.getValue() - d_maxAngleVariation.getValue();
-        if(rabs(m_deltaMax[0] - d_angle.getValue()) >= d_maxAngleVariation.getValue() || !d_maxAngle.isSet())
-            m_deltaMax[0] = d_angle.getValue() + d_maxAngleVariation.getValue();
+        if(rabs(m_deltaMin[0] - angle[0]) >= d_maxAngleVariation.getValue() || !d_minAngle.isSet())
+            m_deltaMin[0] = angle[0] - d_maxAngleVariation.getValue();
+        if(rabs(m_deltaMax[0] - angle[0]) >= d_maxAngleVariation.getValue() || !d_maxAngle.isSet())
+            m_deltaMax[0] = angle[0] + d_maxAngleVariation.getValue();
     }
 }
 
@@ -259,6 +252,11 @@ void JointActuator<DataTypes>::storeResults(vector<double> &lambda, vector<doubl
     if(!this->isComponentStateValid())
         return ;
 
+    auto effort = sofa::helper::getWriteAccessor(d_lambda);
+    auto angle = sofa::helper::getWriteAccessor(d_delta);
+    effort[0] = lambda[0];
+    angle[0] = delta[0];
+
     d_effort.setValue(lambda[0]);
     d_angle.setValue(delta[0]);
     updateLimit();
diff --git a/src/SoftRobots.Inverse/component/constraint/PositionEffector.h b/src/SoftRobots.Inverse/component/constraint/PositionEffector.h
index 0c97cf4..85af634 100644
--- a/src/SoftRobots.Inverse/component/constraint/PositionEffector.h
+++ b/src/SoftRobots.Inverse/component/constraint/PositionEffector.h
@@ -68,7 +68,7 @@ class PositionEffector : public Effector<DataTypes>, public softrobots::constrai
                                 const sofa::linearalgebra::BaseVector *Jdx) override;
     ///////////////////////////////////////////////////////////////
 
-    sofa::Data<VecCoord>                                d_effectorGoal;
+    sofa::Data<VecCoord> d_effectorGoal;
 
     void setTargetDefaultValue();
     void resizeData();
diff --git a/src/SoftRobots.Inverse/component/constraint/PositionEquality.inl b/src/SoftRobots.Inverse/component/constraint/PositionEquality.inl
index 7e3e666..6f1d425 100644
--- a/src/SoftRobots.Inverse/component/constraint/PositionEquality.inl
+++ b/src/SoftRobots.Inverse/component/constraint/PositionEquality.inl
@@ -54,8 +54,6 @@ PositionEquality<DataTypes>::PositionEquality(MechanicalState* object)
                                  "Example of use: to allow the cable to reach an \n"
                                  "initial configuration before optimizing."))
 {
-    // PositionEquality of dimension 1
-    m_deltaEqual.resize(1);
 }
 
 
diff --git a/src/SoftRobots.Inverse/component/constraint/SlidingActuator.h b/src/SoftRobots.Inverse/component/constraint/SlidingActuator.h
index e917528..32e4366 100644
--- a/src/SoftRobots.Inverse/component/constraint/SlidingActuator.h
+++ b/src/SoftRobots.Inverse/component/constraint/SlidingActuator.h
@@ -135,8 +135,10 @@ class SlidingActuator : public Actuator<DataTypes>
     sofa::Data<SetIndexArray>         d_indices;
 
     sofa::Data<double>                d_initForce;
+    SOFA_ATTRIBUTE_DEPRECATED("v26.06", "v27.06", "Use d_lambda instead.")
     sofa::Data<double>                d_force;
     sofa::Data<double>                d_initDisplacement;
+    SOFA_ATTRIBUTE_DEPRECATED("v26.06", "v27.06", "Use d_delta instead.")
     sofa::Data<double>                d_displacement;
     sofa::Data<bool>                  d_accumulateDisp;
 
diff --git a/src/SoftRobots.Inverse/component/constraint/SlidingActuator.inl b/src/SoftRobots.Inverse/component/constraint/SlidingActuator.inl
index bd4f51a..0d833e5 100644
--- a/src/SoftRobots.Inverse/component/constraint/SlidingActuator.inl
+++ b/src/SoftRobots.Inverse/component/constraint/SlidingActuator.inl
@@ -77,15 +77,9 @@ SlidingActuator<DataTypes>::SlidingActuator(MechanicalState* object)
     , d_initForce(initData(&d_initForce, double(0.0), "initForce",
                            "Initial force. Default is 0."))
 
-    , d_force(initData(&d_force,double(0.0), "force",
-                          "Output force. Warning: to get the actual force you should divide this value by dt."))
-
     , d_initDisplacement(initData(&d_initDisplacement, double(0.0), "initDisplacement",
                           "Initial displacement. Default is 0."))
 
-    , d_displacement(initData(&d_displacement,double(0.0), "displacement",
-                          "Output displacement compared to the initial position."))
-
     , d_accumulateDisp(initData(&d_accumulateDisp, false, "accumulateDisp", "In case of relative displacement, accumulate the displacement."))
 
     , d_showDirection(initData(&d_showDirection,false, "showDirection",
@@ -106,17 +100,8 @@ SlidingActuator<DataTypes>::SlidingActuator(MechanicalState* object)
     d_initForce.setGroup("Input");
     d_initDisplacement.setGroup("Input");
 
-    d_force.setGroup("Output");
-    d_displacement.setGroup("Output");
-
     d_showDirection.setGroup("Visualization");
     d_showVisuScale.setGroup("Visualization");
-
-    // QP on only one value, we set dimension to one
-    m_deltaMax.resize(1);
-    m_deltaMin.resize(1);
-    m_lambdaMax.resize(1);
-    m_lambdaMin.resize(1);
 }
 
 
@@ -199,6 +184,11 @@ void SlidingActuator<DataTypes>::initData()
         d_direction.setValue(direction);
     }
 
+    auto displacement = sofa::helper::getWriteAccessor(this->d_delta);
+    auto force = sofa::helper::getWriteAccessor(this->d_lambda);
+
+    displacement[0] = d_initDisplacement.getValue();
+    force[0] = d_initForce.getValue();
     d_displacement.setValue(d_initDisplacement.getValue());
     d_force.setValue(d_initForce.getValue());
 }
@@ -219,7 +209,7 @@ void SlidingActuator<DataTypes>::checkIndicesRegardingState()
 template<class DataTypes>
 void SlidingActuator<DataTypes>::initLimit()
 {
-    ReadAccessor<sofa::Data<double>> displacement = d_displacement;
+    ReadAccessor<sofa::Data<sofa::type::vector<double>>> displacement = this->d_delta;
     ReadAccessor<sofa::Data<Real>> maxDispVariation = d_maxDispVariation;
     ReadAccessor<sofa::Data<Real>> maxPositiveDisplacement = d_maxPositiveDisplacement;
     ReadAccessor<sofa::Data<Real>> maxNegativeDisplacement = d_maxNegativeDisplacement;
@@ -254,10 +244,10 @@ void SlidingActuator<DataTypes>::initLimit()
     {
         m_hasDeltaMax = true;
         m_hasDeltaMin = true;
-        if(rabs(m_deltaMin[0] - displacement) >= maxDispVariation || !d_maxNegativeDisplacement.isSet())
-            m_deltaMin[0] = displacement - maxDispVariation;
-        if(rabs(m_deltaMax[0] - displacement) >= maxDispVariation || !d_maxPositiveDisplacement.isSet())
-            m_deltaMax[0] = displacement + maxDispVariation;
+        if(rabs(m_deltaMin[0] - displacement[0]) >= maxDispVariation || !d_maxNegativeDisplacement.isSet())
+            m_deltaMin[0] = displacement[0] - maxDispVariation;
+        if(rabs(m_deltaMax[0] - displacement[0]) >= maxDispVariation || !d_maxPositiveDisplacement.isSet())
+            m_deltaMax[0] = displacement[0] + maxDispVariation;
     }
 }
 
@@ -265,23 +255,23 @@ void SlidingActuator<DataTypes>::initLimit()
 template<class DataTypes>
 void SlidingActuator<DataTypes>::updateLimit()
 {
-    ReadAccessor<sofa::Data<double>> displacement = d_displacement;
+    ReadAccessor<sofa::Data<sofa::type::vector<double>>> displacement = this->d_delta;
     ReadAccessor<sofa::Data<Real>> maxDispVariation = d_maxDispVariation;
     ReadAccessor<sofa::Data<Real>> maxPositiveDisplacement = d_maxPositiveDisplacement;
     ReadAccessor<sofa::Data<Real>> maxNegativeDisplacement = d_maxNegativeDisplacement;
 
     if(d_maxPositiveDisplacement.isSet())
     {
-        if (d_accumulateDisp.getValue() && displacement > 0)
-            m_deltaMax[0] = maxPositiveDisplacement - displacement;
+        if (d_accumulateDisp.getValue() && displacement[0] > 0)
+            m_deltaMax[0] = maxPositiveDisplacement - displacement[0];
         else
             m_deltaMax[0] = maxPositiveDisplacement;
     }
 
     if(d_maxNegativeDisplacement.isSet())
     {
-        if (d_accumulateDisp.getValue() && displacement < 0)
-            m_deltaMin[0] = -maxNegativeDisplacement - displacement;
+        if (d_accumulateDisp.getValue() && displacement[0] < 0)
+            m_deltaMin[0] = -maxNegativeDisplacement - displacement[0];
         else
             m_deltaMin[0] = -maxNegativeDisplacement;
     }
@@ -297,10 +287,10 @@ void SlidingActuator<DataTypes>::updateLimit()
         }
         else
         {
-            if(rabs(m_deltaMin[0] - displacement) >= maxDispVariation || !d_maxNegativeDisplacement.isSet())
-                m_deltaMin[0] = displacement - maxDispVariation;
-            if(rabs(m_deltaMax[0] - displacement) >= maxDispVariation || !d_maxPositiveDisplacement.isSet())
-                m_deltaMax[0] = displacement + maxDispVariation;
+            if(rabs(m_deltaMin[0] - displacement[0]) >= maxDispVariation || !d_maxNegativeDisplacement.isSet())
+                m_deltaMin[0] = displacement[0] - maxDispVariation;
+            if(rabs(m_deltaMax[0] - displacement[0]) >= maxDispVariation || !d_maxPositiveDisplacement.isSet())
+                m_deltaMax[0] = displacement[0] + maxDispVariation;
         }
     }
 }
@@ -378,16 +368,22 @@ void SlidingActuator<DataTypes>::storeResults(sofa::type::vector<double> &lambda
 {
     if(d_componentState.getValue() != ComponentState::Valid)
         return ;
+
+    auto l = sofa::helper::getWriteAccessor(this->d_lambda);
+    l[0] = lambda[0];
     d_force.setValue(lambda[0]);
 
+    auto d = sofa::helper::getWriteAccessor(this->d_delta);
     double& displacement = sofa::helper::getWriteAccessor(d_displacement);
     if(d_accumulateDisp.getValue())
     {
         displacement += delta[0];
+        d[0] += delta[0];
     }
     else
     {
         displacement = delta[0];
+        d[0] = delta[0];
     }
 
     updateLimit();
diff --git a/src/SoftRobots.Inverse/component/constraint/SurfacePressureActuator.inl b/src/SoftRobots.Inverse/component/constraint/SurfacePressureActuator.inl
index 4110402..55d6044 100644
--- a/src/SoftRobots.Inverse/component/constraint/SurfacePressureActuator.inl
+++ b/src/SoftRobots.Inverse/component/constraint/SurfacePressureActuator.inl
@@ -49,13 +49,6 @@ SurfacePressureActuator<DataTypes>::SurfacePressureActuator(MechanicalState* obj
     // These data from SurfacePressureModel have no sense for actuator
     d_eqPressure.setDisplayed(false);
     d_eqVolumeGrowth.setDisplayed(false);
-
-    // QP on only one value, we set dimension to one
-    m_lambdaInit.resize(1);
-    m_deltaMax.resize(1);
-    m_deltaMin.resize(1);
-    m_lambdaMax.resize(1);
-    m_lambdaMin.resize(1);
 }
 
 template<class DataTypes>
@@ -91,6 +84,9 @@ template<class DataTypes>
 void SurfacePressureActuator<DataTypes>::initData()
 {
     d_volumeGrowth.setValue(0.0);
+
+    auto pressure = sofa::helper::getWriteAccessor(this->d_lambda);
+    pressure[0] = d_initPressure.getValue();
     d_pressure.setValue(d_initPressure.getValue());
 
     if(d_initPressure.isSet()){
@@ -150,7 +146,7 @@ void SurfacePressureActuator<DataTypes>::initLimits()
 template<class DataTypes>
 void SurfacePressureActuator<DataTypes>::updateLimits()
 {
-    sofa::helper::ReadAccessor<sofa::Data<double>> volumeGrowth = d_volumeGrowth;
+    sofa::helper::ReadAccessor<sofa::Data<sofa::type::vector<double>>> volumeGrowth = this->d_delta;
     sofa::helper::ReadAccessor<sofa::Data<Real>> maxVolumeGrowthVariation = d_maxVolumeGrowthVariation;
     sofa::helper::ReadAccessor<sofa::Data<Real>> maxVolumeGrowth = d_maxVolumeGrowth;
     sofa::helper::ReadAccessor<sofa::Data<Real>> minVolumeGrowth = d_minVolumeGrowth;
@@ -163,10 +159,10 @@ void SurfacePressureActuator<DataTypes>::updateLimits()
 
     if(d_maxVolumeGrowthVariation.isSet())
     {
-        if(rabs(m_deltaMax[0] - volumeGrowth) >= maxVolumeGrowthVariation || !d_maxVolumeGrowth.isSet())
-            m_deltaMax[0] = volumeGrowth + maxVolumeGrowthVariation;
-        if(rabs(m_deltaMin[0] + volumeGrowth) <= -maxVolumeGrowthVariation || !d_minVolumeGrowth.isSet())
-            m_deltaMin[0] = volumeGrowth - maxVolumeGrowthVariation;
+        if(rabs(m_deltaMax[0] - volumeGrowth[0]) >= maxVolumeGrowthVariation || !d_maxVolumeGrowth.isSet())
+            m_deltaMax[0] = volumeGrowth[0] + maxVolumeGrowthVariation;
+        if(rabs(m_deltaMin[0] + volumeGrowth[0]) <= -maxVolumeGrowthVariation || !d_minVolumeGrowth.isSet())
+            m_deltaMin[0] = volumeGrowth[0] - maxVolumeGrowthVariation;
     }
 }
 
@@ -174,6 +170,11 @@ template<class DataTypes>
 void SurfacePressureActuator<DataTypes>::storeResults(sofa::type::vector<double> &lambda,
                                                       sofa::type::vector<double> &delta)
 {
+    auto l = sofa::helper::getWriteAccessor(this->d_lambda);
+    auto d = sofa::helper::getWriteAccessor(this->d_delta);
+    l[0] = lambda[0];
+    d[0] = delta[0];
+
     d_pressure.setValue(lambda[0]);
     d_volumeGrowth.setValue(delta[0]);
 
diff --git a/src/SoftRobots.Inverse/component/constraint/SurfacePressureEquality.inl b/src/SoftRobots.Inverse/component/constraint/SurfacePressureEquality.inl
index 1dfaf03..aad58a1 100644
--- a/src/SoftRobots.Inverse/component/constraint/SurfacePressureEquality.inl
+++ b/src/SoftRobots.Inverse/component/constraint/SurfacePressureEquality.inl
@@ -47,10 +47,6 @@ SurfacePressureEquality<DataTypes>::SurfacePressureEquality(MechanicalState* obj
     d_minVolumeGrowth.setDisplayed(false);
     d_maxPressure.setDisplayed(false);
     d_minPressure.setDisplayed(false);
-
-    // QP on only one value, we set dimension to one
-    m_lambdaEqual.resize(1);
-    m_deltaEqual.resize(1);
 }
 
 template<class DataTypes>
diff --git a/src/SoftRobots.Inverse/component/constraint/VolumeEffector.inl b/src/SoftRobots.Inverse/component/constraint/VolumeEffector.inl
index f099d73..c14b6ad 100644
--- a/src/SoftRobots.Inverse/component/constraint/VolumeEffector.inl
+++ b/src/SoftRobots.Inverse/component/constraint/VolumeEffector.inl
@@ -85,6 +85,8 @@ void VolumeEffector<DataTypes>::getConstraintViolation(const ConstraintParams* c
 template<class DataTypes>
 void VolumeEffector<DataTypes>::storeResults(sofa::type::vector<double> &delta)
 {
+    auto d = sofa::helper::getWriteAccessor(this->d_delta);
+    d[0] = delta[0];
     d_volumeGrowth.setValue(delta[0]);
 }
 
diff --git a/src/SoftRobots.Inverse/component/constraint/YoungModulusActuator.h b/src/SoftRobots.Inverse/component/constraint/YoungModulusActuator.h
index 3eef222..a10c96d 100644
--- a/src/SoftRobots.Inverse/component/constraint/YoungModulusActuator.h
+++ b/src/SoftRobots.Inverse/component/constraint/YoungModulusActuator.h
@@ -103,6 +103,7 @@ class YoungModulusActuator : public Actuator<DataTypes>
     sofa::Data<Real> d_maxYoung;
     sofa::Data<Real> d_maxYoungVariationRatio;
 
+    SOFA_ATTRIBUTE_DEPRECATED("v26.06", "v27.06", "Use d_lambda instead.")
     sofa::Data<Real> d_youngModulus;
     Real m_initialYoungModulus;
 
@@ -125,6 +126,7 @@ class YoungModulusActuator : public Actuator<DataTypes>
     /// Bring inherited attributes and function in the current lookup context.
     /// otherwise any access to the base::attribute would require
     /// the "this->" approach.
+    using Actuator<DataTypes>::d_lambda ;
     using Actuator<DataTypes>::m_state ;
     using Actuator<DataTypes>::m_nbLines ;
     using Actuator<DataTypes>::d_constraintIndex ;
diff --git a/src/SoftRobots.Inverse/component/constraint/YoungModulusActuator.inl b/src/SoftRobots.Inverse/component/constraint/YoungModulusActuator.inl
index 91a8b7f..9a58c93 100644
--- a/src/SoftRobots.Inverse/component/constraint/YoungModulusActuator.inl
+++ b/src/SoftRobots.Inverse/component/constraint/YoungModulusActuator.inl
@@ -54,19 +54,13 @@ YoungModulusActuator<DataTypes>::YoungModulusActuator(MechanicalState* object)
                                         "Maximum variation of young / its actual value. \n"
                                         "If unspecified default value 1.0e1."))
 
-    , d_youngModulus(initData(&d_youngModulus, (Real)0., "youngModulus", "Optimized Young modulus."))
-
     , l_forceField(initLink("forceField", "link to the force field"))
 
     , m_initialYoungModulus(0.0)
     , m_initError(false)
     , m_deltaYoungModulus(0.0)
 {
-    // QP on only one value, we set dimension to one
-    m_lambdaMax.resize(1);
-    m_lambdaMin.resize(1);
-
-    d_youngModulus.setReadOnly(true);
+    this->setLambdaNameAndHelp("youngModulus", "Optimized Young modulus");
 }
 
 
@@ -103,21 +97,21 @@ void YoungModulusActuator<DataTypes>::initLimit()
 template<class DataTypes>
 void YoungModulusActuator<DataTypes>::updateLimit()
 {
-    const auto& youngModulus = sofa::helper::getReadAccessor(d_youngModulus);
+    const auto& youngModulus = sofa::helper::getReadAccessor(d_lambda);
     const auto& minYoung = sofa::helper::getReadAccessor(d_minYoung);
     const auto& maxYoung = sofa::helper::getReadAccessor(d_maxYoung);
     const auto& maxYoungVariationRatio = sofa::helper::getReadAccessor(d_maxYoungVariationRatio);
 
-    m_lambdaMin[0] =- (youngModulus - minYoung);
-    m_lambdaMax[0] = maxYoung - youngModulus;
+    m_lambdaMin[0] =- (youngModulus[0] - minYoung);
+    m_lambdaMax[0] = maxYoung - youngModulus[0];
 
-    double youngMin = youngModulus - youngModulus * maxYoungVariationRatio;
+    double youngMin = youngModulus[0] - youngModulus[0] * maxYoungVariationRatio;
     if(youngMin >= minYoung)
-        m_lambdaMin[0] =- youngModulus * maxYoungVariationRatio;
+        m_lambdaMin[0] =- youngModulus[0] * maxYoungVariationRatio;
 
-    double youngMax = youngModulus + youngModulus * maxYoungVariationRatio;
+    double youngMax = youngModulus[0] + youngModulus[0] * maxYoungVariationRatio;
     if(youngMax <= maxYoung)
-        m_lambdaMax[0] = youngModulus * maxYoungVariationRatio;
+        m_lambdaMax[0] = youngModulus[0] * maxYoungVariationRatio;
 }
 
 
@@ -134,6 +128,8 @@ void YoungModulusActuator<DataTypes>::bwdInit()
             msg_info() << "Found force field named " << l_forceField->getName();
             m_initialYoungModulus = l_forceField->d_youngModulus.getValue()[0];
 
+            auto youngModulus = sofa::helper::getWriteAccessor(d_lambda);
+            youngModulus[0] = m_initialYoungModulus;
             d_youngModulus.setValue(m_initialYoungModulus);
             initLimit();
         }
@@ -152,6 +148,8 @@ void YoungModulusActuator<DataTypes>::reset()
     if(d_componentState.getValue() == ComponentState::Invalid)
         return;
 
+    auto youngModulus = sofa::helper::getWriteAccessor(d_lambda);
+    youngModulus[0] = m_initialYoungModulus;
     d_youngModulus.setValue(m_initialYoungModulus);
     initLimit();
 }
@@ -179,6 +177,8 @@ void YoungModulusActuator<DataTypes>::buildConstraintMatrix(const ConstraintPara
     
     MatrixDerivRowIterator rowIterator = matrix.writeLine(constraintIndex);
     const auto& youngModulus = l_forceField->d_youngModulus.getValue()[0];
+    auto lambda = sofa::helper::getWriteAccessor(d_lambda);
+    lambda[0] = youngModulus;
     d_youngModulus.setValue(youngModulus);
 
     for (unsigned int j=0; j<force.size(); j++)
@@ -240,6 +240,8 @@ void YoungModulusActuator<DataTypes>::storeResults(vector<double> &lambda, vecto
     if(d_componentState.getValue() == ComponentState::Invalid)
         return;
 
+    auto l = sofa::helper::getWriteAccessor(d_lambda);
+    l[0] += Real(lambda[0]);
     Real youngModulus = sofa::helper::getWriteAccessor(d_youngModulus);
     youngModulus += Real(lambda[0]);
 
diff --git a/src/SoftRobots.Inverse/component/solver/QPInverseProblemSolver.cpp b/src/SoftRobots.Inverse/component/solver/QPInverseProblemSolver.cpp
index 95e53bf..fa772a2 100644
--- a/src/SoftRobots.Inverse/component/solver/QPInverseProblemSolver.cpp
+++ b/src/SoftRobots.Inverse/component/solver/QPInverseProblemSolver.cpp
@@ -159,6 +159,8 @@ QPInverseProblemSolver::QPInverseProblemSolver()
 
     , d_objective(initData(&d_objective, 0.0, "objective", "Calculated optimal objective function value."))
 
+    , d_mode(initData(&d_mode, sofa::helper::OptionsGroup{"inverse",  "skipSolve"}, "mode", "Solver mode. In the `skipSolve` case, the component will skip the solving step."))
+
     , m_CP1(nullptr)
     , m_CP2(nullptr)
     , m_CP3(nullptr)
@@ -496,12 +498,12 @@ bool QPInverseProblemSolver::solveSystem(const ConstraintParams * cParams,
     if(d_minContactForces.isSet()) m_currentCP->setMinContactForces(d_minContactForces.getValue());
     if(d_maxContactForces.isSet()) m_currentCP->setMaxContactForces(d_maxContactForces.getValue());
 
-    double objective;
-    int iterations;
+    double objective = 0.;
+    int iterations = 0;
+    if (d_mode.getValue().getSelectedId() == 0)
     {
         sofa::helper::ScopedAdvancedTimer("ConstraintsQP");
         m_currentCP->solve(objective, iterations);
-
     }
 
     module::QPInverseProblem::QPConstraintLists* qpCLists = m_currentCP->getQPConstraintLists();
diff --git a/src/SoftRobots.Inverse/component/solver/QPInverseProblemSolver.h b/src/SoftRobots.Inverse/component/solver/QPInverseProblemSolver.h
index 5ba881e..6f22ecb 100644
--- a/src/SoftRobots.Inverse/component/solver/QPInverseProblemSolver.h
+++ b/src/SoftRobots.Inverse/component/solver/QPInverseProblemSolver.h
@@ -156,6 +156,8 @@ class SOFA_SOFTROBOTS_INVERSE_API QPInverseProblemSolver : public sofa::componen
     sofa::Data<double>    d_maxContactForces;
     sofa::Data<SReal >    d_objective;
 
+    sofa::Data<sofa::helper::OptionsGroup> d_mode;
+
 protected:
 
     MultiVecDerivId m_lambdaId;