diff --git a/.github/actions/build-test-python/entrypoint.sh b/.github/actions/build-test-python/entrypoint.sh
index 7933628ec..b1737f537 100755
--- a/.github/actions/build-test-python/entrypoint.sh
+++ b/.github/actions/build-test-python/entrypoint.sh
@@ -1,7 +1,7 @@
 #!/bin/sh -l
 
 echo ">>> Installing control libraries..."
-bash /github/workspace/source/install.sh --auto --no-controllers --no-dynamical-systems --no-robot-model || exit 1
+bash /github/workspace/source/install.sh --auto --no-controllers --no-robot-model || exit 1
 bash /github/workspace/protocol/install.sh --auto || exit 1
 
 echo ">>> Building Python bindings..."
diff --git a/.github/workflows/generate-docs.yml b/.github/workflows/generate-docs.yml
index ae0602e8f..96cdb983f 100644
--- a/.github/workflows/generate-docs.yml
+++ b/.github/workflows/generate-docs.yml
@@ -25,7 +25,7 @@ jobs:
         if: ${{ github.event_name == 'release' }}
         shell: bash
         run: |
-          TAG="${GITHUB_REF#refs-tags/}"
+          TAG="${GITHUB_REF#refs/tags/}"
           TAG="${TAG/\//-}"
           mkdir -p doxygen/docs/versions
           sudo mv doxygen/docs/html doxygen/docs/versions/${TAG}
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 559652986..e16f5936c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,7 @@
 # CHANGELOG
 
 Release Versions:
+- [5.0.0](#500)
 - [4.1.0](#410)
 - [4.0.0](#400)
 - [3.1.0](#310)
@@ -8,6 +9,119 @@ Release Versions:
 - [2.0.0](#200)
 - [1.0.0](#100)
 
+## 5.0.0
+
+Version 5.0.0 refactors the dynamical systems and controllers libraries with a
+factory pattern and parameter interface for easier creation, manipulation and
+substitution of these classes. This major change breaks any implementations using
+dynamical systems or controllers from the prior version.
+
+See the updated documentation for usage guidelines for the new DynamicalSystemsFactory
+and ControllerFactory.
+
+This release also includes substantial improvements to the python bindings, including
+class bindings for the dynamical systems library. Additional fixes and improvements
+have been made throughout the framework.
+
+### Breaking changes
+
+This release contains the following breaking changes:
+- Relocate `Jacobian` and `JointState` family headers
+- Refactor dynamical system classes to use `IDynamicalSystem` base interface
+- Refactor controller classes to use `IController` base interface
+
+**state_representation**
+
+To make joint-space files more structurally consistent with Cartesian-space files,
+the following headers have been relocated.
+- `state_representation/robot/Joint*.hpp` headers are now in `state_representation/space/joint/Joint*.hpp`
+- `state_representation/robot/Jacobian.hpp` header is now in `state_representation/space/Jacobian.hpp`
+
+Any C++ implementations that include the files from a prior version should update the file paths
+in the `#include` directives. The namespaces themselves in C++ and Python are unaffected.
+
+**dynamical_systems**
+
+The previous DS classes inheriting from the concrete `DynamicalSystem` base class have been
+refactored and partially renamed to inherit from the new abstract `IDynamicalSystem` base class.
+
+- `dynamical_systems::Blending` has been removed
+- `dynamical_systems::Circular` has been refactored
+- `dynamical_systems::DynamicalSystem` has been refactored and renamed to `dynamical_systems::IDynamicalSystem`
+- `dynamical_systems::Linear` has been refactored and renamed to `dynamical_systems::PointAttractor`
+- `dynamical_systems::Ring` has been refactored
+- `dynamical_systems::DefaultDynamicalSystem` has been introduced
+
+It is no longer recommended to directly instantiate and use these classes. The new factory method
+`dynamical_systems::DynamicalSystemFactory<S>::create_dynamical_system(type)` should be used instead.
+See the documentation for more information.
+
+**controllers**
+
+The previous controller classes inheriting from the concrete `Controller` base class have been
+refactored and partially renamed to inherit from the new abstract `IController` base class.
+
+- `controllers::Controller` has been refactored and renamed to `controllers::Controller`
+- `controllers::CartesianTwistController` has been refactored and renamed to `controllers::CompliantTwist`
+- `controllers::Dissipative` has been refactored
+- `controllers::Impedance` has been refactored
+- `controllers::VelocityImpedance` has been refactored
+
+It is no longer recommended to directly instantiate and use these classes. The new factory method
+`controllers::ControllerFactory<S>::create_controller(type)` should be used instead.
+See the documentation for more information.
+
+### Features
+
+**state_representation**
+- Add CartesianAcceleration class in state representation (#248)
+
+**dynamical_systems**
+- Create DS interface and DS factory classes (#227)
+- Refactor Linear DS to PointAttractor DS with factory (#229)
+- Refactor Circular DS with factory (#230)
+- Refactor Ring DS with factory and remove old DS base class (#231)
+- Refactor dynamical systems using factory pattern (#233)
+- Propagate DS refactor to demos (#234)
+- Avoid exception with the default DS in evaluate (#237)
+- Add the `set_parameter_value` function in the DS base class (#236)
+- Remove the `set_base_frame` logic for `JointState` based DS
+  and override `is_compatible` for PointAttractor DS (#236, #239)
+- Return a state that has same name as input in PointAttractor (#241)
+- Update README of dynamical systems (#242)
+
+**controllers**
+- Add IController and ControllerFactory and refactor Controllers (#253, #254, #255)
+
+**python**
+- Add python bindings for dynamical_systems module (#238)
+
+**clproto**
+- Update pybindings and clproto with CartesianAcceleration (#250)
+
+### Fixes and improvements
+
+**state_representation**
+- Add static method to create Parameter pointer (#226)
+- Templated get_value method for Parameter (#228)
+- Mark the JointState as filled when one index was set (#245)
+- Add ParameterMap base class (#247)
+- Relocate Jacobian and JointState family files to the 'space/' directory (#249, #251)
+
+**python**
+- Add support for copy module in Python bindings (#232)
+- Add empty constructors and python bindings for the
+  Shape and Ellipsoid classes (#235)
+
+**general**
+- Install Eigen version 3.4 manually (#240)
+
+### Behind the scenes
+
+- Fix tag generation for release docs (#225)
+- Add user sshd configuration and user 'developer' in base Dockerfile
+  and update all the Dockerfiles and scripts (#244, #246)
+
 ## 4.1.0
 
 Version 4.1.0 contains a few improvements to the behaviour and usage of the libraries,
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 41728d8b9..4a0295bda 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -31,7 +31,7 @@ Step 2: If not already done, [create a remote toolchain in CLion](https://www.je
 using the following credentials:
  - Host: `127.0.0.1`
  - Port: `2222` (or custom specified port)
- - User name: `remote`
+ - User name: `developer`
  - Authentication type: `Key pair`
  
 Step 3: If not already done, [create a CMake profile that uses the remote toolchain](https://www.jetbrains.com/help/clion/remote-projects-support.html#CMakeProfile).
diff --git a/Dockerfile.base b/Dockerfile.base
index fc19201a2..666971714 100644
--- a/Dockerfile.base
+++ b/Dockerfile.base
@@ -1,4 +1,4 @@
-FROM ubuntu:20.04 AS core-build-dependencies
+FROM ubuntu:20.04 as core-build-dependencies
 ENV DEBIAN_FRONTEND=noninteractive
 
 # install core compilation and access dependencies for building the libraries
@@ -28,9 +28,12 @@ RUN echo "deb [arch=amd64] http://robotpkg.openrobots.org/packages/debian/pub $(
     && curl http://robotpkg.openrobots.org/packages/debian/robotpkg.key \
     | apt-key add -
 
+RUN wget -c https://gitlab.com/libeigen/eigen/-/archive/3.4.0/eigen-3.4.0.tar.gz -O - | tar -xz
+RUN cd eigen-3.4.0 && mkdir build && cd build && cmake .. && make install
+RUN rm -r eigen-3.4.0
+
 # install dependencies for building the libraries
 RUN apt-get update && apt-get install -y \
-    libeigen3-dev \
     robotpkg-pinocchio \
     && apt-get clean \
     && rm -rf /var/lib/apt/lists/*
@@ -66,19 +69,56 @@ WORKDIR /home
 RUN rm -rf /tmp/*
 
 
-FROM project-dependencies as development-dependencies
+FROM project-dependencies as ssh-configuration
 
 RUN apt-get update && apt-get install -y \
-    clang \
+    sudo \
+    libssl-dev \
+    ssh \
     iputils-ping \
+    rsync \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# Configure sshd server settings
+RUN ( \
+    echo 'LogLevel DEBUG2'; \
+    echo 'PubkeyAuthentication yes'; \
+    echo 'Subsystem sftp /usr/lib/openssh/sftp-server'; \
+  ) > /etc/ssh/sshd_config_development \
+  && mkdir /run/sshd
+
+ENV USER developer
+ENV HOME /home/${USER}
+
+# create amd configure a new user
+ARG UID=1000
+ARG GID=1000
+RUN addgroup --gid ${GID} ${USER}
+RUN adduser --gecos "Remote User" --uid ${UID} --gid ${GID} ${USER} && yes | passwd ${USER}
+RUN usermod -a -G dialout ${USER}
+RUN echo "${USER} ALL=(ALL) NOPASSWD: ALL" > /etc/sudoers.d/99_aptget
+RUN chmod 0440 /etc/sudoers.d/99_aptget && chown root:root /etc/sudoers.d/99_aptget
+
+# Configure sshd entrypoint to authorise the new user for ssh access and
+# optionally update UID and GID when invoking the container with the entrypoint script
+COPY ./docker/sshd_entrypoint.sh /sshd_entrypoint.sh
+RUN chmod 744 /sshd_entrypoint.sh
+
+# create the credentials to be able to pull private repos using ssh
+RUN mkdir /root/.ssh/ && ssh-keyscan github.com | tee -a /root/.ssh/known_hosts
+
+RUN echo "session required pam_limits.so" | tee --append /etc/pam.d/common-session > /dev/null
+
+
+FROM ssh-configuration as development-dependencies
+
+RUN apt-get update && apt-get install -y \
+    clang \
     gdb \
-    libssl-dev \
     python \
     python3-dev \
     python3-pip \
-    rsync \
-    ssh \
-    sudo \
     tar \
     unzip \
     && apt-get clean \
diff --git a/Dockerfile.proto b/Dockerfile.proto
index 3ddcc1997..60aeee26c 100644
--- a/Dockerfile.proto
+++ b/Dockerfile.proto
@@ -1,4 +1,4 @@
-FROM ubuntu:20.04 AS build-stage
+FROM ubuntu:20.04 as build-stage
 ARG PROTOBUF_VERSION=3.17.0
 ENV DEBIAN_FRONTEND=noninteractive
 
@@ -25,7 +25,8 @@ RUN ./autogen.sh \
     && make \
     && make install
 
-FROM ubuntu:20.04 AS google-dependencies
+
+FROM ubuntu:20.04 as google-dependencies
 COPY --from=build-stage /usr/local/include/google /usr/local/include/google
 COPY --from=build-stage /usr/local/lib/libproto* /usr/local/lib/
 COPY --from=build-stage /usr/local/bin/protoc /usr/local/bin
diff --git a/demos/control_loop_examples/Dockerfile b/demos/control_loop_examples/Dockerfile
index 88e5f380d..d1b556100 100644
--- a/demos/control_loop_examples/Dockerfile
+++ b/demos/control_loop_examples/Dockerfile
@@ -1,4 +1,4 @@
-FROM control-libraries/source-dependencies as runtime-demonstrations
+FROM epfl-lasa/control-libraries/source:install
 
 WORKDIR /tmp/
 COPY . ./control_loop_examples
@@ -7,4 +7,6 @@ WORKDIR /tmp/control_loop_examples/build
 RUN cmake .. && make -j all && make install
 
 WORKDIR /usr/local/bin
-RUN rm -rf /tmp/demos/
\ No newline at end of file
+RUN rm -rf /tmp/demos/
+
+USER developer
\ No newline at end of file
diff --git a/demos/control_loop_examples/run-demo.sh b/demos/control_loop_examples/run-demo.sh
index ce9b65a07..b23ac496f 100755
--- a/demos/control_loop_examples/run-demo.sh
+++ b/demos/control_loop_examples/run-demo.sh
@@ -1,36 +1,44 @@
 #!/usr/bin/env bash
-# Build a docker image to compile the library and run tests
-MULTISTAGE_TARGET="runtime-demonstrations"
 
-REBUILD=0
-while getopts 'r' opt; do
-    case $opt in
-        r) REBUILD=1 ;;
-        *) echo 'Error in command line parsing' >&2
-           exit 1
-    esac
-done
-shift "$(( OPTIND - 1 ))"
-
-NAME=$(echo "${PWD##*/}" | tr _ -)/$MULTISTAGE_TARGET
-TAG="latest"
-TARGET_SCRIPT=${1}
+IMAGE_NAME=epfl-lasa/control-libraries/control-loop-examples
+IMAGE_TAG=latest
 
-BUILD_FLAGS=(--target "${MULTISTAGE_TARGET}")
-BUILD_FLAGS+=(-t "${NAME}:${TAG}")
+HELP_MESSAGE="Usage: run-demo.sh [-s <script>] [-r] [-v]
+Options:
+  -s, --script             If provided, the desired script that should be
+                           executed when starting the container.
+  -r, --rebuild            Rebuild the image using the docker
+                           --no-cache option.
+  -v, --verbose            Use the verbose option during the building
+                           process.
+  -h, --help               Show this help message.
+"
 
-if [ "$REBUILD" -eq 1 ]; then
-    BUILD_FLAGS+=(--no-cache)
-fi
+BUILD_FLAGS=()
+TARGET_SCRIPT=""
+while [[ $# -gt 0 ]]; do
+  opt="$1"
+  case $opt in
+    -s|--script) TARGET_SCRIPT="$2"; shift;;
+    -r|--rebuild) BUILD_FLAGS+=(--no-cache); shift ;;
+    -v|--verbose) BUILD_FLAGS+=(--progress=plain); shift ;;
+    -h|--help) echo "${HELP_MESSAGE}" ; exit 0 ;;
+    *) echo 'Error in command line parsing' >&2
+       echo -e "\n${HELP_MESSAGE}"
+       exit 1
+  esac
+done
 
-MULTISTAGE_SOURCE_TARGET="source-dependencies"
-DOCKER_BUILDKIT=1 docker build --target "${MULTISTAGE_SOURCE_TARGET}" \
-  -t "control-libraries/${MULTISTAGE_SOURCE_TARGET}" \
-  -f ../../source/Dockerfile.source ../../source || exit
-DOCKER_BUILDKIT=1 docker build "${BUILD_FLAGS[@]}" . || exit
+docker pull ghcr.io/epfl-lasa/control-libraries/development-dependencies
+DOCKER_BUILDKIT=1 docker build --target install \
+  -t epfl-lasa/control-libraries/source:install \
+  --build-arg BUILD_TESTING=OFF \
+  "${BUILD_FLAGS[@]}" \
+  -f ../../source/Dockerfile.source ../../source || exit 1
+DOCKER_BUILDKIT=1 docker build "${BUILD_FLAGS[@]}" . -t "${IMAGE_NAME}:${IMAGE_TAG}" || exit 1
 
-if [ -z "${1}" ]; then
-  docker run -it --rm "${NAME}:${TAG}"
+if [ -z "${TARGET_SCRIPT}" ]; then
+  docker run -it --rm "${IMAGE_NAME}:${IMAGE_TAG}"
 else
-  docker run --rm "${NAME}:${TAG}" "./${1}"
+  docker run --rm "${IMAGE_NAME}:${IMAGE_TAG}" "./${TARGET_SCRIPT}"
 fi
diff --git a/demos/control_loop_examples/scripts/robot_kinematics_control_loop.cpp b/demos/control_loop_examples/scripts/robot_kinematics_control_loop.cpp
index 2c1e7fd51..b68003d33 100644
--- a/demos/control_loop_examples/scripts/robot_kinematics_control_loop.cpp
+++ b/demos/control_loop_examples/scripts/robot_kinematics_control_loop.cpp
@@ -3,9 +3,9 @@
 #include <utility>
 #include <state_representation/space/cartesian/CartesianPose.hpp>
 #include <state_representation/space/cartesian/CartesianTwist.hpp>
-#include <state_representation/robot/JointPositions.hpp>
-#include <state_representation/robot/JointVelocities.hpp>
-#include <dynamical_systems/Linear.hpp>
+#include <state_representation/space/joint/JointPositions.hpp>
+#include <state_representation/space/joint/JointVelocities.hpp>
+#include "dynamical_systems/DynamicalSystemFactory.hpp"
 #include <robot_model/Model.hpp>
 
 using namespace state_representation;
@@ -38,39 +38,44 @@ class DummyRobotInterface {
     QPInverseVelocityParameters parameters;
     parameters.dt = dt;
     // apply the inverse velocity
-    JointVelocities desired_joint_velocities = this->robot_.inverse_velocity(desired_eef_twist,
-                                                                             this->joint_positions,
-                                                                             parameters);
+    JointVelocities desired_joint_velocities = this->robot_.inverse_velocity(
+        desired_eef_twist, this->joint_positions, parameters
+    );
     // integrate the new position
     this->joint_positions = dt * desired_joint_velocities + this->joint_positions;
   }
 };
 
-void control_loop_step(DummyRobotInterface& robot,
-                       const Linear<CartesianState>& ds,
-                       const std::chrono::nanoseconds& dt) {
+void control_loop_step(
+    DummyRobotInterface& robot, const std::shared_ptr<IDynamicalSystem<CartesianState>>& ds,
+    const std::chrono::nanoseconds& dt
+) {
   // read the robot state
   robot.read_robot_state();
   // print the state and eef pose
   std::cout << robot.joint_positions << std::endl;
   std::cout << robot.eef_pose << std::endl;
   // get the twist evaluated at current pose
-  CartesianTwist desired_twist = ds.evaluate(robot.eef_pose);
+  CartesianTwist desired_twist = ds->evaluate(robot.eef_pose);
   // send the desired twist to the robot
   robot.send_control_command(desired_twist, dt);
 }
 
 void control_loop(DummyRobotInterface& robot, const std::chrono::nanoseconds& dt, double tolerance) {
-  // set a desired target for the robot eef and a linear ds toward the target
+  // set a desired target for the robot eef and a point attractor ds toward the target
   CartesianPose target(robot.eef_pose.get_name(), robot.eef_pose.get_reference_frame());
   target.set_position(.5, .0, .75);
   Eigen::Quaterniond orientation(Eigen::AngleAxisd(M_PI, Eigen::Vector3d::UnitY()));
   target.set_orientation(orientation);
-  Linear<CartesianState> linear_ds(target);
+  std::shared_ptr<IDynamicalSystem<CartesianState>>
+      ds = DynamicalSystemFactory<CartesianState>::create_dynamical_system(
+      DynamicalSystemFactory<CartesianState>::DYNAMICAL_SYSTEM::POINT_ATTRACTOR
+  );
+  ds->set_parameter(make_shared_parameter("attractor", target));
 
   double distance;
   do {
-    control_loop_step(robot, linear_ds, dt);
+    control_loop_step(robot, ds, dt);
     distance = dist(robot.eef_pose, target, CartesianStateVariable::POSE);
     std::cout << "distance to attractor: " << std::to_string(distance) << std::endl;
     std::cout << "-----------" << std::endl;
@@ -86,7 +91,6 @@ void control_loop(DummyRobotInterface& robot, const std::chrono::nanoseconds& dt
 }
 
 int main(int, char**) {
-  std::string robot_name = "franka";
   std::string urdf_path = std::string(SCRIPT_FIXTURES) + "panda_arm.urdf";
   DummyRobotInterface robot("franka", urdf_path);
   auto dt = 100ms;
diff --git a/demos/control_loop_examples/scripts/task_space_control_loop.cpp b/demos/control_loop_examples/scripts/task_space_control_loop.cpp
index e6b9c164d..8297b211f 100644
--- a/demos/control_loop_examples/scripts/task_space_control_loop.cpp
+++ b/demos/control_loop_examples/scripts/task_space_control_loop.cpp
@@ -2,17 +2,18 @@
 #include <thread>
 #include <state_representation/space/cartesian/CartesianPose.hpp>
 #include <state_representation/space/cartesian/CartesianTwist.hpp>
-#include <dynamical_systems/Linear.hpp>
+#include "dynamical_systems/DynamicalSystemFactory.hpp"
 
 using namespace state_representation;
 using namespace dynamical_systems;
 using namespace std::chrono_literals;
 
-CartesianPose control_loop_step(const CartesianPose& pose,
-                                const Linear<CartesianState>& ds,
-                                const std::chrono::nanoseconds& dt) {
+CartesianPose control_loop_step(
+    const CartesianPose& pose, const std::shared_ptr<IDynamicalSystem<CartesianState>>& ds,
+    const std::chrono::nanoseconds& dt
+) {
   // get the twist evaluated at current pose
-  CartesianTwist desired_twist = ds.evaluate(pose);
+  CartesianTwist desired_twist = ds->evaluate(pose);
   // integrate the twist and add it to the current pose
   CartesianPose new_pose = dt * desired_twist + pose;
   // print the new pose
@@ -22,15 +23,19 @@ CartesianPose control_loop_step(const CartesianPose& pose,
 }
 
 void control_loop(const std::chrono::nanoseconds& dt, double tolerance) {
-  // set a desired target and a linear ds toward the target
+  // set a desired target and a point attractor ds toward the target
   CartesianPose target = CartesianPose::Random("frame");
-  Linear<CartesianState> linear_ds(target);
+  std::shared_ptr<IDynamicalSystem<CartesianState>>
+      ds = DynamicalSystemFactory<CartesianState>::create_dynamical_system(
+      DynamicalSystemFactory<CartesianState>::DYNAMICAL_SYSTEM::POINT_ATTRACTOR
+  );
+  ds->set_parameter(make_shared_parameter("attractor", target));
   // set a starting pose
   CartesianPose current_pose = CartesianPose::Random("frame");
   // loop until target is reached
   double distance;
   do {
-    current_pose = control_loop_step(current_pose, linear_ds, dt);
+    current_pose = control_loop_step(current_pose, ds, dt);
     distance = dist(current_pose, target, CartesianStateVariable::POSE);
     std::cout << "distance to attractor: " << std::to_string(distance) << std::endl;
     std::cout << "-----------" << std::endl;
diff --git a/demos/ros2_examples/Dockerfile b/demos/ros2_examples/Dockerfile
index 3d7b2edf7..182362f0d 100644
--- a/demos/ros2_examples/Dockerfile
+++ b/demos/ros2_examples/Dockerfile
@@ -1,4 +1,4 @@
-FROM control-libraries/source-dependencies as ros-dependencies
+FROM epfl-lasa/control-libraries/source:install as ros-dependencies
 
 # install ROS
 ENV ROS_DISTRO="foxy"
@@ -14,20 +14,7 @@ RUN apt update && apt install -y ros-${ROS_DISTRO}-ros-base \
     sudo \
     && apt-get clean && rm -rf /var/lib/apt/lists/*
 
-# create a user with same permissions as the host itself
-ENV USER ros2
-ARG UID=1000
-ARG GID=1000
-RUN addgroup --gid ${GID} ${USER}
-RUN adduser --gecos "ROS2 User" --disabled-password --uid ${UID} --gid ${GID} ${USER}
-RUN usermod -a -G dialout ${USER}
-RUN echo "${USER} ALL=(ALL) NOPASSWD: ALL" | sudo tee -a /etc/sudoers.d/99_aptget > /dev/null \
-    && chmod 0440 /etc/sudoers.d/99_aptget \
-    && chown root:root /etc/sudoers.d/99_aptget
-
-# change user to the newly created one
-USER ${USER}
-ENV HOME /home/${USER}
+USER developer
 
 # add and build a ros workspace
 ENV ROS_WORKSPACE ${HOME}/ros2_ws
diff --git a/demos/ros2_examples/README.md b/demos/ros2_examples/README.md
index 877f8c720..d7b9c570b 100644
--- a/demos/ros2_examples/README.md
+++ b/demos/ros2_examples/README.md
@@ -19,10 +19,10 @@ Running the scripts uses ROS2 commands, e.g. to run the `task_space_control_loop
 ros2 run ros2_examples task_space_control_loop
 ```
 
-You can also directly use the launchfile that starts any requirement for the demo to run correctly:
+You can also directly use the launch file that starts any requirement for the demo to run correctly:
 
 ```console
-ros2 launch ros2_examples task_space_control_loop.py
+ros2 launch ros2_examples task_space_control_loop.launch.py
 ```
 
 ## `task_space_control_loop`
diff --git a/demos/ros2_examples/launch/task_space_control_loop.py b/demos/ros2_examples/launch/task_space_control_loop.launch.py
similarity index 100%
rename from demos/ros2_examples/launch/task_space_control_loop.py
rename to demos/ros2_examples/launch/task_space_control_loop.launch.py
diff --git a/demos/ros2_examples/run-demo.sh b/demos/ros2_examples/run-demo.sh
index 976209689..9cfde2c49 100755
--- a/demos/ros2_examples/run-demo.sh
+++ b/demos/ros2_examples/run-demo.sh
@@ -1,74 +1,74 @@
 #!/usr/bin/env bash
-# change to false if not using nvidia graphic cards
-USE_NVIDIA_TOOLKIT=false
+
 # change to  false to use host network
-ISISOLATED=true
+IS_ISOLATED=true
 
-# Build a docker image to compile the library and run tests
 MULTISTAGE_TARGET="runtime-demonstrations"
+IMAGE_NAME=epfl-lasa/control-libraries/ros2-examples
+IMAGE_TAG="${MULTISTAGE_TARGET}"
+GPUS=""
 
 NETWORK=host
-if [ "${ISISOLATED}" = true ]; then
+if [ "${IS_ISOLATED}" = true ]; then
     docker network inspect isolated >/dev/null 2>&1 || docker network create --driver bridge isolated
     NETWORK=isolated
 fi
 
-REBUILD=0
-while getopts 'r' opt; do
-    case $opt in
-        r) REBUILD=1 ;;
-        *) echo 'Error in command line parsing' >&2
-           exit 1
-    esac
-done
-shift "$(( OPTIND - 1 ))"
+HELP_MESSAGE="Usage: run-demo.sh [-r] [-v]
+Options:
+  --gpus <gpu_options>     Add GPU access for applications that
+                           require hardware acceleration (e.g. Gazebo)
+                           For the list of gpu_options parameters see:
+      >>> https://docs.docker.com/config/containers/resource_constraints
+  -r, --rebuild            Rebuild the image using the docker
+                           --no-cache option.
+  -v, --verbose            Use the verbose option during the building
+                           process.
+  -h, --help               Show this help message.
+"
 
-PACKAGE_NAME=$(echo "${PWD##*/}" | tr _ -)
-IMAGE_NAME="${PACKAGE_NAME}/$MULTISTAGE_TARGET"
-TAG="latest"
+BUILD_FLAGS=()
+while [[ $# -gt 0 ]]; do
+  opt="$1"
+  case $opt in
+    --gpus) GPUS=$2; shift 2;;
+    -r|--rebuild) BUILD_FLAGS+=(--no-cache); shift ;;
+    -v|--verbose) BUILD_FLAGS+=(--progress=plain); shift ;;
+    -h|--help) echo "${HELP_MESSAGE}" ; exit 0 ;;
+    *) echo 'Error in command line parsing' >&2
+       echo -e "\n${HELP_MESSAGE}"
+       exit 1
+  esac
+done
 
-BUILD_FLAGS=(--target "${MULTISTAGE_TARGET}")
+docker pull ghcr.io/epfl-lasa/control-libraries/development-dependencies
+DOCKER_BUILDKIT=1 docker build --target install \
+  -t epfl-lasa/control-libraries/source:install \
+  --build-arg BUILD_TESTING=OFF \
+  "${BUILD_FLAGS[@]}" \
+  -f ../../source/Dockerfile.source ../../source || exit 1
+DOCKER_BUILDKIT=1 docker build "${BUILD_FLAGS[@]}" . --target "${MULTISTAGE_TARGET}" -t "${IMAGE_NAME}:${IMAGE_TAG}" || exit 1
 
-if [[ "$OSTYPE" != "darwin"* ]]; then
-  UID="$(id -u "${USER}")"
-  GID="$(id -g "${USER}")"
-  BUILD_FLAGS+=(--build-arg UID="${UID}")
-  BUILD_FLAGS+=(--build-arg GID="${GID}")
+RUN_FLAGS=(-u developer)
+if [ -n "${GPUS}" ]; then
+  RUN_FLAGS+=(--gpus "${GPUS}")
+  RUN_FLAGS+=(--env DISPLAY="${DISPLAY}")
+  RUN_FLAGS+=(--env NVIDIA_VISIBLE_DEVICES="${NVIDIA_VISIBLE_DEVICES:-all}")
+  RUN_FLAGS+=(--env NVIDIA_DRIVER_CAPABILITIES="${NVIDIA_DRIVER_CAPABILITIES:+$NVIDIA_DRIVER_CAPABILITIES,}graphics")
 fi
 
-BUILD_FLAGS+=(-t "${IMAGE_NAME}:${TAG}")
-
-if [ "$REBUILD" -eq 1 ]; then
-    BUILD_FLAGS+=(--no-cache)
+if [[ "${OSTYPE}" == "darwin"* ]]; then
+  RUN_FLAGS+=(-e DISPLAY=host.docker.internal:0)
+else
+  xhost +
+  RUN_FLAGS+=(-e DISPLAY="${DISPLAY}")
+  RUN_FLAGS+=(-e XAUTHORITY="${XAUTHORITY}")
+  RUN_FLAGS+=(-v /tmp/.X11-unix:/tmp/.X11-unix:rw)
+  RUN_FLAGS+=(--device=/dev/dri:/dev/dri)
 fi
 
-MULTISTAGE_SOURCE_TARGET="source-dependencies"
-DOCKER_BUILDKIT=1 docker build --target "${MULTISTAGE_SOURCE_TARGET}" \
-  -t "control-libraries/${MULTISTAGE_SOURCE_TARGET}" \
-  -f ../../source/Dockerfile.source ../../source || exit
-DOCKER_BUILDKIT=1 docker build "${BUILD_FLAGS[@]}" . || exit
-
-#create a shared volume to store rviz config files
-mkdir -p "rviz"
-docker volume create --driver local \
-    --opt type="none" \
-    --opt device="${PWD}/rviz/" \
-    --opt o="bind" \
-    "${PACKAGE_NAME}_rviz_vol"
-
-[[ ${USE_NVIDIA_TOOLKIT} = true ]] && GPU_FLAG="--gpus all" || GPU_FLAG=""
-
-xhost +
-docker run \
-  ${GPU_FLAG} \
-  --privileged \
-  -it \
-  --rm \
-  --net="${NETWORK}" \
-  --volume="/tmp/.X11-unix:/tmp/.X11-unix:rw" \
-  --volume="$XAUTH:$XAUTH" \
-  --volume="${PACKAGE_NAME}_rviz_vol:/home/ros2/ros2_ws/install/ros2_examples/share/ros2_examples/rviz/:rw" \
-  --env XAUTHORITY="$XAUTH" \
-  --env DISPLAY="${DISPLAY}" \
-  "${IMAGE_NAME}:${TAG}"
-
+docker run -it --rm --net="${NETWORK}" \
+  "${RUN_FLAGS[@]}" \
+  --volume="$(pwd)/rviz:/home/developer/ros2_ws/src/ros2_examples/rviz/:rw" \
+  --name "${CONTAINER_NAME}" \
+  "${IMAGE_NAME}:${IMAGE_TAG}" /bin/bash
diff --git a/demos/ros2_examples/scripts/task_space_control_loop.cpp b/demos/ros2_examples/scripts/task_space_control_loop.cpp
index 36b0bf1c7..ccf0bc325 100644
--- a/demos/ros2_examples/scripts/task_space_control_loop.cpp
+++ b/demos/ros2_examples/scripts/task_space_control_loop.cpp
@@ -6,7 +6,7 @@
 #include <tf2_geometry_msgs/tf2_geometry_msgs.h>
 #include <state_representation/space/cartesian/CartesianPose.hpp>
 #include <state_representation/space/cartesian/CartesianTwist.hpp>
-#include <dynamical_systems/Linear.hpp>
+#include "dynamical_systems/DynamicalSystemFactory.hpp"
 
 using namespace state_representation;
 using namespace dynamical_systems;
@@ -20,7 +20,7 @@ class TaskSpaceControlLoop : public rclcpp::Node {
   std::thread run_thread_; ///< thread object to start the main loop, i.e. the run function, in parallel of the rest
   CartesianPose current_pose_; ///< current pose
   CartesianPose target_; ///< attractor pose
-  std::shared_ptr<Linear < CartesianState>> dynamical_system_ = nullptr; ///< dynamical system to the attractor
+  std::shared_ptr<IDynamicalSystem<CartesianState>> dynamical_system_; ///< dynamical system to the attractor
 
   void send_transform(const CartesianPose& pose, const std::string& pose_name_prefix = "") {
     auto node_handle = this->shared_from_this();
@@ -52,10 +52,12 @@ class TaskSpaceControlLoop : public rclcpp::Node {
   }
 
   void init() {
-    // set a desired target and a linear ds toward the target
+    // set a desired target and a point attractor ds toward the target
     this->target_ = CartesianPose::Random("frame");
-    this->dynamical_system_ = std::make_shared<Linear < CartesianState>>
-    (this->target_);
+    this->dynamical_system_ = DynamicalSystemFactory<CartesianState>::create_dynamical_system(
+        DynamicalSystemFactory<CartesianState>::DYNAMICAL_SYSTEM::POINT_ATTRACTOR
+    );
+    this->dynamical_system_->set_parameter(make_shared_parameter("attractor", this->target_));
     // set a starting pose
     this->current_pose_ = CartesianPose::Random("frame");
     // add the run thread
diff --git a/demos/ros_examples/Dockerfile b/demos/ros_examples/Dockerfile
index 17567898e..b32e80a73 100644
--- a/demos/ros_examples/Dockerfile
+++ b/demos/ros_examples/Dockerfile
@@ -1,4 +1,4 @@
-FROM control-libraries/source-dependencies as ros-dependencies
+FROM epfl-lasa/control-libraries/source:install as ros-dependencies
 
 # install ROS
 ENV ROS_DISTRO="noetic"
@@ -16,20 +16,7 @@ RUN apt update && apt install -y ros-${ROS_DISTRO}-ros-base \
     sudo \
     && apt-get clean && rm -rf /var/lib/apt/lists/*
 
-# create a user with same permissions as the host itself
-ENV USER ros
-ARG UID=1000
-ARG GID=1000
-RUN addgroup --gid ${GID} ${USER}
-RUN adduser --gecos "ROS User" --disabled-password --uid ${UID} --gid ${GID} ${USER}
-RUN usermod -a -G dialout ${USER}
-RUN echo "${USER} ALL=(ALL) NOPASSWD: ALL" | sudo tee -a /etc/sudoers.d/99_aptget > /dev/null \
-    && chmod 0440 /etc/sudoers.d/99_aptget \
-    && chown root:root /etc/sudoers.d/99_aptget
-
-# change user to the newly created one
-USER ${USER}
-ENV HOME /home/${USER}
+USER developer
 
 # add and build a ros workspace
 ENV ROS_WORKSPACE ${HOME}/ros_ws
@@ -50,10 +37,6 @@ RUN sudo chmod +x /sbin/update_bashrc ; \
 COPY config/entrypoint.sh /ros_entrypoint.sh
 RUN sudo chmod +x /ros_entrypoint.sh ; sudo chown ${USER} /ros_entrypoint.sh ;
 
-# env vars for the nvidia-container-runtime.
-ENV NVIDIA_VISIBLE_DEVICES all
-ENV NVIDIA_DRIVER_CAPABILITIES graphics,utility,compute
-
 
 FROM ros-dependencies as runtime-demonstrations
 
diff --git a/demos/ros_examples/README.md b/demos/ros_examples/README.md
index 3daf4b3c1..8c82e393a 100644
--- a/demos/ros_examples/README.md
+++ b/demos/ros_examples/README.md
@@ -45,18 +45,19 @@ At each control step, the scripts publishes the desired joint velocity to the `v
 To run this script and visualize the robot, follow the steps below to launch a *PyBullet* simulation with a ROS interface:
 
 - in a first terminal, run:
-    ```bash
-    cd control-libraries/demos/ros_examples
-    bash run-demo.sh # this will build a docker image and spin up a container
-    # inside the container
-    roslaunch ros_examples joint_space_velocity_control.launch robot_name:=franka
-    ```
-- in a second terminal, run:
     ```bash
     # in a directory of your choice (preferably not in the control-libraries directory)
-    git clone https://github.com/domire8/pybullet_ros.git --branch control-libraries-demo --single-branch
+    git clone https://github.com/domire8/pybullet_ros.git  --depth 1 --branch control-libraries-demo
     cd pybullet_ros/docker
     bash build-run.sh # this will build a docker image and spin up a container
     # inside the container
     roslaunch pybullet_ros franka.launch
     ```
+
+- in a second terminal, run:
+    ```bash
+    cd control-libraries/demos/ros_examples
+    bash run-demo.sh # this will build a docker image and spin up a container
+    # inside the container
+    roslaunch ros_examples joint_space_velocity_control.launch robot_name:=franka
+    ```
diff --git a/demos/ros_examples/run-demo.sh b/demos/ros_examples/run-demo.sh
index 12de861d4..09915fd47 100755
--- a/demos/ros_examples/run-demo.sh
+++ b/demos/ros_examples/run-demo.sh
@@ -1,64 +1,65 @@
 #!/usr/bin/env bash
-# change to false if not using nvidia graphic cards
-USE_NVIDIA_TOOLKIT=false
 
-# Build a docker image to compile the library and run tests
 MULTISTAGE_TARGET="runtime-demonstrations"
+IMAGE_NAME=epfl-lasa/control-libraries/ros-examples
+IMAGE_TAG="${MULTISTAGE_TARGET}"
+GPUS=""
 
-REBUILD=0
-while getopts 'r' opt; do
-    case $opt in
-        r) REBUILD=1 ;;
-        *) echo 'Error in command line parsing' >&2
-           exit 1
-    esac
-done
-shift "$(( OPTIND - 1 ))"
+HELP_MESSAGE="Usage: run-demo.sh [-r] [-v]
+Options:
+  --gpus <gpu_options>     Add GPU access for applications that
+                           require hardware acceleration (e.g. Gazebo)
+                           For the list of gpu_options parameters see:
+      >>> https://docs.docker.com/config/containers/resource_constraints
+  -r, --rebuild            Rebuild the image using the docker
+                           --no-cache option.
+  -v, --verbose            Use the verbose option during the building
+                           process.
+  -h, --help               Show this help message.
+"
 
-PACKAGE_NAME=$(echo "${PWD##*/}" | tr _ -)
-IMAGE_NAME="${PACKAGE_NAME}/$MULTISTAGE_TARGET"
-TAG="latest"
+BUILD_FLAGS=()
+while [[ $# -gt 0 ]]; do
+  opt="$1"
+  case $opt in
+    --gpus) GPUS=$2; shift 2;;
+    -r|--rebuild) BUILD_FLAGS+=(--no-cache); shift ;;
+    -v|--verbose) BUILD_FLAGS+=(--progress=plain); shift ;;
+    -h|--help) echo "${HELP_MESSAGE}" ; exit 0 ;;
+    *) echo 'Error in command line parsing' >&2
+       echo -e "\n${HELP_MESSAGE}"
+       exit 1
+  esac
+done
 
-BUILD_FLAGS=(--target "${MULTISTAGE_TARGET}")
+docker pull ghcr.io/epfl-lasa/control-libraries/development-dependencies
+DOCKER_BUILDKIT=1 docker build --target install \
+  -t epfl-lasa/control-libraries/source:install \
+  --build-arg BUILD_TESTING=OFF \
+  "${BUILD_FLAGS[@]}" \
+  -f ../../source/Dockerfile.source ../../source || exit 1
+DOCKER_BUILDKIT=1 docker build "${BUILD_FLAGS[@]}" . --target "${MULTISTAGE_TARGET}" -t "${IMAGE_NAME}:${IMAGE_TAG}" || exit 1
 
-if [[ "$OSTYPE" != "darwin"* ]]; then
-  UID="$(id -u "${USER}")"
-  GID="$(id -g "${USER}")"
-  BUILD_FLAGS+=(--build-arg UID="${UID}")
-  BUILD_FLAGS+=(--build-arg GID="${GID}")
+RUN_FLAGS=(-u developer)
+if [ -n "${GPUS}" ]; then
+  RUN_FLAGS+=(--gpus "${GPUS}")
+  RUN_FLAGS+=(--env DISPLAY="${DISPLAY}")
+  RUN_FLAGS+=(--env NVIDIA_VISIBLE_DEVICES="${NVIDIA_VISIBLE_DEVICES:-all}")
+  RUN_FLAGS+=(--env NVIDIA_DRIVER_CAPABILITIES="${NVIDIA_DRIVER_CAPABILITIES:+$NVIDIA_DRIVER_CAPABILITIES,}graphics")
 fi
-BUILD_FLAGS+=(-t "${IMAGE_NAME}:${TAG}")
 
-if [ "$REBUILD" -eq 1 ]; then
-    BUILD_FLAGS+=(--no-cache)
+if [[ "${OSTYPE}" == "darwin"* ]]; then
+  RUN_FLAGS+=(-e DISPLAY=host.docker.internal:0)
+else
+  xhost +
+  RUN_FLAGS+=(-e DISPLAY="${DISPLAY}")
+  RUN_FLAGS+=(-e XAUTHORITY="${XAUTHORITY}")
+  RUN_FLAGS+=(-v /tmp/.X11-unix:/tmp/.X11-unix:rw)
+  RUN_FLAGS+=(--device=/dev/dri:/dev/dri)
 fi
 
-MULTISTAGE_SOURCE_TARGET="source-dependencies"
-DOCKER_BUILDKIT=1 docker build --target "${MULTISTAGE_SOURCE_TARGET}" \
-  -t "control-libraries/${MULTISTAGE_SOURCE_TARGET}" \
-  -f ../../source/Dockerfile.source ../../source || exit
-DOCKER_BUILDKIT=1 docker build "${BUILD_FLAGS[@]}" . || exit
-
-#create a shared volume to store rviz config files
-mkdir -p "rviz"
-docker volume create --driver local \
-    --opt type="none" \
-    --opt device="${PWD}/rviz/" \
-    --opt o="bind" \
-    "${PACKAGE_NAME}_rviz_vol"
-
-[[ ${USE_NVIDIA_TOOLKIT} = true ]] && GPU_FLAG="--gpus all" || GPU_FLAG=""
-
-xhost +
-docker run \
-  ${GPU_FLAG} \
-  --privileged \
-  -it \
-  --rm \
-  --net="host" \
-  --volume="/tmp/.X11-unix:/tmp/.X11-unix:rw" \
-  --volume="${XAUTHORITY}:${XAUTHORITY}" \
-  --volume="${PACKAGE_NAME}_rviz_vol:/home/ros/ros_ws/src/ros_examples/rviz/:rw" \
-  --env XAUTHORITY="${XAUTHORITY}" \
-  --env DISPLAY="${DISPLAY}" \
-  "${IMAGE_NAME}:${TAG}"
+docker run -it --rm --net=host \
+  "${RUN_FLAGS[@]}" \
+  --volume="$(pwd)/rviz:/home/developer/ros_ws/src/ros_examples/rviz/:rw" \
+  --name "${CONTAINER_NAME}" \
+  "${IMAGE_NAME}:${IMAGE_TAG}" /bin/bash
\ No newline at end of file
diff --git a/demos/ros_examples/scripts/joint_space_velocity_control.cpp b/demos/ros_examples/scripts/joint_space_velocity_control.cpp
index 49ec5216e..960edc99a 100644
--- a/demos/ros_examples/scripts/joint_space_velocity_control.cpp
+++ b/demos/ros_examples/scripts/joint_space_velocity_control.cpp
@@ -4,8 +4,8 @@
 #include <sensor_msgs/JointState.h>
 #include <state_representation/space/cartesian/CartesianPose.hpp>
 #include <state_representation/space/cartesian/CartesianTwist.hpp>
-#include <state_representation/robot/JointVelocities.hpp>
-#include <dynamical_systems/Linear.hpp>
+#include <state_representation/space/joint/JointVelocities.hpp>
+#include "dynamical_systems/DynamicalSystemFactory.hpp"
 #include <robot_model/Model.hpp>
 
 using namespace state_representation;
@@ -71,17 +71,23 @@ class RobotInterface {
 }
 
 void control_loop(RobotInterface& robot, const int& freq) {
-  // set a desired target and a linear ds toward the target
+  // set a desired target and a point attractor ds toward the target
   CartesianPose target(robot.get_robot_frames().back(), robot.get_robot_frames().front());
   target.set_position(.5, .0, .5);
   target.set_orientation(Eigen::Quaterniond(0, 1, 0, 0));
   std::vector<double> gains = {50.0, 50.0, 50.0, 10.0, 10.0, 10.0};
-  Linear<CartesianState> linear_ds(target, gains);
+
+  std::shared_ptr<IDynamicalSystem<CartesianState>>
+      ds = DynamicalSystemFactory<CartesianState>::create_dynamical_system(
+      DynamicalSystemFactory<CartesianState>::DYNAMICAL_SYSTEM::POINT_ATTRACTOR
+  );
+  ds->set_parameter(make_shared_parameter("attractor", target));
+  ds->set_parameter(make_shared_parameter("gain", gains));
 
   ros::Rate rate(freq);
   while (ros::ok()) {
     if (robot.state_received) {
-      CartesianTwist twist = linear_ds.evaluate(robot.get_eef_pose());
+      CartesianTwist twist = ds->evaluate(robot.get_eef_pose());
       twist.clamp(0.25, 0.5);
       JointVelocities command = robot.inverse_velocity(twist);
       robot.publish(command);
diff --git a/demos/ros_examples/scripts/task_space_control_loop.cpp b/demos/ros_examples/scripts/task_space_control_loop.cpp
index 2932bca10..d970a3555 100644
--- a/demos/ros_examples/scripts/task_space_control_loop.cpp
+++ b/demos/ros_examples/scripts/task_space_control_loop.cpp
@@ -4,7 +4,7 @@
 #include <tf/transform_broadcaster.h>
 #include <state_representation/space/cartesian/CartesianPose.hpp>
 #include <state_representation/space/cartesian/CartesianTwist.hpp>
-#include <dynamical_systems/Linear.hpp>
+#include "dynamical_systems/DynamicalSystemFactory.hpp"
 
 using namespace state_representation;
 using namespace dynamical_systems;
@@ -14,22 +14,22 @@ void send_transform(const CartesianPose& pose, const std::string& pose_name_pref
   static tf::TransformBroadcaster br;
   tf::Transform transform;
   transform.setOrigin(tf::Vector3(pose.get_position()(0), pose.get_position()(1), pose.get_position()(2)));
-  transform.setRotation(tf::Quaternion(pose.get_orientation().x(),
-                                        pose.get_orientation().y(),
-                                        pose.get_orientation().z(),
-                                        pose.get_orientation().w()));
+  transform.setRotation(
+      tf::Quaternion(
+          pose.get_orientation().x(), pose.get_orientation().y(), pose.get_orientation().z(),
+          pose.get_orientation().w()));
   std::string prefix = (pose_name_prefix != "") ? pose_name_prefix + "_" : "";
-  br.sendTransform(tf::StampedTransform(transform,
-                                        ros::Time::now(),
-                                        pose.get_reference_frame(),
-                                        prefix + pose.get_name()));
+  br.sendTransform(
+      tf::StampedTransform(
+          transform, ros::Time::now(), pose.get_reference_frame(), prefix + pose.get_name()));
 }
 
-CartesianPose control_loop_step(const CartesianPose& pose,
-                                const Linear<CartesianState>& ds,
-                                const std::chrono::nanoseconds& dt) {
+CartesianPose control_loop_step(
+    const CartesianPose& pose, const std::shared_ptr<IDynamicalSystem<CartesianState>>& ds,
+    const std::chrono::nanoseconds& dt
+) {
   // get the twist evaluated at current pose
-  CartesianTwist desired_twist = ds.evaluate(pose);
+  CartesianTwist desired_twist = ds->evaluate(pose);
   // integrate the twist and add it to the current pose
   CartesianPose new_pose = dt * desired_twist + pose;
   // return it
@@ -37,15 +37,19 @@ CartesianPose control_loop_step(const CartesianPose& pose,
 }
 
 void control_loop(const std::chrono::nanoseconds& dt, double tolerance) {
-  // set a desired target and a linear ds toward the target
+  // set a desired target and a point attractor ds toward the target
   CartesianPose target = CartesianPose::Random("frame");
-  Linear<CartesianState> linear_ds(target);
+  std::shared_ptr<IDynamicalSystem<CartesianState>>
+      ds = DynamicalSystemFactory<CartesianState>::create_dynamical_system(
+      DynamicalSystemFactory<CartesianState>::DYNAMICAL_SYSTEM::POINT_ATTRACTOR
+  );
+  ds->set_parameter(make_shared_parameter("attractor", target));
   // set a starting pose
   CartesianPose current_pose = CartesianPose::Random("frame");
   // loop until target is reached
   double distance;
   do {
-    current_pose = control_loop_step(current_pose, linear_ds, dt);
+    current_pose = control_loop_step(current_pose, ds, dt);
     distance = dist(current_pose, target, CartesianStateVariable::POSE);
     send_transform(target, "attractor");
     send_transform(current_pose);
diff --git a/docker/sshd_entrypoint.sh b/docker/sshd_entrypoint.sh
new file mode 100644
index 000000000..4c323033a
--- /dev/null
+++ b/docker/sshd_entrypoint.sh
@@ -0,0 +1,49 @@
+#!/bin/bash
+
+USERNAME=root
+PUBLIC_KEY=""
+USER_ID=""
+GROUP_ID=""
+
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+  -k | --key)
+    PUBLIC_KEY=$2
+    shift 2
+    ;;
+  -u | --user)
+    USERNAME=$2
+    shift 2
+    ;;
+  -i | --uid)
+    USER_ID=$2
+    shift 2
+    ;;
+  -g | --gid)
+    GROUP_ID=$2
+    shift 2
+    ;;
+  *)
+    echo "Unknown option: $1" >&2
+    exit 1
+    ;;
+  esac
+done
+
+# update the USER_ID and GROUP_ID of the specified user
+if [ -n "${USER_ID}" ] && [ -n "${GROUP_ID}" ]; then
+  groupmod -g "${GROUP_ID}" "${USERNAME}"
+  usermod -u "${USER_ID}" -g "${GROUP_ID}" "${USERNAME}"
+fi
+
+if [ -n "${PUBLIC_KEY}" ]; then
+  # authorise the specified user for ssh login
+  HOME="/home/${USERNAME}"
+  mkdir -p "${HOME}"/.ssh
+  echo "${PUBLIC_KEY}" >"${HOME}"/.ssh/authorized_keys
+  chmod -R 755 "${HOME}"/.ssh
+  chown -R "${USERNAME}:${USERNAME}" "${HOME}"/.ssh
+fi
+
+# start the ssh server
+/usr/sbin/sshd -D -e -f /etc/ssh/sshd_config_development
diff --git a/doxygen/doxygen.conf b/doxygen/doxygen.conf
index 04f4f45ce..90391fd60 100644
--- a/doxygen/doxygen.conf
+++ b/doxygen/doxygen.conf
@@ -38,6 +38,7 @@ PROJECT_NAME           = "Control Libraries"
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
+PROJECT_NUMBER         = 5.0.0
 PROJECT_NUMBER         = 4.1.0
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
diff --git a/protocol/clproto_cpp/CMakeLists.txt b/protocol/clproto_cpp/CMakeLists.txt
index 9f437695a..4c052ea81 100644
--- a/protocol/clproto_cpp/CMakeLists.txt
+++ b/protocol/clproto_cpp/CMakeLists.txt
@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.9)
-project(clproto VERSION 4.1.0)
+project(clproto VERSION 5.0.0)
 
 set(CMAKE_CXX_STANDARD 17)
 
diff --git a/protocol/clproto_cpp/README.md b/protocol/clproto_cpp/README.md
index 467c561c8..b38a60b55 100644
--- a/protocol/clproto_cpp/README.md
+++ b/protocol/clproto_cpp/README.md
@@ -60,7 +60,7 @@ the encoded fields back into an ordered vector to be decoded.
 ```c++
 #include <clproto.h>
 #include <state_representation/space/cartesian/CartesianState.hpp>
-#include <state_representation/robot/JointState.hpp>
+#include <state_representation/space/joint/JointState.hpp>
 
 using namespace state_representation;
 
diff --git a/protocol/clproto_cpp/include/clproto/encoders.h b/protocol/clproto_cpp/include/clproto/encoders.h
index d79eccd81..d480f20c3 100644
--- a/protocol/clproto_cpp/include/clproto/encoders.h
+++ b/protocol/clproto_cpp/include/clproto/encoders.h
@@ -5,8 +5,8 @@
 #include <state_representation/State.hpp>
 #include <state_representation/space/SpatialState.hpp>
 #include <state_representation/space/cartesian/CartesianState.hpp>
-#include <state_representation/robot/Jacobian.hpp>
-#include <state_representation/robot/JointState.hpp>
+#include <state_representation/space/Jacobian.hpp>
+#include <state_representation/space/joint/JointState.hpp>
 #include <state_representation/parameters/Parameter.hpp>
 
 #include "clproto.h"
diff --git a/protocol/clproto_cpp/src/clproto.cpp b/protocol/clproto_cpp/src/clproto.cpp
index 2e9d4d92e..37b19be7a 100644
--- a/protocol/clproto_cpp/src/clproto.cpp
+++ b/protocol/clproto_cpp/src/clproto.cpp
@@ -11,13 +11,14 @@
 #include <state_representation/space/cartesian/CartesianState.hpp>
 #include <state_representation/space/cartesian/CartesianPose.hpp>
 #include <state_representation/space/cartesian/CartesianTwist.hpp>
+#include <state_representation/space/cartesian/CartesianAcceleration.hpp>
 #include <state_representation/space/cartesian/CartesianWrench.hpp>
-#include <state_representation/robot/Jacobian.hpp>
-#include <state_representation/robot/JointState.hpp>
-#include <state_representation/robot/JointPositions.hpp>
-#include <state_representation/robot/JointVelocities.hpp>
-#include <state_representation/robot/JointAccelerations.hpp>
-#include <state_representation/robot/JointTorques.hpp>
+#include <state_representation/space/Jacobian.hpp>
+#include <state_representation/space/joint/JointState.hpp>
+#include <state_representation/space/joint/JointPositions.hpp>
+#include <state_representation/space/joint/JointVelocities.hpp>
+#include <state_representation/space/joint/JointAccelerations.hpp>
+#include <state_representation/space/joint/JointTorques.hpp>
 #include <state_representation/geometry/Shape.hpp>
 #include <state_representation/geometry/Ellipsoid.hpp>
 
@@ -380,6 +381,52 @@ bool decode(const std::string& msg, CartesianTwist& obj) {
   }
 }
 
+/* ----------------------
+ *  CartesianAcceleration
+ * ---------------------- */
+template<>
+std::string encode<CartesianAcceleration>(const CartesianAcceleration& obj);
+template<>
+CartesianAcceleration decode(const std::string& msg);
+template<>
+bool decode(const std::string& msg, CartesianAcceleration& obj);
+template<>
+std::string encode<CartesianAcceleration>(const CartesianAcceleration& obj) {
+  proto::StateMessage message;
+  auto cartesian_state = encoder(static_cast<CartesianState>(obj));
+  *message.mutable_cartesian_acceleration()->mutable_spatial_state() = cartesian_state.spatial_state();
+  *message.mutable_cartesian_acceleration()->mutable_linear_acceleration() = cartesian_state.linear_acceleration();
+  *message.mutable_cartesian_acceleration()->mutable_angular_acceleration() = cartesian_state.angular_acceleration();
+  return message.SerializeAsString();
+}
+template<>
+CartesianAcceleration decode(const std::string& msg) {
+  CartesianAcceleration obj;
+  if (!decode(msg, obj)) {
+    throw DecodingException("Could not decode the message into a CartesianAcceleration");
+  }
+  return obj;
+}
+template<>
+bool decode(const std::string& msg, CartesianAcceleration& obj) {
+  try {
+    proto::StateMessage message;
+    if (!(message.ParseFromString(msg)
+        && message.message_type_case() == proto::StateMessage::MessageTypeCase::kCartesianAcceleration)) {
+      return false;
+    }
+    auto acceleration = message.cartesian_acceleration();
+    obj.set_name(acceleration.spatial_state().state().name());
+    obj.set_reference_frame(acceleration.spatial_state().reference_frame());
+    obj.set_linear_acceleration(decoder(acceleration.linear_acceleration()));
+    obj.set_angular_acceleration(decoder(acceleration.angular_acceleration()));
+    obj.set_empty(acceleration.spatial_state().state().empty());
+    return true;
+  } catch (...) {
+    return false;
+  }
+}
+
 /* ----------------------
  *    CartesianWrench
  * ---------------------- */
diff --git a/protocol/clproto_cpp/test/tests/test_cartesian_space_proto.cpp b/protocol/clproto_cpp/test/tests/test_cartesian_space_proto.cpp
index 71c7d1fec..f9d1da137 100644
--- a/protocol/clproto_cpp/test/tests/test_cartesian_space_proto.cpp
+++ b/protocol/clproto_cpp/test/tests/test_cartesian_space_proto.cpp
@@ -4,6 +4,7 @@
 #include <state_representation/space/cartesian/CartesianState.hpp>
 #include <state_representation/space/cartesian/CartesianPose.hpp>
 #include <state_representation/space/cartesian/CartesianTwist.hpp>
+#include <state_representation/space/cartesian/CartesianAcceleration.hpp>
 #include <state_representation/space/cartesian/CartesianWrench.hpp>
 
 #include "clproto.h"
@@ -74,6 +75,22 @@ TEST(CartesianProtoTest, EncodeDecodeCartesianTwist) {
   EXPECT_NEAR(send_state.dist(recv_state), 0, 1e-5);
 }
 
+TEST(CartesianProtoTest, EncodeDecodeCartesianAcceleration) {
+  auto send_state = CartesianAcceleration::Random("A", "B");
+  std::string msg = clproto::encode(send_state);
+  EXPECT_TRUE(clproto::is_valid(msg));
+  EXPECT_TRUE(clproto::check_message_type(msg) == clproto::CARTESIAN_ACCELERATION_MESSAGE);
+
+  CartesianAcceleration recv_state;
+  EXPECT_NO_THROW(clproto::decode<CartesianAcceleration>(msg));
+  EXPECT_TRUE(clproto::decode(msg, recv_state));
+  EXPECT_FALSE(recv_state.is_empty());
+
+  EXPECT_STREQ(send_state.get_name().c_str(), recv_state.get_name().c_str());
+  EXPECT_STREQ(send_state.get_reference_frame().c_str(), recv_state.get_reference_frame().c_str());
+  EXPECT_NEAR(send_state.dist(recv_state), 0, 1e-5);
+}
+
 TEST(CartesianProtoTest, EncodeDecodeCartesianWrench) {
   auto send_state = CartesianWrench::Random("A", "B");
   std::string msg = clproto::encode(send_state);
@@ -123,6 +140,17 @@ TEST(CartesianProtoTest, EncodeDecodeEmptyCartesianTwist) {
   EXPECT_TRUE(recv_state.is_empty());
 }
 
+TEST(CartesianProtoTest, EncodeDecodeEmptyCartesianAcceleration) {
+  CartesianAcceleration empty_state;
+  EXPECT_TRUE(empty_state.is_empty());
+  std::string msg;
+  EXPECT_NO_THROW(msg = clproto::encode(empty_state));
+
+  CartesianAcceleration recv_state;
+  EXPECT_NO_THROW(recv_state = clproto::decode<CartesianAcceleration>(msg));
+  EXPECT_TRUE(recv_state.is_empty());
+}
+
 TEST(CartesianProtoTest, EncodeDecodeEmptyCartesianWrench) {
   CartesianWrench empty_state;
   EXPECT_TRUE(empty_state.is_empty());
diff --git a/protocol/clproto_cpp/test/tests/test_joint_space_proto.cpp b/protocol/clproto_cpp/test/tests/test_joint_space_proto.cpp
index dfddd5ee3..20aa85505 100644
--- a/protocol/clproto_cpp/test/tests/test_joint_space_proto.cpp
+++ b/protocol/clproto_cpp/test/tests/test_joint_space_proto.cpp
@@ -1,11 +1,11 @@
 #include <gtest/gtest.h>
 
-#include <state_representation/robot/Jacobian.hpp>
-#include <state_representation/robot/JointState.hpp>
-#include <state_representation/robot/JointPositions.hpp>
-#include <state_representation/robot/JointVelocities.hpp>
-#include <state_representation/robot/JointAccelerations.hpp>
-#include <state_representation/robot/JointTorques.hpp>
+#include <state_representation/space/Jacobian.hpp>
+#include <state_representation/space/joint/JointState.hpp>
+#include <state_representation/space/joint/JointPositions.hpp>
+#include <state_representation/space/joint/JointVelocities.hpp>
+#include <state_representation/space/joint/JointAccelerations.hpp>
+#include <state_representation/space/joint/JointTorques.hpp>
 
 #include "clproto.h"
 
diff --git a/protocol/clproto_cpp/test/tests/test_json.cpp b/protocol/clproto_cpp/test/tests/test_json.cpp
index e3d0c6313..cde803f0f 100644
--- a/protocol/clproto_cpp/test/tests/test_json.cpp
+++ b/protocol/clproto_cpp/test/tests/test_json.cpp
@@ -1,7 +1,7 @@
 #include <gtest/gtest.h>
 
 #include <state_representation/space/cartesian/CartesianState.hpp>
-#include <state_representation/robot/JointState.hpp>
+#include <state_representation/space/joint/JointState.hpp>
 
 #include "clproto.h"
 
diff --git a/protocol/clproto_cpp/test/tests/test_packing.cpp b/protocol/clproto_cpp/test/tests/test_packing.cpp
index 73018695a..5ad9a8701 100644
--- a/protocol/clproto_cpp/test/tests/test_packing.cpp
+++ b/protocol/clproto_cpp/test/tests/test_packing.cpp
@@ -1,8 +1,8 @@
 #include <gtest/gtest.h>
 
 #include <state_representation/space/cartesian/CartesianState.hpp>
-#include <state_representation/robot/Jacobian.hpp>
-#include <state_representation/robot/JointState.hpp>
+#include <state_representation/space/Jacobian.hpp>
+#include <state_representation/space/joint/JointState.hpp>
 
 #include "clproto.h"
 
diff --git a/python/Dockerfile.python b/python/Dockerfile.python
index cd1860216..ba09e891b 100644
--- a/python/Dockerfile.python
+++ b/python/Dockerfile.python
@@ -1,29 +1,23 @@
-ARG BASE_IMAGE=ghcr.io/epfl-lasa/control-libraries/development-dependencies:latest
-FROM ${BASE_IMAGE} AS python-install
+FROM ghcr.io/epfl-lasa/control-libraries/development-dependencies:latest as python-install
 ARG BRANCH=develop
 
 WORKDIR /source
 RUN git clone --single-branch --branch $BRANCH https://github.com/epfl-lasa/control-libraries
-RUN bash control-libraries/source/install.sh --auto --no-controllers --no-dynamical-systems --no-robot-model
+RUN bash control-libraries/source/install.sh --auto --no-controllers --no-robot-model
 RUN bash control-libraries/protocol/install.sh --auto
 
+COPY include control-libraries/python/include
 COPY source control-libraries/python/source
 COPY pyproject.toml setup.py control-libraries/python/
 RUN pip3 install control-libraries/python
 
 
-FROM python-install AS dev-user
+FROM python-install as build-testing
 
-RUN useradd --create-home --shell /bin/bash dev
-USER dev
-WORKDIR /home/dev
+USER developer
+WORKDIR ${HOME}
 
 COPY test ./test
 RUN python3 -m unittest
 
 CMD ["/bin/bash"]
-
-
-FROM python-install AS remote-user
-
-ENTRYPOINT ["/.ssh_entrypoint.sh"]
diff --git a/python/README.md b/python/README.md
index 77218c101..22748489d 100644
--- a/python/README.md
+++ b/python/README.md
@@ -36,8 +36,10 @@ Once installed, you can simply import the module with an optional short alias:
 ```python
 #!/usr/bin/env python
 import state_representation as sr
+import dynamical_systems
 
 print(sr.__version__)
+print(dynamical_systems.__version__)
 
 A = sr.CartesianState.Random("A")
 print(A)
@@ -47,8 +49,10 @@ Or, directly import specific classes from the module.
 ```python
 #!/usr/bin/env python
 from state_representation import JointState
+from dynamical_systems import create_cartesian_ds, DYNAMICAL_SYSTEM
 
 B = JointState.Random("B", 3)
+ds = create_cartesian_ds(DYNAMICAL_SYSTEM.POINT_ATTRACTOR)
 ```
 
 If the `clproto` C++ library is installed, the installation steps above will automatically install the `clproto`
@@ -71,16 +75,31 @@ Bindings exist for the following modules, classes and methods:
 
 - `state_representation`:
   - `State`
+  - `StateType`
   - `SpatialState`
   - `CartesianState`
   - `CartesianPose`
   - `CartesianTwist`
+  - `CartesianAcceleration`
   - `CartesianWrench`
   - `JointState`
   - `JointPositions`
   - `JointVelocities`
   - `JointTorques`
   - `Jacobian`
+  - `Shape`
+  - `Ellipsoid`
+  - `Parameter`
+- `dynamical_systems`:
+  - `DYNAMICAL_SYSTEM`
+  - `create_cartesian_ds(type)`
+  - `create_joint_ds(type)`
+  - `CartesianDefaultDS`
+  - `CartesianPointAttractorDS`
+  - `CircularDS`
+  - `RingDS`
+  - `JointDefaultDS`
+  - `JointPointAttractorDS`
 - `clproto`:
   - `MessageType`
   - `ParameterMessageType`
diff --git a/python/dev-server.sh b/python/dev-server.sh
old mode 100644
new mode 100755
index 7038f2deb..f243d6240
--- a/python/dev-server.sh
+++ b/python/dev-server.sh
@@ -1,77 +1,90 @@
-#!/bin/bash
+#!/usr/bin/env bash
+
+IMAGE_NAME=epfl-lasa/control-libraries/python/development
+CONTAINER_NAME=epfl-lasa-control-libraries-python-development-ssh
 
-BASE_IMAGE=control-libraries/remote-development:latest
-IMAGE_NAME=control-libraries/python/remote
-CONTAINER_NAME=control-libraries-python-ssh
-CONTAINER_HOSTNAME=control-libraries-python
 BRANCH=$(git branch --show-current)
 
 SSH_PORT=2233
-SSH_KEY_FILE="$HOME/.ssh/id_rsa.pub"
+SSH_KEY_FILE="${HOME}/.ssh/id_rsa.pub"
 
-HELP_MESSAGE="Usage: ./dev-server.sh [--port <port>] [--key-file </path/to/id_rsa.pub>]
+HELP_MESSAGE="Usage: ./dev-server.sh [-p <port>] [-k <file>] [-r] [-v]
 
 Build and run a docker container as an SSH toolchain server for remote development.
 
 The server is bound to the specified port on localhost (127.0.0.1)
 and uses passwordless RSA key-pair authentication. The host public key
 is read from the specified key file and copied to the server on startup.
+On linux hosts, the UID and GID of the specified user will also be
+set to match the UID and GID of the host user by the entry script.
 
 The server will run in the background as ${CONTAINER_NAME}.
 
-You can connect with 'ssh remote@localhost -p <port>'.
+You can connect with 'ssh developer@localhost -p <port>'.
 
-Close the server with 'docker container stop ${CONTAINER_NAME}'.
+Close the server with 'docker stop ${CONTAINER_NAME}'.
 
 Options:
-  -b, --branch [branch]    Specify the branch of control libraries
+  -b, --branch <branch>    Specify the branch of control libraries
                            that should be used to build the image.
-  -p, --port [XXXX]        Specify the port to bind for SSH
+  -p, --port <XXXX>        Specify the port to bind for SSH
                            connection.
                            (default: ${SSH_PORT})
-
   -k, --key-file [path]    Specify the path of the RSA
                            public key file.
                            (default: ${SSH_KEY_FILE})
-
+  -r, --rebuild            Rebuild the image using the docker
+                           --no-cache option.
+  -v, --verbose            Use the verbose option during the building
+                           process.
   -h, --help               Show this help message."
 
-function image_not_found() {
-  MESSAGE="Could not find the required Docker image '${BASE_IMAGE}'
-from ../source/Dockerfile.source. Make sure to build it with the 'dev-server.sh' script
-in the 'source' directory."
-  echo "${MESSAGE}" && exit 1
-}
-
-docker image inspect "${BASE_IMAGE}" >/dev/null 2>&1 || image_not_found
-
-BUILD_ARGS=(--build-arg BASE_IMAGE=control-libraries/remote-development:latest)
+BUILD_FLAGS=()
 while [ "$#" -gt 0 ]; do
   case "$1" in
-    -b|--branch) BRANCH=$2; shift 2;;
-    -r|--rebuild) BUILD_ARGS+=(--no-cache); shift 1;;
-    -p|--port) SSH_PORT=$2; shift 2;;
-    -k|--key-file) SSH_KEY_FILE=$2; shift 2;;
-    -h|--help) echo "${HELP_MESSAGE}"; exit 0;;
-    *) echo "Unknown option: $1" >&2; echo "${HELP_MESSAGE}"; exit 1;;
+  -p|--port) SSH_PORT=$2; shift 2;;
+  -b|--branch) BRANCH=$2; shift 2;;
+  -k|--key-file) SSH_KEY_FILE=$2; shift 2;;
+  -r|--rebuild) BUILD_FLAGS+=(--no-cache); shift ;;
+  -v|--verbose) BUILD_FLAGS+=(--progress=plain); shift ;;
+  -h|--help) echo "${HELP_MESSAGE}"; exit 0;;
+  *) echo 'Error in command line parsing' >&2
+     echo -e "\n${HELP_MESSAGE}"
+     exit 1
   esac
 done
 
+PUBLIC_KEY=$(cat "${SSH_KEY_FILE}")
+
+COMMAND_FLAGS=()
+COMMAND_FLAGS+=(--key "${PUBLIC_KEY}")
+COMMAND_FLAGS+=(--user developer)
+
+if [[ "${OSTYPE}" != "darwin"* ]]; then
+  USER_ID=$(id -u "${USER}")
+  GROUP_ID=$(id -g "${USER}")
+  COMMAND_FLAGS+=(--uid "${USER_ID}")
+  COMMAND_FLAGS+=(--gid "${GROUP_ID}")
+fi
+
 echo "Using control libraries branch ${BRANCH}"
-BUILD_ARGS+=(--build-arg BRANCH="${BRANCH}")
+BUILD_FLAGS+=(--build-arg BRANCH="${BRANCH}")
 
+docker pull ghcr.io/epfl-lasa/control-libraries/development-dependencies:latest
 DOCKER_BUILDKIT=1 docker build . --file ./Dockerfile.python \
-  "${BUILD_ARGS[@]}" \
-  --target remote-user \
+  "${BUILD_FLAGS[@]}" \
+  --target python-install \
   --tag "${IMAGE_NAME}" || exit 1
 
 docker container stop "${CONTAINER_NAME}" >/dev/null 2>&1
 docker rm --force "${CONTAINER_NAME}" >/dev/null 2>&1
 
-docker run -d --cap-add sys_ptrace \
+echo "Starting background container with access port ${SSH_PORT} for user developer"
+docker run -d --rm --cap-add sys_ptrace \
+  --user root \
   --publish 127.0.0.1:"${SSH_PORT}":22 \
   --name "${CONTAINER_NAME}" \
-  --hostname "${CONTAINER_HOSTNAME}" \
-  "${IMAGE_NAME}" "$(cat "${SSH_KEY_FILE}")"
+  --hostname "${CONTAINER_NAME}" \
+  "${IMAGE_NAME}" /sshd_entrypoint.sh "${COMMAND_FLAGS[@]}"
 
 echo "${CONTAINER_NAME}"
diff --git a/python/include/dynamical_systems_bindings.h b/python/include/dynamical_systems_bindings.h
new file mode 100644
index 000000000..bcdc10791
--- /dev/null
+++ b/python/include/dynamical_systems_bindings.h
@@ -0,0 +1,14 @@
+#pragma once
+
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include <dynamical_systems/IDynamicalSystem.hpp>
+
+namespace py = pybind11;
+using namespace pybind11::literals;
+using namespace dynamical_systems;
+
+void bind_type(py::module_& m);
+void bind_cartesian(py::module_& m);
+void bind_joint(py::module_& m);
diff --git a/python/include/parameter_container.h b/python/include/parameter_container.h
index 55ce44be2..ad0837bf9 100644
--- a/python/include/parameter_container.h
+++ b/python/include/parameter_container.h
@@ -3,10 +3,11 @@
 #include "state_representation_bindings.h"
 
 #include <state_representation/State.hpp>
+#include <state_representation/geometry/Ellipsoid.hpp>
 #include <state_representation/parameters/ParameterInterface.hpp>
 #include <state_representation/parameters/Parameter.hpp>
 #include <state_representation/space/cartesian/CartesianPose.hpp>
-#include <state_representation/robot/JointPositions.hpp>
+#include <state_representation/space/joint/JointPositions.hpp>
 
 struct ParameterValues {
   int int_value;
@@ -21,6 +22,7 @@ struct ParameterValues {
   CartesianPose cartesian_pose;
   JointState joint_state;
   JointPositions joint_positions;
+  Ellipsoid ellipsoid;
   Eigen::MatrixXd matrix_value;
   Eigen::VectorXd vector_value;
 };
@@ -37,3 +39,7 @@ class ParameterContainer : public ParameterInterface {
 
   ParameterValues values;
 };
+
+ParameterContainer parameter_interface_ptr_to_container(const std::shared_ptr<ParameterInterface>& parameter);
+
+std::shared_ptr<ParameterInterface> container_to_parameter_interface_ptr(const ParameterContainer& parameter);
\ No newline at end of file
diff --git a/python/include/py_dynamical_system.h b/python/include/py_dynamical_system.h
new file mode 100644
index 000000000..214a24db9
--- /dev/null
+++ b/python/include/py_dynamical_system.h
@@ -0,0 +1,25 @@
+#include <dynamical_systems/IDynamicalSystem.hpp>
+#include <state_representation/parameters/ParameterInterface.hpp>
+
+template<class S>
+class PyDynamicalSystem : public IDynamicalSystem<S>, public std::enable_shared_from_this<PyDynamicalSystem<S>> {
+public:
+  using IDynamicalSystem<S>::IDynamicalSystem;
+
+  [[nodiscard]] bool is_compatible(const S& state) const override {
+    PYBIND11_OVERRIDE(bool, IDynamicalSystem<S>, is_compatible, state);
+  }
+
+  void set_base_frame(const S& base_frame) override {
+    PYBIND11_OVERRIDE(void, IDynamicalSystem<S>, set_base_frame, base_frame);
+  }
+
+protected:
+  [[nodiscard]] S compute_dynamics(const S& state) const override {
+    PYBIND11_OVERRIDE_PURE(S, IDynamicalSystem<S>, compute_dynamics, state);
+  }
+
+  void validate_and_set_parameter(const std::shared_ptr<state_representation::ParameterInterface>& parameter) override {
+    PYBIND11_OVERRIDE_PURE(void, IDynamicalSystem<S>, validate_and_set_parameter, parameter);
+  }
+};
diff --git a/python/include/state_representation_bindings.h b/python/include/state_representation_bindings.h
index a2b33699d..8edc56ae4 100644
--- a/python/include/state_representation_bindings.h
+++ b/python/include/state_representation_bindings.h
@@ -23,4 +23,5 @@ void bind_state(py::module_& m);
 void bind_cartesian_space(py::module_& m);
 void bind_joint_space(py::module_& m);
 void bind_jacobian(py::module_& m);
-void bind_parameters(py::module_& m);
\ No newline at end of file
+void bind_parameters(py::module_& m);
+void bind_geometry(py::module_& m);
diff --git a/python/run.sh b/python/run.sh
index 06bc7ced2..1ada9b806 100755
--- a/python/run.sh
+++ b/python/run.sh
@@ -1,26 +1,43 @@
-#!/bin/sh
+#!/usr/bin/env bash
 
+IMAGE_NAME=epfl-lasa/control-libraries/python/test
 BRANCH=$(git branch --show-current)
 
-BUILD_ARGS=()
-while [ "$#" -gt 0 ]; do
-  case "$1" in
-    -b|--branch) BRANCH=$2; shift 2;;
-    -r|--rebuild) BUILD_ARGS+=(--no-cache); shift 1;;
-    *) echo "Unknown option: $1" >&2; exit 1;;
+HELP_MESSAGE="Usage: run.sh [-b <branch>] [-r] [-v]
+Options:
+  -b, --branch <branch>    Specify the branch of control libraries
+                           that should be used to build the image.
+  -r, --rebuild            Rebuild the image using the docker
+                           --no-cache option.
+  -v, --verbose            Use the verbose option during the building
+                           process.
+  -h, --help               Show this help message.
+"
+
+BUILD_FLAGS=()
+while [[ $# -gt 0 ]]; do
+  opt="$1"
+  case $opt in
+    -b|--branch) BRANCH=$2;shift 2;;
+    -r|--rebuild) BUILD_FLAGS+=(--no-cache); shift ;;
+    -v|--verbose) BUILD_FLAGS+=(--progress=plain); shift ;;
+    -h|--help) echo "${HELP_MESSAGE}" ; exit 0 ;;
+    *) echo 'Error in command line parsing' >&2
+       echo -e "\n${HELP_MESSAGE}"
+       exit 1
   esac
 done
 
 echo "Using control libraries branch ${BRANCH}"
-BUILD_ARGS+=(--build-arg BRANCH="${BRANCH}")
+BUILD_FLAGS+=(--build-arg BRANCH="${BRANCH}")
 
 docker pull ghcr.io/epfl-lasa/control-libraries/development-dependencies:latest
-docker build . --file ./Dockerfile.python \
-  "${BUILD_ARGS[@]}" \
-  --target dev-user \
-  --tag control-libraries/python/test || exit 1
+DOCKER_BUILDKIT=1 docker build . --file ./Dockerfile.python \
+  "${BUILD_FLAGS[@]}" \
+  --target build-testing \
+  --tag "${IMAGE_NAME}" || exit 1
 
 docker run -it --rm \
   --volume "$(pwd)":/source/control-libraries/python \
-  --name control-libraries-python-test \
-  control-libraries/python/test
+  --name "${IMAGE_NAME//[\/.]/-}" \
+  "${IMAGE_NAME}"
diff --git a/python/setup.py b/python/setup.py
index 033850008..4c3a83f07 100644
--- a/python/setup.py
+++ b/python/setup.py
@@ -5,11 +5,12 @@
 import warnings
 import os
 
-__version__ = "4.1.0"
-__libraries__ = ['state_representation', 'clproto']
+__version__ = "5.0.0"
+__libraries__ = ['state_representation', 'clproto', 'dynamical_systems']
 __include_dirs__ = ['include']
 
 __install_clproto_module__ = True
+__install_dynamical_systems_module__ = True
 
 # check that eigen and state_representation libraries can be found
 try:
@@ -27,6 +28,9 @@
             if lib == 'clproto':
                 warnings.warn(f'{msg} The clproto module will not be installed.')
                 __install_clproto_module__ = False
+            if lib == 'dynamical_systems':
+                warnings.warn(f'{msg} The dynamical_systems module will not be installed.')
+                __install_dynamical_systems_module__ = False
             else:
                 raise Exception(msg)
 except Exception as e:
@@ -56,6 +60,17 @@
                           )
     )
 
+if __install_dynamical_systems_module__:
+    ext_modules.append(
+        Pybind11Extension("dynamical_systems",
+                          sorted(glob("source/dynamical_systems/*.cpp") + glob("source/common/*.cpp")),
+                          cxx_std=17,
+                          include_dirs=__include_dirs__,
+                          libraries=['state_representation', 'dynamical_systems'],
+                          define_macros=[('MODULE_VERSION_INFO', __version__)],
+                          )
+    )
+
 setup(
     name="control-libraries",
     version=__version__,
diff --git a/python/source/clproto/bind_clproto.cpp b/python/source/clproto/bind_clproto.cpp
index 2c74361d3..094dfeec5 100644
--- a/python/source/clproto/bind_clproto.cpp
+++ b/python/source/clproto/bind_clproto.cpp
@@ -9,12 +9,12 @@
 #include <state_representation/space/cartesian/CartesianPose.hpp>
 #include <state_representation/space/cartesian/CartesianTwist.hpp>
 #include <state_representation/space/cartesian/CartesianWrench.hpp>
-#include <state_representation/robot/Jacobian.hpp>
-#include <state_representation/robot/JointState.hpp>
-#include <state_representation/robot/JointPositions.hpp>
-#include <state_representation/robot/JointVelocities.hpp>
-#include <state_representation/robot/JointAccelerations.hpp>
-#include <state_representation/robot/JointTorques.hpp>
+#include <state_representation/space/Jacobian.hpp>
+#include <state_representation/space/joint/JointState.hpp>
+#include <state_representation/space/joint/JointPositions.hpp>
+#include <state_representation/space/joint/JointVelocities.hpp>
+#include <state_representation/space/joint/JointAccelerations.hpp>
+#include <state_representation/space/joint/JointTorques.hpp>
 #include <state_representation/geometry/Shape.hpp>
 #include <state_representation/geometry/Ellipsoid.hpp>
 
diff --git a/python/source/common/parameter_container.cpp b/python/source/common/parameter_container.cpp
index 3506debc8..da48687c6 100644
--- a/python/source/common/parameter_container.cpp
+++ b/python/source/common/parameter_container.cpp
@@ -49,6 +49,9 @@ void ParameterContainer::set_value(const py::object& value) {
     case StateType::PARAMETER_JOINTPOSITIONS:
       values.joint_positions = value.cast<JointPositions>();
       break;
+    case StateType::PARAMETER_ELLIPSOID:
+      values.ellipsoid = value.cast<Ellipsoid>();
+      break;
     case StateType::PARAMETER_MATRIX:
       values.matrix_value = value.cast<Eigen::MatrixXd>();
       break;
@@ -87,6 +90,8 @@ py::object ParameterContainer::get_value() {
       return py::cast(values.joint_state);
     case StateType::PARAMETER_JOINTPOSITIONS:
       return py::cast(values.joint_positions);
+    case StateType::PARAMETER_ELLIPSOID:
+      return py::cast(values.ellipsoid);
     case StateType::PARAMETER_MATRIX:
       return py::cast(values.matrix_value);
     case StateType::PARAMETER_VECTOR:
@@ -94,4 +99,155 @@ py::object ParameterContainer::get_value() {
     default:
       return py::none();
   }
+}
+
+ParameterContainer parameter_interface_ptr_to_container(const std::shared_ptr<ParameterInterface>& parameter) {
+  switch (parameter->get_type()) {
+    case StateType::PARAMETER_INT: {
+      auto param = std::static_pointer_cast<Parameter<int>>(parameter);
+      return ParameterContainer(param->get_name(), py::cast(param->get_value()), param->get_type());
+      break;
+    }
+    case StateType::PARAMETER_INT_ARRAY: {
+      auto param = std::static_pointer_cast<Parameter<std::vector<int>>>(parameter);
+      return ParameterContainer(param->get_name(), py::cast(param->get_value()), param->get_type());
+      break;
+    }
+    case StateType::PARAMETER_DOUBLE: {
+      auto param = std::static_pointer_cast<Parameter<double>>(parameter);
+      return ParameterContainer(param->get_name(), py::cast(param->get_value()), param->get_type());
+      break;
+    }
+    case StateType::PARAMETER_DOUBLE_ARRAY: {
+      auto param = std::static_pointer_cast<Parameter<std::vector<double>>>(parameter);
+      return ParameterContainer(param->get_name(), py::cast(param->get_value()), param->get_type());
+      break;
+    }
+    case StateType::PARAMETER_BOOL: {
+      auto param = std::static_pointer_cast<Parameter<bool>>(parameter);
+      return ParameterContainer(param->get_name(), py::cast(param->get_value()), param->get_type());
+      break;
+    }
+    case StateType::PARAMETER_BOOL_ARRAY: {
+      auto param = std::static_pointer_cast<Parameter<std::vector<bool>>>(parameter);
+      return ParameterContainer(param->get_name(), py::cast(param->get_value()), param->get_type());
+      break;
+    }
+    case StateType::PARAMETER_STRING: {
+      auto param = std::static_pointer_cast<Parameter<std::string>>(parameter);
+      return ParameterContainer(param->get_name(), py::cast(param->get_value()), param->get_type());
+      break;
+    }
+    case StateType::PARAMETER_STRING_ARRAY: {
+      auto param = std::static_pointer_cast<Parameter<std::vector<std::string>>>(parameter);
+      return ParameterContainer(param->get_name(), py::cast(param->get_value()), param->get_type());
+      break;
+    }
+    case StateType::PARAMETER_CARTESIANSTATE: {
+      auto param = std::static_pointer_cast<Parameter<CartesianState>>(parameter);
+      return ParameterContainer(param->get_name(), py::cast(param->get_value()), param->get_type());
+      break;
+    }
+    case StateType::PARAMETER_CARTESIANPOSE: {
+      auto param = std::static_pointer_cast<Parameter<CartesianPose>>(parameter);
+      return ParameterContainer(param->get_name(), py::cast(param->get_value()), param->get_type());
+      break;
+    }
+    case StateType::PARAMETER_JOINTSTATE: {
+      auto param = std::static_pointer_cast<Parameter<JointState>>(parameter);
+      return ParameterContainer(param->get_name(), py::cast(param->get_value()), param->get_type());
+      break;
+    }
+    case StateType::PARAMETER_JOINTPOSITIONS: {
+      auto param = std::static_pointer_cast<Parameter<JointPositions>>(parameter);
+      return ParameterContainer(param->get_name(), py::cast(param->get_value()), param->get_type());
+      break;
+    }
+    case StateType::PARAMETER_ELLIPSOID: {
+      auto param = std::static_pointer_cast<Parameter<Ellipsoid>>(parameter);
+      return ParameterContainer(param->get_name(), py::cast(param->get_value()), param->get_type());
+      break;
+    }
+    case StateType::PARAMETER_MATRIX: {
+      auto param = std::static_pointer_cast<Parameter<Eigen::MatrixXd>>(parameter);
+      return ParameterContainer(param->get_name(), py::cast(param->get_value()), param->get_type());
+      break;
+    }
+    case StateType::PARAMETER_VECTOR: {
+      auto param = std::static_pointer_cast<Parameter<Eigen::VectorXd>>(parameter);
+      return ParameterContainer(param->get_name(), py::cast(param->get_value()), param->get_type());
+      break;
+    }
+    default:
+      throw std::invalid_argument("The conversion from this StateType to ParameterContainer is not supported yet.");
+      break;
+  }
+}
+
+std::shared_ptr<ParameterInterface> container_to_parameter_interface_ptr(const ParameterContainer& parameter) {
+  switch (parameter.get_type()) {
+    case StateType::PARAMETER_INT: {
+      return std::make_shared<Parameter<int>>(parameter.get_name(), parameter.values.int_value);
+      break;
+    }
+    case StateType::PARAMETER_INT_ARRAY: {
+      return std::make_shared<Parameter<std::vector<int>>>(parameter.get_name(), parameter.values.int_array_value);
+      break;
+    }
+    case StateType::PARAMETER_DOUBLE: {
+      return std::make_shared<Parameter<double>>(parameter.get_name(), parameter.values.double_value);
+      break;
+    }
+    case StateType::PARAMETER_DOUBLE_ARRAY: {
+      return std::make_shared<Parameter<std::vector<double>>>(parameter.get_name(), parameter.values.double_array_value);
+      break;
+    }
+    case StateType::PARAMETER_BOOL: {
+      return std::make_shared<Parameter<bool>>(parameter.get_name(), parameter.values.bool_value);
+      break;
+    }
+    case StateType::PARAMETER_BOOL_ARRAY: {
+      return std::make_shared<Parameter<std::vector<bool>>>(parameter.get_name(), parameter.values.bool_array_value);
+      break;
+    }
+    case StateType::PARAMETER_STRING: {
+      return std::make_shared<Parameter<std::string>>(parameter.get_name(), parameter.values.string_value);
+      break;
+    }
+    case StateType::PARAMETER_STRING_ARRAY: {
+      return std::make_shared<Parameter<std::vector<std::string>>>(parameter.get_name(), parameter.values.string_array_value);
+      break;
+    }
+    case StateType::PARAMETER_CARTESIANSTATE: {
+      return std::make_shared<Parameter<CartesianState>>(parameter.get_name(), parameter.values.cartesian_state);
+      break;
+    }
+    case StateType::PARAMETER_CARTESIANPOSE: {
+      return std::make_shared<Parameter<CartesianPose>>(parameter.get_name(), parameter.values.cartesian_pose);
+      break;
+    }
+    case StateType::PARAMETER_JOINTSTATE: {
+      return std::make_shared<Parameter<JointState>>(parameter.get_name(), parameter.values.joint_state);
+      break;
+    }
+    case StateType::PARAMETER_JOINTPOSITIONS: {
+      return std::make_shared<Parameter<JointPositions>>(parameter.get_name(), parameter.values.joint_positions);
+      break;
+    }
+    case StateType::PARAMETER_ELLIPSOID: {
+      return std::make_shared<Parameter<Ellipsoid>>(parameter.get_name(), parameter.values.ellipsoid);
+      break;
+    }
+    case StateType::PARAMETER_MATRIX: {
+      return std::make_shared<Parameter<Eigen::MatrixXd>>(parameter.get_name(), parameter.values.matrix_value);
+      break;
+    }
+      case StateType::PARAMETER_VECTOR: {
+        return std::make_shared<Parameter<Eigen::VectorXd>>(parameter.get_name(), parameter.values.vector_value);
+        break;
+      }
+    default:
+      return {};
+      break;
+  }
 }
\ No newline at end of file
diff --git a/python/source/dynamical_systems/bind_cartesian.cpp b/python/source/dynamical_systems/bind_cartesian.cpp
new file mode 100644
index 000000000..274391f37
--- /dev/null
+++ b/python/source/dynamical_systems/bind_cartesian.cpp
@@ -0,0 +1,87 @@
+#include "dynamical_systems_bindings.h"
+
+#include <dynamical_systems/Circular.hpp>
+#include <dynamical_systems/DefaultDynamicalSystem.hpp>
+#include <dynamical_systems/DynamicalSystemFactory.hpp>
+#include <dynamical_systems/IDynamicalSystem.hpp>
+#include <dynamical_systems/PointAttractor.hpp>
+#include <dynamical_systems/Ring.hpp>
+#include <state_representation/parameters/Parameter.hpp>
+#include <state_representation/space/cartesian/CartesianState.hpp>
+
+#include "parameter_container.h"
+#include "py_dynamical_system.h"
+
+using namespace state_representation;
+
+void cartesian(py::module_& m) {
+  py::class_<IDynamicalSystem<CartesianState>, PyDynamicalSystem<CartesianState>> c(m, "ICartesianDS");
+
+  c.def(py::init<>());
+
+  c.def("is_compatible", &IDynamicalSystem<CartesianState>::is_compatible);
+  c.def("evaluate", &IDynamicalSystem<CartesianState>::evaluate);
+  c.def("get_base_frame", &IDynamicalSystem<CartesianState>::get_base_frame);
+  c.def("set_base_frame", &IDynamicalSystem<CartesianState>::set_base_frame);
+
+  c.def("get_parameter", [](IDynamicalSystem<CartesianState>& self, const std::string& name) {
+    return parameter_interface_ptr_to_container(self.get_parameter(name));
+  });
+  c.def("get_parameters", [](IDynamicalSystem<CartesianState>& self) {
+    py::dict dict;
+    for (const auto& param_it : self.get_parameters()) {
+      dict[py::str(param_it.first)] = parameter_interface_ptr_to_container(param_it.second);
+    }
+    return dict;
+  });
+  c.def("get_parameter_value", [](IDynamicalSystem<CartesianState>& self, const std::string& name) {
+    return parameter_interface_ptr_to_container(self.get_parameter(name)).get_value();
+  });
+  c.def("get_parameter_list", [](IDynamicalSystem<CartesianState>& self) {
+    py::list list;
+    for (const auto& param_it : self.get_parameters()) {
+      list.append(parameter_interface_ptr_to_container(param_it.second));
+    }
+    return list;
+  });
+
+  c.def("set_parameter", [](IDynamicalSystem<CartesianState>& self, const ParameterContainer& parameter) {
+    self.set_parameter(container_to_parameter_interface_ptr(parameter));
+  });
+  c.def("set_parameters", [](IDynamicalSystem<CartesianState>& self, const std::vector<ParameterContainer>& parameters) {
+    for (auto param : parameters) {
+      self.set_parameter(container_to_parameter_interface_ptr(param));
+    }
+  });
+  c.def("set_parameters", [](IDynamicalSystem<CartesianState>& self, const std::map<std::string, ParameterContainer>& parameters) {
+    for (const auto& param_it: parameters) {
+      self.set_parameter(container_to_parameter_interface_ptr(param_it.second));
+    }
+  });
+}
+
+void bind_cartesian(py::module_& m) {
+  cartesian(m);
+  py::class_<Circular, IDynamicalSystem<CartesianState>>(m, "CartesianCircularDS").def(py::init<>());
+  py::class_<DefaultDynamicalSystem<CartesianState>, IDynamicalSystem<CartesianState>>(m, "CartesianDefaultDS").def(py::init<>());
+  py::class_<PointAttractor<CartesianState>, IDynamicalSystem<CartesianState>>(m, "CartesianPointAttractorDS").def(py::init<>());
+  py::class_<Ring, IDynamicalSystem<CartesianState>>(m, "CartesianRingDS").def(py::init<>());
+
+  m.def("create_cartesian_ds", [](DynamicalSystemFactory<CartesianState>::DYNAMICAL_SYSTEM type) -> py::object {
+    switch (type) {
+      case DynamicalSystemFactory<CartesianState>::DYNAMICAL_SYSTEM::CIRCULAR:
+        return py::cast(Circular());
+        break;
+      case DynamicalSystemFactory<CartesianState>::DYNAMICAL_SYSTEM::POINT_ATTRACTOR:
+        return py::cast(PointAttractor<CartesianState>());
+        break;
+      case DynamicalSystemFactory<CartesianState>::DYNAMICAL_SYSTEM::RING:
+        return py::cast(Ring());
+        break;
+      default:
+      case DynamicalSystemFactory<CartesianState>::DYNAMICAL_SYSTEM::NONE:
+        return py::cast(DefaultDynamicalSystem<CartesianState>());
+        break;
+    }
+  });
+}
diff --git a/python/source/dynamical_systems/bind_joint.cpp b/python/source/dynamical_systems/bind_joint.cpp
new file mode 100644
index 000000000..4fb967718
--- /dev/null
+++ b/python/source/dynamical_systems/bind_joint.cpp
@@ -0,0 +1,77 @@
+#include "dynamical_systems_bindings.h"
+
+#include <dynamical_systems/DefaultDynamicalSystem.hpp>
+#include <dynamical_systems/DynamicalSystemFactory.hpp>
+#include <dynamical_systems/IDynamicalSystem.hpp>
+#include <dynamical_systems/PointAttractor.hpp>
+#include <state_representation/parameters/Parameter.hpp>
+#include <state_representation/space/joint/JointState.hpp>
+
+#include "parameter_container.h"
+#include "py_dynamical_system.h"
+
+using namespace state_representation;
+
+void joint(py::module_& m) {
+  py::class_<IDynamicalSystem<JointState>, PyDynamicalSystem<JointState>> c(m, "IJointDS");
+
+  c.def(py::init<>());
+
+  c.def("is_compatible", &IDynamicalSystem<JointState>::is_compatible);
+  c.def("evaluate", &IDynamicalSystem<JointState>::evaluate);
+  c.def("get_base_frame", &IDynamicalSystem<JointState>::get_base_frame);
+  c.def("set_base_frame", &IDynamicalSystem<JointState>::set_base_frame);
+
+  c.def("get_parameter", [](IDynamicalSystem<JointState>& self, const std::string& name) {
+    return parameter_interface_ptr_to_container(self.get_parameter(name));
+  });
+  c.def("get_parameters", [](IDynamicalSystem<JointState>& self) {
+    py::dict dict;
+    for (const auto& param_it : self.get_parameters()) {
+      dict[py::str(param_it.first)] = parameter_interface_ptr_to_container(param_it.second);
+    }
+    return dict;
+  });
+  c.def("get_parameter_value", [](IDynamicalSystem<JointState>& self, const std::string& name) {
+    return parameter_interface_ptr_to_container(self.get_parameter(name)).get_value();
+  });
+  c.def("get_parameter_list", [](IDynamicalSystem<JointState>& self) {
+    py::list list;
+    for (const auto& param_it : self.get_parameters()) {
+      list.append(parameter_interface_ptr_to_container(param_it.second));
+    }
+    return list;
+  });
+
+  c.def("set_parameter", [](IDynamicalSystem<JointState>& self, const ParameterContainer& parameter) {
+    self.set_parameter(container_to_parameter_interface_ptr(parameter));
+  });
+  c.def("set_parameters", [](IDynamicalSystem<JointState>& self, const std::vector<ParameterContainer>& parameters) {
+    for (auto param : parameters) {
+      self.set_parameter(container_to_parameter_interface_ptr(param));
+    }
+  });
+  c.def("set_parameters", [](IDynamicalSystem<JointState>& self, const std::map<std::string, ParameterContainer>& parameters) {
+    for (const auto& param_it: parameters) {
+      self.set_parameter(container_to_parameter_interface_ptr(param_it.second));
+    }
+  });
+}
+
+void bind_joint(py::module_& m) {
+  joint(m);
+  py::class_<DefaultDynamicalSystem<JointState>, IDynamicalSystem<JointState>>(m, "JointDefaultDS").def(py::init<>());
+  py::class_<PointAttractor<JointState>, IDynamicalSystem<JointState>>(m, "JointPointAttractorDS").def(py::init<>());
+
+  m.def("create_joint_ds", [](DynamicalSystemFactory<CartesianState>::DYNAMICAL_SYSTEM type) -> py::object {
+    switch (type) {
+      case DynamicalSystemFactory<CartesianState>::DYNAMICAL_SYSTEM::POINT_ATTRACTOR:
+        return py::cast(PointAttractor<JointState>());
+        break;
+      default:
+      case DynamicalSystemFactory<CartesianState>::DYNAMICAL_SYSTEM::NONE:
+        return py::cast(DefaultDynamicalSystem<JointState>());
+        break;
+    }
+  });
+}
diff --git a/python/source/dynamical_systems/bind_type.cpp b/python/source/dynamical_systems/bind_type.cpp
new file mode 100644
index 000000000..cfe122fe5
--- /dev/null
+++ b/python/source/dynamical_systems/bind_type.cpp
@@ -0,0 +1,15 @@
+#include "dynamical_systems_bindings.h"
+
+#include <dynamical_systems/DynamicalSystemFactory.hpp>
+#include <state_representation/space/cartesian/CartesianState.hpp>
+
+using namespace state_representation;
+
+void bind_type(py::module_& m) {
+  py::enum_<DynamicalSystemFactory<CartesianState>::DYNAMICAL_SYSTEM>(m, "DYNAMICAL_SYSTEM")
+      .value("NONE", DynamicalSystemFactory<CartesianState>::DYNAMICAL_SYSTEM::NONE)
+      .value("CIRCULAR", DynamicalSystemFactory<CartesianState>::DYNAMICAL_SYSTEM::CIRCULAR)
+      .value("POINT_ATTRACTOR", DynamicalSystemFactory<CartesianState>::DYNAMICAL_SYSTEM::POINT_ATTRACTOR)
+      .value("RING", DynamicalSystemFactory<CartesianState>::DYNAMICAL_SYSTEM::RING)
+      .export_values();
+}
diff --git a/python/source/dynamical_systems/dynamical_systems_bindings.cpp b/python/source/dynamical_systems/dynamical_systems_bindings.cpp
new file mode 100644
index 000000000..3ebf786c7
--- /dev/null
+++ b/python/source/dynamical_systems/dynamical_systems_bindings.cpp
@@ -0,0 +1,18 @@
+#include "dynamical_systems_bindings.h"
+
+#define STRINGIFY(x) #x
+#define MACRO_STRINGIFY(x) STRINGIFY(x)
+
+PYBIND11_MODULE(dynamical_systems, m) {
+  m.doc() = "Python bindings for control libraries dynamical_systems";
+
+  #ifdef MODULE_VERSION_INFO
+  m.attr("__version__") = MACRO_STRINGIFY(MODULE_VERSION_INFO);
+  #else
+  m.attr("__version__") = "dev";
+  #endif
+
+  bind_type(m);
+  bind_cartesian(m);
+  bind_joint(m);
+}
diff --git a/python/source/state_representation/bind_cartesian_space.cpp b/python/source/state_representation/bind_cartesian_space.cpp
index 301395763..edba03367 100644
--- a/python/source/state_representation/bind_cartesian_space.cpp
+++ b/python/source/state_representation/bind_cartesian_space.cpp
@@ -5,6 +5,7 @@
 #include <state_representation/space/cartesian/CartesianState.hpp>
 #include <state_representation/space/cartesian/CartesianPose.hpp>
 #include <state_representation/space/cartesian/CartesianTwist.hpp>
+#include <state_representation/space/cartesian/CartesianAcceleration.hpp>
 #include <state_representation/space/cartesian/CartesianWrench.hpp>
 
 
@@ -19,6 +20,12 @@ void spatial_state(py::module_& m) {
   c.def("set_reference_frame", &SpatialState::set_reference_frame, "Setter of the reference frame.", "reference_frame"_a);
   c.def("is_compatible", &SpatialState::is_compatible, "Check if the state is compatible for operations with the state given as argument.", "state"_a);
 
+  c.def("__copy__", [](const SpatialState &state) {
+    return SpatialState(state);
+  });
+  c.def("__deepcopy__", [](const SpatialState &state, py::dict) {
+    return SpatialState(state);
+  }, "memo"_a);
   c.def("__repr__", [](const SpatialState& state) {
     std::stringstream buffer;
     buffer << state;
@@ -36,7 +43,7 @@ void cartesian_state_variable(py::module_& m) {
       .value("TWIST", CartesianStateVariable::TWIST)
       .value("LINEAR_ACCELERATION", CartesianStateVariable::LINEAR_ACCELERATION)
       .value("ANGULAR_ACCELERATION", CartesianStateVariable::ANGULAR_ACCELERATION)
-      .value("ACCELERATIONS", CartesianStateVariable::ACCELERATIONS)
+      .value("ACCELERATION", CartesianStateVariable::ACCELERATION)
       .value("FORCE", CartesianStateVariable::FORCE)
       .value("TORQUE", CartesianStateVariable::TORQUE)
       .value("WRENCH", CartesianStateVariable::WRENCH)
@@ -65,8 +72,8 @@ void cartesian_state(py::module_& m) {
   c.def("get_twist", &CartesianState::get_twist, "Getter of the 6d twist from linear and angular velocity attributes");
 
   c.def("get_linear_acceleration", &CartesianState::get_linear_acceleration, "Getter of the linear acceleration attribute");
-  c.def("get_angular_acceleration", &CartesianState::get_angular_acceleration, "Getter of the linear acceleration attribute");
-  c.def("get_accelerations", &CartesianState::get_accelerations, "Getter of the 6d accelerations from linear and angular acceleration attributes");
+  c.def("get_angular_acceleration", &CartesianState::get_angular_acceleration, "Getter of the angular acceleration attribute");
+  c.def("get_acceleration", &CartesianState::get_acceleration, "Getter of the 6d acceleration from linear and angular acceleration attributes");
 
   c.def("get_force", &CartesianState::get_force, "Getter of the force attribute");
   c.def("get_torque", &CartesianState::get_torque, "Getter of the torque attribute");
@@ -85,8 +92,8 @@ void cartesian_state(py::module_& m) {
   c.def("set_twist", &CartesianState::set_twist, "Setter of the linear and angular velocities from a 6d twist vector");
 
   c.def("set_linear_acceleration", &CartesianState::set_linear_acceleration, "Setter of the linear acceleration attribute");
-  c.def("set_angular_acceleration", &CartesianState::set_angular_acceleration, "Setter of the linear acceleration attribute");
-  c.def("set_accelerations", &CartesianState::set_accelerations, "Setter of the linear and angular accelerations from a 6d acceleration vector");
+  c.def("set_angular_acceleration", &CartesianState::set_angular_acceleration, "Setter of the angular acceleration attribute");
+  c.def("set_acceleration", &CartesianState::set_acceleration, "Setter of the linear and angular acceleration from a 6d acceleration vector");
 
   c.def("set_force", &CartesianState::set_force, "Setter of the force attribute");
   c.def("set_torque", &CartesianState::set_torque, "Setter of the torque attribute");
@@ -120,6 +127,12 @@ void cartesian_state(py::module_& m) {
 
   c.def("to_list", &CartesianState::to_std_vector, "Return the state as a list");
 
+  c.def("__copy__", [](const CartesianState &state) {
+    return CartesianState(state);
+  });
+  c.def("__deepcopy__", [](const CartesianState &state, py::dict) {
+    return CartesianState(state);
+  }, "memo"_a);
   c.def("__repr__", [](const CartesianState& state) {
     std::stringstream buffer;
     buffer << state;
@@ -156,7 +169,7 @@ void cartesian_pose(py::module_& m) {
       "twist",
       "linear_acceleration",
       "angular_acceleration",
-      "accelerations",
+      "acceleration",
       "force",
       "torque",
       "wrench"
@@ -193,6 +206,12 @@ void cartesian_pose(py::module_& m) {
   c.def("norms", &CartesianPose::norms, "Compute the norms of the state variable specified by the input type (default is full pose)", "state_variable_type"_a=CartesianStateVariable::POSE);
   c.def("normalized", &CartesianPose::normalized, "Compute the normalized pose at the state variable given in argument (default is full pose)", "state_variable_type"_a=CartesianStateVariable::POSE);
 
+  c.def("__copy__", [](const CartesianPose &pose) {
+    return CartesianPose(pose);
+  });
+  c.def("__deepcopy__", [](const CartesianPose &pose, py::dict) {
+    return CartesianPose(pose);
+  }, "memo"_a);
   c.def("__repr__", [](const CartesianPose& pose) {
     std::stringstream buffer;
     buffer << pose;
@@ -200,7 +219,6 @@ void cartesian_pose(py::module_& m) {
   });
 }
 
-
 void cartesian_twist(py::module_& m) {
   py::class_<CartesianTwist, CartesianState> c(m, "CartesianTwist");
 
@@ -223,7 +241,7 @@ void cartesian_twist(py::module_& m) {
       "pose",
       "linear_acceleration",
       "angular_acceleration",
-      "accelerations",
+      "acceleration",
       "force",
       "torque",
       "wrench"
@@ -245,6 +263,7 @@ void cartesian_twist(py::module_& m) {
   c.def(py::self / double());
   c.def(py::self *= Eigen::Matrix<double, 6, 6>());
   c.def(py::self * std::chrono::nanoseconds());
+  c.def(py::self / std::chrono::nanoseconds());
 
   c.def(double() * py::self);
   c.def(std::chrono::nanoseconds() * py::self);
@@ -260,6 +279,12 @@ void cartesian_twist(py::module_& m) {
   c.def("norms", &CartesianTwist::norms, "Compute the norms of the state variable specified by the input type (default is full twist)", "state_variable_type"_a=CartesianStateVariable::TWIST);
   c.def("normalized", &CartesianTwist::normalized, "Compute the normalized twist at the state variable given in argument (default is full twist)", "state_variable_type"_a=CartesianStateVariable::TWIST);
 
+  c.def("__copy__", [](const CartesianTwist &twist) {
+    return CartesianTwist(twist);
+  });
+  c.def("__deepcopy__", [](const CartesianTwist &twist, py::dict) {
+    return CartesianTwist(twist);
+  }, "memo"_a);
   c.def("__repr__", [](const CartesianTwist& twist) {
     std::stringstream buffer;
     buffer << twist;
@@ -267,6 +292,77 @@ void cartesian_twist(py::module_& m) {
   });
 }
 
+void cartesian_acceleration(py::module_& m) {
+  py::class_<CartesianAcceleration, CartesianState> c(m, "CartesianAcceleration");
+
+  c.def(py::init(), "Empty constructor");
+  c.def(py::init<const std::string&, const std::string&>(), "Constructor with name and reference frame provided", "name"_a, "reference"_a=std::string("world"));
+  c.def(py::init<const CartesianAcceleration&>(), "Copy constructor", "acceleration"_a);
+  c.def(py::init<const CartesianState&>(), "Copy constructor from a CartesianState", "state"_a);
+  c.def(py::init<const CartesianTwist&>(), "Copy constructor from a CartesianTwist by considering that it is equivalent to dividing the twist by 1 second", "twist"_a);
+
+  c.def(py::init<const std::string&, const Eigen::Vector3d&, const std::string&>(), "Construct a CartesianAcceleration from a linear acceleration given as a vector.", "name"_a, "linear_acceleration"_a, "reference"_a=std::string("world"));
+  c.def(py::init<const std::string&, const Eigen::Vector3d&, const Eigen::Vector3d&, const std::string&>(), "Construct a CartesianAcceleration from a linear acceleration and angular acceleration given as vectors.", "name"_a, "linear_acceleration"_a, "angular_acceleration"_a, "reference"_a=std::string("world"));
+  c.def(py::init<const std::string&, const Eigen::Matrix<double, 6, 1>&, const std::string&>(), "Construct a CartesianAcceleration from a single 6d acceleration vector", "name"_a, "acceleration"_a, "reference"_a=std::string("world"));
+
+  c.def_static("Zero", &CartesianAcceleration::Zero, "Constructor for the zero acceleration", "name"_a, "reference"_a=std::string("world"));
+  c.def_static("Random", &CartesianAcceleration::Random, "Constructor for a random acceleration", "name"_a, "reference"_a=std::string("world"));
+
+  std::vector<std::string> deleted_attributes = {
+      "position",
+      "orientation",
+      "pose",
+      "linear_velocity",
+      "angular_velocity",
+      "twist",
+      "force",
+      "torque",
+      "wrench"
+  };
+
+  for (const std::string& attr : deleted_attributes) {
+    c.def(std::string("get_" + attr).c_str(), [](const CartesianAcceleration&) -> void {}, "Deleted method from parent class.");
+    c.def(std::string("set_" + attr).c_str(), [](const CartesianAcceleration& acceleration) -> CartesianAcceleration { return acceleration; }, "Deleted method from parent class.");
+  }
+
+  c.def(py::self += py::self);
+  c.def(py::self + py::self);
+  c.def(py::self -= py::self);
+  c.def(py::self - py::self);
+
+  c.def(py::self *= double());
+  c.def(py::self * double());
+  c.def(py::self /= double());
+  c.def(py::self / double());
+  c.def(py::self *= Eigen::Matrix<double, 6, 6>());
+  c.def(py::self * std::chrono::nanoseconds());
+
+  c.def(double() * py::self);
+  c.def(std::chrono::nanoseconds() * py::self);
+  c.def(Eigen::Matrix<double, 6, 6>() * py::self);
+
+  c.def("clamp", &CartesianAcceleration::clamp, "Clamp inplace the magnitude of the acceleration to the values in argument", "max_linear"_a, "max_angular"_a, "linear_noise_ratio"_a=0, "angular_noise_ratio"_a=0);
+  c.def("clamped", &CartesianAcceleration::clamped, "Return the clamped acceleration", "max_linear"_a, "max_angular"_a, "linear_noise_ratio"_a=0, "angular_noise_ratio"_a=0);
+
+  c.def("copy", &CartesianAcceleration::copy, "Return a copy of the CartesianAcceleration");
+  c.def("data", &CartesianAcceleration::data, "Returns the acceleration data as a vector");
+  c.def("set_data", py::overload_cast<const Eigen::VectorXd&>(&CartesianAcceleration::set_data), "Set the acceleration data from a vector", "data"_a);
+  c.def("set_data", py::overload_cast<const std::vector<double>&>(&CartesianAcceleration::set_data), "Set the acceleration data from a list", "data"_a);
+  c.def("norms", &CartesianAcceleration::norms, "Compute the norms of the state variable specified by the input type (default is full acceleration)", "state_variable_type"_a=CartesianStateVariable::ACCELERATION);
+  c.def("normalized", &CartesianAcceleration::normalized, "Compute the normalized acceleration at the state variable given in argument (default is full acceleration)", "state_variable_type"_a=CartesianStateVariable::ACCELERATION);
+
+  c.def("__copy__", [](const CartesianAcceleration &acceleration) {
+    return CartesianAcceleration(acceleration);
+  });
+  c.def("__deepcopy__", [](const CartesianAcceleration &acceleration, py::dict) {
+    return CartesianAcceleration(acceleration);
+  }, "memo"_a);
+  c.def("__repr__", [](const CartesianAcceleration& acceleration) {
+    std::stringstream buffer;
+    buffer << acceleration;
+    return buffer.str();
+  });
+}
 
 void cartesian_wrench(py::module_& m) {
   py::class_<CartesianWrench, CartesianState> c(m, "CartesianWrench");
@@ -292,7 +388,7 @@ void cartesian_wrench(py::module_& m) {
       "twist",
       "linear_acceleration",
       "angular_acceleration",
-      "accelerations",
+      "acceleration",
   };
 
   for (const std::string& attr : deleted_attributes) {
@@ -321,6 +417,12 @@ void cartesian_wrench(py::module_& m) {
   c.def("norms", &CartesianWrench::norms, "Compute the norms of the state variable specified by the input type (default is full wrench)", "state_variable_type"_a=CartesianStateVariable::WRENCH);
   c.def("normalized", &CartesianWrench::normalized, "Compute the normalized twist at the state variable given in argument (default is full wrench)", "state_variable_type"_a=CartesianStateVariable::WRENCH);
 
+  c.def("__copy__", [](const CartesianWrench &wrench) {
+    return CartesianWrench(wrench);
+  });
+  c.def("__deepcopy__", [](const CartesianWrench &wrench, py::dict) {
+    return CartesianWrench(wrench);
+  }, "memo"_a);
   c.def("__repr__", [](const CartesianWrench& wrench) {
     std::stringstream buffer;
     buffer << wrench;
@@ -334,5 +436,6 @@ void bind_cartesian_space(py::module_& m) {
   cartesian_state(m);
   cartesian_pose(m);
   cartesian_twist(m);
+  cartesian_acceleration(m);
   cartesian_wrench(m);
 }
diff --git a/python/source/state_representation/bind_geometry.cpp b/python/source/state_representation/bind_geometry.cpp
new file mode 100644
index 000000000..52940c8cc
--- /dev/null
+++ b/python/source/state_representation/bind_geometry.cpp
@@ -0,0 +1,74 @@
+#include "state_representation_bindings.h"
+
+#include <state_representation/State.hpp>
+#include <state_representation/geometry/Shape.hpp>
+#include <state_representation/geometry/Ellipsoid.hpp>
+
+
+void shape(py::module_& m) {
+  py::class_<Shape, State> c(m, "Shape");
+
+  c.def(py::init<const StateType&, const std::string&, const std::string&>(), "Constructor with name but empty state.", "type"_a, "name"_a, "reference_frame"_a=std::string("world"));
+  c.def(py::init<const Shape&>(), "Copy constructor from another Shape.", "shape"_a);
+
+  c.def("get_center_state", &Shape::get_center_state, "Getter of the state.");
+  c.def("get_center_pose", &Shape::get_center_pose, "Getter of the pose from the state.");
+  c.def("get_center_position", &Shape::get_center_position, "Getter of the position from the state.");
+  c.def("get_center_orientation", &Shape::get_center_orientation, "Getter of the orientation from the state.");
+  c.def("get_center_twist", &Shape::get_center_twist, "Getter of the twist from the state.");
+
+  c.def("set_center_state", &Shape::set_center_state, "Setter of the state.");
+  c.def("set_center_pose", &Shape::set_center_pose, "Setter of the pose from the state.");
+  c.def("set_center_position", &Shape::set_center_position, "Setter of the position from the state.");
+  c.def("set_center_orientation", &Shape::set_center_orientation, "Setter of the orientation from the state.");
+
+  c.def("__copy__", [](const Shape &shape) {
+    return Shape(shape);
+  });
+  c.def("__deepcopy__", [](const Shape &shape, py::dict) {
+    return Shape(shape);
+  }, "memo"_a);
+  c.def("__repr__", [](const Shape& shape) {
+    std::stringstream buffer;
+    buffer << shape;
+    return buffer.str();
+  });
+}
+
+void ellipsoid(py::module_& m) {
+  py::class_<Ellipsoid, Shape> c(m, "Ellipsoid");
+
+  c.def(py::init<const std::string&, const std::string&>(), "Constructor with name but empty state.", "name"_a, "reference_frame"_a=std::string("world"));
+  c.def(py::init<const Ellipsoid&>(), "Copy constructor from another Ellipsoid.", "ellipsoid"_a);
+
+  c.def("get_axis_lengths", &Ellipsoid::get_axis_lengths, "Getter of the axis lengths.");
+  c.def("get_axis_length", &Ellipsoid::get_axis_length, "Getter of the axis length in one direction.", "index"_a);
+  c.def("set_axis_lengths", py::overload_cast<const std::vector<double>&>(&Ellipsoid::set_axis_lengths), "Setter of the axis lengths.", "axis_lengths"_a);
+  c.def("set_axis_lengths", py::overload_cast<unsigned int, double>(&Ellipsoid::set_axis_lengths), "Setter of the axis length at given index.", "index"_a, "axis_length"_a);
+  c.def("get_rotation_angle", &Ellipsoid::get_rotation_angle, "Getter of the rotation angle.");
+  c.def("set_rotation_angle", &Ellipsoid::set_rotation_angle, "Setter of the rotation angle.", "rotation_angle"_a);
+
+  c.def("get_rotation", &Ellipsoid::get_rotation, "Getter of the rotation.");
+  c.def("sample_from_parameterization", &Ellipsoid::sample_from_parameterization, "Function to sample an obstacle from its parameterization.", "nb_samples"_a);
+  c.def("from_algebraic_equation", &Ellipsoid::from_algebraic_equation, "Compute an ellipsoid from its algebraic equation ax2 + bxy + cy2 + cx + ey + f.");
+  c.def("fit", &Ellipsoid::fit, "Fit an ellipsoid on a set of points.");
+
+  c.def("to_std_vector", &Ellipsoid::to_std_vector, "Convert the ellipse to an std vector representation of its parameter.");
+
+  c.def("__copy__", [](const Shape &shape) {
+    return Shape(shape);
+  });
+  c.def("__deepcopy__", [](const Shape &shape, py::dict) {
+    return Shape(shape);
+  }, "memo"_a);
+  c.def("__repr__", [](const Shape& shape) {
+    std::stringstream buffer;
+    buffer << shape;
+    return buffer.str();
+  });
+}
+
+void bind_geometry(py::module_& m) {
+  shape(m);
+  ellipsoid(m);
+}
diff --git a/python/source/state_representation/bind_jacobian.cpp b/python/source/state_representation/bind_jacobian.cpp
index 0ac4b7bcc..a9556fba7 100644
--- a/python/source/state_representation/bind_jacobian.cpp
+++ b/python/source/state_representation/bind_jacobian.cpp
@@ -2,7 +2,7 @@
 
 #include <tuple>
 #include <state_representation/State.hpp>
-#include <state_representation/robot/Jacobian.hpp>
+#include <state_representation/space/Jacobian.hpp>
 
 void bind_jacobian(py::module_& m) {
   py::class_<Jacobian, State> c(m, "Jacobian");
@@ -72,6 +72,12 @@ void bind_jacobian(py::module_& m) {
   c.def(CartesianPose() * py::self);
   c.def(Eigen::MatrixXd() * py::self);
 
+  c.def("__copy__", [](const Jacobian &jacobian) {
+    return Jacobian(jacobian);
+  });
+  c.def("__deepcopy__", [](const Jacobian &jacobian, py::dict) {
+    return Jacobian(jacobian);
+    }, "memo"_a);
   c.def("__repr__", [](const Jacobian& jacobian) {
     std::stringstream buffer;
     buffer << jacobian;
diff --git a/python/source/state_representation/bind_joint_space.cpp b/python/source/state_representation/bind_joint_space.cpp
index 26d679781..f2df5b303 100644
--- a/python/source/state_representation/bind_joint_space.cpp
+++ b/python/source/state_representation/bind_joint_space.cpp
@@ -1,10 +1,10 @@
 #include "state_representation_bindings.h"
 
 #include <state_representation/State.hpp>
-#include <state_representation/robot/JointState.hpp>
-#include <state_representation/robot/JointPositions.hpp>
-#include <state_representation/robot/JointVelocities.hpp>
-#include <state_representation/robot/JointTorques.hpp>
+#include <state_representation/space/joint/JointState.hpp>
+#include <state_representation/space/joint/JointPositions.hpp>
+#include <state_representation/space/joint/JointVelocities.hpp>
+#include <state_representation/space/joint/JointTorques.hpp>
 
 void joint_state_variable(py::module_& m) {
   py::enum_<JointStateVariable>(m, "JointStateVariable")
@@ -94,6 +94,12 @@ void joint_state(py::module_& m) {
 
   c.def("to_list", &JointState::to_std_vector, "Return the state as a list.");
 
+  c.def("__copy__", [](const JointState &state) {
+    return JointState(state);
+  });
+  c.def("__deepcopy__", [](const JointState &state, py::dict) {
+    return JointState(state);
+  }, "memo"_a);
   c.def("__repr__", [](const JointState& state) {
     std::stringstream buffer;
     buffer << state;
@@ -154,6 +160,12 @@ void joint_positions(py::module_& m) {
   c.def("set_data", py::overload_cast<const Eigen::VectorXd&>(&JointPositions::set_data), "Set the positions data from a vector", "data"_a);
   c.def("set_data", py::overload_cast<const std::vector<double>&>(&JointPositions::set_data), "Set the positions data from a list", "data"_a);
 
+  c.def("__copy__", [](const JointPositions &positions) {
+    return JointPositions(positions);
+  });
+  c.def("__deepcopy__", [](const JointPositions &positions, py::dict) {
+    return JointPositions(positions);
+  }, "memo"_a);
   c.def("__repr__", [](const JointPositions& positions) {
     std::stringstream buffer;
     buffer << positions;
@@ -207,7 +219,9 @@ void joint_velocities(py::module_& m) {
   c.def(py::self / double());
   c.def(py::self / std::chrono::nanoseconds());
   c.def(py::self * std::chrono::nanoseconds());
+
   c.def(double() * py::self);
+  c.def(std::chrono::nanoseconds() * py::self);
   c.def(Eigen::ArrayXd() * py::self);
   c.def(Eigen::MatrixXd() * py::self);
 
@@ -221,6 +235,12 @@ void joint_velocities(py::module_& m) {
   c.def("clamp", py::overload_cast<const Eigen::ArrayXd&, const Eigen::ArrayXd&>(&JointVelocities::clamp), "Clamp inplace the magnitude of the velocity to the values in argument", "max_absolute_value_array"_a, "noise_ratio_array"_a);
   c.def("clamped", py::overload_cast<const Eigen::ArrayXd&, const Eigen::ArrayXd&>(&JointVelocities::clamp), "Return the velocity clamped to the values in argument", "max_absolute_value_array"_a, "noise_ratio_array"_a);
 
+  c.def("__copy__", [](const JointVelocities &velocities) {
+    return JointVelocities(velocities);
+  });
+  c.def("__deepcopy__", [](const JointVelocities &velocities, py::dict) {
+    return JointVelocities(velocities);
+  }, "memo"_a);
   c.def("__repr__", [](const JointVelocities& velocities) {
     std::stringstream buffer;
     buffer << velocities;
@@ -272,7 +292,9 @@ void joint_accelerations(py::module_& m) {
   c.def(py::self /= double());
   c.def(py::self / double());
   c.def(py::self * std::chrono::nanoseconds());
+
   c.def(double() * py::self);
+  c.def(std::chrono::nanoseconds() * py::self);
   c.def(Eigen::ArrayXd() * py::self);
   c.def(Eigen::MatrixXd() * py::self);
 
@@ -286,6 +308,12 @@ void joint_accelerations(py::module_& m) {
   c.def("clamp", py::overload_cast<const Eigen::ArrayXd&, const Eigen::ArrayXd&>(&JointAccelerations::clamp), "Clamp inplace the magnitude of the accelerations to the values in argument", "max_absolute_value_array"_a, "noise_ratio_array"_a);
   c.def("clamped", py::overload_cast<const Eigen::ArrayXd&, const Eigen::ArrayXd&>(&JointAccelerations::clamp), "Return the accelerations clamped to the values in argument", "max_absolute_value_array"_a, "noise_ratio_array"_a);
 
+  c.def("__copy__", [](const JointAccelerations &accelerations) {
+    return JointAccelerations(accelerations);
+  });
+  c.def("__deepcopy__", [](const JointAccelerations &accelerations, py::dict) {
+    return JointAccelerations(accelerations);
+  }, "memo"_a);
   c.def("__repr__", [](const JointAccelerations& accelerations) {
     std::stringstream buffer;
     buffer << accelerations;
@@ -349,6 +377,12 @@ void joint_torques(py::module_& m) {
   c.def("clamp", py::overload_cast<const Eigen::ArrayXd&, const Eigen::ArrayXd&>(&JointTorques::clamp), "Clamp inplace the magnitude of the torque to the values in argument", "max_absolute_value_array"_a, "noise_ratio_array"_a);
   c.def("clamped", py::overload_cast<const Eigen::ArrayXd&, const Eigen::ArrayXd&>(&JointTorques::clamp), "Return the torque clamped to the values in argument", "max_absolute_value_array"_a, "noise_ratio_array"_a);
 
+  c.def("__copy__", [](const JointTorques &torques) {
+    return JointTorques(torques);
+  });
+  c.def("__deepcopy__", [](const JointTorques &torques, py::dict) {
+    return JointTorques(torques);
+  }, "memo"_a);
   c.def("__repr__", [](const JointTorques& torques) {
     std::stringstream buffer;
     buffer << torques;
diff --git a/python/source/state_representation/bind_parameters.cpp b/python/source/state_representation/bind_parameters.cpp
index 0c2a58faa..d1602cc54 100644
--- a/python/source/state_representation/bind_parameters.cpp
+++ b/python/source/state_representation/bind_parameters.cpp
@@ -18,6 +18,12 @@ void parameter(py::module_& m) {
   c.def("get_value", &ParameterContainer::get_value, "Getter of the value attribute.");
   c.def("set_value", &ParameterContainer::set_value, "Setter of the value attribute.", py::arg("value"));
 
+  c.def("__copy__", [](const ParameterContainer &parameter) {
+    return ParameterContainer(parameter);
+  });
+  c.def("__deepcopy__", [](const ParameterContainer &parameter, py::dict) {
+    return ParameterContainer(parameter);
+  }, "memo"_a);
   c.def("__repr__", [](const ParameterContainer& parameter) {
     std::stringstream buffer;
     switch (parameter.get_type()) {
diff --git a/python/source/state_representation/bind_state.cpp b/python/source/state_representation/bind_state.cpp
index 60e787319..57f76d6b4 100644
--- a/python/source/state_representation/bind_state.cpp
+++ b/python/source/state_representation/bind_state.cpp
@@ -53,6 +53,12 @@ void state(py::module_& m) {
   c.def("is_compatible", &State::is_compatible, "Check if the state is compatible for operations with the state given as argument", "state"_a);
   c.def("initialize", &State::initialize, "Initialize the State to a zero value");
 
+  c.def("__copy__", [](const State &state) {
+    return State(state);
+  });
+  c.def("__deepcopy__", [](const State &state, py::dict) {
+    return State(state);
+  }, "memo"_a);
   c.def("__repr__", [](const State& state) {
     std::stringstream buffer;
     buffer << state;
diff --git a/python/source/state_representation/state_representation_bindings.cpp b/python/source/state_representation/state_representation_bindings.cpp
index e67abe219..d3e99c797 100644
--- a/python/source/state_representation/state_representation_bindings.cpp
+++ b/python/source/state_representation/state_representation_bindings.cpp
@@ -17,4 +17,5 @@ PYBIND11_MODULE(state_representation, m) {
   bind_joint_space(m);
   bind_jacobian(m);
   bind_parameters(m);
-}
\ No newline at end of file
+  bind_geometry(m);
+}
diff --git a/python/test/robot/__init__.py b/python/test/dynamical_systems/__init__.py
similarity index 100%
rename from python/test/robot/__init__.py
rename to python/test/dynamical_systems/__init__.py
diff --git a/python/test/dynamical_systems/test_cartesian_point_attractor.py b/python/test/dynamical_systems/test_cartesian_point_attractor.py
new file mode 100644
index 000000000..ac3e01170
--- /dev/null
+++ b/python/test/dynamical_systems/test_cartesian_point_attractor.py
@@ -0,0 +1,95 @@
+import numpy as np
+import state_representation as sr
+import unittest
+from datetime import timedelta
+from dynamical_systems import CartesianPointAttractorDS
+
+
+class TestCartesianPointAttractor(unittest.TestCase):
+
+    def assert_np_array_equal(self, a: np.array, b: np.array, places=3):
+        try:
+            np.testing.assert_almost_equal(a, b, decimal=places)
+        except AssertionError as e:
+            self.fail(f'{e}')
+
+    def test_empty_constructor(self):
+        ds = CartesianPointAttractorDS()
+        attractor = sr.CartesianPose.Identity("CAttractor", "A")
+
+        self.assertTrue(ds.get_parameter_value("attractor").is_empty())
+        self.assertTrue(ds.get_base_frame().is_empty())
+        ds.set_parameter(sr.Parameter("attractor", attractor, sr.StateType.PARAMETER_CARTESIANPOSE))
+        self.assertFalse(ds.get_parameter_value("attractor").is_empty())
+        self.assertFalse(ds.get_base_frame().is_empty())
+        self.assertEqual(ds.get_base_frame().get_name(), attractor.get_reference_frame())
+        self.assertEqual(ds.get_base_frame().get_reference_frame(), attractor.get_reference_frame())
+        self.assert_np_array_equal(ds.get_base_frame().get_transformation_matrix(), np.eye(4))
+
+    def test_is_compatible(self):
+        ds = CartesianPointAttractorDS()
+        state1 = sr.CartesianState.Identity("B", "A")
+        state2 = sr.CartesianState.Identity("D", "C")
+        state3 = sr.CartesianState.Identity("C", "A")
+        state4 = sr.CartesianState.Identity("C", "B")
+
+        with self.assertRaises(RuntimeError):
+            ds.evaluate(state1)
+
+        ds.set_base_frame(state1)
+        with self.assertRaises(RuntimeError):
+            ds.evaluate(state2)
+        with self.assertRaises(RuntimeError):
+            ds.evaluate(state3)
+        with self.assertRaises(RuntimeError):
+            ds.evaluate(state4)
+
+        ds.set_parameter(sr.Parameter("attractor", sr.CartesianPose.Identity("CAttractor", "A"),
+                                      sr.StateType.PARAMETER_CARTESIANPOSE))
+        self.assertTrue(ds.is_compatible(state1))
+        self.assertFalse(ds.is_compatible(state2))
+        self.assertTrue(ds.is_compatible(state3))
+        self.assertTrue(ds.is_compatible(state4))
+
+    def test_pose(self):
+        ds = CartesianPointAttractorDS()
+        target = sr.CartesianPose.Random("B")
+        ds.set_parameter(sr.Parameter("attractor", target, sr.StateType.PARAMETER_CARTESIANPOSE))
+
+        current_pose = sr.CartesianPose.Identity("B")
+        for i in range(100):
+            twist = sr.CartesianTwist(ds.evaluate(current_pose))
+            current_pose += timedelta(milliseconds=100) * twist
+
+        self.assertTrue(current_pose.dist(target, sr.CartesianStateVariable.POSITION) < 1e-3)
+        self.assertTrue(current_pose.dist(target, sr.CartesianStateVariable.ORIENTATION) < 1e-3)
+
+    def test_stacked_moving_reference_frames(self):
+        AinWorld = sr.CartesianState.Random("A")
+        BinA = sr.CartesianState.Random("B", "A")
+        CinA = sr.CartesianState(sr.CartesianPose.Random("C", "A"))
+
+        ds = CartesianPointAttractorDS()
+        ds.set_parameter(sr.Parameter("attractor", BinA, sr.StateType.PARAMETER_CARTESIANSTATE))
+
+        twist = sr.CartesianTwist(ds.evaluate(CinA))
+
+        CinA.set_linear_velocity(np.random.rand(3, 1))
+        CinA.set_angular_velocity(np.random.rand(3, 1))
+        twist2 = sr.CartesianTwist(ds.evaluate(CinA))
+
+        self.assertTrue(np.linalg.norm(twist.data()) - np.linalg.norm(twist2.data()) < 1e-5)
+
+        twist = AinWorld * ds.evaluate(CinA)
+
+        ds.set_base_frame(AinWorld)
+        CinWorld = AinWorld * CinA
+        twist2 = ds.evaluate(CinWorld)
+
+        self.assertEqual(twist.get_reference_frame(), AinWorld.get_reference_frame())
+        self.assertEqual(twist.get_reference_frame(), twist2.get_reference_frame())
+        self.assertTrue(np.linalg.norm(twist.data()) - np.linalg.norm(twist2.data()) < 1e-5)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/python/test/dynamical_systems/test_circular.py b/python/test/dynamical_systems/test_circular.py
new file mode 100644
index 000000000..6ad6af9e9
--- /dev/null
+++ b/python/test/dynamical_systems/test_circular.py
@@ -0,0 +1,80 @@
+import numpy as np
+import state_representation as sr
+import unittest
+from datetime import timedelta
+from dynamical_systems import CartesianCircularDS
+
+
+class TestCircular(unittest.TestCase):
+
+    @classmethod
+    def setUp(cls):
+        cls.center = sr.CartesianPose.Identity("B")
+        cls.limit_cycle = sr.Ellipsoid("limit_cycle")
+        cls.radius = 10.0
+        cls.nb_steps = 2000
+        cls.dt = timedelta(milliseconds=10)
+        cls.tol = 1e-3
+        cls.limit_cycle.set_center_pose(cls.center)
+        cls.limit_cycle.set_axis_lengths([cls.radius, cls.radius])
+
+    def assert_np_array_equal(self, a: np.array, b: np.array, places=3):
+        try:
+            np.testing.assert_almost_equal(a, b, decimal=places)
+        except AssertionError as e:
+            self.fail(f'{e}')
+
+    def test_empty_constructor(self):
+        ds = CartesianCircularDS()
+        self.assertTrue(ds.get_parameter_value("limit_cycle").get_center_state().is_empty())
+        self.assertTrue(ds.get_base_frame().is_empty())
+
+        ds.set_parameter(sr.Parameter("limit_cycle", self.limit_cycle, sr.StateType.PARAMETER_ELLIPSOID))
+        self.assertFalse(ds.get_parameter_value("limit_cycle").get_center_state().is_empty())
+        self.assertFalse(ds.get_base_frame().is_empty())
+
+        self.assertEqual(ds.get_base_frame().get_name(), self.center.get_reference_frame())
+        self.assertEqual(ds.get_base_frame().get_reference_frame(), self.center.get_reference_frame())
+        self.assert_np_array_equal(ds.get_base_frame().get_transformation_matrix(), np.eye(4))
+
+    def test_is_compatible(self):
+        ds = CartesianCircularDS()
+        state1 = sr.CartesianState.Identity("world", "A")
+        state2 = sr.CartesianState("D", "C")
+        state3 = sr.CartesianState("C", "A")
+        state4 = sr.CartesianState("C", "world")
+
+        with self.assertRaises(RuntimeError):
+            ds.evaluate(state1)
+
+        ds.set_base_frame(state1)
+        with self.assertRaises(RuntimeError):
+            ds.evaluate(state2)
+        with self.assertRaises(RuntimeError):
+            ds.evaluate(state3)
+        with self.assertRaises(RuntimeError):
+            ds.evaluate(state4)
+
+        ds.set_parameter(sr.Parameter("limit_cycle", self.limit_cycle, sr.StateType.PARAMETER_ELLIPSOID))
+        self.assertTrue(ds.is_compatible(state1))
+        self.assertFalse(ds.is_compatible(state2))
+        self.assertTrue(ds.is_compatible(state3))
+        self.assertTrue(ds.is_compatible(state4))
+
+    def test_points_on_radius_random_center(self):
+        ds = CartesianCircularDS()
+        self.limit_cycle.set_center_position(np.random.rand(3, 1))
+        ds.set_parameter(sr.Parameter("limit_cycle", self.limit_cycle, sr.StateType.PARAMETER_ELLIPSOID))
+
+        current_pose = sr.CartesianPose("A", 10 * np.random.rand(3, 1))
+        for i in range(self.nb_steps):
+            twist = sr.CartesianTwist(ds.evaluate(current_pose))
+            twist.clamp(10, 10, 0.001, 0.001)
+            current_pose += self.dt * twist
+
+        self.assertTrue(current_pose.dist(self.limit_cycle.get_center_pose(),
+                                          sr.CartesianStateVariable.POSITION) - self.radius < self.tol)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/python/test/dynamical_systems/test_ds.py b/python/test/dynamical_systems/test_ds.py
new file mode 100644
index 000000000..092500e1e
--- /dev/null
+++ b/python/test/dynamical_systems/test_ds.py
@@ -0,0 +1,73 @@
+import state_representation as sr
+import unittest
+from dynamical_systems import ICartesianDS, DYNAMICAL_SYSTEM, create_cartesian_ds, create_joint_ds
+
+DS_METHOD_EXPECTS = [
+    'is_compatible',
+    'evaluate',
+    'get_base_frame',
+    'set_base_frame',
+    'get_parameter',
+    'get_parameters',
+    'get_parameter_value',
+    'get_parameter_list',
+    'set_parameter',
+    'set_parameters'
+]
+
+
+class TestDynamicalSystems(unittest.TestCase):
+
+    def test_callable_methods(self):
+        methods = [m for m in dir(ICartesianDS) if callable(getattr(ICartesianDS, m))]
+        for expected in DS_METHOD_EXPECTS:
+            self.assertIn(expected, methods)
+
+    def test_cartesian_factory(self):
+        cart_ds = create_cartesian_ds(DYNAMICAL_SYSTEM.NONE)
+        cart_ds.set_base_frame(sr.CartesianState.Identity("A"))
+        cart_ds.evaluate(sr.CartesianState.Identity("C", "A"))
+        self.assertTrue(cart_ds.evaluate(sr.CartesianState.Identity("C", "A")).is_empty())
+        self.assertTrue(len(cart_ds.get_parameter_list()) == 0)
+
+        param_list = [sr.Parameter("test", 1.0, sr.StateType.PARAMETER_DOUBLE)]
+        with self.assertRaises(RuntimeError):
+            cart_ds.set_parameters(param_list)
+
+    def test_cartesian_ds(self):
+        ds = create_cartesian_ds(DYNAMICAL_SYSTEM.POINT_ATTRACTOR)
+        expected_params = ["attractor", "gain"]
+        for param in list(ds.get_parameters().keys()):
+            self.assertIn(param, expected_params)
+
+        ds = create_cartesian_ds(DYNAMICAL_SYSTEM.RING)
+        expected_params = ["center", "rotation_offset", "radius", "width", "speed", "field_strength", "normal_gain",
+                           "angular_gain"]
+        for param in list(ds.get_parameters().keys()):
+            self.assertIn(param, expected_params)
+
+        ds = create_cartesian_ds(DYNAMICAL_SYSTEM.CIRCULAR)
+        expected_params = ["limit_cycle", "planar_gain", "normal_gain", "circular_velocity"]
+        for param in list(ds.get_parameters().keys()):
+            self.assertIn(param, expected_params)
+
+    def test_joint_factory(self):
+        joint_ds = create_joint_ds(DYNAMICAL_SYSTEM.NONE)
+        joint_ds.set_base_frame(sr.JointState.Zero("robot", 3))
+        joint_ds.evaluate(sr.JointState.Random("robot", 3))
+        self.assertTrue(joint_ds.evaluate(sr.JointState.Random("robot", 3)).is_empty())
+        self.assertTrue(len(joint_ds.get_parameter_list()) == 0)
+
+        param_list = [sr.Parameter("test", 1.0, sr.StateType.PARAMETER_DOUBLE)]
+        with self.assertRaises(RuntimeError):
+            joint_ds.set_parameters(param_list)
+
+    def test_joint_ds(self):
+        ds = create_joint_ds(DYNAMICAL_SYSTEM.POINT_ATTRACTOR)
+        expected_params = ["attractor", "gain"]
+        for param in list(ds.get_parameters().keys()):
+            self.assertIn(param, expected_params)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/python/test/dynamical_systems/test_joint_point_attractor.py b/python/test/dynamical_systems/test_joint_point_attractor.py
new file mode 100644
index 000000000..b13d71837
--- /dev/null
+++ b/python/test/dynamical_systems/test_joint_point_attractor.py
@@ -0,0 +1,32 @@
+import state_representation as sr
+import unittest
+from datetime import timedelta
+from dynamical_systems import JointPointAttractorDS
+
+
+class TestJointPointAttractor(unittest.TestCase):
+    def test_empty_constructor(self):
+        ds = JointPointAttractorDS()
+        attractor = sr.JointPositions.Zero("robot", 3)
+
+        self.assertTrue(ds.get_parameter_value("attractor").is_empty())
+        self.assertTrue(ds.get_base_frame().is_empty())
+        ds.set_parameter(sr.Parameter("attractor", attractor, sr.StateType.PARAMETER_JOINTPOSITIONS))
+        self.assertFalse(ds.get_parameter_value("attractor").is_empty())
+
+    def test_convergence(self):
+        ds = JointPointAttractorDS()
+        attractor = sr.JointPositions.Random("robot", 3)
+        ds.set_parameter(sr.Parameter("attractor", attractor, sr.StateType.PARAMETER_JOINTPOSITIONS))
+
+        current_state = sr.JointPositions.Random("robot", 3)
+        current_state.set_data(10 * current_state.data())
+        for i in range(100):
+            velocities = sr.JointVelocities(ds.evaluate(current_state))
+            current_state += timedelta(milliseconds=100) * velocities
+
+        self.assertTrue(current_state.dist(attractor, sr.JointStateVariable.POSITIONS) < 1e-3)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/python/test/dynamical_systems/test_ring.py b/python/test/dynamical_systems/test_ring.py
new file mode 100644
index 000000000..be22fd5e7
--- /dev/null
+++ b/python/test/dynamical_systems/test_ring.py
@@ -0,0 +1,117 @@
+import copy
+import numpy as np
+import state_representation as sr
+import unittest
+from datetime import timedelta
+from dynamical_systems import CartesianRingDS
+
+
+class TestRing(unittest.TestCase):
+
+    @classmethod
+    def setUp(cls):
+        cls.center = sr.CartesianPose.Identity("A")
+        cls.radius = 10.0
+        cls.width = 1.0
+        cls.speed = 1.0
+        cls.nb_steps = 1000
+        cls.dt = timedelta(milliseconds=10)
+        cls.tol = 1e-3
+
+    def assert_np_array_equal(self, a: np.array, b: np.array, places=3):
+        try:
+            np.testing.assert_almost_equal(a, b, decimal=places)
+        except AssertionError as e:
+            self.fail(f'{e}')
+
+    def test_empty_constructor(self):
+        ds = CartesianRingDS()
+        center = sr.CartesianPose.Identity("CAttractor", "A")
+
+        self.assertTrue(ds.get_parameter_value("center").is_empty())
+        ds.set_parameter(sr.Parameter("center", center, sr.StateType.PARAMETER_CARTESIANPOSE))
+        self.assertFalse(ds.get_parameter_value("center").is_empty())
+
+        self.assertFalse(ds.get_base_frame().is_empty())
+        self.assertEqual(ds.get_base_frame().get_name(), center.get_reference_frame())
+        self.assertEqual(ds.get_base_frame().get_reference_frame(), center.get_reference_frame())
+        self.assert_np_array_equal(ds.get_base_frame().get_transformation_matrix(), np.eye(4))
+
+    def test_is_compatible(self):
+        ds = CartesianRingDS()
+        center = sr.CartesianPose.Identity("CAttractor", "A")
+        state1 = sr.CartesianState.Identity("B", "A")
+        state2 = sr.CartesianState.Identity("D", "C")
+        state3 = sr.CartesianState.Identity("C", "A")
+        state4 = sr.CartesianState.Identity("C", "B")
+
+        with self.assertRaises(RuntimeError):
+            ds.evaluate(state1)
+
+        ds.set_base_frame(state1)
+        with self.assertRaises(RuntimeError):
+            ds.evaluate(state2)
+        with self.assertRaises(RuntimeError):
+            ds.evaluate(state3)
+        with self.assertRaises(RuntimeError):
+            ds.evaluate(state4)
+
+        ds.set_parameter(sr.Parameter("center", center, sr.StateType.PARAMETER_CARTESIANPOSE))
+        self.assertTrue(ds.is_compatible(state1))
+        self.assertFalse(ds.is_compatible(state2))
+        self.assertTrue(ds.is_compatible(state3))
+        self.assertTrue(ds.is_compatible(state4))
+
+    def test_points_on_radius(self):
+        ds = CartesianRingDS()
+        ds.set_parameter(sr.Parameter("center", self.center, sr.StateType.PARAMETER_CARTESIANPOSE))
+        ds.set_parameter(sr.Parameter("radius", self.radius, sr.StateType.PARAMETER_DOUBLE))
+        ds.set_parameter(sr.Parameter("width", self.width, sr.StateType.PARAMETER_DOUBLE))
+        ds.set_parameter(sr.Parameter("speed", self.speed, sr.StateType.PARAMETER_DOUBLE))
+
+        current_pose = copy.deepcopy(self.center)
+        twist = sr.CartesianTwist(ds.evaluate(current_pose))
+        self.assertTrue(np.linalg.norm(twist.data()) < self.tol)
+
+        current_pose.set_position(self.radius, 0, 0)
+        twist = sr.CartesianTwist(ds.evaluate(current_pose))
+        self.assertTrue(twist.get_linear_velocity()[0] < self.tol)
+        self.assertTrue(abs(twist.get_linear_velocity()[1] - self.speed) < self.tol)
+
+        current_pose.set_position(0, self.radius, 0)
+        twist = sr.CartesianTwist(ds.evaluate(current_pose))
+        self.assertTrue(abs(twist.get_linear_velocity()[0] + self.speed) < self.tol)
+        self.assertTrue(twist.get_linear_velocity()[1] < self.tol)
+
+        current_pose.set_position(-self.radius, 0, 0)
+        twist = sr.CartesianTwist(ds.evaluate(current_pose))
+        self.assertTrue(twist.get_linear_velocity()[0] < self.tol)
+        self.assertTrue(abs(twist.get_linear_velocity()[1] + self.speed) < self.tol)
+
+        current_pose.set_position(0, -self.radius, 0)
+        twist = sr.CartesianTwist(ds.evaluate(current_pose))
+        self.assertTrue(abs(twist.get_linear_velocity()[0] - self.speed) < self.tol)
+        self.assertTrue(twist.get_linear_velocity()[1] < self.tol)
+
+        current_pose.set_position(self.radius, 0, 1)
+        twist = sr.CartesianTwist(ds.evaluate(current_pose))
+        self.assertTrue(abs(twist.get_linear_velocity()[2] + 1) < self.tol)
+
+    def test_convergence_on_radius_random_center(self):
+        center = sr.CartesianPose.Random("A")
+        ds = CartesianRingDS()
+        ds.set_parameter(sr.Parameter("center", center, sr.StateType.PARAMETER_CARTESIANPOSE))
+        ds.set_parameter(sr.Parameter("radius", self.radius, sr.StateType.PARAMETER_DOUBLE))
+
+        current_pose = sr.CartesianPose("B", self.radius * np.random.rand(3, 1))
+        for i in range(self.nb_steps):
+            twist = sr.CartesianTwist(ds.evaluate(current_pose))
+            twist.clamp(10, 10, 0.001, 0.001)
+            current_pose += self.dt * twist
+
+        self.assertTrue(
+            abs(np.linalg.norm(current_pose.get_position() - center.get_position()) - self.radius) < self.tol)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/python/test/space/__init__.py b/python/test/state_representation/__init__.py
similarity index 100%
rename from python/test/space/__init__.py
rename to python/test/state_representation/__init__.py
diff --git a/python/test/state_representation/space/__init__.py b/python/test/state_representation/space/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/python/test/state_representation/space/cartesian/__init__.py b/python/test/state_representation/space/cartesian/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/python/test/space/test_cartesian_pose.py b/python/test/state_representation/space/cartesian/test_cartesian_pose.py
similarity index 71%
rename from python/test/space/test_cartesian_pose.py
rename to python/test/state_representation/space/cartesian/test_cartesian_pose.py
index 832c90374..22c4df022 100755
--- a/python/test/space/test_cartesian_pose.py
+++ b/python/test/state_representation/space/cartesian/test_cartesian_pose.py
@@ -1,4 +1,6 @@
 import unittest
+import copy
+
 from state_representation import CartesianPose
 import numpy as np
 
@@ -20,5 +22,12 @@ def test_constructors(self):
         self.assert_np_array_equal(A.get_position(), [1, 2, 3])
         self.assert_np_array_equal(A.get_orientation(), [1, 2, 3, 4] / np.linalg.norm([1, 2, 3, 4]))
 
+    def test_copy(self):
+        state = CartesianPose().Random("test")
+        for state_copy in [copy.copy(state), copy.deepcopy(state)]:
+            self.assertEqual(state.get_name(), state_copy.get_name())
+            self.assertEqual(state.get_reference_frame(), state_copy.get_reference_frame())
+            self.assert_np_array_equal(state.data(), state_copy.data())
+
 if __name__ == '__main__':
     unittest.main()
\ No newline at end of file
diff --git a/python/test/space/test_cartesian_state.py b/python/test/state_representation/space/cartesian/test_cartesian_state.py
similarity index 93%
rename from python/test/space/test_cartesian_state.py
rename to python/test/state_representation/space/cartesian/test_cartesian_state.py
index 6df30d34a..289697682 100755
--- a/python/test/space/test_cartesian_state.py
+++ b/python/test/state_representation/space/cartesian/test_cartesian_state.py
@@ -1,11 +1,12 @@
 import unittest
+import copy
 
 import numpy as np
 from numpy.testing import assert_array_equal, assert_array_almost_equal
 from state_representation import State, CartesianState, StateType, CartesianStateVariable
 
-from .test_spatial_state import SPATIAL_STATE_METHOD_EXPECTS
-from ..test_state import STATE_METHOD_EXPECTS
+from ..test_spatial_state import SPATIAL_STATE_METHOD_EXPECTS
+from ...test_state import STATE_METHOD_EXPECTS
 
 CARTESIAN_STATE_METHOD_EXPECTS = [
     'Identity',
@@ -16,7 +17,7 @@
     'data',
     'set_data',
     'dist',
-    'get_accelerations',
+    'get_acceleration',
     'get_angular_acceleration',
     'get_angular_velocity',
     'get_force',
@@ -42,7 +43,7 @@
     'normalized',
     'norms',
     'reset_timestamp',
-    'set_accelerations',
+    'set_acceleration',
     'set_angular_acceleration',
     'set_angular_velocity',
     'set_empty',
@@ -130,7 +131,7 @@ def test_identity_initialization(self):
         self.assertAlmostEqual(np.linalg.norm(identity.get_orientation()), 1)
         self.assertAlmostEqual(identity.get_orientation()[0], 1)
         self.assertAlmostEqual(np.linalg.norm(identity.get_twist()), 0)
-        self.assertAlmostEqual(np.linalg.norm(identity.get_accelerations()), 0)
+        self.assertAlmostEqual(np.linalg.norm(identity.get_acceleration()), 0)
         self.assertAlmostEqual(np.linalg.norm(identity.get_wrench()), 0)
 
     def test_random_initialization(self):
@@ -141,9 +142,14 @@ def test_random_initialization(self):
         self.assertAlmostEqual(np.linalg.norm(random.get_orientation()), 1)
         [self.assertTrue(random.get_orientation()[i] != 0) for i in range(4)]
         self.assertTrue(np.linalg.norm(random.get_twist()) > 0)
-        self.assertTrue(np.linalg.norm(random.get_accelerations()) > 0)
+        self.assertTrue(np.linalg.norm(random.get_acceleration()) > 0)
         self.assertTrue(np.linalg.norm(random.get_wrench()) > 0)
 
+    def test_copy(self):
+        state = CartesianState().Random("test")
+        for state_copy in [copy.copy(state), copy.deepcopy(state)]:
+            self.assert_name_frame_data_equal(state, state_copy)
+
     def test_copy_constructor(self):
         random = CartesianState().Random("test")
         copy1 = random
@@ -224,9 +230,9 @@ def test_get_set_fields(self):
         angular_acceleration = np.random.rand(3)
         cs.set_angular_acceleration(angular_acceleration)
         assert_array_almost_equal(cs.get_angular_acceleration(), angular_acceleration)
-        accelerations = np.random.rand(6)
-        cs.set_accelerations(accelerations)
-        assert_array_almost_equal(cs.get_accelerations(), accelerations)
+        acceleration = np.random.rand(6)
+        cs.set_acceleration(acceleration)
+        assert_array_almost_equal(cs.get_acceleration(), acceleration)
 
         # wrench
         force = np.random.rand(3)
@@ -267,7 +273,7 @@ def test_set_zero(self):
     def test_get_set_data(self):
         cs1 = CartesianState().Identity("test")
         cs2 = CartesianState().Random("test")
-        concatenated_state = np.hstack((cs1.get_pose(), cs1.get_twist(), cs1.get_accelerations(), cs1.get_wrench()))
+        concatenated_state = np.hstack((cs1.get_pose(), cs1.get_twist(), cs1.get_acceleration(), cs1.get_wrench()))
         assert_array_almost_equal(cs1.data(), concatenated_state)
         assert_array_almost_equal(cs1.array(), concatenated_state)
 
@@ -301,8 +307,8 @@ def test_clamping(self):
                              CartesianStateVariable.LINEAR_ACCELERATION, 3)
         self.clamping_helper(state, state.get_angular_acceleration, state.set_angular_acceleration,
                              CartesianStateVariable.ANGULAR_ACCELERATION, 3)
-        self.clamping_helper(state, state.get_accelerations, state.set_accelerations,
-                             CartesianStateVariable.ACCELERATIONS, 6)
+        self.clamping_helper(state, state.get_acceleration, state.set_acceleration,
+                             CartesianStateVariable.ACCELERATION, 6)
         self.clamping_helper(state, state.get_force, state.set_force, CartesianStateVariable.FORCE, 3)
         self.clamping_helper(state, state.get_torque, state.set_torque, CartesianStateVariable.TORQUE, 3)
         self.clamping_helper(state, state.get_wrench, state.set_wrench, CartesianStateVariable.WRENCH, 6)
@@ -363,7 +369,7 @@ def test_distance(self):
         self.assertAlmostEqual(cs1.dist(cs3, CartesianStateVariable.ORIENTATION), orient_dist)
         self.assertAlmostEqual(cs1.dist(cs3, CartesianStateVariable.POSE), pos_dist + orient_dist)
         self.assertAlmostEqual(cs1.dist(cs3, CartesianStateVariable.TWIST), lin_vel_dist + ang_vel_dist)
-        self.assertAlmostEqual(cs1.dist(cs3, CartesianStateVariable.ACCELERATIONS), lin_acc_dist + ang_acc_dist)
+        self.assertAlmostEqual(cs1.dist(cs3, CartesianStateVariable.ACCELERATION), lin_acc_dist + ang_acc_dist)
         self.assertAlmostEqual(cs1.dist(cs3, CartesianStateVariable.WRENCH), force_dist + torque_dist)
         self.assertAlmostEqual(cs1.dist(cs3), cs3.dist(cs1, CartesianStateVariable.ALL))
 
@@ -380,7 +386,7 @@ def test_addition(self):
         assert_array_almost_equal(csum.get_position(), cs1.get_position() + cs2.get_position())
         # TODO orientation sum
         assert_array_almost_equal(csum.get_twist(), cs1.get_twist() + cs2.get_twist())
-        assert_array_almost_equal(csum.get_accelerations(), cs1.get_accelerations() + cs2.get_accelerations())
+        assert_array_almost_equal(csum.get_acceleration(), cs1.get_acceleration() + cs2.get_acceleration())
         assert_array_almost_equal(csum.get_wrench(), cs1.get_wrench() + cs2.get_wrench())
 
         cs1 += cs2
@@ -400,7 +406,7 @@ def test_subtraction(self):
         assert_array_almost_equal(cdiff.get_position(), cs1.get_position() - cs2.get_position())
         # TODO orientation diff
         assert_array_almost_equal(cdiff.get_twist(), cs1.get_twist() - cs2.get_twist())
-        assert_array_almost_equal(cdiff.get_accelerations(), cs1.get_accelerations() - cs2.get_accelerations())
+        assert_array_almost_equal(cdiff.get_acceleration(), cs1.get_acceleration() - cs2.get_acceleration())
         assert_array_almost_equal(cdiff.get_wrench(), cs1.get_wrench() - cs2.get_wrench())
 
         cs1 -= cs2
@@ -415,7 +421,7 @@ def test_scalar_multiplication(self):
         assert_array_almost_equal(cscaled.get_position(), scalar * cs.get_position())
         # TODO orientation mult
         assert_array_almost_equal(cscaled.get_twist(), scalar * cs.get_twist())
-        assert_array_almost_equal(cscaled.get_accelerations(), scalar * cs.get_accelerations())
+        assert_array_almost_equal(cscaled.get_acceleration(), scalar * cs.get_acceleration())
         assert_array_almost_equal(cscaled.get_wrench(), scalar * cs.get_wrench())
 
         cs *= scalar
@@ -434,7 +440,7 @@ def test_scalar_division(self):
         assert_array_almost_equal(cscaled.get_position(), cs.get_position() / scalar)
         # TODO orientation diff
         assert_array_almost_equal(cscaled.get_twist(), cs.get_twist() / scalar)
-        assert_array_almost_equal(cscaled.get_accelerations(), cs.get_accelerations() / scalar)
+        assert_array_almost_equal(cscaled.get_acceleration(), cs.get_acceleration() / scalar)
         assert_array_almost_equal(cscaled.get_wrench(), cs.get_wrench() / scalar)
 
         cs /= scalar
diff --git a/python/test/state_representation/space/joint/__init__.py b/python/test/state_representation/space/joint/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/python/test/robot/test_joint_state.py b/python/test/state_representation/space/joint/test_joint_state.py
similarity index 71%
rename from python/test/robot/test_joint_state.py
rename to python/test/state_representation/space/joint/test_joint_state.py
index 5332e36f3..ced910fd4 100755
--- a/python/test/robot/test_joint_state.py
+++ b/python/test/state_representation/space/joint/test_joint_state.py
@@ -1,4 +1,6 @@
 import unittest
+import copy
+
 from state_representation import JointState
 
 JOINT_STATE_METHOD_EXPECTS = [
@@ -48,10 +50,20 @@
 
 
 class TestJointState(unittest.TestCase):
+    def assert_np_array_equal(self, a, b):
+        self.assertListEqual(list(a), list(b))
+
     def test_callable_methods(self):
         methods = [m for m in dir(JointState) if callable(getattr(JointState, m))]
         for expected in JOINT_STATE_METHOD_EXPECTS:
             self.assertIn(expected, methods)
 
+    def test_copy(self):
+        state = JointState().Random("test", 3)
+        for state_copy in [copy.copy(state), copy.deepcopy(state)]:
+            self.assertEqual(state.get_name(), state_copy.get_name())
+            self.assertListEqual(state.get_names(), state_copy.get_names())
+            self.assert_np_array_equal(state.data(), state_copy.data())
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/python/test/robot/test_jacobian.py b/python/test/state_representation/space/test_jacobian.py
similarity index 85%
rename from python/test/robot/test_jacobian.py
rename to python/test/state_representation/space/test_jacobian.py
index 3f6c6f81b..0dbd11075 100644
--- a/python/test/robot/test_jacobian.py
+++ b/python/test/state_representation/space/test_jacobian.py
@@ -1,4 +1,5 @@
 import unittest
+import copy
 
 import numpy as np
 from state_representation import Jacobian, CartesianPose, CartesianTwist, CartesianWrench, JointVelocities
@@ -49,6 +50,14 @@ def test_constructors(self):
         B = Jacobian.Random("robot", 7, "ee")
         B.copy()
 
+    def test_copy(self):
+        state = Jacobian.Random("robot", 7, "ee")
+        for state_copy in [copy.copy(state), copy.deepcopy(state)]:
+            self.assertEqual(state.get_frame(), state_copy.get_frame())
+            self.assertEqual(state.get_reference_frame(), state_copy.get_reference_frame())
+            self.assertListEqual(state.get_joint_names(), state_copy.get_joint_names())
+            self.assert_np_array_equal(state.data().flatten(), state_copy.data().flatten())
+
     def test_getters(self):
         jac = Jacobian("jacobian", 3, "ee", "robot")
         self.assertEqual(jac.cols(), 3)
diff --git a/python/test/space/test_spatial_state.py b/python/test/state_representation/space/test_spatial_state.py
similarity index 77%
rename from python/test/space/test_spatial_state.py
rename to python/test/state_representation/space/test_spatial_state.py
index 78f534207..e1cbd781e 100644
--- a/python/test/space/test_spatial_state.py
+++ b/python/test/state_representation/space/test_spatial_state.py
@@ -1,8 +1,8 @@
 import unittest
+import copy
 
 from state_representation import SpatialState, StateType
-
-from test.test_state import STATE_METHOD_EXPECTS
+from ..test_state import STATE_METHOD_EXPECTS
 
 SPATIAL_STATE_METHOD_EXPECTS = [
     'get_reference_frame',
@@ -39,6 +39,14 @@ def test_constructors(self):
         self.assertEqual(state2.get_reference_frame(), state3.get_reference_frame())
         self.assertEqual(state2.is_empty(), state3.is_empty())
 
+    def test_copy(self):
+        state = SpatialState(StateType.CARTESIANSTATE, "test", "robot", False)
+        for state_copy in [copy.copy(state), copy.deepcopy(state)]:
+            self.assertEqual(state.get_type(), state_copy.get_type())
+            self.assertEqual(state.get_name(), state_copy.get_name())
+            self.assertEqual(state.get_reference_frame(), state_copy.get_reference_frame())
+            self.assertEqual(state.is_empty(), state_copy.is_empty())
+
     def test_compatibility(self):
         state1 = SpatialState(StateType.CARTESIANSTATE, "test", "robot", True)
         state2 = SpatialState(StateType.STATE, "test")
diff --git a/python/test/state_representation/test_geometry.py b/python/test/state_representation/test_geometry.py
new file mode 100644
index 000000000..621aa84a5
--- /dev/null
+++ b/python/test/state_representation/test_geometry.py
@@ -0,0 +1,61 @@
+import unittest
+
+from state_representation import Shape, Ellipsoid
+
+SHAPE_METHOD_EXPECTS = [
+    'get_center_state',
+    'get_center_pose',
+    'get_center_position',
+    'get_center_orientation',
+    'get_center_twist',
+    'set_center_state',
+    'set_center_pose',
+    'set_center_position',
+    'set_center_orientation'
+]
+
+ELLIPSOID_METHOD_EXPECTS = [
+    'get_axis_lengths',
+    'get_axis_length',
+    'set_axis_lengths',
+    'get_rotation_angle',
+    'set_rotation_angle',
+    'get_rotation',
+    'sample_from_parameterization',
+    'from_algebraic_equation',
+    'fit',
+    'to_std_vector'
+]
+
+
+class TestState(unittest.TestCase):
+
+    def test_callable_methods(self):
+        methods = [m for m in dir(Shape) if callable(getattr(Shape, m))]
+        for expected in SHAPE_METHOD_EXPECTS:
+            self.assertIn(expected, methods)
+
+        methods = [m for m in dir(Ellipsoid) if callable(getattr(Ellipsoid, m))]
+        for expected in ELLIPSOID_METHOD_EXPECTS:
+            self.assertIn(expected, methods)
+
+    def test_sampling(self):
+        ellipse = Ellipsoid("test")
+        points = ellipse.sample_from_parameterization(100)
+        for point in points:
+            x = point.get_position()[0]
+            y = point.get_position()[1]
+            d = x * x + y * y - 1.0
+            self.assertTrue(abs(d) < 1e-3)
+
+        ellipse.set_axis_lengths([3., 0.5, 0.])
+        points = ellipse.sample_from_parameterization(100)
+        for point in points:
+            x = point.get_position()[0]
+            y = point.get_position()[1]
+            d = x * x / 9.0 + y * y / 0.25 - 1.0
+            self.assertTrue(abs(d) < 1e-3)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/python/test/test_parameters.py b/python/test/state_representation/test_parameters.py
similarity index 93%
rename from python/test/test_parameters.py
rename to python/test/state_representation/test_parameters.py
index 1978c38ac..cb36eeef8 100755
--- a/python/test/test_parameters.py
+++ b/python/test/state_representation/test_parameters.py
@@ -148,7 +148,7 @@ def test_param_joint_state(self):
         param1 = sr.Parameter("joint_state", values, sr.StateType.PARAMETER_JOINTSTATE)
         self.joint_equal(param1.get_value(), values)
 
-    def test_param_cartesian_pose(self):
+    def test_param_joint_positions(self):
         param = sr.Parameter("joint_positions", sr.StateType.PARAMETER_JOINTPOSITIONS)
         self.assertTrue(param.is_empty())
         self.assertEqual(param.get_name(), "joint_positions")
@@ -159,6 +159,17 @@ def test_param_cartesian_pose(self):
         param1 = sr.Parameter("joint_positions", values, sr.StateType.PARAMETER_JOINTPOSITIONS)
         self.joint_equal(param1.get_value(), values)
 
+    def test_param_ellipsoid(self):
+        param = sr.Parameter("ellipse", sr.StateType.PARAMETER_ELLIPSOID)
+        self.assertTrue(param.is_empty())
+        self.assertEqual(param.get_name(), "ellipse")
+        self.assertEqual(param.get_type(), sr.StateType.PARAMETER_ELLIPSOID)
+        values = sr.Ellipsoid("test")
+        param.set_value(values)
+        self.assertTrue(param.get_value().get_name(), values.get_name())
+        param1 = sr.Parameter("ellipse", values, sr.StateType.PARAMETER_ELLIPSOID)
+        self.assertTrue(param1.get_value().get_name(), values.get_name())
+
     def test_param_matrix(self):
         param = sr.Parameter("matrix", sr.StateType.PARAMETER_MATRIX)
         self.assertTrue(param.is_empty())
diff --git a/python/test/test_state.py b/python/test/state_representation/test_state.py
similarity index 93%
rename from python/test/test_state.py
rename to python/test/state_representation/test_state.py
index b63b2a321..66ce225ce 100644
--- a/python/test/test_state.py
+++ b/python/test/state_representation/test_state.py
@@ -1,6 +1,7 @@
 import time
 import unittest
 import datetime
+import copy
 
 from state_representation import State, StateType
 
@@ -76,6 +77,10 @@ def test_timestamp(self):
         state.set_timestamp(datetime.datetime.now().timestamp())
         self.assertFalse(state.is_deprecated(0.1))
 
+    def test_copy(self):
+        state = State(StateType.STATE, "test", False)
+        state2 = copy.copy(state)
+        state3 = copy.deepcopy(state)
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/source/CMakeLists.txt b/source/CMakeLists.txt
index 078ae52a8..73d8b281b 100644
--- a/source/CMakeLists.txt
+++ b/source/CMakeLists.txt
@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.9)
 
-project(control-libraries VERSION 4.1.0)
+project(control-libraries VERSION 5.0.0)
 
 # Build options
 option(BUILD_TESTING "Build all tests." OFF)
@@ -39,14 +39,14 @@ endif()
 
 add_subdirectory(state_representation)
 
-if(BUILD_CONTROLLERS)
-  add_subdirectory(controllers)
-endif()
-
 if(BUILD_DYNAMICAL_SYSTEMS)
   add_subdirectory(dynamical_systems)
 endif()
 
-if(BUILD_ROBOT_MODEL)
+if(BUILD_ROBOT_MODEL OR BUILD_CONTROLLERS)
   add_subdirectory(robot_model)
 endif()
+
+if(BUILD_CONTROLLERS)
+  add_subdirectory(controllers)
+endif()
diff --git a/source/Dockerfile.source b/source/Dockerfile.source
index b94b67d7a..f01d6fea4 100644
--- a/source/Dockerfile.source
+++ b/source/Dockerfile.source
@@ -1,28 +1,4 @@
-FROM ghcr.io/epfl-lasa/control-libraries/development-dependencies as remote-development
-
-RUN ( \
-    echo 'LogLevel DEBUG2'; \
-    echo 'PubkeyAuthentication yes'; \
-    echo 'Subsystem sftp /usr/lib/openssh/sftp-server'; \
-  ) > /etc/ssh/sshd_config_development \
-  && mkdir /run/sshd
-
-RUN useradd -m remote && yes | passwd remote && usermod -s /bin/bash remote
-WORKDIR /home/remote
-
-RUN ( \
-    echo '#!/bin/bash'; \
-    echo 'mkdir -p /home/remote/.ssh'; \
-    echo 'echo "$1" > /home/remote/.ssh/authorized_keys'; \
-    echo 'chmod -R 755 /home/remote/.ssh'; \
-    echo 'chown -R remote:remote /home/remote/.ssh'; \
-    echo '/usr/sbin/sshd -D -e -f /etc/ssh/sshd_config_development'; \
-  ) > /.ssh_entrypoint.sh && chmod 744 /.ssh_entrypoint.sh
-
-ENTRYPOINT ["/.ssh_entrypoint.sh"]
-
-
-FROM ghcr.io/epfl-lasa/control-libraries/development-dependencies as build-testing
+FROM ghcr.io/epfl-lasa/control-libraries/development-dependencies as build
 ARG BUILD_TESTING=ON
 ARG BUILD_CONTROLLERS=ON
 ARG BUILD_DYNAMICAL_SYSTEMS=ON
@@ -38,20 +14,14 @@ RUN cmake -DBUILD_CONTROLLERS="${BUILD_CONTROLLERS}" \
     -DBUILD_TESTING="${BUILD_TESTING}" .. \
   && make -j all
 
-RUN CTEST_OUTPUT_ON_FAILURE=1 make test
 
+FROM build as testing
 
-FROM ghcr.io/epfl-lasa/control-libraries/development-dependencies as source-dependencies
+RUN CTEST_OUTPUT_ON_FAILURE=1 make test
+RUN rm -rf /tmp/control_lib/
 
-WORKDIR /tmp/control_lib
-COPY ./ ./
 
-WORKDIR /tmp/control_lib/build
-RUN cmake -DBUILD_CONTROLLERS="ON" \
-    -DBUILD_DYNAMICAL_SYSTEMS="ON" \
-    -DBUILD_ROBOT_MODEL="ON" \
-    -DBUILD_TESTING="OFF" .. \
-  && make -j all \
-  && make install
+FROM build as install
 
+RUN make install
 RUN rm -rf /tmp/control_lib/
diff --git a/source/README.md b/source/README.md
index 29f232f6a..701512bcd 100644
--- a/source/README.md
+++ b/source/README.md
@@ -45,7 +45,7 @@ a robot.
 
 Source: [controllers](./controllers)
 
-Dependencies: `state_representation`
+Dependencies: `state_representation`, `robot_model`
 
 ---
 
@@ -81,10 +81,12 @@ It can be run with several optional arguments:
 
 ### Manual installation steps
 
-Eigen3 is required for building `state_representation` and all other libraries.
-You can install it with:
+Eigen3 (release [3.4.0](https://gitlab.com/libeigen/eigen/-/releases/3.4.0)) is required for
+building `state_representation` and all other libraries. You can install it with:
 ```shell script
-apt-get install libeigen3-dev
+wget -c https://gitlab.com/libeigen/eigen/-/archive/3.4.0/eigen-3.4.0.tar.gz -O - | tar -xz
+cd eigen-3.4.0 && mkdir build && cd build && cmake .. && make install
+cd ../.. && rm -r eigen-3.4.0
 ```
 
 Pinocchio is required for building the `robot_model` library. Installing this requires
diff --git a/source/build-test.sh b/source/build-test.sh
index 39c571d40..e0d1b125b 100755
--- a/source/build-test.sh
+++ b/source/build-test.sh
@@ -1,35 +1,42 @@
 #!/usr/bin/env bash
-# Build a docker image to compile the library and run tests
 
-MULTISTAGE_TARGET="build-testing"
+MULTISTAGE_TARGET="testing"
+IMAGE_NAME=epfl-lasa/control-libraries/source
+IMAGE_TAG="${MULTISTAGE_TARGET}"
+
 BUILD_TESTING="ON"
 BUILD_CONTROLLERS="ON"
 BUILD_DYNAMICAL_SYSTEMS="ON"
 BUILD_ROBOT_MODEL="ON"
 
-REBUILD=0
-while getopts 'r' opt; do
-    case $opt in
-        r) REBUILD=1 ;;
-        *) echo 'Error in command line parsing' >&2
-           exit 1
-    esac
-done
-shift "$(( OPTIND - 1 ))"
+HELP_MESSAGE="Usage: build-test.sh [-r] [-v]
+Options:
+  -r, --rebuild            Rebuild the image using the docker
+                           --no-cache option.
+  -v, --verbose            Use the verbose option during the building
+                           process.
+  -h, --help               Show this help message.
+"
 
-NAME=$(echo "${PWD##*/}" | tr _ -)/$MULTISTAGE_TARGET
-TAG="latest"
+BUILD_FLAGS=()
+while [[ $# -gt 0 ]]; do
+  opt="$1"
+  case $opt in
+    -r|--rebuild) BUILD_FLAGS+=(--no-cache); shift ;;
+    -v|--verbose) BUILD_FLAGS+=(--progress=plain); shift ;;
+    -h|--help) echo "${HELP_MESSAGE}"; exit 0 ;;
+    *) echo 'Error in command line parsing' >&2
+       echo -e "\n${HELP_MESSAGE}"
+       exit 1
+  esac
+done
 
 BUILD_FLAGS=(--target "${MULTISTAGE_TARGET}")
 BUILD_FLAGS+=(--build-arg "BUILD_TESTING=${BUILD_TESTING}")
 BUILD_FLAGS+=(--build-arg "BUILD_CONTROLLERS=${BUILD_CONTROLLERS}")
 BUILD_FLAGS+=(--build-arg "BUILD_DYNAMICAL_SYSTEMS=${BUILD_DYNAMICAL_SYSTEMS}")
 BUILD_FLAGS+=(--build-arg "BUILD_ROBOT_MODEL=${BUILD_ROBOT_MODEL}")
-BUILD_FLAGS+=(-t "${NAME}:${TAG}")
-
-if [ "$REBUILD" -eq 1 ]; then
-    BUILD_FLAGS+=(--no-cache)
-fi
+BUILD_FLAGS+=(-t "${IMAGE_NAME}:${IMAGE_TAG}")
 
 docker pull ghcr.io/epfl-lasa/control-libraries/development-dependencies
 DOCKER_BUILDKIT=1 docker build . --file ./Dockerfile.source "${BUILD_FLAGS[@]}"
diff --git a/source/controllers/CMakeLists.txt b/source/controllers/CMakeLists.txt
index 105aaeb41..7224d9c67 100644
--- a/source/controllers/CMakeLists.txt
+++ b/source/controllers/CMakeLists.txt
@@ -1,16 +1,22 @@
 project(controllers)
 
+find_library(robot_model REQUIRED)
+
 get_target_property(STATE_REPRESENTATION_INCLUDE_DIR state_representation INCLUDE_DIRECTORIES)
+get_target_property(ROBOT_MODEL_INCLUDE_DIR robot_model INCLUDE_DIRECTORIES)
 include_directories(
   include
   ${STATE_REPRESENTATION_INCLUDE_DIR}
+  ${ROBOT_MODEL_INCLUDE_DIR}
 )
 
 set(CORE_SOURCES
-  src/impedance/CartesianTwistController.cpp
+  src/ControllerFactory.cpp
+  src/IController.cpp
+  src/impedance/CompliantTwist.cpp
+  src/impedance/Dissipative.cpp
   src/impedance/Impedance.cpp
   src/impedance/VelocityImpedance.cpp
-  src/impedance/Dissipative.cpp
 )
 
 add_library(${PROJECT_NAME} SHARED
@@ -20,6 +26,7 @@ add_library(${PROJECT_NAME} SHARED
 target_link_libraries(${PROJECT_NAME}
   Eigen3::Eigen
   state_representation
+  robot_model
 )
 
 install(DIRECTORY include/
@@ -42,5 +49,6 @@ if (BUILD_TESTING)
     ${GTEST_LIBRARIES}
     pthread
   )
+  target_compile_definitions(test_controllers PRIVATE TEST_FIXTURES="${CMAKE_CURRENT_SOURCE_DIR}/test/fixtures/")
   add_test(NAME test_controllers COMMAND test_controllers)
 endif ()
diff --git a/source/controllers/README.md b/source/controllers/README.md
index aba57ca9c..e7a3a97c6 100644
--- a/source/controllers/README.md
+++ b/source/controllers/README.md
@@ -1,122 +1,248 @@
 # Controllers
 
-This library introduces a set of controllers to be used in robotic control-loop schemes. Each controller is templated
-to accepted an input space from `state_representation` and is derived from the `Controller` base class, e.g.,
+This library introduces a set of controllers to be used in robotic control-loop schemes. 
 
-```cpp
-Impedance<state_representation::JointState> joint_space_impedance;
-Disspative<state_representation::CartesianState> task_space_dissipative;
-```
+All controllers have a common interface inheriting from the `IController<S>` class, which is templated to 
+operate in a particular space `S`, namely joint space or Cartesian space.
+
+## Constructing a controller
+
+The `ControllerFactory<S>` provides construction helpers for controllers using a factory pattern.
+Specific controllers are created and injected into a common `shared_ptr<IController<S>>`.
+
+The `CartesianControllerFactory` and `JointControllerFactory` are shortcuts for the Cartesian and joint space 
+controller factories.
 
-The main functions of each controllers are the `compute_command` variations. They implement the main algorithms of the
-controllers. Depending on the controller, they are used to define a command from some input parameters.
+The factory provides a static function `create_controller`, which can take a number of inputs.
+The first input argument is always the controller type (defined in `controllers/ControllerType.hpp`).
 
-```cpp
+```c++
+#include "controllers/ControllerFactory.hpp"
+
+using namespace controllers;
 using namespace state_representation;
 
-Impedance<JointState> joint_space_impedance;
-JointVelocities desired_velocities;
-JointVelocities real_robot_velocities;
+// create a Cartesian impedance controller
+std::shared_ptr<IController<CartesianState>> cart_ctrl;
+cart_ctrl = CartesianControllerFactory::create_controller(CONTROLLER_TYPE::IMPEDANCE);
+
+// create a compliant Cartesian twist controller using "auto" to avoid verbose typing
+auto twist_ctrl = CartesianControllerFactory::create_controller(CONTROLLER_TYPE::COMPLIANT_TWIST);
+```
+
+The `create_controller` function also has an input for the number of control dimensions. The Cartesian factory
+ignores this input as the dimensionality can be automatically inferred for Cartesian controllers.
+For the joint-space factory however, the number of joints should be provided so that the controller can initialize
+all internal properties to the correct dimensionality.
+
+```c++
+unsigned int number_of_joints = 7;
+auto joint_ctrl = JointControllerFactory::create_controller(CONTROLLER_TYPE::IMPEDANCE, number_of_joints);
+```
+
+Some controllers use a `robot_model::Model` object for internal computation. This can be provided as an input
+to the `create_controller` function, in which case the number of dimensions is automatically inferred from the model.
+
+```c++
+#include "controllers/ControllerFactory.hpp"
+#include "robot_model/Model.hpp"
+
+using namespace controllers;
 
-JointTorques command = joint_space_impedance.compute_command(desired_velocities,
-                                                             real_robot_velocities)
+// create a robot model
+auto robot = robot_model::Model("my_robot", "/path/to/robot.urdf");
+
+// create a joint-space dissipative controller with a robot model
+auto joint_ctrl = JointControllerFactory::create_controller(CONTROLLER_TYPE::DISSIPATIVE, robot);
+
+// create a Cartesian impedance controller operating only on velocity error with a robot model
+auto twist_ctrl = CartesianControllerFactory::create_controller(CONTROLLER_TYPE::VELOCITY_IMPEDANCE, robot);
 ```
 
-Some `compute_command` variations allows to transform one space to the other using extra parameters.
+Finally, initial controller parameters can be passed to `create_controller` as a list. See the next section
+for more details on parameter configuration.
 
-```cpp
+```c++
+#include "controllers/ControllerFactory.hpp"
+#include "state_representation/parameters/Parameter.hpp"
+
+using namespace controllers;
 using namespace state_representation;
 
-Dissipative<CartesianState> task_space_dissipative;
-CartesianTwist desired_twist;
-CartesianTwist real_eef_twist;
-Jacobian robot_jacobian;
+std::list<std::shared_ptr<ParameterInterface>> parameters;
+parameters.emplace_back(make_shared_parameter("damping", 10.0));
+parameters.emplace_back(make_shared_parameter("stiffness", 5.0));
+parameters.emplace_back(make_shared_parameter("inertia", 1.0));
 
-JointTorques command = task_space_dissipative.compute_command(desired_twist,
-                                                              real_eef_twist,
-                                                              jacobian)
+auto ctrl = CartesianControllerFactory::create_controller(CONTROLLER_TYPE::IMPEDANCE, parameters);
 ```
 
-The above formulation is equivalent to:
+## Using a controller
+
+The controller factory returns a base class pointer `shared_ptr<IController<S>>` for the chosen state type `S`,
+pointing to an instance of a specific derived controller. This allows all controllers to share the same consistent
+interface for usage and configuration.
+
+### Parameters
+
+Controllers support custom parameterization through the base interface using `state_representation::ParameterMap`
+methods:
+- `get_parameters()`
+- `get_parameter(name)`
+- `get_parameter_value<T>(name)`
+- `set_parameters(parameters)`
+- `set_parameter(parameter)`
+- `set_parameter_value(name, value)`
+
+These methods can be used after construction to get or set controller parameters. Refer to the documentation
+on `controllers::IController<>` and `state_representation::ParameterMap` for more information.
+
+For controllers that use a `robot_model::Model` object, there are additional interface methods that can be used
+to get or set the current robot model. Note that changing the robot model dimensionality, reference frame or joint
+frames at runtime could cause unexpected behaviour.
+- `get_robot_model()`
+- `set_robot_model(robot_model)`
+
+### Compute command
+
+The main purpose of each controller is the `compute_command` function, which calculates an output state from a 
+desired command state and feedback state. For example, the impedance controller takes the error between the command
+state and the feedback state and multiplies it by some linear gains to compute the output state. 
+
+```c++
+#include "controllers/ControllerFactory.hpp"
+#include "state_representation/space/cartesian/CartesianState.hpp"
+
+using namespace controllers;
+
+// create a Cartesian impedance controller
+auto ctrl = CartesianControllerFactory::create_controller(CONTROLLER_TYPE::IMPEDANCE);
+
+auto command_state = CartesianState::Random("command");
+auto feedback_state = CartesianState::Random("feedback");
+
+// compute the command output
+auto command_output = ctrl->compute_command(command_state, feedback_state);
+```
+
+For Cartesian controllers, `compute_command` is overloaded with extra parameters to enable direct computation of a
+joint-space command output. This is done using the Jacobian matrix relating task-space forces to joint-space torques.
+The Jacobian can be passed to `compute_command` directly if it is known. Alternatively, if the controller has been
+configured with an associated robot model, the Jacobian can be automatically derived from the current joint positions.
+
+```c++
+#include "robot_model/Model.hpp"
+#include "state_representation/space/cartesian/JointState.hpp"
 
-```cpp
 using namespace state_representation;
 
-Dissipative<CartesianState> task_space_dissipative;
-CartesianTwist desired_twist;
-CartesianTwist real_eef_twist;
-Jacobian robot_jacobian;
+// create a Cartesian impedance controller
+auto ctrl = CartesianControllerFactory::create_controller(CONTROLLER_TYPE::IMPEDANCE);
+
+// create a robot model
+auto robot = robot_model::Model("my_robot", "/path/to/robot.urdf");
+
+// create some state variables
+auto current_joints = JointState::Random(robot.get_robot_name(), robot.get_number_of_joints());
+auto command_state = CartesianState::Random("command");
+auto feedback_state = CartesianState::Random("feedback");
 
-CartesianWrench task_command = task_space_dissipative.compute_command(desired_twist,
-                                                                      real_eef_twist)
+// compute the command output in joint space using a manually calculated Jacobian
+auto jacobian = robot.compute_jacobian(current_joints);
+auto joint_command_output_1 = ctrl->compute_command(command_state, feedback_state, jacobian);
 
-JointTorques joint_command = robot_jacobian.transpose() * task_command;
+// the above is simply equivalent to:
+// joint_command = jacobian.transpose() * CartesianWrench(ctrl->compute_command(command_state, feedback_state));
+
+// if controller has a robot model, compute the joint command by passing the current joint positions
+ctrl->set_robot_model(robot);
+auto joint_command_output_2 = ctrl->compute_command(command_state, feedback_state, current_joints);
 ```
 
-## Creating a new controller
+## Developing a new controller
 
-To create a new controller, you need to create a class that derives from the `Controller` base class or any derived
+To implement a new controller, you need to create a class that derives from the `IController` base class or any derived
 controller such as `Impedance`. This class can be templated to accept different input spaces (e.g. `CartesianState`
 or `JointState`) or specify the desired input space.
 
-```cpp
-using namespace state_representation;
+The derived controller should override `compute_command` to produce custom behaviour. In addition, if the controller
+has any parameters, you should:
+- Add parameter pointers as class properties
+- Initialize and declare parameters in the constructor
+- Override the protected `validate_and_set_parameter` method
+
+```c++
+// MyCartesianController.hpp
+#include "controllers/IController.hpp"
+#include "state_representation/space/cartesian/CartesianState.hpp"
 
-class MyController:
-public Controller<CartesianState> {
-private:
-  ...
+class MyCartesianController : public controllers::IController<state_representation::CartesianState> {
 public:
-  CartesianState compute_command(const CartesianState& desired_state,
-                                 const CartesianState& feedback_state);
+  // initialize and declare parameters
+  MyCartesianController();
+  
+  // override this method to implement custom control logic
+  state_representation::CartesianState compute_command(
+      const state_representation::CartesianState& desired_state,
+      const state_representation::CartesianState& feedback_state
+  ) override;
+  
+protected:
+  // override this method to update controller configurations when a parameter is modified
+  void validate_and_set_parameter(const std::shared_ptr<state_representation::ParameterInterface>& parameter) override;
+  
+  // add any additional parameters as class properties
+  std::shared_ptr<state_representation::Parameter<int>> foo_;
+  std::shared_ptr<state_representation::Parameter<double>> bar_;
 };
 ```
 
-The only thing to implement is then the desired variation of the `compute_command` functions.
+```c++
+// MyCartesianController.cpp
+#include "MyCartesianController.hpp"
 
-```cpp
-CartesianState MyController::compute_command(const CartesianState& desired_state,
-                                             const CartesianState& feedback_state) {
-  CartesianState command = ...;
-  return command;
-}
-```
+#include "controllers/exceptions/InvalidParameterException.hpp"
 
-The main goal of this library is to reuse as much as possible the functionalities between controllers. Therefore, if
-your controller is a variation of an impedance controller that simply adds extra way of computing the damping or
-stiffness matrix (e.g. `Dissipative`), it should extend from it and reuse the main function calls.
-
-```cpp
 using namespace state_representation;
 
-class MyImpedanceController:
-public Impedance<CartesianState> {
-private:
-  ...
-public:
-  CartesianState compute_command(const CartesianState& desired_state,
-                                 const CartesianState& feedback_state);
-};
+namespace controllers {
 
-CartesianState MyImpedanceController::compute_command(const CartesianState& desired_state,
-                                                      const CartesianState& feedback_state) {
-  // do extra stuff like compute the damping or stiffness matrix
-  ...
-  CartesianWrench command = this->Impedance<CartesianState>(desired_state, feedback_state);
-  // eventually do extra stuff before returning the command
-  ...
-  return command;
+// initialize parameters
+MyCartesianController::MyCartesianController() :
+    foo_(make_shared_parameter<int>(1)),
+    bar_(make_shared_parameter<double>(2.0)) {
+  // "declare" parameters by inserting them into the parameter list with an associated name
+  this->parameters_.insert(std::make_pair("foo", foo_));
+  this->parameters_.insert(std::make_pair("bar", bar_));
 }
-```
 
-With this implementation, you don't need to specify anything specific for using the space changing functionalities, it will be derived from the inheritance chain.
+// implement the command logic
+CartesianState MyCartesianController::compute_command(
+    const CartesianState& desired_state, const CartesianState& feedback_state
+) {
+    CartesianState command = ...;
+    return command;
+}
+
+// implement parameter validation
+void MyCartesianController::validate_and_set_parameter(
+    const std::shared_ptr<state_representation::ParameterInterface>& parameter
+) {
+  if (parameter->get_name() == "foo") {
+    auto value = std::static_pointer_cast<state_representation::Parameter<int>>(parameter);
+    // if a parameter value is not supported by the controller, throw an InvalidParameterException
+    if (value < 0 || value > 10) {
+      throw exceptions::InvalidParameterException("Parameter foo must be in range [0 - 10]");
+    }
+    this->foo_->set_value(value);
+  } else if (parameter->get_name() == "bar") {
+    this->bar_->set_value(std::static_pointer_cast<state_representation::Parameter<double>>(parameter));
+  }
+}
 
-```cpp
-CartesianState MyImpedanceController::compute_command(const CartesianState& desired_state,
-                                                      const CartesianState& feedback_state,
-                                                      const Jacobian& jacobian) {
-  // simply call the compute_command from impedance
-  return this->Impedance<CartesianState>(desired_state, feedback_state, jacobian);
 }
 ```
 
+The main goal of this library is to reuse as much as possible the functionalities between controllers. Therefore, if
+your controller is a variation of an impedance controller that simply adds extra way of computing the damping or
+stiffness matrix (e.g. `Dissipative`), it should extend from it and reuse the main function calls.
diff --git a/source/controllers/include/controllers/Controller.hpp b/source/controllers/include/controllers/Controller.hpp
deleted file mode 100644
index 054f52989..000000000
--- a/source/controllers/include/controllers/Controller.hpp
+++ /dev/null
@@ -1,91 +0,0 @@
-#pragma once
-
-#include "controllers/exceptions/NotImplementedException.hpp"
-#include "state_representation/parameters/ParameterInterface.hpp"
-#include "state_representation/robot/Jacobian.hpp"
-#include <list>
-#include <memory>
-
-/**
- * @namespace controllers
- * @brief Systems to determine a command output from measured and desired inputs
- */
-namespace controllers {
-/**
- * @class Controller
- * @brief Abstract class to define a controller either in joint or cartesian spaces
- * @tparam SIn the input state type of the controller
- * @tparam SOut the output command type of the controller
- */
-template<class S>
-class Controller {
-public:
-  /**
-   * @brief Empty constructor
-   */
-  explicit Controller();
-
-  /**
-   * @brief Compute the command based on the input state
-   * To be redefined based on the actual controller implementation
-   * @param state the input state of the system. This function accept any number of extra arguments.
-   * @return the output command at the input state
-   */
-  virtual S compute_command(const S& state, ...);
-
-  /**
-   * @brief Compute the command based on the desired state and a feedback state
-   * To be redefined based on the actual controller implementation.
-   * @param desired_state the desired state of the system.
-   * @param feedback_state the real state of the system as read from feedback loop
-   * @return the output command at the input state
-   */
-  virtual S compute_command(const S& desired_state, const S& feedback_state);
-
-  /**
-   * @brief Compute the command based on the desired state and a feedback state
-   * To be redefined based on the actual controller implementation.
-   * @param desired_state the desired state of the system.
-   * @param feedback_state the real state of the system as read from feedback loop
-   * @param jacobian the Jacobian matrix of the robot to convert from one state to the other
-   * @return the output command at the input state
-   */
-  virtual state_representation::JointState compute_command(const S& desired_state,
-                                                           const S& feedback_state,
-                                                           const state_representation::Jacobian& jacobian);
-
-  /**
-   * @brief Return a list of all the parameters of the controller
-   * @return the list of parameters
-   */
-  virtual std::list<std::shared_ptr<state_representation::ParameterInterface>> get_parameters() const;
-};
-
-template<class S>
-Controller<S>::Controller() {}
-
-template<class S>
-std::list<std::shared_ptr<state_representation::ParameterInterface>> Controller<S>::get_parameters() const {
-  std::list<std::shared_ptr<state_representation::ParameterInterface>> param_list;
-  return param_list;
-}
-
-template<class S>
-S Controller<S>::compute_command(const S&, ...) {
-  throw exceptions::NotImplementedException("compute_command(state, ...) not implemented for the base controller class");
-}
-
-template<class S>
-S Controller<S>::compute_command(const S&, const S&) {
-  throw exceptions::NotImplementedException(
-      "compute_command(desired_state, feedback_state) not implemented for the base controller class");
-}
-
-template<class S>
-state_representation::JointState Controller<S>::compute_command(const S&,
-                                                                const S&,
-                                                                const state_representation::Jacobian&) {
-  throw exceptions::NotImplementedException(
-      "compute_command(desired_state, feedback_state) not implemented for the base controller class");
-}
-}// namespace controllers
diff --git a/source/controllers/include/controllers/ControllerFactory.hpp b/source/controllers/include/controllers/ControllerFactory.hpp
new file mode 100644
index 000000000..aa631f346
--- /dev/null
+++ b/source/controllers/include/controllers/ControllerFactory.hpp
@@ -0,0 +1,81 @@
+#pragma once
+
+#include "controllers/IController.hpp"
+#include "controllers/ControllerType.hpp"
+#include "robot_model/Model.hpp"
+
+#include "state_representation/space/cartesian/CartesianState.hpp"
+#include "state_representation/space/joint/JointState.hpp"
+
+namespace controllers {
+
+/**
+ * @class ControllerFactory
+ * @brief Factory to create a shared pointer to a controller.
+ * @tparam S Underlying state type of the controller
+ */
+template<class S>
+class ControllerFactory {
+public:
+
+  /**
+   * @brief Create a controller of the desired type.
+   * @param type The type of controller
+   * @param dimensions The dimensionality of the controller (6 for Cartesian space, number of joints for joint space)
+   * @return The shared pointer to the controller
+   */
+  static std::shared_ptr<IController<S>> create_controller(CONTROLLER_TYPE type, unsigned int dimensions = 6);
+
+  /**
+   * @brief Create a controller of the desired type with initial parameters
+   * @param type The type of controller
+   * @param parameters A list of parameters to set on the controller
+   * @param dimensions The dimensionality of the controller (6 for Cartesian space, number of joints for joint space)
+   * @return The shared pointer to the controller
+   */
+  static std::shared_ptr<IController<S>> create_controller(
+      CONTROLLER_TYPE type, const std::list<std::shared_ptr<state_representation::ParameterInterface>>& parameters,
+      unsigned int dimensions = 6
+  );
+
+  /**
+   * @brief Create a controller of the desired type with an associated robot model.
+   * @param type The type of controller
+   * @param robot_model The robot model to associate with the controller. This is used to infer the dimensionality
+   * of the controller and influence controller behaviour depending on the controller type.
+   * @return The shared pointer to the controller
+   */
+  static std::shared_ptr<IController<S>> create_controller(
+      CONTROLLER_TYPE type, const robot_model::Model& robot_model
+  );
+
+  /**
+   * @brief Create a controller of the desired type with initial parameters and an associated robot model.
+   * @param type The type of controller
+   * @param parameters A list of parameters to set on the controller
+   * @param robot_model The robot model to associate with the controller
+   * @return The shared pointer to the controller
+   */
+  static std::shared_ptr<IController<S>> create_controller(
+      CONTROLLER_TYPE type, const std::list<std::shared_ptr<state_representation::ParameterInterface>>& parameters,
+      const robot_model::Model& robot_model
+  );
+};
+
+template<class S>
+std::shared_ptr<IController<S>> ControllerFactory<S>::create_controller(CONTROLLER_TYPE type, unsigned int dimensions) {
+  std::list<std::shared_ptr<state_representation::ParameterInterface>> parameters;
+  return ControllerFactory<S>::create_controller(type, parameters, dimensions);
+}
+
+template<class S>
+std::shared_ptr<IController<S>>
+ControllerFactory<S>::create_controller(CONTROLLER_TYPE type, const robot_model::Model& robot_model) {
+  std::list<std::shared_ptr<state_representation::ParameterInterface>> parameters;
+  return ControllerFactory<S>::create_controller(type, parameters, robot_model);
+}
+
+typedef ControllerFactory<state_representation::CartesianState> CartesianControllerFactory;
+typedef ControllerFactory<state_representation::JointState> JointControllerFactory;
+
+}// namespace controllers
diff --git a/source/controllers/include/controllers/ControllerType.hpp b/source/controllers/include/controllers/ControllerType.hpp
new file mode 100644
index 000000000..31e178e75
--- /dev/null
+++ b/source/controllers/include/controllers/ControllerType.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+namespace controllers {
+
+/**
+ * @brief Enumeration of the implemented controllers
+ */
+enum class CONTROLLER_TYPE {
+  NONE,
+  IMPEDANCE,
+  DISSIPATIVE,
+  DISSIPATIVE_LINEAR,
+  DISSIPATIVE_ANGULAR,
+  DISSIPATIVE_DECOUPLED,
+  VELOCITY_IMPEDANCE,
+  COMPLIANT_TWIST
+};
+
+}
\ No newline at end of file
diff --git a/source/controllers/include/controllers/IController.hpp b/source/controllers/include/controllers/IController.hpp
new file mode 100644
index 000000000..a3c5b325e
--- /dev/null
+++ b/source/controllers/include/controllers/IController.hpp
@@ -0,0 +1,100 @@
+#pragma once
+
+#include <list>
+#include <map>
+#include <memory>
+
+#include "controllers/exceptions/NoRobotModelException.hpp"
+
+#include "robot_model/Model.hpp"
+#include "state_representation/parameters/ParameterMap.hpp"
+#include "state_representation/space/Jacobian.hpp"
+#include "state_representation/space/joint/JointPositions.hpp"
+#include "state_representation/space/joint/JointState.hpp"
+
+/**
+ * @namespace controllers
+ * @brief Systems to determine a command output from measured and desired inputs
+ */
+namespace controllers {
+/**
+ * @class IController
+ * @brief Abstract class to define a controller in a desired state type, such as joint or Cartesian spaces
+ * @tparam S the state type of the controller
+ */
+template<class S>
+class IController : public state_representation::ParameterMap {
+public:
+  /**
+   * @brief Empty constructor
+   */
+  IController() = default;
+
+  /**
+   * @brief Empty destructor
+   */
+  virtual ~IController() = default;
+
+  /**
+   * @brief Compute the command output based on the commanded state and a feedback state
+   * To be redefined based on the actual controller implementation.
+   * @param command_state the input state to the controller
+   * @param feedback_state the current state of the system given as feedback
+   * @return the output command at the input state
+   */
+  [[nodiscard]] virtual S compute_command(const S& command_state, const S& feedback_state) = 0;
+
+  /**
+   * @brief Compute the command output in joint space
+   * @param command_state
+   * @param feedback_state
+   * @param jacobian the Jacobian matrix relating Cartesian forces to joint space
+   * @return
+   */
+  [[nodiscard]] state_representation::JointState compute_command(
+      const S& command_state, const S& feedback_state, const state_representation::Jacobian& jacobian
+  );
+
+  /**
+   * @brief Compute the command output in joint space from command and feedback states in task space
+   * @details This method requires the controller to have an associated robot model to compute the Jacobian.
+   * @param command_state
+   * @param feedback_state
+   * @param joint_positions The current joint positions, which are required for computing the Jacobian
+   * @param frame_name
+   * @return
+   */
+  [[nodiscard]] state_representation::JointState compute_command(
+      const S& command_state, const S& feedback_state, const state_representation::JointPositions& joint_positions,
+      const std::string& frame_name = ""
+  );
+
+  /**
+   * @brief Get the robot model associated with the controller.
+   * @return The robot model
+   */
+  [[nodiscard]] const robot_model::Model& get_robot_model();
+
+  /**
+   * @brief Set the robot model associated with the controller.
+   * @param robot_model The robot model
+   */
+  void set_robot_model(const robot_model::Model& robot_model);
+
+protected:
+  std::shared_ptr<robot_model::Model> robot_model_; ///< The robot model associated with the controller
+};
+
+template<class S>
+const robot_model::Model& IController<S>::get_robot_model() {
+  if (this->robot_model_ == nullptr) {
+    throw exceptions::NoRobotModelException("No robot model");
+  }
+  return *this->robot_model_;
+}
+
+template<class S>
+void IController<S>::set_robot_model(const robot_model::Model& robot_model) {
+  this->robot_model_ = std::make_shared<robot_model::Model>(robot_model);
+}
+}// namespace controllers
diff --git a/source/controllers/include/controllers/exceptions/InvalidControllerException.hpp b/source/controllers/include/controllers/exceptions/InvalidControllerException.hpp
new file mode 100644
index 000000000..787ceea99
--- /dev/null
+++ b/source/controllers/include/controllers/exceptions/InvalidControllerException.hpp
@@ -0,0 +1,11 @@
+#pragma once
+
+#include <stdexcept>
+#include <string>
+
+namespace controllers::exceptions {
+class InvalidControllerException : public std::logic_error {
+public:
+  explicit InvalidControllerException(const std::string& msg) : std::logic_error(msg) {};
+};
+}
diff --git a/source/controllers/include/controllers/exceptions/NoRobotModelException.hpp b/source/controllers/include/controllers/exceptions/NoRobotModelException.hpp
new file mode 100644
index 000000000..5aa4a6df5
--- /dev/null
+++ b/source/controllers/include/controllers/exceptions/NoRobotModelException.hpp
@@ -0,0 +1,11 @@
+#pragma once
+
+#include <stdexcept>
+#include <string>
+
+namespace controllers::exceptions {
+class NoRobotModelException : public std::runtime_error {
+public:
+  explicit NoRobotModelException(const std::string& msg) : std::runtime_error(msg) {};
+};
+}
diff --git a/source/controllers/include/controllers/exceptions/NotImplementedException.hpp b/source/controllers/include/controllers/exceptions/NotImplementedException.hpp
index c8e95287a..75db95f5d 100644
--- a/source/controllers/include/controllers/exceptions/NotImplementedException.hpp
+++ b/source/controllers/include/controllers/exceptions/NotImplementedException.hpp
@@ -1,13 +1,11 @@
 #pragma once
 
-#include <exception>
-#include <iostream>
+#include <stdexcept>
+#include <string>
 
-namespace controllers {
-namespace exceptions {
+namespace controllers::exceptions {
 class NotImplementedException : public std::logic_error {
 public:
-  explicit NotImplementedException(const std::string& msg) : logic_error(msg){};
+  explicit NotImplementedException(const std::string& msg) : std::logic_error(msg) {};
 };
-}// namespace exceptions
-}// namespace controllers
+}
diff --git a/source/controllers/include/controllers/impedance/CartesianTwistController.hpp b/source/controllers/include/controllers/impedance/CartesianTwistController.hpp
deleted file mode 100644
index 866477cb3..000000000
--- a/source/controllers/include/controllers/impedance/CartesianTwistController.hpp
+++ /dev/null
@@ -1,170 +0,0 @@
-#pragma once
-
-#include "controllers/Controller.hpp"
-#include "controllers/impedance/Dissipative.hpp"
-#include "controllers/impedance/VelocityImpedance.hpp"
-#include "state_representation/parameters/Parameter.hpp"
-
-namespace controllers::impedance {
-/**
- * @class CartesianTwistController
- * @brief A concrete controller class specifically for controlling
- * 6 degree of freedom Cartesian twist with a combination of impedance
- * controllers. The linear velocity is controlled with the Dissipative
- * controller class, while the angular velocity is controlled
- * with the VelocityImpedance class.
- */
-class CartesianTwistController : public Controller<state_representation::CartesianState> {
-private:
-  std::shared_ptr<state_representation::Parameter<double>>
-      linear_principle_damping_; ///< damping along principle eigenvector of linear velocity error
-  std::shared_ptr<state_representation::Parameter<double>>
-      linear_orthogonal_damping_; ///< damping along secondary eigenvectors of linear velocity error
-  std::shared_ptr<state_representation::Parameter<double>> angular_stiffness_; ///< stiffness of angular displacement
-  std::shared_ptr<state_representation::Parameter<double>> angular_damping_; ///< damping of angular velocity error
-
-  Dissipative<state_representation::CartesianState> dissipative_ctrl_;
-  VelocityImpedance<state_representation::CartesianState> velocity_impedance_ctrl_;
-public:
-  /**
-   * @brief Constructor for the CartesianTwistController
-   * @param linear_principle_damping damping along principle eigenvector of linear velocity error
-   * @param linear_orthogonal_damping damping along secondary eigenvectors of linear velocity error
-   * @param angular_stiffness stiffness of angular displacement
-   * @param angular_damping damping of angular velocity error
-   */
-  CartesianTwistController(double linear_principle_damping,
-                           double linear_orthogonal_damping,
-                           double angular_stiffness,
-                           double angular_damping);
-
-  /**
-   * @brief Constructor for the CartesianTwistController with vector form gains
-   * @param gains Eigen 4d vector of gains in the order linear_principle_damping,
-   * linear_orthogonal_damping, angular_stiffness, angular_damping
-   */
-  explicit CartesianTwistController(const Eigen::Vector4d& gains);
-
-  /**
-   * @brief Copy constructor
-   * @param other the controller to copy
-   */
-  CartesianTwistController(const CartesianTwistController& other);
-
-  /**
-   * @brief Swap the values of the two controllers
-   * @param controller1 controller to be swapped with 2
-   * @param controller2 controller to be swapped with 1
-   */
-  friend void swap(CartesianTwistController& controller1, CartesianTwistController& controller2);
-
-  /**
-   * @param Assignment operator
-   * @param other the controller to copy
-   * @return reference to the controller with values from other
-   */
-  CartesianTwistController& operator=(const CartesianTwistController& other);
-
-  /**
-   * @brief Setter of the linear principle damping
-   * @param the new principle damping value
-   */
-  void set_linear_principle_damping(double linear_principle_damping);
-
-  /**
-   * @brief Setter of the linear orthogonal damping
-   * @param the new orthogonal damping value
-   */
-  void set_linear_orthogonal_damping(double linear_orthogonal_damping);
-
-  /**
-   * @brief Setter of the linear damping values
-   * @param linear_principle_damping the new principle damping value
-   * @param linear_orthogonal_damping the new orthogonal damping value
-   */
-  void set_linear_gains(double linear_principle_damping, double linear_orthogonal_damping);
-
-  /**
-   * @brief Setter of the angular stiffness
-   * @param the new stiffness value
-   */
-  void set_angular_stiffness(double angular_stiffness);
-
-  /**
-   * @brief Setter of the angular damping
-   * @param the new damping value
-   */
-  void set_angular_damping(double angular_damping);
-
-  /**
-   * @brief Setter of the angular damping
-   * @param angular_stiffness the new angular stiffness value
-   * @param angular_damping the new angular damping value
-   */
-  void set_angular_gains(double angular_stiffness, double angular_damping);
-
-  /**
-   * @brief Setter of the controller gains
-   * @param linear_principle_damping damping along principle eigenvector of linear velocity error
-   * @param linear_orthogonal_damping damping along secondary eigenvectors of linear velocity error
-   * @param angular_stiffness stiffness of angular displacement
-   * @param angular_damping damping of angular velocity error
-   */
-  void set_gains(double linear_principle_damping,
-                 double linear_orthogonal_damping,
-                 double angular_stiffness,
-                 double angular_damping);
-
-  /**
-   * @brief Setter of the controller gains
-   * @param the new gains as a vector of linear principle damping,
-   * linear orthogonal, angular stiffness and angular damping values
-   */
-  void set_gains(const Eigen::Vector4d& gains);
-
-  /**
-   * @brief Getter of the controller gains
-   * @return the new gains as a vector of linear principle damping,
-   * linear orthogonal, angular stiffness and angular damping values
-   */
-  Eigen::Vector4d get_gains() const;
-
-  /**
-   * @brief Return a list of all the parameters of the controller
-   * @return the list of parameters
-   */
-  std::list<std::shared_ptr<state_representation::ParameterInterface>> get_parameters() const override;
-
-  /**
-   * @brief Compute the force (task space) or torque (joint space) command based on the input state 
-   * of the system as the error between the desired state and the real state.
-   * @param desired_state the desired state to reach
-   * @param feedback_state the real state of the system as read from feedback loop
-   * @return the output command at the input state
-   */
-  state_representation::CartesianState compute_command(const state_representation::CartesianState& desired_state,
-                                                       const state_representation::CartesianState& feedback_state) override;
-
-  /**
-   * @brief Compute the command based on the desired state and a feedback state in a non const fashion
-   * To be redefined based on the actual controller implementation.
-   * @param desired_state the desired state of the system.
-   * @param feedback_state the real state of the system as read from feedback loop
-   * @param jacobian the Jacobian matrix of the robot to convert from one state to the other
-   * @return the output command at the input state
-   */
-  state_representation::JointState compute_command(const state_representation::CartesianState& desired_state,
-                                                   const state_representation::CartesianState& feedback_state,
-                                                   const state_representation::Jacobian& jacobian) override;
-};
-
-inline void swap(CartesianTwistController& controller1, CartesianTwistController& controller2) {
-  std::swap(controller1.linear_principle_damping_, controller2.linear_principle_damping_);
-  std::swap(controller1.linear_orthogonal_damping_, controller2.linear_orthogonal_damping_);
-  std::swap(controller1.angular_stiffness_, controller2.angular_stiffness_);
-  std::swap(controller1.angular_damping_, controller2.angular_damping_);
-  swap(controller1.dissipative_ctrl_, controller2.dissipative_ctrl_);
-  swap(controller1.velocity_impedance_ctrl_, controller2.velocity_impedance_ctrl_);
-}
-
-}// namespace controllers
diff --git a/source/controllers/include/controllers/impedance/CompliantTwist.hpp b/source/controllers/include/controllers/impedance/CompliantTwist.hpp
new file mode 100644
index 000000000..acef09e1e
--- /dev/null
+++ b/source/controllers/include/controllers/impedance/CompliantTwist.hpp
@@ -0,0 +1,110 @@
+#pragma once
+
+#include "controllers/IController.hpp"
+#include "controllers/impedance/Dissipative.hpp"
+#include "controllers/impedance/VelocityImpedance.hpp"
+#include "state_representation/parameters/Parameter.hpp"
+
+namespace controllers::impedance {
+/**
+ * @class CompliantTwist
+ * @brief A concrete controller class specifically for controlling
+ * 6 degree of freedom Cartesian twist with a combination of impedance
+ * controllers. The linear velocity is controlled with the Dissipative
+ * controller class, while the angular velocity is controlled
+ * with the VelocityImpedance class.
+ */
+class CompliantTwist : public IController<state_representation::CartesianState> {
+
+public:
+
+  /**
+   * @brief Constructor from an initial parameter list
+   * @param parameters A parameter list containing initial gain values
+   */
+  explicit CompliantTwist(
+      const std::list<std::shared_ptr<state_representation::ParameterInterface>>& parameters
+  );
+
+  /**
+   * @brief Constructor taking gain parameters as arguments
+   * @param linear_principle_damping damping along principle eigenvector of linear velocity error
+   * @param linear_orthogonal_damping damping along secondary eigenvectors of linear velocity error
+   * @param angular_stiffness stiffness of angular displacement
+   * @param angular_damping damping of angular velocity error
+   */
+  CompliantTwist(
+      double linear_principle_damping, double linear_orthogonal_damping, double angular_stiffness,
+      double angular_damping
+  );
+
+  /**
+   * @brief Compute the force (task space) or torque (joint space) command based on the input state 
+   * of the system as the error between the desired state and the real state.
+   * @param desired_state the desired state to reach
+   * @param feedback_state the real state of the system as read from feedback loop
+   * @return the output command at the input state
+   */
+  state_representation::CartesianState compute_command(
+      const state_representation::CartesianState& desired_state,
+      const state_representation::CartesianState& feedback_state
+  ) override;
+
+protected:
+
+  /**
+   * @brief Validate and set parameters for controller gains.
+   * @param parameter A parameter interface pointer
+   */
+  void validate_and_set_parameter(const std::shared_ptr<state_representation::ParameterInterface>& parameter) override;
+
+  /**
+   * @brief Setter of the linear principle damping
+   * @param the new principle damping value
+   */
+  void set_linear_principle_damping(double linear_principle_damping);
+
+  /**
+   * @brief Setter of the linear orthogonal damping
+   * @param the new orthogonal damping value
+   */
+  void set_linear_orthogonal_damping(double linear_orthogonal_damping);
+
+  /**
+   * @brief Setter of the linear damping values
+   * @param linear_principle_damping the new principle damping value
+   * @param linear_orthogonal_damping the new orthogonal damping value
+   */
+  void set_linear_gains(double linear_principle_damping, double linear_orthogonal_damping);
+
+  /**
+   * @brief Setter of the angular stiffness
+   * @param the new stiffness value
+   */
+  void set_angular_stiffness(double angular_stiffness);
+
+  /**
+   * @brief Setter of the angular damping
+   * @param the new damping value
+   */
+  void set_angular_damping(double angular_damping);
+
+  /**
+   * @brief Setter of the angular damping
+   * @param angular_stiffness the new angular stiffness value
+   * @param angular_damping the new angular damping value
+   */
+  void set_angular_gains(double angular_stiffness, double angular_damping);
+
+  std::shared_ptr<state_representation::Parameter<double>>
+      linear_principle_damping_; ///< damping along principle eigenvector of linear velocity error
+  std::shared_ptr<state_representation::Parameter<double>>
+      linear_orthogonal_damping_; ///< damping along secondary eigenvectors of linear velocity error
+  std::shared_ptr<state_representation::Parameter<double>> angular_stiffness_; ///< stiffness of angular displacement
+  std::shared_ptr<state_representation::Parameter<double>> angular_damping_; ///< damping of angular velocity error
+
+  Dissipative<state_representation::CartesianState> dissipative_ctrl_; ///< controller for linear space
+  VelocityImpedance<state_representation::CartesianState> velocity_impedance_ctrl_; ///< controller for angular space
+};
+
+}// namespace controllers
diff --git a/source/controllers/include/controllers/impedance/Dissipative.hpp b/source/controllers/include/controllers/impedance/Dissipative.hpp
index e2c05fe13..2ffe183c2 100644
--- a/source/controllers/include/controllers/impedance/Dissipative.hpp
+++ b/source/controllers/include/controllers/impedance/Dissipative.hpp
@@ -7,6 +7,7 @@
 #include <eigen3/Eigen/Dense>
 
 namespace controllers::impedance {
+
 /**
  * @enum ComputationalSpaceType
  * @brief Selector of the space in which the controller should be computed
@@ -16,10 +17,7 @@ namespace controllers::impedance {
  * and angular part separately
  */
 enum class ComputationalSpaceType {
-  LINEAR,
-  ANGULAR,
-  DECOUPLED_TWIST,
-  FULL
+  LINEAR, ANGULAR, DECOUPLED_TWIST, FULL
 };
 
 /**
@@ -28,85 +26,43 @@ enum class ComputationalSpaceType {
  */
 template<class S>
 class Dissipative : public Impedance<S> {
-private:
-  ComputationalSpaceType computational_space_;///< the space in which to compute the command vector
-  unsigned int nb_dimensions_;///< the number of dimensions of the input space
-  Eigen::MatrixXd basis_;///< basis matrix used to compute the damping matrix
-  std::shared_ptr<state_representation::Parameter<Eigen::VectorXd>>
-      damping_eigenvalues_;///< coefficient of eigenvalues used in the damping matrix computation
-
-  /**
-   * @brief Constructor with specified computational space and number of dimensions. Both parameters are
-   * mutually exclusive and therefore initialized independently in other constructors
-   */
-  explicit Dissipative(const ComputationalSpaceType& computational_space, unsigned int nb_dimensions);
 
 public:
-  /**
-   * @brief Constructor with specified computational space. Default is DECOUPLED_TWIST
-   * @param computational_space the space in which to compute the command in LINEAR, ANGULAR, DECOUPLED_TWIST or FULL.
-   * Default is DECOUPLED_TWIST
-   */
-  explicit Dissipative(const ComputationalSpaceType& computational_space = ComputationalSpaceType::DECOUPLED_TWIST);
-
-  /**
-   * @brief Constructor with specified number of dimensions. Automatically use the full damping matrix.
-   * @param nb_dimensions the number of dimensions of the damping matrix
-   */
-  explicit Dissipative(unsigned int nb_dimensions);
-
-  /**
-   * @brief Copy constructor
-   * @param other the controller to copy
-   */
-  Dissipative(const Dissipative<S>& other);
-
-  /**
-   * @brief Swap the values of the two controllers
-   * @tparam U space of the controller
-   * @param controller1 controller to be swapped with 2
-   * @param controller2 controller to be swapped with 1
-   */
-  template<class U>
-  friend void swap(Dissipative<U>& controller1, Dissipative<U>& controller2);
 
   /**
-   * @param Assignment operator
-   * @param other the controller to copy
-   * @return reference to the controller with values from other
+   * @brief Base constructor.
+   * @param computational_space The computational space type
+   * @param dimensions The number of dimensions
    */
-  Dissipative<S>& operator=(const Dissipative<S>& other);
+  explicit Dissipative(const ComputationalSpaceType& computational_space, unsigned int dimensions = 6);
 
   /**
-   * @brief Getter of the damping eigenvalues parameter
-   * @return the eigenvalues as a Vetor6D
+   * @brief Constructor from an initial parameter list.
+   * @param parameters A parameter list containing the initial parameters
+   * @param computational_space The computational space type
+   * @param dimensions The number of dimensions
    */
-  Eigen::VectorXd get_damping_eigenvalues() const;
+  explicit Dissipative(
+      const std::list<std::shared_ptr<state_representation::ParameterInterface>>& parameters,
+      const ComputationalSpaceType& computational_space, unsigned int dimensions = 6
+  );
 
   /**
-   * @brief Getter of the damping eigenvalue corresponding to the specified index
-   * @param index the index of the eigenvalue (number between 0 and 5)
-   * @return the eigenvalue at desired index
+   * @brief Compute the force (task space) or torque (joint space) command based on the input state
+   * of the system as the error between the desired state and the real state.
+   * @param command_state the desired state to reach
+   * @param feedback_state the real state of the system as read from feedback loop
+   * @return the output command at the input state
    */
-  double get_damping_eigenvalue(unsigned int index) const;
+  S compute_command(const S& command_state, const S& feedback_state) override;
 
-  /**
-   * @brief Setter of the damping eigenvalues parameter
-   * @param damping_eigenvalues the new values of the eigenvalue as a Vector6D
-   */
-  void set_damping_eigenvalues(const Eigen::VectorXd& damping_eigenvalues);
+protected:
 
   /**
-   * @brief Setter of the damping eigenvalue corresponding to the specified index
-   * @param damping_eigenvalue the new value of the eigenvalue
-   * @param index the index of the eigenvalue (number between 0 and 5)
+   * @brief Validate and set parameter for damping eigenvalues.
+   * @param parameter A parameter interface pointer
    */
-  void set_damping_eigenvalue(double damping_eigenvalue, unsigned int index);
-
-  /**
-   * @brief Get the eigenvalues in a diagonal matrix form
-   */
-  Eigen::MatrixXd get_diagonal_eigenvalues() const;
+  void validate_and_set_parameter(const std::shared_ptr<state_representation::ParameterInterface>& parameter) override;
 
   /**
    * @brief Orthornormalize the basis matrix given in input wrt the main engenvector
@@ -133,109 +89,54 @@ class Dissipative : public Impedance<S> {
    */
   void compute_damping(const S& desired_velocity);
 
-  /**
-   * @brief Compute the force (task space) or torque (joint space) command based on the input state
-   * of the system as the error between the desired state and the real state.
-   * @param desired_state the desired state to reach
-   * @param feedback_state the real state of the system as read from feedback loop
-   * @return the output command at the input state
-   */
-  S compute_command(const S& desired_state, const S& feedback_state) override;
+  std::shared_ptr<state_representation::Parameter<Eigen::VectorXd>>
+      damping_eigenvalues_; ///< coefficient of eigenvalues used in the damping matrix computation
 
-  /**
-   * @brief Compute the command based on the desired state and a feedback state
-   * To be redefined based on the actual controller implementation.
-   * @param desired_state the desired state of the system.
-   * @param feedback_state the real state of the system as read from feedback loop
-   * @param jacobian the Jacobian matrix of the robot to convert from one state to the other
-   * @return the output command at the input state
-   */
-  state_representation::JointState compute_command(const S& desired_state,
-                                                   const S& feedback_state,
-                                                   const state_representation::Jacobian& jacobian) override;
+  const ComputationalSpaceType computational_space_; ///< the space in which to compute the command vector
+
+  Eigen::MatrixXd basis_; ///< basis matrix used to compute the damping matrix
 
-  /**
-   * @brief Return a list of all the parameters of the controller
-   * @return the list of parameters
-   */
-  std::list<std::shared_ptr<state_representation::ParameterInterface>> get_parameters() const;
 };
 
 template<class S>
-Dissipative<S>::Dissipative(const ComputationalSpaceType& computational_space, unsigned int nb_dimensions) :
-    Impedance<S>(Eigen::MatrixXd::Zero(nb_dimensions, nb_dimensions),
-                 Eigen::MatrixXd::Identity(nb_dimensions, nb_dimensions),
-                 Eigen::MatrixXd::Zero(nb_dimensions, nb_dimensions)),
+Dissipative<S>::Dissipative(const ComputationalSpaceType& computational_space, unsigned int dimensions) :
+    Impedance<S>(dimensions),
+    damping_eigenvalues_(
+        state_representation::make_shared_parameter<Eigen::VectorXd>(
+            "damping_eigenvalues", Eigen::ArrayXd::Ones(dimensions))),
     computational_space_(computational_space),
-    nb_dimensions_(nb_dimensions),
-    basis_(Eigen::MatrixXd::Random(nb_dimensions, nb_dimensions)),
-    damping_eigenvalues_(std::make_shared<state_representation::Parameter<Eigen::VectorXd>>("damping_eigenvalues",
-                                                                                            Eigen::ArrayXd::Ones(nb_dimensions))) {}
-
-template<class S>
-Dissipative<S>::Dissipative(const Dissipative<S>& other):
-    Impedance<S>(other),
-    computational_space_(other.computational_space_),
-    nb_dimensions_(other.nb_dimensions_),
-    basis_(other.basis_),
-    damping_eigenvalues_(std::make_shared<state_representation::Parameter<Eigen::VectorXd>>("damping_eigenvalues",
-                                                                                            other.get_damping_eigenvalues())) {}
-
-template<class U>
-inline void swap(Dissipative<U>& controller1, Dissipative<U>& controller2) {
-  swap(static_cast<Impedance<U>&>(controller1), static_cast<Impedance<U>&>(controller2));
-  std::swap(controller1.computational_space_, controller2.computational_space_);
-  std::swap(controller1.nb_dimensions_, controller2.nb_dimensions_);
-  std::swap(controller1.basis_, controller2.basis_);
-  std::swap(controller1.damping_eigenvalues_, controller2.damping_eigenvalues_);
-}
-
-template<class S>
-Dissipative<S>& Dissipative<S>::operator=(const Dissipative<S>& other) {
-  Dissipative<S> tmp(other);
-  swap(*this, tmp);
-  return *this;
+    basis_(Eigen::MatrixXd::Random(dimensions, dimensions)) {
+  this->parameters_.erase("stiffness");
+  this->stiffness_->set_value(Eigen::MatrixXd::Zero(dimensions, dimensions));
+  this->parameters_.erase("inertia");
+  this->inertia_->set_value(Eigen::MatrixXd::Zero(dimensions, dimensions));
+
+  this->damping_->set_value(Eigen::MatrixXd::Identity(dimensions, dimensions));
+  this->parameters_.insert(std::make_pair("damping_eigenvalues", damping_eigenvalues_));
 }
 
 template<class S>
-inline Eigen::VectorXd Dissipative<S>::get_damping_eigenvalues() const {
-  return this->damping_eigenvalues_->get_value();
+Dissipative<S>::Dissipative(
+    const std::list<std::shared_ptr<state_representation::ParameterInterface>>& parameters,
+    const ComputationalSpaceType& computational_space, unsigned int dimensions
+) :
+    Dissipative<S>(computational_space, dimensions) {
+  this->set_parameters(parameters);
 }
 
 template<class S>
-inline double Dissipative<S>::get_damping_eigenvalue(unsigned int index) const {
-  Eigen::VectorXd eigenvalues = this->get_damping_eigenvalues();
-  return eigenvalues(index);
-}
-
-template<class S>
-inline void Dissipative<S>::set_damping_eigenvalues(const Eigen::VectorXd& damping_eigenvalues) {
-  this->damping_eigenvalues_->set_value(damping_eigenvalues);
-}
-
-template<class S>
-inline void Dissipative<S>::set_damping_eigenvalue(double damping_eigenvalue, unsigned int index) {
-  Eigen::VectorXd eigenvalues = this->get_damping_eigenvalues();
-  eigenvalues(index) = damping_eigenvalue;
-  this->set_damping_eigenvalues(eigenvalues);
-}
-
-template<class S>
-inline Eigen::MatrixXd Dissipative<S>::get_diagonal_eigenvalues() const {
-  return this->get_damping_eigenvalues().asDiagonal();
-}
-
-template<class S>
-inline std::list<std::shared_ptr<state_representation::ParameterInterface>>
-Dissipative<S>::get_parameters() const {
-  std::list<std::shared_ptr<state_representation::ParameterInterface>> param_list;
-  param_list.push_back(this->damping_eigenvalues_);
-  return param_list;
+void Dissipative<S>::validate_and_set_parameter(
+    const std::shared_ptr<state_representation::ParameterInterface>& parameter
+) {
+  if (parameter->get_name() == "damping_eigenvalues") {
+    this->damping_eigenvalues_->set_value(this->gain_matrix_from_parameter(parameter).diagonal());
+  }
 }
 
 template<class S>
-Eigen::MatrixXd Dissipative<S>::orthonormalize_basis(const Eigen::MatrixXd& basis,
-                                                     const Eigen::VectorXd& main_eigenvector) {
+Eigen::MatrixXd Dissipative<S>::orthonormalize_basis(
+    const Eigen::MatrixXd& basis, const Eigen::VectorXd& main_eigenvector
+) {
   Eigen::MatrixXd orthonormal_basis = basis;
   uint dim = basis.rows();
   orthonormal_basis.col(0) = main_eigenvector.normalized();
@@ -249,24 +150,20 @@ Eigen::MatrixXd Dissipative<S>::orthonormalize_basis(const Eigen::MatrixXd& basi
 }
 
 template<class S>
-S Dissipative<S>::compute_command(const S& desired_state,
-                                  const S& feedback_state) {
-  // compute the damping matrix out of the desired_state twist
-  this->compute_damping(desired_state);
+S Dissipative<S>::compute_command(
+    const S& command_state, const S& feedback_state
+) {
+  // compute the damping matrix out of the command_state twist
+  this->compute_damping(command_state);
   // apply the impedance control law
-  return this->Impedance<S>::compute_command(desired_state, feedback_state);
+  return this->Impedance<S>::compute_command(command_state, feedback_state);
 }
 
 template<class S>
 void Dissipative<S>::compute_damping(const S& desired_velocity) {
   this->basis_ = this->compute_orthonormal_basis(desired_velocity);
-  this->set_damping(this->basis_ * this->get_diagonal_eigenvalues() * this->basis_.transpose());
+  auto diagonal_eigenvalues = this->damping_eigenvalues_->get_value().asDiagonal();
+  this->damping_->set_value(this->basis_ * diagonal_eigenvalues * this->basis_.transpose());
 }
 
-template<class S>
-state_representation::JointState Dissipative<S>::compute_command(const S& desired_state,
-                                                                 const S& feedback_state,
-                                                                 const state_representation::Jacobian& jacobian) {
-  return this->Impedance<S>::compute_command(desired_state, feedback_state, jacobian);
-}
 }// namespace controllers
diff --git a/source/controllers/include/controllers/impedance/Impedance.hpp b/source/controllers/include/controllers/impedance/Impedance.hpp
index dc930875d..30a8f6350 100644
--- a/source/controllers/include/controllers/impedance/Impedance.hpp
+++ b/source/controllers/include/controllers/impedance/Impedance.hpp
@@ -1,180 +1,145 @@
 #pragma once
 
-#include "controllers/Controller.hpp"
-#include "state_representation/parameters/Parameter.hpp"
 #include <eigen3/Eigen/Core>
 #include <eigen3/Eigen/Dense>
 
+#include "controllers/IController.hpp"
+#include "state_representation/parameters/Parameter.hpp"
+#include "state_representation/State.hpp"
+
 namespace controllers::impedance {
+
 /**
  * @class Impedance
  * @brief Definition of an impedance controller in either joint or task space
- * @tparam S the space of the controller either CartesianState or JointState
+ * @tparam S the space of the controller (either CartesianState or JointState)
  */
 template<class S>
-class Impedance : public Controller<S> {
-private:
-  std::shared_ptr<state_representation::Parameter<Eigen::MatrixXd>>
-      stiffness_;///< stiffness matrix of the controller associated to position
-  std::shared_ptr<state_representation::Parameter<Eigen::MatrixXd>>
-      damping_;  ///< damping matrix of the controller associated to velocity
-  std::shared_ptr<state_representation::Parameter<Eigen::MatrixXd>>
-      inertia_;  ///< inertia matrix of the controller associated to acceleration
-
+class Impedance : public IController<S> {
 public:
-  /**
-   * @brief Constructor initializing all the matrices
-   * @param stiffness the stiffness matrix
-   * @param damping the damping matrix
-   * @param inertia the inertia matrix
-   */
-  explicit Impedance(const Eigen::MatrixXd& stiffness, const Eigen::MatrixXd& damping, const Eigen::MatrixXd& inertia);
 
   /**
-   * @brief Copy constructor
-   * @param other the controller to copy
+   * @brief Base constructor.
+   * @details This initializes all gain matrices to the identity matrix of the corresponding dimensionality.
+   * @param dimensions The number of dimensions associated with the controller
    */
-  Impedance(const Impedance<S>& other);
+  explicit Impedance(unsigned int dimensions = 6);
 
   /**
-   * @brief Swap the values of the two controllers
-   * @tparam U space of the controller
-   * @param controller1 controller to be swapped with 2
-   * @param controller2 controller to be swapped with 1
+   * @brief Constructor from an initial parameter list
+   * @param parameters A parameter list containing initial gain values
+   * @param dimensions The number of dimensions associated with the controller
    */
-  template<class U>
-  friend void swap(Impedance<U>& controller1, Impedance<U>& controller2);
+  explicit Impedance(
+      const std::list<std::shared_ptr<state_representation::ParameterInterface>>& parameters,
+      unsigned int dimensions = 6
+  );
 
   /**
-   * @param Assignment operator
-   * @param other the controller to copy
-   * @return reference to the controller with values from other
+   * @copydoc IController::compute_command(const S&,const S&)
    */
-  Impedance<S>& operator=(const Impedance<S>& other);
+  S compute_command(const S& command_state, const S& feedback_state) override;
 
-  /**
-   * @brief Compute the force (task space) or torque (joint space) command based on the input state 
-   * of the system as the error between the desired state and the real state.
-   * @param desired_state the desired state to reach
-   * @param feedback_state the real state of the system as read from feedback loop
-   * @return the output command at the input state
-   */
-  virtual S compute_command(const S& desired_state, const S& feedback_state);
+protected:
 
   /**
-   * @brief Compute the command based on the desired state and a feedback state
-   * To be redefined based on the actual controller implementation.
-   * @param desired_state the desired state of the system.
-   * @param feedback_state the real state of the system as read from feedback loop
-   * @param jacobian the Jacobian matrix of the robot to convert from one state to the other
-   * @return the output command at the input state
+   * @brief Validate and set parameters for damping, stiffness and inertia gain matrices.
+   * @param parameter A parameter interface pointer
    */
-  virtual state_representation::JointState compute_command(const S& desired_state,
-                                                           const S& feedback_state,
-                                                           const state_representation::Jacobian& jacobian);
+  void validate_and_set_parameter(const std::shared_ptr<state_representation::ParameterInterface>& parameter) override;
 
   /**
-   * @brief Getter of the stiffness matrix
-   * @return the stiffness matrix
+   * @brief Convert a parameterized gain to a gain matrix
+   * @param parameter A parameter interface pointer of type double, double array or matrix
+   * @return A square gain matrix
    */
-  const Eigen::MatrixXd& get_stiffness() const;
+  Eigen::MatrixXd
+  gain_matrix_from_parameter(const std::shared_ptr<state_representation::ParameterInterface>& parameter);
 
-  /**
-   * @brief Getter of the damping matrix
-   * @return the damping matrix
-   */
-  const Eigen::MatrixXd& get_damping() const;
-
-  /**
-   * @brief Getter of the inertia matrix
-   * @return the inertia matrix
-   */
-  const Eigen::MatrixXd& get_inertia() const;
-
-  /**
-   * @brief Setter of the stiffness matrix
-   * @param the new stiffness matrix
-   */
-  void set_stiffness(const Eigen::MatrixXd& stiffness);
-
-  /**
-   * @brief Setter of the damping matrix
-   * @param the new damping matrix
-   */
-  void set_damping(const Eigen::MatrixXd& damping);
-
-  /**
-   * @brief Setter of the inertia matrix
-   * @param the new inertia matrix
-   */
-  void set_inertia(const Eigen::MatrixXd& inertia);
+  std::shared_ptr<state_representation::Parameter<Eigen::MatrixXd>>
+      stiffness_; ///< stiffness matrix of the controller associated to position
+  std::shared_ptr<state_representation::Parameter<Eigen::MatrixXd>>
+      damping_; ///< damping matrix of the controller associated to velocity
+  std::shared_ptr<state_representation::Parameter<Eigen::MatrixXd>>
+      inertia_; ///< inertia matrix of the controller associated to acceleration
 
-  /**
-   * @brief Return a list of all the parameters of the controller
-   * @return the list of parameters
-   */
-  virtual std::list<std::shared_ptr<state_representation::ParameterInterface>> get_parameters() const;
+  const unsigned int dimensions_; ///< dimensionality of the control space and associated gain matricess
 };
 
 template<class S>
-Impedance<S>::Impedance(const Impedance<S>& other):
-    stiffness_(std::make_shared<state_representation::Parameter<Eigen::MatrixXd>>("stiffness",
-                                                                                  other.get_stiffness())),
-    damping_(std::make_shared<state_representation::Parameter<Eigen::MatrixXd>>("damping",
-                                                                                other.get_damping())),
-    inertia_(std::make_shared<state_representation::Parameter<Eigen::MatrixXd>>("inertia",
-                                                                                other.get_inertia())) {}
-
-template<class U>
-inline void swap(Impedance<U>& controller1, Impedance<U>& controller2) {
-  std::swap(controller1.stiffness_, controller2.stiffness_);
-  std::swap(controller1.damping_, controller2.damping_);
-  std::swap(controller1.inertia_, controller2.inertia_);
-}
-
-template<class S>
-inline Impedance<S>& Impedance<S>::operator=(const Impedance<S>& other) {
-  Impedance<S> tmp(other);
-  swap(*this, tmp);
-  return *this;
+Impedance<S>::Impedance(unsigned int dimensions) :
+    stiffness_(
+        state_representation::make_shared_parameter<Eigen::MatrixXd>(
+            "stiffness", Eigen::MatrixXd::Identity(dimensions, dimensions))), damping_(
+    state_representation::make_shared_parameter<Eigen::MatrixXd>(
+        "damping", Eigen::MatrixXd::Identity(dimensions, dimensions))), inertia_(
+    state_representation::make_shared_parameter<Eigen::MatrixXd>(
+        "inertia", Eigen::MatrixXd::Identity(dimensions, dimensions))), dimensions_(dimensions) {
+  this->parameters_.insert(std::make_pair("stiffness", stiffness_));
+  this->parameters_.insert(std::make_pair("damping", damping_));
+  this->parameters_.insert(std::make_pair("inertia", inertia_));
 }
 
 template<class S>
-inline const Eigen::MatrixXd& Impedance<S>::get_stiffness() const {
-  return this->stiffness_->get_value();
+Impedance<S>::Impedance(
+    const std::list<std::shared_ptr<state_representation::ParameterInterface>>& parameters, unsigned int dimensions
+) :
+    Impedance(dimensions) {
+  this->set_parameters(parameters);
 }
 
 template<class S>
-inline const Eigen::MatrixXd& Impedance<S>::get_damping() const {
-  return this->damping_->get_value();
+void Impedance<S>::validate_and_set_parameter(
+    const std::shared_ptr<state_representation::ParameterInterface>& parameter
+) {
+  if (parameter->get_name() == "stiffness") {
+    this->stiffness_->set_value(this->gain_matrix_from_parameter(parameter));
+  } else if (parameter->get_name() == "damping") {
+    this->damping_->set_value(this->gain_matrix_from_parameter(parameter));
+  } else if (parameter->get_name() == "inertia") {
+    this->inertia_->set_value(this->gain_matrix_from_parameter(parameter));
+  }
 }
 
 template<class S>
-inline const Eigen::MatrixXd& Impedance<S>::get_inertia() const {
-  return this->inertia_->get_value();
+Eigen::MatrixXd Impedance<S>::gain_matrix_from_parameter(
+    const std::shared_ptr<state_representation::ParameterInterface>& parameter
+) {
+  Eigen::MatrixXd matrix;
+  if (parameter->get_type() == state_representation::StateType::PARAMETER_DOUBLE) {
+    auto gain = std::static_pointer_cast<state_representation::Parameter<double>>(parameter);
+    matrix = gain->get_value() * Eigen::MatrixXd::Identity(this->dimensions_, this->dimensions_);
+  } else if (parameter->get_type() == state_representation::StateType::PARAMETER_DOUBLE_ARRAY) {
+    auto gain = std::static_pointer_cast<state_representation::Parameter<std::vector<double>>>(parameter);
+    if (gain->get_value().size() != this->dimensions_) {
+      throw state_representation::exceptions::IncompatibleSizeException(
+          "The provided diagonal coefficients do not match the dimensionality of the controller ("
+              + std::to_string(this->dimensions_) + ")");
+    }
+    Eigen::VectorXd diagonal = Eigen::VectorXd::Map(gain->get_value().data(), this->dimensions_);
+    matrix = diagonal.asDiagonal();
+  } else if (parameter->get_type() == state_representation::StateType::PARAMETER_VECTOR) {
+    auto gain = std::static_pointer_cast<state_representation::Parameter<Eigen::VectorXd>>(parameter);
+    if (gain->get_value().size() != this->dimensions_) {
+      throw state_representation::exceptions::IncompatibleSizeException(
+          "The provided diagonal coefficients do not match the dimensionality of the controller ("
+              + std::to_string(this->dimensions_) + ")");
+    }
+    Eigen::VectorXd diagonal = gain->get_value();
+    matrix = diagonal.asDiagonal();
+  } else if (parameter->get_type() == state_representation::StateType::PARAMETER_MATRIX) {
+    auto gain = std::static_pointer_cast<state_representation::Parameter<Eigen::MatrixXd>>(parameter);
+    if (gain->get_value().rows() != this->dimensions_ || gain->get_value().cols() != this->dimensions_) {
+      auto dim = std::to_string(this->dimensions_);
+      throw state_representation::exceptions::IncompatibleSizeException(
+          "The provided matrix does not have the expected size (" + dim + "x" + dim + ")");
+    }
+    matrix = gain->get_value();
+  } else {
+    throw state_representation::exceptions::InvalidParameterException(
+        "Parameter " + parameter->get_name() + " has incorrect type");
+  }
+  return matrix;
 }
 
-template<class S>
-inline void Impedance<S>::set_stiffness(const Eigen::MatrixXd& stiffness) {
-  this->stiffness_->set_value(stiffness);
-}
-
-template<class S>
-inline void Impedance<S>::set_damping(const Eigen::MatrixXd& damping) {
-  this->damping_->set_value(damping);
-}
-
-template<class S>
-inline void Impedance<S>::set_inertia(const Eigen::MatrixXd& inertia) {
-  this->inertia_->set_value(inertia);
-}
-
-template<class S>
-std::list<std::shared_ptr<state_representation::ParameterInterface>> Impedance<S>::get_parameters() const {
-  std::list<std::shared_ptr<state_representation::ParameterInterface>> param_list;
-  param_list.push_back(this->stiffness_);
-  param_list.push_back(this->damping_);
-  param_list.push_back(this->inertia_);
-  return param_list;
-}
 }// namespace controllers
diff --git a/source/controllers/include/controllers/impedance/VelocityImpedance.hpp b/source/controllers/include/controllers/impedance/VelocityImpedance.hpp
index 03e30705f..f6a72101e 100644
--- a/source/controllers/include/controllers/impedance/VelocityImpedance.hpp
+++ b/source/controllers/include/controllers/impedance/VelocityImpedance.hpp
@@ -8,40 +8,29 @@ namespace controllers::impedance {
 /**
  * @class VelocityImpedance
  * @brief A velocity impedance is a normal impedance controller
- * that only take a velocity input and integrate it for position error
- * @tparam S the space of the controller either CartesianState or JointState
+ * that only uses velocity input and integrates it for position error
+ * @tparam S the space of the controller (either CartesianState or JointState)
  */
 template<class S>
 class VelocityImpedance : public Impedance<S> {
 public:
-  /**
-   * @brief Constructor initializing all the matrices
-   * @param stiffness the stiffness matrix
-   * @param damping the damping matrix
-   */
-  explicit VelocityImpedance(const Eigen::MatrixXd& stiffness, const Eigen::MatrixXd& damping);
 
   /**
-   * @brief Copy constructor
-   * @param other the controller to copy
+   * @brief Base constructor.
+   * @details This initializes all gain matrices to the identity matrix of the corresponding dimensionality.
+   * @param dimensions The number of dimensions associated with the controller
    */
-  VelocityImpedance(const VelocityImpedance<S>& other);
+  explicit VelocityImpedance(unsigned int dimensions = 6);
 
   /**
-   * @brief Swap the values of the two controllers
-   * @tparam U space of the controller
-   * @param controller1 controller to be swapped with 2
-   * @param controller2 controller to be swapped with 1
+   * @brief Constructor from an initial parameter list
+   * @param parameters A parameter list containing initial gain values
+   * @param dimensions The number of dimensions associated with the controller
    */
-  template<class U>
-  friend void swap(VelocityImpedance<U>& controller1, VelocityImpedance<U>& controller2);
-
-  /**
-   * @param Assignment operator
-   * @param other the controller to copy
-   * @return reference to the controller with values from other
-   */
-  VelocityImpedance<S>& operator=(const VelocityImpedance<S>& other);
+  explicit VelocityImpedance(
+      const std::list<std::shared_ptr<state_representation::ParameterInterface>>& parameters,
+      unsigned int dimensions = 6
+  );
 
   /**
    * @brief Compute the force (task space) or torque (joint space) command based on the input state 
@@ -51,40 +40,20 @@ class VelocityImpedance : public Impedance<S> {
    * @return the output command at the input state
    */
   S compute_command(const S& desired_state, const S& feedback_state) override;
-
-  /**
-   * @brief Compute the command based on the desired state and a feedback state in a non const fashion
-   * To be redefined based on the actual controller implementation.
-   * @param desired_state the desired state of the system.
-   * @param feedback_state the real state of the system as read from feedback loop
-   * @param jacobian the Jacobian matrix of the robot to convert from one state to the other
-   * @return the output command at the input state
-   */
-  state_representation::JointState compute_command(const S& desired_state,
-                                                   const S& feedback_state,
-                                                   const state_representation::Jacobian& jacobian) override;
 };
 
 template<class S>
-VelocityImpedance<S>::VelocityImpedance(const VelocityImpedance<S>& other):
-    Impedance<S>(other) {}
-
-template<class U>
-inline void swap(VelocityImpedance<U>& controller1, VelocityImpedance<U>& controller2) {
-  swap(static_cast<Impedance<U>&>(controller1), static_cast<Impedance<U>&>(controller2));
+VelocityImpedance<S>::VelocityImpedance(unsigned int dimensions) : Impedance<S>(dimensions) {
+  this->parameters_.erase("inertia");
+  this->inertia_->set_value(Eigen::MatrixXd::Zero(dimensions, dimensions));
 }
 
 template<class S>
-inline VelocityImpedance<S>& VelocityImpedance<S>::operator=(const VelocityImpedance<S>& other) {
-  VelocityImpedance<S> tmp(other);
-  swap(*this, tmp);
-  return *this;
+VelocityImpedance<S>::VelocityImpedance(
+    const std::list<std::shared_ptr<state_representation::ParameterInterface>>& parameters, unsigned int dimensions
+) :
+    VelocityImpedance<S>(dimensions) {
+  this->set_parameters(parameters);
 }
 
-template<class S>
-state_representation::JointState VelocityImpedance<S>::compute_command(const S& desired_state,
-                                                                       const S& feedback_state,
-                                                                       const state_representation::Jacobian& jacobian) {
-  return this->Impedance<S>::compute_command(desired_state, feedback_state, jacobian);
-}
 }// namespace controllers
diff --git a/source/controllers/src/ControllerFactory.cpp b/source/controllers/src/ControllerFactory.cpp
new file mode 100644
index 000000000..acf710846
--- /dev/null
+++ b/source/controllers/src/ControllerFactory.cpp
@@ -0,0 +1,94 @@
+#include "controllers/ControllerFactory.hpp"
+
+#include "controllers/exceptions/InvalidControllerException.hpp"
+#include "controllers/impedance/Impedance.hpp"
+#include "controllers/impedance/VelocityImpedance.hpp"
+#include "controllers/impedance/Dissipative.hpp"
+#include "controllers/impedance/CompliantTwist.hpp"
+
+using namespace state_representation;
+
+namespace controllers {
+
+template<>
+std::shared_ptr<IController<CartesianState>> ControllerFactory<CartesianState>::create_controller(
+    CONTROLLER_TYPE type, const std::list<std::shared_ptr<ParameterInterface>>& parameters, unsigned int
+) {
+  switch (type) {
+    case CONTROLLER_TYPE::IMPEDANCE:
+      return std::make_shared<impedance::Impedance<CartesianState>>(parameters);
+    case CONTROLLER_TYPE::VELOCITY_IMPEDANCE:
+      return std::make_shared<impedance::VelocityImpedance<CartesianState>>(parameters);
+    case CONTROLLER_TYPE::DISSIPATIVE:
+      return std::make_shared<impedance::Dissipative<CartesianState>>(
+          parameters, impedance::ComputationalSpaceType::FULL);
+    case CONTROLLER_TYPE::DISSIPATIVE_LINEAR:
+      return std::make_shared<impedance::Dissipative<CartesianState>>(
+          parameters, impedance::ComputationalSpaceType::LINEAR);
+    case CONTROLLER_TYPE::DISSIPATIVE_ANGULAR:
+      return std::make_shared<impedance::Dissipative<CartesianState>>(
+          parameters, impedance::ComputationalSpaceType::ANGULAR);
+    case CONTROLLER_TYPE::DISSIPATIVE_DECOUPLED:
+      return std::make_shared<impedance::Dissipative<CartesianState>>(
+          parameters, impedance::ComputationalSpaceType::DECOUPLED_TWIST);
+    case CONTROLLER_TYPE::COMPLIANT_TWIST:
+      return std::make_shared<impedance::CompliantTwist>(parameters);
+    default:
+    case CONTROLLER_TYPE::NONE:
+      return nullptr;
+  }
+}
+
+template<>
+std::shared_ptr<IController<JointState>> ControllerFactory<JointState>::create_controller(
+    CONTROLLER_TYPE type, const std::list<std::shared_ptr<ParameterInterface>>& parameters, unsigned int dimensions
+) {
+  switch (type) {
+    case CONTROLLER_TYPE::IMPEDANCE:
+      return std::make_shared<impedance::Impedance<JointState>>(parameters, dimensions);
+    case CONTROLLER_TYPE::VELOCITY_IMPEDANCE:
+      return std::make_shared<impedance::VelocityImpedance<JointState>>(parameters, dimensions);
+    case CONTROLLER_TYPE::DISSIPATIVE:
+      return std::make_shared<impedance::Dissipative<JointState>>(
+          parameters, impedance::ComputationalSpaceType::FULL, dimensions);
+    case CONTROLLER_TYPE::DISSIPATIVE_LINEAR:
+    case CONTROLLER_TYPE::DISSIPATIVE_ANGULAR:
+    case CONTROLLER_TYPE::DISSIPATIVE_DECOUPLED:
+      throw exceptions::InvalidControllerException(
+          "The JointState dissipative controller cannot be decoupled into linear and angular terms");
+    case CONTROLLER_TYPE::COMPLIANT_TWIST:
+      throw exceptions::InvalidControllerException(
+          "The compliant twist controller only works in Cartesian space");
+    default:
+    case CONTROLLER_TYPE::NONE:
+      return nullptr;
+  }
+}
+
+template<>
+std::shared_ptr<IController<CartesianState>> ControllerFactory<CartesianState>::create_controller(
+    CONTROLLER_TYPE type, const std::list<std::shared_ptr<ParameterInterface>>& parameters,
+    const robot_model::Model& robot_model
+) {
+  auto ctrl = ControllerFactory<CartesianState>::create_controller(type, parameters);
+  if (ctrl == nullptr) {
+    throw exceptions::InvalidControllerException("Cannot assign robot model to this controller!");
+  }
+  ctrl->set_robot_model(robot_model);
+  return ctrl;
+}
+
+template<>
+std::shared_ptr<IController<JointState>> ControllerFactory<JointState>::create_controller(
+    CONTROLLER_TYPE type, const std::list<std::shared_ptr<ParameterInterface>>& parameters,
+    const robot_model::Model& robot_model
+) {
+  auto ctrl = ControllerFactory<JointState>::create_controller(type, parameters, robot_model.get_number_of_joints());
+  if (ctrl == nullptr) {
+    throw exceptions::InvalidControllerException("Cannot assign robot model to this controller!");
+  }
+  ctrl->set_robot_model(robot_model);
+  return ctrl;
+}
+
+}// namespace controllers
diff --git a/source/controllers/src/IController.cpp b/source/controllers/src/IController.cpp
new file mode 100644
index 000000000..fbe28ccdc
--- /dev/null
+++ b/source/controllers/src/IController.cpp
@@ -0,0 +1,43 @@
+#include "controllers/IController.hpp"
+
+#include "controllers/exceptions/NotImplementedException.hpp"
+
+using namespace state_representation;
+
+namespace controllers {
+
+template<class S>
+JointState IController<S>::compute_command(const S&, const S&, const Jacobian&) {
+  throw exceptions::NotImplementedException(
+      "Computation of a joint-space command with a Jacobian is not implemented for this controller.");
+}
+
+template<class S>
+JointState IController<S>::compute_command(const S&, const S&, const JointPositions&, const std::string&) {
+  throw exceptions::NotImplementedException(
+      "Computation of a joint-space command from joint positions is not implemented for this controller.");
+}
+
+template<>
+JointState IController<CartesianState>::compute_command(
+    const CartesianState& command_state, const CartesianState& feedback_state,
+    const Jacobian& jacobian
+) {
+  return jacobian.transpose() * CartesianWrench(this->compute_command(command_state, feedback_state));
+}
+
+template<>
+JointState IController<CartesianState>::compute_command(
+    const CartesianState& command_state, const CartesianState& feedback_state, const JointPositions& joint_positions,
+    const std::string& frame_name
+) {
+  if (this->robot_model_ == nullptr) {
+    throw exceptions::NoRobotModelException(
+        "A robot model is required to convert the control command from Cartesian to joint space");
+  }
+
+  auto jacobian = this->robot_model_->compute_jacobian(joint_positions, frame_name);
+  return this->compute_command(command_state, feedback_state, jacobian);
+}
+
+}
\ No newline at end of file
diff --git a/source/controllers/src/impedance/CartesianTwistController.cpp b/source/controllers/src/impedance/CartesianTwistController.cpp
deleted file mode 100644
index cbd71f591..000000000
--- a/source/controllers/src/impedance/CartesianTwistController.cpp
+++ /dev/null
@@ -1,119 +0,0 @@
-#include "controllers/impedance/CartesianTwistController.hpp"
-
-namespace controllers::impedance {
-
-using namespace state_representation;
-
-CartesianTwistController::CartesianTwistController(double linear_principle_damping,
-                                                   double linear_orthogonal_damping,
-                                                   double angular_stiffness,
-                                                   double angular_damping) :
-    linear_principle_damping_(std::make_shared<Parameter<double>>("linear_principle_damping",
-                                                                  linear_principle_damping)),
-    linear_orthogonal_damping_(std::make_shared<Parameter<double>>("linear_orthogonal_damping",
-                                                                   linear_orthogonal_damping)),
-    angular_stiffness_(std::make_shared<Parameter<double>>("angular_stiffness", angular_stiffness)),
-    angular_damping_(std::make_shared<Parameter<double>>("angular_damping", angular_damping)),
-    dissipative_ctrl_(ComputationalSpaceType::LINEAR),
-    velocity_impedance_ctrl_(Eigen::MatrixXd::Zero(6, 6), Eigen::MatrixXd::Zero(6, 6)) {
-  set_linear_gains(linear_principle_damping, linear_orthogonal_damping);
-  set_angular_gains(angular_stiffness, angular_damping);
-}
-
-CartesianTwistController::CartesianTwistController(const Eigen::Vector4d& gains) :
-    CartesianTwistController(gains(0), gains(1), gains(2), gains(3)) {}
-
-CartesianTwistController::CartesianTwistController(const CartesianTwistController& other) :
-    linear_principle_damping_(std::make_shared<Parameter<double>>("linear_principle_damping", other.get_gains()(0))),
-    linear_orthogonal_damping_(std::make_shared<Parameter<double>>("linear_orthogonal_damping", other.get_gains()(1))),
-    angular_stiffness_(std::make_shared<Parameter<double>>("angular_stiffness", other.get_gains()(2))),
-    angular_damping_(std::make_shared<Parameter<double>>("angular_damping", other.get_gains()(3))),
-    dissipative_ctrl_(other.dissipative_ctrl_),
-    velocity_impedance_ctrl_(other.velocity_impedance_ctrl_) {}
-
-CartesianTwistController& CartesianTwistController::operator=(const CartesianTwistController& other) {
-  CartesianTwistController tmp(other);
-  swap(*this, tmp);
-  return *this;
-}
-
-void CartesianTwistController::set_gains(double linear_principle_damping,
-                                         double linear_orthogonal_damping,
-                                         double angular_stiffness,
-                                         double angular_damping) {
-  set_linear_gains(linear_principle_damping, linear_orthogonal_damping);
-  set_angular_gains(angular_stiffness, angular_damping);
-}
-
-void CartesianTwistController::set_gains(const Eigen::Vector4d& gains) {
-  set_linear_gains(gains(0), gains(1));
-  set_angular_gains(gains(2), gains(3));
-}
-
-Eigen::Vector4d CartesianTwistController::get_gains() const {
-  return Eigen::Vector4d(linear_principle_damping_->get_value(),
-                         linear_orthogonal_damping_->get_value(),
-                         angular_stiffness_->get_value(),
-                         angular_damping_->get_value());
-}
-
-void CartesianTwistController::set_linear_principle_damping(double linear_principle_damping) {
-  set_linear_gains(linear_principle_damping, linear_orthogonal_damping_->get_value());
-}
-
-void CartesianTwistController::set_linear_orthogonal_damping(double linear_orthogonal_damping) {
-  set_linear_gains(linear_principle_damping_->get_value(), linear_orthogonal_damping);
-}
-
-void CartesianTwistController::set_linear_gains(double linear_principle_damping, double linear_orthogonal_damping) {
-  linear_principle_damping_->set_value(linear_principle_damping);
-  linear_orthogonal_damping_->set_value(linear_orthogonal_damping);
-
-  Eigen::VectorXd damping(6);
-  damping << linear_principle_damping, linear_orthogonal_damping, linear_orthogonal_damping, 0, 0, 0;
-  dissipative_ctrl_.set_damping_eigenvalues(damping);
-}
-
-void CartesianTwistController::set_angular_stiffness(double angular_stiffness) {
-  set_angular_gains(angular_stiffness, angular_damping_->get_value());
-}
-
-void CartesianTwistController::set_angular_damping(double angular_damping) {
-  set_angular_gains(angular_stiffness_->get_value(), angular_damping);
-}
-
-void CartesianTwistController::set_angular_gains(double angular_stiffness, double angular_damping) {
-  angular_stiffness_->set_value(angular_stiffness);
-  angular_damping_->set_value(angular_damping);
-
-  Eigen::MatrixXd k(6, 6), d(6, 6);
-  k.diagonal() << 0, 0, 0, angular_stiffness, angular_stiffness, angular_stiffness;
-  d.diagonal() << 0, 0, 0, angular_damping, angular_damping, angular_damping;
-  velocity_impedance_ctrl_.set_stiffness(k);
-  velocity_impedance_ctrl_.set_damping(d);
-}
-
-std::list<std::shared_ptr<ParameterInterface>> CartesianTwistController::get_parameters() const {
-  std::list<std::shared_ptr<ParameterInterface>> param_list;
-  param_list.push_back(linear_principle_damping_);
-  param_list.push_back(linear_orthogonal_damping_);
-  param_list.push_back(angular_stiffness_);
-  param_list.push_back(angular_damping_);
-  return param_list;
-}
-
-CartesianState
-CartesianTwistController::compute_command(const CartesianState& desired_state, const CartesianState& feedback_state) {
-  CartesianWrench command = dissipative_ctrl_.compute_command(CartesianTwist(desired_state), CartesianTwist(feedback_state));
-  command += velocity_impedance_ctrl_.compute_command(desired_state, feedback_state);
-  return command;
-}
-
-JointState CartesianTwistController::compute_command(const CartesianState& desired_state,
-                                                     const CartesianState& feedback_state,
-                                                     const Jacobian& jacobian) {
-  CartesianWrench wrench = compute_command(desired_state, feedback_state);
-  return jacobian.transpose() * wrench;
-}
-
-}
\ No newline at end of file
diff --git a/source/controllers/src/impedance/CompliantTwist.cpp b/source/controllers/src/impedance/CompliantTwist.cpp
new file mode 100644
index 000000000..920aa1a39
--- /dev/null
+++ b/source/controllers/src/impedance/CompliantTwist.cpp
@@ -0,0 +1,98 @@
+#include "controllers/impedance/CompliantTwist.hpp"
+
+#include "state_representation/exceptions/InvalidParameterException.hpp"
+
+namespace controllers::impedance {
+
+using namespace state_representation;
+
+CompliantTwist::CompliantTwist(
+    double linear_principle_damping, double linear_orthogonal_damping, double angular_stiffness, double angular_damping
+) : linear_principle_damping_(
+    std::make_shared<Parameter<double>>("linear_principle_damping", linear_principle_damping)),
+    linear_orthogonal_damping_(
+        std::make_shared<Parameter<double>>("linear_orthogonal_damping", linear_orthogonal_damping)),
+    angular_stiffness_(std::make_shared<Parameter<double>>("angular_stiffness", angular_stiffness)),
+    angular_damping_(std::make_shared<Parameter<double>>("angular_damping", angular_damping)),
+    dissipative_ctrl_(ComputationalSpaceType::LINEAR),
+    velocity_impedance_ctrl_(6) {
+  this->parameters_.insert(std::make_pair("linear_principle_damping", linear_principle_damping_));
+  this->parameters_.insert(std::make_pair("linear_orthogonal_damping", linear_orthogonal_damping_));
+  this->parameters_.insert(std::make_pair("angular_stiffness", angular_stiffness_));
+  this->parameters_.insert(std::make_pair("angular_damping", angular_damping_));
+
+  set_linear_gains(linear_principle_damping, linear_orthogonal_damping);
+  set_angular_gains(angular_stiffness, angular_damping);
+}
+
+CompliantTwist::CompliantTwist(
+    const std::list<std::shared_ptr<state_representation::ParameterInterface>>& parameters
+) : CompliantTwist(1, 1, 1, 1) {
+  this->set_parameters(parameters);
+}
+
+void CompliantTwist::set_linear_principle_damping(double linear_principle_damping) {
+  set_linear_gains(linear_principle_damping, linear_orthogonal_damping_->get_value());
+}
+
+void CompliantTwist::set_linear_orthogonal_damping(double linear_orthogonal_damping) {
+  set_linear_gains(linear_principle_damping_->get_value(), linear_orthogonal_damping);
+}
+
+void CompliantTwist::set_linear_gains(double linear_principle_damping, double linear_orthogonal_damping) {
+  linear_principle_damping_->set_value(linear_principle_damping);
+  linear_orthogonal_damping_->set_value(linear_orthogonal_damping);
+
+  Eigen::VectorXd damping(6);
+  damping << linear_principle_damping, linear_orthogonal_damping, linear_orthogonal_damping, 0, 0, 0;
+  dissipative_ctrl_.set_parameter_value("damping_eigenvalues", damping);
+}
+
+void CompliantTwist::set_angular_stiffness(double angular_stiffness) {
+  set_angular_gains(angular_stiffness, angular_damping_->get_value());
+}
+
+void CompliantTwist::set_angular_damping(double angular_damping) {
+  set_angular_gains(angular_stiffness_->get_value(), angular_damping);
+}
+
+void CompliantTwist::set_angular_gains(double angular_stiffness, double angular_damping) {
+  angular_stiffness_->set_value(angular_stiffness);
+  angular_damping_->set_value(angular_damping);
+
+  Eigen::MatrixXd k(6, 6), d(6, 6);
+  k.diagonal() << 0, 0, 0, angular_stiffness, angular_stiffness, angular_stiffness;
+  d.diagonal() << 0, 0, 0, angular_damping, angular_damping, angular_damping;
+  velocity_impedance_ctrl_.set_parameter_value("stiffness", k);
+  velocity_impedance_ctrl_.set_parameter_value("damping", d);
+}
+
+CartesianState CompliantTwist::compute_command(
+    const CartesianState& desired_state, const CartesianState& feedback_state
+) {
+  CartesianState
+      command = dissipative_ctrl_.compute_command(CartesianTwist(desired_state), CartesianTwist(feedback_state));
+  command += velocity_impedance_ctrl_.compute_command(desired_state, feedback_state);
+  return command;
+}
+
+void CompliantTwist::validate_and_set_parameter(
+    const std::shared_ptr<state_representation::ParameterInterface>& parameter
+) {
+  if (parameter->get_type() != StateType::PARAMETER_DOUBLE) {
+    throw state_representation::exceptions::InvalidParameterException(
+        "Parameter " + parameter->get_name() + " must be a double");
+  }
+  double value = std::static_pointer_cast<Parameter<double>>(parameter)->get_value();
+  if (parameter->get_name() == "linear_principle_damping") {
+    this->set_linear_principle_damping(value);
+  } else if (parameter->get_name() == "linear_orthogonal_damping") {
+    this->set_linear_orthogonal_damping(value);
+  } else if (parameter->get_name() == "angular_stiffness") {
+    this->set_angular_stiffness(value);
+  } else if (parameter->get_name() == "angular_damping") {
+    this->set_angular_damping(value);
+  }
+}
+
+}
\ No newline at end of file
diff --git a/source/controllers/src/impedance/Dissipative.cpp b/source/controllers/src/impedance/Dissipative.cpp
index 61e47f381..c650712f0 100644
--- a/source/controllers/src/impedance/Dissipative.cpp
+++ b/source/controllers/src/impedance/Dissipative.cpp
@@ -1,19 +1,10 @@
 #include "controllers/impedance/Dissipative.hpp"
 
+#include "controllers/exceptions/NotImplementedException.hpp"
+
 using namespace state_representation;
 
 namespace controllers::impedance {
-template<class S>
-Dissipative<S>::Dissipative(const ComputationalSpaceType& computational_space):
-    Dissipative<S>(computational_space, 6) {}
-
-template Dissipative<CartesianState>::Dissipative(const ComputationalSpaceType&);
-
-template<class S>
-Dissipative<S>::Dissipative(unsigned int nb_dimensions):
-    Dissipative<S>(ComputationalSpaceType::FULL, nb_dimensions) {}
-
-template Dissipative<JointState>::Dissipative(unsigned int);
 
 template<class S>
 Eigen::MatrixXd Dissipative<S>::compute_orthonormal_basis(const S&) {
@@ -24,11 +15,11 @@ Eigen::MatrixXd Dissipative<S>::compute_orthonormal_basis(const S&) {
 template<>
 Eigen::MatrixXd Dissipative<CartesianState>::compute_orthonormal_basis(const CartesianState& desired_velocity) {
   double tolerance = 1e-4;
-  Eigen::MatrixXd updated_basis = Eigen::MatrixXd::Zero(this->nb_dimensions_, this->nb_dimensions_);
+  Eigen::MatrixXd updated_basis = Eigen::MatrixXd::Zero(this->dimensions_, this->dimensions_);
   switch (this->computational_space_) {
     case ComputationalSpaceType::LINEAR: {
       const Eigen::Vector3d& linear_velocity = desired_velocity.get_linear_velocity();
-      // only update the damping if the commanded linear velocity is non null
+      // only update the damping if the commanded linear velocity is non-null
       if (linear_velocity.norm() < tolerance) {
         updated_basis.topLeftCorner<3, 3>() = Eigen::Matrix3d::Identity();
         return updated_basis;
@@ -40,14 +31,14 @@ Eigen::MatrixXd Dissipative<CartesianState>::compute_orthonormal_basis(const Car
     }
     case ComputationalSpaceType::ANGULAR: {
       const Eigen::Vector3d& angular_velocity = desired_velocity.get_angular_velocity();
-      // only update the damping if the commanded angular velocity is non null
+      // only update the damping if the commanded angular velocity is non-null
       if (angular_velocity.norm() < tolerance) {
         updated_basis.bottomRightCorner<3, 3>() = Eigen::Matrix3d::Identity();
         return updated_basis;
       }
       // return only the angular block
-      updated_basis.bottomRightCorner<3, 3>() =
-          Dissipative<CartesianState>::orthonormalize_basis(this->basis_.bottomRightCorner<3, 3>(), angular_velocity);
+      updated_basis.bottomRightCorner<3, 3>() = Dissipative<CartesianState>::orthonormalize_basis(
+          this->basis_.bottomRightCorner<3, 3>(), angular_velocity);
       break;
     }
     case ComputationalSpaceType::DECOUPLED_TWIST: {
@@ -61,20 +52,20 @@ Eigen::MatrixXd Dissipative<CartesianState>::compute_orthonormal_basis(const Car
         updated = true;
       }
       if (angular_velocity.norm() > tolerance) {
-        updated_basis.block<3, 3>(3, 3) =
-            Dissipative<CartesianState>::orthonormalize_basis(this->basis_.bottomRightCorner<3, 3>(), angular_velocity);
+        updated_basis.block<3, 3>(3, 3) = Dissipative<CartesianState>::orthonormalize_basis(
+            this->basis_.bottomRightCorner<3, 3>(), angular_velocity);
         updated = true;
       }
       // at least the linear or angular parts have been updated
       if (!updated) {
-        return Eigen::MatrixXd::Identity(this->nb_dimensions_, this->nb_dimensions_);
+        return Eigen::MatrixXd::Identity(this->dimensions_, this->dimensions_);
       }
       break;
     }
     case ComputationalSpaceType::FULL: {
       // only update the damping if the commanded velocity is non null
       if (desired_velocity.get_twist().norm() < tolerance) {
-        return Eigen::MatrixXd::Identity(this->nb_dimensions_, this->nb_dimensions_);
+        return Eigen::MatrixXd::Identity(this->dimensions_, this->dimensions_);
       }
       // return the full damping matrix
       updated_basis = Dissipative<CartesianState>::orthonormalize_basis(this->basis_, desired_velocity.get_twist());
@@ -86,15 +77,15 @@ Eigen::MatrixXd Dissipative<CartesianState>::compute_orthonormal_basis(const Car
 
 template<>
 Eigen::MatrixXd Dissipative<JointState>::compute_orthonormal_basis(const JointState& desired_velocity) {
-  if (desired_velocity.get_size() != this->nb_dimensions_) {
+  if (desired_velocity.get_size() != this->dimensions_) {
     throw state_representation::exceptions::IncompatibleSizeException(
-        "The input state is of incorrect dimensions, expected "
-            + std::to_string(this->nb_dimensions_) + " got " + std::to_string(desired_velocity.get_size()));
+        "The input state is of incorrect dimensions, expected " + std::to_string(this->dimensions_) + " got "
+            + std::to_string(desired_velocity.get_size()));
   }
   double tolerance = 1e-4;
-  // only update the damping if the commanded velocity is non null
+  // only update the damping if the commanded velocity is non-null
   if (desired_velocity.get_velocities().norm() < tolerance) {
-    return Eigen::MatrixXd::Identity(this->nb_dimensions_, this->nb_dimensions_);
+    return Eigen::MatrixXd::Identity(this->dimensions_, this->dimensions_);
   }
   // return the full damping matrix
   return Dissipative<JointState>::orthonormalize_basis(this->basis_, desired_velocity.get_velocities());
diff --git a/source/controllers/src/impedance/Impedance.cpp b/source/controllers/src/impedance/Impedance.cpp
index 81b1c8da0..db494bd50 100644
--- a/source/controllers/src/impedance/Impedance.cpp
+++ b/source/controllers/src/impedance/Impedance.cpp
@@ -1,82 +1,55 @@
 #include "controllers/impedance/Impedance.hpp"
-#include "state_representation/robot/JointState.hpp"
-#include "state_representation/robot/JointTorques.hpp"
+
+#include "controllers/exceptions/NotImplementedException.hpp"
+#include "state_representation/space/joint/JointState.hpp"
 #include "state_representation/space/cartesian/CartesianState.hpp"
-#include "state_representation/space/cartesian/CartesianWrench.hpp"
 
 using namespace state_representation;
 
 namespace controllers::impedance {
-template<class S>
-Impedance<S>::Impedance(const Eigen::MatrixXd& stiffness,
-                        const Eigen::MatrixXd& damping,
-                        const Eigen::MatrixXd& inertia)
-    : stiffness_(std::make_shared<Parameter<Eigen::MatrixXd>>("stiffness", stiffness)),
-      damping_(std::make_shared<Parameter<Eigen::MatrixXd>>("damping", damping)),
-      inertia_(std::make_shared<Parameter<Eigen::MatrixXd>>("inertia", inertia)) {}
-
-template Impedance<CartesianState>::Impedance(const Eigen::MatrixXd&,
-                                              const Eigen::MatrixXd&,
-                                              const Eigen::MatrixXd&);
-template Impedance<JointState>::Impedance(const Eigen::MatrixXd&,
-                                          const Eigen::MatrixXd&,
-                                          const Eigen::MatrixXd&);
 
 template<class S>
 S Impedance<S>::compute_command(const S&, const S&) {
-  throw exceptions::NotImplementedException(
-      "compute_command(desired_state, feedback_state) not implemented for this input class");
+  throw exceptions::NotImplementedException("compute_command is not implemented for this state variable");
 }
 
 template<>
-CartesianState Impedance<CartesianState>::compute_command(const CartesianState& desired_state,
-                                                          const CartesianState& feedback_state) {
-  CartesianState state_error = desired_state - feedback_state;
+CartesianState Impedance<CartesianState>::compute_command(
+    const CartesianState& command_state, const CartesianState& feedback_state
+) {
+  CartesianState state_error = command_state - feedback_state;
   // compute the wrench using the formula W = I * acc_desired + K * e_pose + D * e_twist + e_wrench
-  CartesianWrench command(feedback_state.get_name(), feedback_state.get_reference_frame());
+  CartesianState command(feedback_state.get_name(), feedback_state.get_reference_frame());
   // compute force
-  Eigen::Vector3d position_control = this->get_stiffness().topLeftCorner<3,3>() * state_error.get_position()
-      + this->get_damping().topLeftCorner<3,3>() * state_error.get_linear_velocity()
-      + this->get_inertia().topLeftCorner<3,3>() * desired_state.get_linear_acceleration();
+  Eigen::Vector3d position_control = this->stiffness_->get_value().topLeftCorner<3, 3>() * state_error.get_position()
+      + this->damping_->get_value().topLeftCorner<3, 3>() * state_error.get_linear_velocity()
+      + this->inertia_->get_value().topLeftCorner<3, 3>() * command_state.get_linear_acceleration();
   Eigen::Vector3d commanded_force = position_control + state_error.get_force();
   command.set_force(commanded_force);
   // compute torque (orientation requires special care)
-  Eigen::Vector3d orientation_control = this->get_stiffness().bottomRightCorner<3,3>() * state_error.get_orientation().vec()
-      + this->get_damping().bottomRightCorner<3,3>() * state_error.get_angular_velocity()
-      + this->get_inertia().bottomRightCorner<3,3>() * desired_state.get_angular_acceleration();
+  Eigen::Vector3d orientation_control =
+      this->stiffness_->get_value().bottomRightCorner<3, 3>() * state_error.get_orientation().vec()
+          + this->damping_->get_value().bottomRightCorner<3, 3>() * state_error.get_angular_velocity()
+          + this->inertia_->get_value().bottomRightCorner<3, 3>() * command_state.get_angular_acceleration();
   Eigen::Vector3d commanded_torque = orientation_control + state_error.get_torque();
   command.set_torque(commanded_torque);
   return command;
 }
 
 template<>
-JointState Impedance<JointState>::compute_command(const JointState& desired_state,
-                                                  const JointState& feedback_state) {
-  JointState state_error = desired_state - feedback_state;
+JointState Impedance<JointState>::compute_command(
+    const JointState& command_state, const JointState& feedback_state
+) {
+  JointState state_error = command_state - feedback_state;
   // compute the wrench using the formula T = I * acc_desired + K * e_pos + D * e_vel + e_tor
-  JointTorques command(feedback_state.get_name(), feedback_state.get_names());
+  JointState command(feedback_state.get_name(), feedback_state.get_names());
   // compute torques
-  Eigen::VectorXd state_control = this->get_stiffness() * state_error.get_positions()
-      + this->get_damping() * state_error.get_velocities()
-      + this->get_inertia() * desired_state.get_accelerations();
+  Eigen::VectorXd state_control = this->stiffness_->get_value() * state_error.get_positions()
+      + this->damping_->get_value() * state_error.get_velocities()
+      + this->inertia_->get_value() * command_state.get_accelerations();
   Eigen::VectorXd commanded_torques = state_control + state_error.get_torques();
   command.set_torques(commanded_torques);
   return command;
 }
 
-template<class S>
-JointState Impedance<S>::compute_command(const S&,
-                                         const S&,
-                                         const state_representation::Jacobian&) {
-  throw exceptions::NotImplementedException(
-      "compute_command(desired_state, feedback_state) not implemented for this input class");
-}
-
-template<>
-state_representation::JointState Impedance<CartesianState>::compute_command(const CartesianState& desired_state,
-                                                                            const CartesianState& feedback_state,
-                                                                            const Jacobian& jacobian) {
-  CartesianWrench command = compute_command(desired_state, feedback_state);
-  return jacobian.transpose() * command;
-}
 }// namespace controllers
\ No newline at end of file
diff --git a/source/controllers/src/impedance/VelocityImpedance.cpp b/source/controllers/src/impedance/VelocityImpedance.cpp
index add44689c..e097ccddd 100644
--- a/source/controllers/src/impedance/VelocityImpedance.cpp
+++ b/source/controllers/src/impedance/VelocityImpedance.cpp
@@ -1,7 +1,9 @@
 #include "controllers/impedance/VelocityImpedance.hpp"
-#include "state_representation/robot/JointState.hpp"
-#include "state_representation/robot/JointPositions.hpp"
-#include "state_representation/robot/JointVelocities.hpp"
+
+#include "controllers/exceptions/NotImplementedException.hpp"
+#include "state_representation/space/joint/JointState.hpp"
+#include "state_representation/space/joint/JointPositions.hpp"
+#include "state_representation/space/joint/JointVelocities.hpp"
 #include "state_representation/space/cartesian/CartesianState.hpp"
 #include "state_representation/space/cartesian/CartesianPose.hpp"
 #include "state_representation/space/cartesian/CartesianTwist.hpp"
@@ -9,15 +11,6 @@
 using namespace state_representation;
 
 namespace controllers::impedance {
-template<class S>
-VelocityImpedance<S>::VelocityImpedance(const Eigen::MatrixXd& stiffness,
-                                        const Eigen::MatrixXd& damping) :
-    Impedance<S>(stiffness, damping, Eigen::MatrixXd::Zero(stiffness.rows(), stiffness.cols())) {}
-
-template VelocityImpedance<CartesianState>::VelocityImpedance(const Eigen::MatrixXd&,
-                                                              const Eigen::MatrixXd&);
-template VelocityImpedance<JointState>::VelocityImpedance(const Eigen::MatrixXd&,
-                                                          const Eigen::MatrixXd&);
 
 template<class S>
 S VelocityImpedance<S>::compute_command(const S&, const S&) {
@@ -26,8 +19,9 @@ S VelocityImpedance<S>::compute_command(const S&, const S&) {
 }
 
 template<>
-CartesianState VelocityImpedance<CartesianState>::compute_command(const CartesianState& desired_state,
-                                                                  const CartesianState& feedback_state) {
+CartesianState VelocityImpedance<CartesianState>::compute_command(
+    const CartesianState& desired_state, const CartesianState& feedback_state
+) {
   using namespace std::chrono_literals;
   // compute the displacement by multiplying the desired twist by the unit time period and add it to the current pose
   CartesianPose desired_pose = 1s * static_cast<CartesianTwist>(desired_state);
@@ -41,9 +35,10 @@ CartesianState VelocityImpedance<CartesianState>::compute_command(const Cartesia
 }
 
 template<>
-JointState VelocityImpedance<JointState>::compute_command(const JointState& desired_state,
-                                                          const JointState& feedback_state) {
-  
+JointState VelocityImpedance<JointState>::compute_command(
+    const JointState& desired_state, const JointState& feedback_state
+) {
+
   using namespace std::chrono_literals;
   // compute the displacement by multiplying the desired velocities by the unit time period and add it to the current positions
   JointPositions desired_positions = 1s * static_cast<JointVelocities>(desired_state);
diff --git a/source/controllers/test/fixtures/panda_arm.urdf b/source/controllers/test/fixtures/panda_arm.urdf
new file mode 100644
index 000000000..cc92817ca
--- /dev/null
+++ b/source/controllers/test/fixtures/panda_arm.urdf
@@ -0,0 +1,134 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- =================================================================================== -->
+<!-- |    This document was autogenerated by xacro from franka_panda_description/robots/panda_arm.urdf.xacro | -->
+<!-- |    EDITING THIS FILE BY HAND IS NOT RECOMMENDED                                 | -->
+<!-- =================================================================================== -->
+<robot name="panda">
+  <link name="panda_link0">
+  </link>
+  <link name="panda_link1">
+    <inertial>
+      <origin rpy="0 0 0" xyz="3.875e-03 2.081e-03 -0.1750"/>
+      <mass value="4.970684"/>
+      <inertia ixx="7.0337e-01" ixy="-1.3900e-04" ixz="6.7720e-03" iyy="7.0661e-01" iyz="1.9169e-02" izz="9.1170e-03"/>
+    </inertial>
+  </link>
+  <joint name="panda_joint1" type="revolute">
+    <safety_controller k_position="100.0" k_velocity="40.0" soft_lower_limit="-2.8973" soft_upper_limit="2.8973"/>
+    <origin rpy="0 0 0" xyz="0 0 0.333"/>
+    <parent link="panda_link0"/>
+    <child link="panda_link1"/>
+    <axis xyz="0 0 1"/>
+    <limit effort="87" lower="-2.8973" upper="2.8973" velocity="2.1750"/>
+    <dynamics damping="10.0" friction="5.0"/>
+  </joint>
+  <link name="panda_link2">
+    <inertial>
+      <origin rpy="0 0 0" xyz="-3.141e-03 -2.872e-02 3.495e-03"/>
+      <mass value="0.646926"/>
+      <inertia ixx="7.9620e-03" ixy="-3.9250e-03" ixz="1.0254e-02" iyy="2.8110e-02" iyz="7.0400e-04" izz="2.5995e-02"/>
+    </inertial>
+  </link>
+  <joint name="panda_joint2" type="revolute">
+    <safety_controller k_position="100.0" k_velocity="40.0" soft_lower_limit="-1.7628" soft_upper_limit="1.7628"/>
+    <origin rpy="-1.57079632679 0 0" xyz="0 0 0"/>
+    <parent link="panda_link1"/>
+    <child link="panda_link2"/>
+    <axis xyz="0 0 1"/>
+    <limit effort="87" lower="-1.7628" upper="1.7628" velocity="2.1750"/>
+    <dynamics damping="5.0" friction="2.0"/>
+  </joint>
+  <link name="panda_link3">
+    <inertial>
+      <origin rpy="0 0 0" xyz="2.7518e-02 3.9252e-02 -6.6502e-02"/>
+      <mass value="3.228604"/>
+      <inertia ixx="3.7242e-02" ixy="-4.7610e-03" ixz="-1.1396e-02" iyy="3.6155e-02" iyz="-1.2805e-02" izz="1.0830e-02"/>
+    </inertial>
+  </link>
+  <joint name="panda_joint3" type="revolute">
+    <safety_controller k_position="100.0" k_velocity="40.0" soft_lower_limit="-2.8973" soft_upper_limit="2.8973"/>
+    <origin rpy="1.57079632679 0 0" xyz="0 -0.316 0"/>
+    <parent link="panda_link2"/>
+    <child link="panda_link3"/>
+    <axis xyz="0 0 1"/>
+    <limit effort="87" lower="-2.8973" upper="2.8973" velocity="2.1750"/>
+    <dynamics damping="5.0" friction="2.0"/>
+  </joint>
+  <link name="panda_link4">
+    <inertial>
+      <origin rpy="0 0 0" xyz="-5.317e-02 1.04419e-01 2.7454e-02"/>
+      <mass value="3.587895"/>
+      <inertia ixx="2.5853e-02" ixy="7.7960e-03" ixz="-1.3320e-03" iyy="1.9552e-02" iyz="8.6410e-03" izz="2.8323e-02"/>
+    </inertial>
+  </link>
+  <joint name="panda_joint4" type="revolute">
+    <safety_controller k_position="100.0" k_velocity="40.0" soft_lower_limit="-3.0718" soft_upper_limit="-0.0698"/>
+    <origin rpy="1.57079632679 0 0" xyz="0.0825 0 0"/>
+    <parent link="panda_link3"/>
+    <child link="panda_link4"/>
+    <axis xyz="0 0 1"/>
+    <limit effort="87" lower="-3.0718" upper="-0.0698" velocity="2.1750"/>
+    <dynamics damping="1.0" friction="0.5"/>
+  </joint>
+  <link name="panda_link5">
+    <inertial>
+      <origin rpy="0 0 0" xyz="-1.1953e-02 4.1065e-02 -3.8437e-02"/>
+      <mass value="1.225946"/>
+      <inertia ixx="3.5549e-02" ixy="-2.1170e-03" ixz="-4.0370e-03" iyy="2.9474e-02" iyz="2.2900e-04" izz="8.6270e-03"/>
+    </inertial>
+  </link>
+  <joint name="panda_joint5" type="revolute">
+    <safety_controller k_position="100.0" k_velocity="40.0" soft_lower_limit="-2.8973" soft_upper_limit="2.8973"/>
+    <origin rpy="-1.57079632679 0 0" xyz="-0.0825 0.384 0"/>
+    <parent link="panda_link4"/>
+    <child link="panda_link5"/>
+    <axis xyz="0 0 1"/>
+    <limit effort="12" lower="-2.8973" upper="2.8973" velocity="2.6100"/>
+    <dynamics damping="2.0" friction="1.0"/>
+  </joint>
+  <link name="panda_link6">
+    <inertial>
+      <origin rpy="0 0 0" xyz="6.0149e-02 -1.4117e-02 -1.0517e-02"/>
+      <mass value="1.666555"/>
+      <inertia ixx="1.9640e-03" ixy="1.0900e-04" ixz="-1.1580e-03" iyy="4.3540e-03" iyz="3.4100e-04" izz="5.4330e-03"/>
+    </inertial>
+  </link>
+  <joint name="panda_joint6" type="revolute">
+    <safety_controller k_position="100.0" k_velocity="40.0" soft_lower_limit="-0.0175" soft_upper_limit="3.7525"/>
+    <origin rpy="1.57079632679 0 0" xyz="0 0 0"/>
+    <parent link="panda_link5"/>
+    <child link="panda_link6"/>
+    <axis xyz="0 0 1"/>
+    <limit effort="12" lower="-0.0175" upper="3.7525" velocity="2.6100"/>
+    <dynamics damping="1.0" friction="0.5"/>
+  </joint>
+  <link name="panda_link7">
+    <inertial>
+      <origin rpy="0 0 0" xyz="1.0517e-02 -4.252e-03 6.1597e-02"/>
+      <mass value="7.35522e-01"/>
+      <inertia ixx="1.2516e-02" ixy="-4.2800e-04" ixz="-1.1960e-03" iyy="1.0027e-02" iyz="-7.4100e-04" izz="4.8150e-03"/>
+    </inertial>
+  </link>
+  <joint name="panda_joint7" type="revolute">
+    <safety_controller k_position="100.0" k_velocity="40.0" soft_lower_limit="-2.8973" soft_upper_limit="2.8973"/>
+    <origin rpy="1.57079632679 0 0" xyz="0.088 0 0"/>
+    <parent link="panda_link6"/>
+    <child link="panda_link7"/>
+    <axis xyz="0 0 1"/>
+    <limit effort="12" lower="-2.8973" upper="2.8973" velocity="2.6100"/>
+    <dynamics damping="1.0" friction="0.5"/>
+  </joint>
+  <link name="panda_link8">
+    <inertial>
+      <origin rpy="0 0 0" xyz="0 0 0"/>
+      <mass value="0.0"/>
+      <inertia ixx="0.001" ixy="0.0" ixz="0.0" iyy="0.001" iyz="0.0" izz="0.001"/>
+    </inertial>
+  </link>
+  <joint name="panda_joint8" type="fixed">
+    <origin rpy="0 0 0" xyz="0 0 0.107"/>
+    <parent link="panda_link7"/>
+    <child link="panda_link8"/>
+    <axis xyz="0 0 0"/>
+  </joint>
+</robot>
diff --git a/source/controllers/test/tests/test_cartesian_twist_controller.cpp b/source/controllers/test/tests/test_cartesian_twist_controller.cpp
deleted file mode 100644
index 3a67784b2..000000000
--- a/source/controllers/test/tests/test_cartesian_twist_controller.cpp
+++ /dev/null
@@ -1,108 +0,0 @@
-#include <gtest/gtest.h>
-
-#include "controllers/impedance/CartesianTwistController.hpp"
-#include "state_representation/space/cartesian/CartesianWrench.hpp"
-#include "state_representation/space/cartesian/CartesianTwist.hpp"
-#include "state_representation/robot/JointTorques.hpp"
-
-using namespace controllers::impedance;
-using namespace state_representation;
-
-TEST(CartesianTwistControllerTest, Constructors) {
-  CartesianTwistController a(1, 2, 3, 4);
-  CartesianTwistController b(Eigen::Vector4d(11, 22, 33, 44));
-
-  EXPECT_NE(a.get_gains().norm(), b.get_gains().norm());
-
-  // copy constructor
-  CartesianTwistController c(a);
-  EXPECT_DOUBLE_EQ(a.get_gains().norm(), c.get_gains().norm());
-
-  // check that the copy was performed deeply and correctly (no shared references)
-  c.set_gains(Eigen::Vector4d(111, 222, 333, 444));
-  EXPECT_NE(a.get_gains().norm(), c.get_gains().norm());
-
-  // check copy by assignment
-  c = b;
-  EXPECT_DOUBLE_EQ(b.get_gains().norm(), c.get_gains().norm());
-
-  // check that the copy was performed deeply and correctly (no shared references)
-  c.set_gains(Eigen::Vector4d(111, 222, 333, 444));
-  EXPECT_NE(b.get_gains().norm(), c.get_gains().norm());
-}
-
-TEST(CartesianTwistControllerTest, CartesianWrench) {
-  CartesianTwistController controller(100, 100, 5, 5);
-
-  auto desired_twist = CartesianTwist::Identity("test");
-  auto feedback_twist = CartesianTwist::Identity("test");
-
-  // check command when desired state == feedback state
-  CartesianWrench command = controller.compute_command(desired_twist, feedback_twist);
-  EXPECT_NEAR(command.data().norm(), 0.0, 1e-5);
-
-  // check command when there is linear velocity error
-  desired_twist.set_linear_velocity(Eigen::Vector3d::Random());
-  command = controller.compute_command(desired_twist, feedback_twist);
-  EXPECT_GT(command.get_force().norm(), 0.0);
-  EXPECT_NEAR(command.get_torque().norm(), 0.0, 1e-5);
-
-  // check command when there is angular velocity error
-  desired_twist.set_linear_velocity(Eigen::Vector3d::Zero());
-  desired_twist.set_angular_velocity(Eigen::Vector3d::Random());
-  command = controller.compute_command(desired_twist, feedback_twist);
-  // expect some non-null data for force
-  EXPECT_NEAR(command.get_force().norm(), 0.0, 1e-5);
-  EXPECT_GT(command.get_torque().norm(), 0.0);
-}
-
-TEST(CartesianTwistControllerTest, JointTorques) {
-  CartesianTwistController controller(100, 100, 5, 5);
-
-  auto desired_twist = CartesianTwist::Random("test");
-  auto feedback_twist = CartesianTwist::Identity("test");
-  auto jacobian = Jacobian::Random("test_robot", 3, "test");
-
-  JointTorques command = controller.compute_command(desired_twist, feedback_twist, jacobian);
-  // expect some non-null data
-  EXPECT_GT(command.data().norm(), 0.0);
-}
-
-TEST(CartesianTwistControllerTest, ParametersAndSetters) {
-  CartesianTwistController controller(1, 2, 3, 4);
-
-  auto params = controller.get_parameters();
-  EXPECT_EQ(params.size(), 4);
-  for (auto& param_interface : params) {
-    auto param = std::dynamic_pointer_cast<Parameter<double>>(param_interface);
-    if (param->get_name() == "linear_principle_damping") {
-      EXPECT_NEAR(param->get_value(), 1, 1e-5);
-      EXPECT_NEAR(controller.get_gains()(0), 1, 1e-5);
-      param->set_value(11);
-      EXPECT_NEAR(controller.get_gains()(0), 11, 1e-5);
-      controller.set_linear_principle_damping(21);
-      EXPECT_NEAR(param->get_value(), 21, 1e-5);
-    } else if (param->get_name() == "linear_orthogonal_damping") {
-      EXPECT_NEAR(param->get_value(), 2, 1e-5);
-      EXPECT_NEAR(controller.get_gains()(1), 2, 1e-5);
-      param->set_value(12);
-      EXPECT_NEAR(controller.get_gains()(1), 12, 1e-5);
-      controller.set_linear_orthogonal_damping(22);
-      EXPECT_NEAR(param->get_value(), 22, 1e-5);
-    } else if (param->get_name() == "angular_stiffness") {
-      EXPECT_NEAR(param->get_value(), 3, 1e-5);
-      EXPECT_NEAR(controller.get_gains()(2), 3, 1e-5);
-      param->set_value(13);
-      EXPECT_NEAR(controller.get_gains()(2), 13, 1e-5);
-      controller.set_angular_stiffness(23);
-      EXPECT_NEAR(param->get_value(), 23, 1e-5);
-    } else if (param->get_name() == "angular_damping") {
-      EXPECT_NEAR(param->get_value(), 4, 1e-5);
-      EXPECT_NEAR(controller.get_gains()(3), 4, 1e-5);
-      param->set_value(14);
-      EXPECT_NEAR(controller.get_gains()(3), 14, 1e-5);
-      controller.set_angular_damping(24);
-      EXPECT_NEAR(param->get_value(), 24, 1e-5);
-    }
-  }
-}
\ No newline at end of file
diff --git a/source/controllers/test/tests/test_compliant_twist_controller.cpp b/source/controllers/test/tests/test_compliant_twist_controller.cpp
new file mode 100644
index 000000000..9f8bb061b
--- /dev/null
+++ b/source/controllers/test/tests/test_compliant_twist_controller.cpp
@@ -0,0 +1,89 @@
+#include <gtest/gtest.h>
+
+#include "controllers/ControllerFactory.hpp"
+#include "state_representation/space/cartesian/CartesianWrench.hpp"
+#include "state_representation/space/cartesian/CartesianTwist.hpp"
+#include "state_representation/space/joint/JointTorques.hpp"
+
+using namespace controllers;
+using namespace state_representation;
+
+class CompliantTwistControllerTest : public ::testing::Test {
+protected:
+  CompliantTwistControllerTest() :
+      command_twist_(CartesianTwist::Identity("test")), feedback_twist_(CartesianTwist::Identity("test")) {
+    controller_ = controllers::CartesianControllerFactory::create_controller(CONTROLLER_TYPE::COMPLIANT_TWIST);
+  }
+
+  void set_gains(double lpd, double lod, double as, double ad) {
+    controller_->set_parameter_value("linear_principle_damping", lpd);
+    controller_->set_parameter_value("linear_orthogonal_damping", lod);
+    controller_->set_parameter_value("angular_stiffness", as);
+    controller_->set_parameter_value("angular_damping", ad);
+  }
+
+  std::shared_ptr<IController<CartesianState>> controller_;
+
+  CartesianTwist command_twist_;
+  CartesianTwist feedback_twist_;
+};
+
+TEST_F(CompliantTwistControllerTest, CartesianWrench) {
+  this->set_gains(100, 100, 5, 5);
+
+  // check command when desired state == feedback state
+  CartesianWrench command = controller_->compute_command(command_twist_, feedback_twist_);
+  EXPECT_NEAR(command.data().norm(), 0.0, 1e-5);
+
+  // check command when there is linear velocity error
+  command_twist_.set_linear_velocity(Eigen::Vector3d::Random());
+  command = controller_->compute_command(command_twist_, feedback_twist_);
+  EXPECT_GT(command.get_force().norm(), 0.0);
+  EXPECT_NEAR(command.get_torque().norm(), 0.0, 1e-5);
+
+  // check command when there is angular velocity error
+  command_twist_.set_linear_velocity(Eigen::Vector3d::Zero());
+  command_twist_.set_angular_velocity(Eigen::Vector3d::Random());
+  // expect some non-null data for force
+  command = controller_->compute_command(command_twist_, feedback_twist_);
+  EXPECT_NEAR(command.get_force().norm(), 0.0, 1e-5);
+  EXPECT_GT(command.get_torque().norm(), 0.0);
+}
+
+TEST_F(CompliantTwistControllerTest, GetAndSetParameters) {
+  this->set_gains(1, 2, 3, 4);
+  auto parameter_map = controller_->get_parameters();
+  EXPECT_EQ(parameter_map.size(), 4);
+  for (auto& param_pair : parameter_map) {
+    auto param = std::dynamic_pointer_cast<Parameter<double>>(param_pair.second);
+    if (param->get_name() == "linear_principle_damping") {
+      EXPECT_NEAR(param->get_value(), 1, 1e-5);
+      EXPECT_NEAR(controller_->get_parameter_value<double>("linear_principle_damping"), 1, 1e-5);
+      param->set_value(11);
+      EXPECT_NEAR(controller_->get_parameter_value<double>("linear_principle_damping"), 11, 1e-5);
+      controller_->set_parameter_value<double>("linear_principle_damping", 21);
+      EXPECT_NEAR(param->get_value(), 21, 1e-5);
+    } else if (param->get_name() == "linear_orthogonal_damping") {
+      EXPECT_NEAR(param->get_value(), 2, 1e-5);
+      EXPECT_NEAR(controller_->get_parameter_value<double>("linear_orthogonal_damping"), 2, 1e-5);
+      param->set_value(12);
+      EXPECT_NEAR(controller_->get_parameter_value<double>("linear_orthogonal_damping"), 12, 1e-5);
+      controller_->set_parameter_value<double>("linear_orthogonal_damping", 22);
+      EXPECT_NEAR(param->get_value(), 22, 1e-5);
+    } else if (param->get_name() == "angular_stiffness") {
+      EXPECT_NEAR(param->get_value(), 3, 1e-5);
+      EXPECT_NEAR(controller_->get_parameter_value<double>("angular_stiffness"), 3, 1e-5);
+      param->set_value(13);
+      EXPECT_NEAR(controller_->get_parameter_value<double>("angular_stiffness"), 13, 1e-5);
+      controller_->set_parameter_value<double>("angular_stiffness", 23);
+      EXPECT_NEAR(param->get_value(), 23, 1e-5);
+    } else if (param->get_name() == "angular_damping") {
+      EXPECT_NEAR(param->get_value(), 4, 1e-5);
+      EXPECT_NEAR(controller_->get_parameter_value<double>("angular_damping"), 4, 1e-5);
+      param->set_value(14);
+      EXPECT_NEAR(controller_->get_parameter_value<double>("angular_damping"), 14, 1e-5);
+      controller_->set_parameter_value<double>("angular_damping", 24);
+      EXPECT_NEAR(param->get_value(), 24, 1e-5);
+    }
+  }
+}
\ No newline at end of file
diff --git a/source/controllers/test/tests/test_controller_factory.cpp b/source/controllers/test/tests/test_controller_factory.cpp
new file mode 100644
index 000000000..7cdcce846
--- /dev/null
+++ b/source/controllers/test/tests/test_controller_factory.cpp
@@ -0,0 +1,208 @@
+#include <gtest/gtest.h>
+
+#include "controllers/ControllerFactory.hpp"
+#include "controllers/exceptions/InvalidControllerException.hpp"
+#include "controllers/exceptions/NoRobotModelException.hpp"
+#include "state_representation/parameters/Parameter.hpp"
+
+using namespace state_representation;
+using namespace controllers;
+
+TEST(ControllerFactoryTest, CreateCartesianController) {
+  std::shared_ptr<IController<CartesianState>> ctrl;
+  EXPECT_EQ(ctrl, nullptr);
+
+  auto command_state = CartesianState::Identity("command");
+  auto feedback_state = CartesianState::Identity("feedback");
+
+  ctrl = CartesianControllerFactory::create_controller(CONTROLLER_TYPE::NONE);
+  EXPECT_EQ(ctrl, nullptr);
+
+  ctrl = CartesianControllerFactory::create_controller(CONTROLLER_TYPE::IMPEDANCE);
+  ASSERT_NE(ctrl, nullptr);
+  {
+    auto parameters = ctrl->get_parameters();
+    EXPECT_EQ(parameters.count("damping"), 1);
+    EXPECT_EQ(parameters.count("stiffness"), 1);
+    EXPECT_EQ(parameters.count("inertia"), 1);
+  }
+  EXPECT_EQ(ctrl->get_parameter_value<Eigen::MatrixXd>("damping").size(), 6 * 6);
+  EXPECT_EQ(ctrl->get_parameter_value<Eigen::MatrixXd>("stiffness").size(), 6 * 6);
+  EXPECT_EQ(ctrl->get_parameter_value<Eigen::MatrixXd>("inertia").size(), 6 * 6);
+  EXPECT_NO_THROW(ctrl->compute_command(command_state, feedback_state));
+
+  ctrl = CartesianControllerFactory::create_controller(CONTROLLER_TYPE::VELOCITY_IMPEDANCE);
+  ASSERT_NE(ctrl, nullptr);
+  {
+    auto parameters = ctrl->get_parameters();
+    EXPECT_EQ(parameters.count("damping"), 1);
+    EXPECT_EQ(parameters.count("stiffness"), 1);
+  }
+  EXPECT_EQ(ctrl->get_parameter_value<Eigen::MatrixXd>("damping").size(), 6 * 6);
+  EXPECT_EQ(ctrl->get_parameter_value<Eigen::MatrixXd>("stiffness").size(), 6 * 6);
+  EXPECT_NO_THROW(ctrl->compute_command(command_state, feedback_state));
+
+  ctrl = CartesianControllerFactory::create_controller(CONTROLLER_TYPE::DISSIPATIVE);
+  ASSERT_NE(ctrl, nullptr);
+  {
+    auto parameters = ctrl->get_parameters();
+    EXPECT_EQ(parameters.count("damping"), 1);
+  }
+  EXPECT_EQ(ctrl->get_parameter_value<Eigen::MatrixXd>("damping").size(), 6 * 6);
+  EXPECT_NO_THROW(ctrl->compute_command(command_state, feedback_state));
+
+  ctrl = CartesianControllerFactory::create_controller(CONTROLLER_TYPE::DISSIPATIVE_LINEAR);
+  ASSERT_NE(ctrl, nullptr);
+  {
+    auto parameters = ctrl->get_parameters();
+    EXPECT_EQ(parameters.count("damping"), 1);
+  }
+  EXPECT_EQ(ctrl->get_parameter_value<Eigen::MatrixXd>("damping").size(), 6 * 6);
+  EXPECT_NO_THROW(ctrl->compute_command(command_state, feedback_state));
+
+  ctrl = CartesianControllerFactory::create_controller(CONTROLLER_TYPE::DISSIPATIVE_ANGULAR);
+  {
+    auto parameters = ctrl->get_parameters();
+    EXPECT_EQ(parameters.count("damping"), 1);
+  }
+  EXPECT_EQ(ctrl->get_parameter_value<Eigen::MatrixXd>("damping").size(), 6 * 6);
+  EXPECT_NO_THROW(ctrl->compute_command(command_state, feedback_state));
+
+  ctrl = CartesianControllerFactory::create_controller(CONTROLLER_TYPE::DISSIPATIVE_DECOUPLED);
+  ASSERT_NE(ctrl, nullptr);
+  {
+    auto parameters = ctrl->get_parameters();
+    EXPECT_EQ(parameters.count("damping"), 1);
+  }
+  EXPECT_EQ(ctrl->get_parameter_value<Eigen::MatrixXd>("damping").size(), 6 * 6);
+  EXPECT_NO_THROW(ctrl->compute_command(command_state, feedback_state));
+
+  ctrl = CartesianControllerFactory::create_controller(CONTROLLER_TYPE::COMPLIANT_TWIST);
+  ASSERT_NE(ctrl, nullptr);
+  {
+    auto parameters = ctrl->get_parameters();
+    EXPECT_EQ(parameters.count("linear_principle_damping"), 1);
+    EXPECT_EQ(parameters.count("linear_orthogonal_damping"), 1);
+    EXPECT_EQ(parameters.count("angular_stiffness"), 1);
+    EXPECT_EQ(parameters.count("angular_damping"), 1);
+  }
+  EXPECT_NO_THROW(ctrl->compute_command(command_state, feedback_state));
+
+  EXPECT_THROW(ctrl->compute_command(command_state, feedback_state, JointState::Zero("robot", 3)),
+               controllers::exceptions::NoRobotModelException);
+}
+
+TEST(ControllerFactoryTest, CreateJointController) {
+  unsigned int dim = 3;
+  std::shared_ptr<IController<JointState>> ctrl;
+  EXPECT_EQ(ctrl, nullptr);
+
+  auto command_state = JointState::Zero("robot", dim);
+  auto feedback_state = JointState::Zero("robot", dim);
+
+  ctrl = JointControllerFactory::create_controller(CONTROLLER_TYPE::NONE, dim);
+  EXPECT_EQ(ctrl, nullptr);
+
+  ctrl = JointControllerFactory::create_controller(CONTROLLER_TYPE::IMPEDANCE, dim);
+  ASSERT_NE(ctrl, nullptr);
+  {
+    auto parameters = ctrl->get_parameters();
+    EXPECT_EQ(parameters.count("damping"), 1);
+    EXPECT_EQ(parameters.count("stiffness"), 1);
+    EXPECT_EQ(parameters.count("inertia"), 1);
+  }
+  EXPECT_EQ(ctrl->get_parameter_value<Eigen::MatrixXd>("damping").size(), dim * dim);
+  EXPECT_EQ(ctrl->get_parameter_value<Eigen::MatrixXd>("stiffness").size(), dim * dim);
+  EXPECT_EQ(ctrl->get_parameter_value<Eigen::MatrixXd>("inertia").size(), dim * dim);
+  EXPECT_NO_THROW(ctrl->compute_command(command_state, feedback_state));
+
+  ctrl = JointControllerFactory::create_controller(CONTROLLER_TYPE::VELOCITY_IMPEDANCE, dim);
+  ASSERT_NE(ctrl, nullptr);
+  {
+    auto parameters = ctrl->get_parameters();
+    EXPECT_EQ(parameters.count("damping"), 1);
+    EXPECT_EQ(parameters.count("stiffness"), 1);
+  }
+  EXPECT_EQ(ctrl->get_parameter_value<Eigen::MatrixXd>("damping").size(), dim * dim);
+  EXPECT_EQ(ctrl->get_parameter_value<Eigen::MatrixXd>("stiffness").size(), dim * dim);
+  EXPECT_NO_THROW(ctrl->compute_command(command_state, feedback_state));
+
+  ctrl = JointControllerFactory::create_controller(CONTROLLER_TYPE::DISSIPATIVE, dim);
+  ASSERT_NE(ctrl, nullptr);
+  {
+    auto parameters = ctrl->get_parameters();
+    EXPECT_EQ(parameters.count("damping"), 1);
+  }
+  EXPECT_EQ(ctrl->get_parameter_value<Eigen::MatrixXd>("damping").size(), dim * dim);
+  EXPECT_NO_THROW(ctrl->compute_command(command_state, feedback_state));
+
+  EXPECT_THROW(JointControllerFactory::create_controller(CONTROLLER_TYPE::DISSIPATIVE_LINEAR),
+               controllers::exceptions::InvalidControllerException);
+  EXPECT_THROW(JointControllerFactory::create_controller(CONTROLLER_TYPE::DISSIPATIVE_ANGULAR),
+               controllers::exceptions::InvalidControllerException);
+  EXPECT_THROW(JointControllerFactory::create_controller(CONTROLLER_TYPE::DISSIPATIVE_DECOUPLED),
+               controllers::exceptions::InvalidControllerException);
+  EXPECT_THROW(JointControllerFactory::create_controller(CONTROLLER_TYPE::COMPLIANT_TWIST),
+               controllers::exceptions::InvalidControllerException);
+}
+
+TEST(ControllerFactoryTest, CreateControllerWithParams) {
+  std::list<std::shared_ptr<state_representation::ParameterInterface>> parameters;
+  parameters.emplace_back(make_shared_parameter("damping", 0.0));
+  parameters.emplace_back(make_shared_parameter("stiffness", 5.0));
+  parameters.emplace_back(make_shared_parameter("inertia", 10.0));
+
+  auto ctrl = CartesianControllerFactory::create_controller(CONTROLLER_TYPE::IMPEDANCE, parameters);
+  ASSERT_NE(ctrl, nullptr);
+  EXPECT_EQ(ctrl->get_parameter_value<Eigen::MatrixXd>("damping").size(), 6 * 6);
+  EXPECT_EQ(ctrl->get_parameter_value<Eigen::MatrixXd>("stiffness").size(), 6 * 6);
+  EXPECT_EQ(ctrl->get_parameter_value<Eigen::MatrixXd>("inertia").size(), 6 * 6);
+
+  EXPECT_EQ(ctrl->get_parameter_value<Eigen::MatrixXd>("damping").sum(), 0.0 * 6);
+  EXPECT_EQ(ctrl->get_parameter_value<Eigen::MatrixXd>("stiffness").sum(), 5.0 * 6);
+  EXPECT_EQ(ctrl->get_parameter_value<Eigen::MatrixXd>("inertia").sum(), 10.0 * 6);
+}
+
+TEST(ControllerFactoryTest, CreateControllerWithRobot) {
+  std::string robot_name = "robot";
+  std::string urdf_path = std::string(TEST_FIXTURES) + "panda_arm.urdf";
+  auto robot = robot_model::Model(robot_name, urdf_path);
+
+  auto command_state = CartesianState::Identity(robot.get_frames().back(), robot.get_base_frame());
+  auto feedback_state = CartesianState::Identity(robot.get_frames().back(), robot.get_base_frame());
+  auto joint_state = JointState::Zero(robot_name, robot.get_number_of_joints());
+
+  EXPECT_THROW(CartesianControllerFactory::create_controller(CONTROLLER_TYPE::NONE, robot),
+               controllers::exceptions::InvalidControllerException);
+
+  EXPECT_THROW(JointControllerFactory::create_controller(CONTROLLER_TYPE::NONE, robot),
+               controllers::exceptions::InvalidControllerException);
+
+  auto cart_ctrl = CartesianControllerFactory::create_controller(CONTROLLER_TYPE::IMPEDANCE, robot);
+  ASSERT_NE(cart_ctrl, nullptr);
+  EXPECT_NO_THROW(cart_ctrl->compute_command(command_state, feedback_state));
+  EXPECT_NO_THROW(cart_ctrl->compute_command(command_state, feedback_state, joint_state));
+  EXPECT_NO_THROW(cart_ctrl->compute_command(command_state, feedback_state, robot.compute_jacobian(joint_state)));
+
+  auto joint_ctrl = JointControllerFactory::create_controller(CONTROLLER_TYPE::IMPEDANCE, robot);
+  ASSERT_NE(joint_ctrl, nullptr);
+  EXPECT_NO_THROW(joint_ctrl->compute_command(joint_state, joint_state));
+  EXPECT_EQ(joint_ctrl->get_parameter_value<Eigen::MatrixXd>("stiffness").size(),
+            robot.get_number_of_joints() * robot.get_number_of_joints());
+}
+
+TEST(ControllerFactoryTest, CreateControllerWithRobotAndParams) {
+  std::list<std::shared_ptr<state_representation::ParameterInterface>> parameters;
+  parameters.emplace_back(make_shared_parameter("damping", 5.0));
+  auto robot = robot_model::Model("robot", std::string(TEST_FIXTURES) + "panda_arm.urdf");
+
+  EXPECT_THROW(JointControllerFactory::create_controller(CONTROLLER_TYPE::NONE, parameters, robot),
+               controllers::exceptions::InvalidControllerException);
+
+  auto ctrl = JointControllerFactory::create_controller(CONTROLLER_TYPE::IMPEDANCE, parameters, robot);
+  ASSERT_NE(ctrl, nullptr);
+  EXPECT_EQ(ctrl->get_parameter_value<Eigen::MatrixXd>("damping").size(),
+            robot.get_number_of_joints() * robot.get_number_of_joints());
+
+  EXPECT_EQ(ctrl->get_parameter_value<Eigen::MatrixXd>("damping").sum(), 5.0 * robot.get_number_of_joints());
+}
\ No newline at end of file
diff --git a/source/controllers/test/tests/test_dissipative_impedance.cpp b/source/controllers/test/tests/test_dissipative_impedance.cpp
index f0ca97b39..1de503764 100644
--- a/source/controllers/test/tests/test_dissipative_impedance.cpp
+++ b/source/controllers/test/tests/test_dissipative_impedance.cpp
@@ -1,58 +1,55 @@
+#include <gtest/gtest.h>
+
+#include "controllers/ControllerFactory.hpp"
 #include "controllers/impedance/Dissipative.hpp"
+
 #include "state_representation/space/cartesian/CartesianTwist.hpp"
 #include "state_representation/space/cartesian/CartesianWrench.hpp"
-#include "state_representation/robot/JointVelocities.hpp"
-#include "state_representation/robot/JointTorques.hpp"
-#include <numeric>
-#include <gtest/gtest.h>
+#include "state_representation/space/joint/JointVelocities.hpp"
+#include "state_representation/space/joint/JointTorques.hpp"
 
+using namespace controllers;
 using namespace controllers::impedance;
 using namespace state_representation;
 
-class DissipativeImpedanceControllerTest : public testing::Test {
-protected:
-  void SetUp() override {}
+class DissipativeWrapper : public Dissipative<CartesianState> {
+public:
+  DissipativeWrapper(const ComputationalSpaceType& computational_space) :
+      Dissipative<CartesianState>(computational_space) {}
 
-  void set_controller_space(const ComputationalSpaceType& computational_space) {
-    task_controller_ = Dissipative<CartesianState>(computational_space);
+  static Eigen::MatrixXd
+  wrap_orthonormalize_basis(const Eigen::MatrixXd& basis, const Eigen::VectorXd& main_eigenvector) {
+    return Dissipative<CartesianState>::orthonormalize_basis(basis, main_eigenvector);
   }
 
-  Dissipative<CartesianState> task_controller_;
-  Dissipative<JointState> joint_controller_ = Dissipative<JointState>(4);
-  double tolerance_ = 1e-4;
+  Eigen::MatrixXd wrap_compute_orthonormal_basis(const CartesianState& desired_velocity) {
+    return this->compute_orthonormal_basis(desired_velocity);
+  }
+
+  void wrap_compute_damping(const CartesianState& desired_velocity) {
+    return this->compute_damping(desired_velocity);
+  }
 };
 
-TEST_F(DissipativeImpedanceControllerTest, TestCopyConstructorCartesian) {
-  Dissipative<CartesianState> new_control = Dissipative<CartesianState>(ComputationalSpaceType::LINEAR);
-  new_control.set_damping_eigenvalue(50, 2);
-  Dissipative<CartesianState> copy(new_control);
-  double tolerance = 1e-4;
-  for (int i = 0; i < 6; ++i) {
-    EXPECT_NEAR(new_control.get_damping().col(i).norm(), copy.get_damping().col(i).norm(), tolerance);
-    EXPECT_NEAR(new_control.get_stiffness().col(i).norm(), copy.get_stiffness().col(i).norm(), tolerance);
-    EXPECT_NEAR(new_control.get_inertia().col(i).norm(), copy.get_inertia().col(i).norm(), tolerance);
+class DissipativeControllerMethodTest : public testing::Test {
+protected:
+  void SetUp() override {
+    set_controller_space(ComputationalSpaceType::FULL);
   }
-  EXPECT_NEAR(new_control.get_damping_eigenvalues().norm(), copy.get_damping_eigenvalues().norm(), tolerance);
-}
 
-TEST_F(DissipativeImpedanceControllerTest, TestAssignmentOperatorCartesian) {
-  Dissipative<CartesianState> new_control = Dissipative<CartesianState>(ComputationalSpaceType::LINEAR);
-  new_control.set_damping_eigenvalue(50, 2);
-  Dissipative<CartesianState> copy = new_control;
-  double tolerance = 1e-4;
-  for (int i = 0; i < 6; ++i) {
-    EXPECT_NEAR(new_control.get_damping().col(i).norm(), copy.get_damping().col(i).norm(), tolerance);
-    EXPECT_NEAR(new_control.get_stiffness().col(i).norm(), copy.get_stiffness().col(i).norm(), tolerance);
-    EXPECT_NEAR(new_control.get_inertia().col(i).norm(), copy.get_inertia().col(i).norm(), tolerance);
+  void set_controller_space(const ComputationalSpaceType& computational_space) {
+    controller_ = std::make_shared<DissipativeWrapper>(computational_space);
   }
-  EXPECT_NEAR(new_control.get_damping_eigenvalues().norm(), copy.get_damping_eigenvalues().norm(), tolerance);
-}
 
-TEST_F(DissipativeImpedanceControllerTest, TestOrthonormalize) {
+  std::shared_ptr<DissipativeWrapper> controller_;
+  double tolerance_ = 1e-4;
+};
+
+TEST_F(DissipativeControllerMethodTest, TestOrthonormalize) {
   Eigen::Matrix3d basis = Eigen::Matrix3d::Random();
   Eigen::Vector3d eigenvector = Eigen::Vector3d::Random();
   // compute the orthonormal basis
-  Eigen::Matrix3d orthonormal_basis = Dissipative<CartesianState>::orthonormalize_basis(basis, eigenvector);
+  Eigen::Matrix3d orthonormal_basis = controller_->wrap_orthonormalize_basis(basis, eigenvector);
   // first column should the normalized eigenvector
   Eigen::Vector3d err = orthonormal_basis.col(0) - eigenvector.normalized();
   for (int i = 0; i < 3; ++i) { EXPECT_NEAR(err(i), 0., tolerance_); }
@@ -66,13 +63,13 @@ TEST_F(DissipativeImpedanceControllerTest, TestOrthonormalize) {
   EXPECT_NEAR(orthonormal_basis.col(2).norm(), 1., tolerance_);
 }
 
-TEST_F(DissipativeImpedanceControllerTest, TestComputeDampingLinear) {
+TEST_F(DissipativeControllerMethodTest, TestComputeDampingLinear) {
   Eigen::MatrixXd damping;
   CartesianTwist vel = CartesianTwist::Random("test");
   Eigen::Matrix3d block;
   set_controller_space(ComputationalSpaceType::LINEAR);
-  task_controller_.compute_damping(vel);
-  damping = task_controller_.get_damping();
+  controller_->wrap_compute_damping(vel);
+  damping = controller_->get_parameter_value<Eigen::MatrixXd>("damping");
   // linear part is identity
   block = damping.topLeftCorner<3, 3>();
   EXPECT_TRUE(block.isApprox(Eigen::Matrix3d::Identity()));
@@ -86,13 +83,13 @@ TEST_F(DissipativeImpedanceControllerTest, TestComputeDampingLinear) {
   EXPECT_TRUE(block.isApprox(Eigen::Matrix3d::Zero()));
 }
 
-TEST_F(DissipativeImpedanceControllerTest, TestComputeDampingAngular) {
+TEST_F(DissipativeControllerMethodTest, TestComputeDampingAngular) {
   Eigen::MatrixXd damping;
   CartesianTwist vel = CartesianTwist::Random("test");
   Eigen::Matrix3d block;
   set_controller_space(ComputationalSpaceType::ANGULAR);
-  task_controller_.compute_damping(vel);
-  damping = task_controller_.get_damping();
+  controller_->wrap_compute_damping(vel);
+  damping = controller_->get_parameter_value<Eigen::MatrixXd>("damping");
   // linear part is 0
   block = damping.topLeftCorner<3, 3>();
   EXPECT_TRUE(block.isApprox(Eigen::Matrix3d::Zero()));
@@ -106,129 +103,137 @@ TEST_F(DissipativeImpedanceControllerTest, TestComputeDampingAngular) {
   EXPECT_TRUE(block.isApprox(Eigen::Matrix3d::Zero()));
 }
 
-TEST_F(DissipativeImpedanceControllerTest, TestComputeDampingDecoupledTwist) {
+TEST_F(DissipativeControllerMethodTest, TestComputeDampingDecoupledTwist) {
   Eigen::MatrixXd damping;
   CartesianTwist vel = CartesianTwist::Random("test");
   set_controller_space(ComputationalSpaceType::DECOUPLED_TWIST);
-  task_controller_.compute_damping(vel);
-  damping = task_controller_.get_damping();
+  controller_->wrap_compute_damping(vel);
+  damping = controller_->get_parameter_value<Eigen::MatrixXd>("damping");
   EXPECT_TRUE(damping.isApprox(Eigen::MatrixXd::Identity(6, 6)));
 }
 
-TEST_F(DissipativeImpedanceControllerTest, TestComputeDampingFull) {
+TEST_F(DissipativeControllerMethodTest, TestComputeDampingFull) {
   Eigen::MatrixXd damping;
   CartesianTwist vel = CartesianTwist::Random("test");
   set_controller_space(ComputationalSpaceType::FULL);
-  task_controller_.compute_damping(vel);
-  damping = task_controller_.get_damping();
+  controller_->wrap_compute_damping(vel);
+  damping = controller_->get_parameter_value<Eigen::MatrixXd>("damping");
   EXPECT_TRUE(damping.isApprox(Eigen::MatrixXd::Identity(6, 6)));
 }
 
-TEST_F(DissipativeImpedanceControllerTest, TestComputeBasisZeroLinear) {
+TEST_F(DissipativeControllerMethodTest, TestComputeBasisZeroLinear) {
   CartesianTwist vel = CartesianTwist::Zero("test");
   set_controller_space(ComputationalSpaceType::LINEAR);
   // then compute it
-  Eigen::MatrixXd basis = task_controller_.compute_orthonormal_basis(vel);
+  Eigen::MatrixXd basis = controller_->wrap_compute_orthonormal_basis(vel);
   Eigen::Matrix3d linear_block = basis.topLeftCorner<3, 3>();
   Eigen::Matrix3d angular_block = basis.bottomRightCorner<3, 3>();
   EXPECT_TRUE(linear_block.isApprox(Eigen::Matrix3d::Identity()));
   EXPECT_TRUE(angular_block.isApprox(Eigen::Matrix3d::Zero()));
 }
 
-TEST_F(DissipativeImpedanceControllerTest, TestComputeBasisZeroAngular) {
+TEST_F(DissipativeControllerMethodTest, TestComputeBasisZeroAngular) {
   CartesianTwist vel = CartesianTwist::Zero("test");
   set_controller_space(ComputationalSpaceType::ANGULAR);
   // then compute it
-  Eigen::MatrixXd basis = task_controller_.compute_orthonormal_basis(vel);
+  Eigen::MatrixXd basis = controller_->wrap_compute_orthonormal_basis(vel);
   Eigen::Matrix3d linear_block = basis.topLeftCorner<3, 3>();
   Eigen::Matrix3d angular_block = basis.bottomRightCorner<3, 3>();
   EXPECT_TRUE(linear_block.isApprox(Eigen::Matrix3d::Zero()));
   EXPECT_TRUE(angular_block.isApprox(Eigen::Matrix3d::Identity()));
 }
 
-TEST_F(DissipativeImpedanceControllerTest, TestComputeBasisZeroDecoupledTwist) {
+TEST_F(DissipativeControllerMethodTest, TestComputeBasisZeroDecoupledTwist) {
   CartesianTwist vel = CartesianTwist::Zero("test");
   set_controller_space(ComputationalSpaceType::DECOUPLED_TWIST);
   // then compute it
-  Eigen::MatrixXd basis = task_controller_.compute_orthonormal_basis(vel);
+  Eigen::MatrixXd basis = controller_->wrap_compute_orthonormal_basis(vel);
   EXPECT_TRUE(basis.isApprox(Eigen::MatrixXd::Identity(6, 6)));
 }
 
-TEST_F(DissipativeImpedanceControllerTest, TestComputeBasisNonZeroLinearDecoupledTwist) {
+TEST_F(DissipativeControllerMethodTest, TestComputeBasisNonZeroLinearDecoupledTwist) {
   CartesianTwist vel = CartesianTwist::Zero("test");
   vel.set_linear_velocity(Eigen::Vector3d::Random());
   set_controller_space(ComputationalSpaceType::DECOUPLED_TWIST);
   // then compute it
-  Eigen::MatrixXd basis = task_controller_.compute_orthonormal_basis(vel);
+  Eigen::MatrixXd basis = controller_->wrap_compute_orthonormal_basis(vel);
   EXPECT_FALSE(basis.isApprox(Eigen::MatrixXd::Identity(6, 6)));
 }
 
-TEST_F(DissipativeImpedanceControllerTest, TestComputeBasisNonZeroAngularDecoupledTwist) {
+TEST_F(DissipativeControllerMethodTest, TestComputeBasisNonZeroAngularDecoupledTwist) {
   CartesianTwist vel = CartesianTwist::Zero("test");
   vel.set_angular_velocity(Eigen::Vector3d::Random());
   set_controller_space(ComputationalSpaceType::DECOUPLED_TWIST);
   // then compute it
-  Eigen::MatrixXd basis = task_controller_.compute_orthonormal_basis(vel);
+  Eigen::MatrixXd basis = controller_->wrap_compute_orthonormal_basis(vel);
   EXPECT_FALSE(basis.isApprox(Eigen::MatrixXd::Identity(6, 6)));
 }
 
-TEST_F(DissipativeImpedanceControllerTest, TestComputeBasisZeroFull) {
+TEST_F(DissipativeControllerMethodTest, TestComputeBasisZeroFull) {
   CartesianTwist vel = CartesianTwist::Zero("test");
   set_controller_space(ComputationalSpaceType::FULL);
-  Eigen::MatrixXd basis = task_controller_.compute_orthonormal_basis(vel);
+  Eigen::MatrixXd basis = controller_->wrap_compute_orthonormal_basis(vel);
   EXPECT_TRUE(basis.isApprox(Eigen::MatrixXd::Identity(6, 6)));
 }
 
-TEST_F(DissipativeImpedanceControllerTest, TestComputeBasisJointState) {
+/*
+TEST_F(DissipativeControllerMethodTest, TestComputeBasisJointState) {
   JointVelocities vel = JointVelocities::Random("test", 4);
   Eigen::MatrixXd basis = joint_controller_.compute_orthonormal_basis(vel);
   EXPECT_FALSE(basis.isApprox(Eigen::MatrixXd::Identity(4, 4)));
 }
 
-TEST_F(DissipativeImpedanceControllerTest, TestComputeBasisZeroJointState) {
+TEST_F(DissipativeControllerMethodTest, TestComputeBasisZeroJointState) {
   JointVelocities vel = JointVelocities::Zero("test", 4);
   Eigen::MatrixXd basis = joint_controller_.compute_orthonormal_basis(vel);
   EXPECT_TRUE(basis.isApprox(Eigen::MatrixXd::Identity(4, 4)));
 }
+*/
+
+TEST(DissipativeControllerTest, TestComputeCommandWithColinearVelocity) {
+  double tolerance = 1e-4;
+  auto controller = CartesianControllerFactory::create_controller(CONTROLLER_TYPE::DISSIPATIVE_LINEAR);
 
-TEST_F(DissipativeImpedanceControllerTest, TestComputeCommandWithColinearVelocity) {
-  set_controller_space(ComputationalSpaceType::LINEAR);
   // set different damping
-  double e1 = 10;
-  task_controller_.set_damping_eigenvalue(e1, 0);
+  auto eigenvalues = controller->get_parameter_value<Eigen::VectorXd>("damping_eigenvalues");
+  eigenvalues(0) = 10.0;
+  controller->set_parameter_value("damping_eigenvalues", eigenvalues);
+
   // set a desired and feeadback velocity
   CartesianTwist desired_twist("test", Eigen::Vector3d(1, 0, 0));
   CartesianTwist feedback_twist("test", Eigen::Vector3d(1, 1, 0));
   // first compute the command with a 0 feedback
-  CartesianWrench command = task_controller_.compute_command(desired_twist, CartesianTwist::Zero("test"));
-  EXPECT_NEAR(command.get_force()(0), 10, tolerance_);
-  EXPECT_NEAR(command.get_force()(1), 0, tolerance_);
-  EXPECT_NEAR(command.get_force()(2), 0, tolerance_);
+  CartesianWrench command = controller->compute_command(desired_twist, CartesianTwist::Zero("test"));
+  EXPECT_NEAR(command.get_force()(0), 10, tolerance);
+  EXPECT_NEAR(command.get_force()(1), 0, tolerance);
+  EXPECT_NEAR(command.get_force()(2), 0, tolerance);
   // then compute it with respect to the feedback
-  command = task_controller_.compute_command(desired_twist, feedback_twist);
-  EXPECT_NEAR(command.get_force()(0), 0, tolerance_);
-  EXPECT_NEAR(command.get_force()(1), -1, tolerance_);
-  EXPECT_NEAR(command.get_force()(2), 0, tolerance_);
+  command = controller->compute_command(desired_twist, feedback_twist);
+  EXPECT_NEAR(command.get_force()(0), 0, tolerance);
+  EXPECT_NEAR(command.get_force()(1), -1, tolerance);
+  EXPECT_NEAR(command.get_force()(2), 0, tolerance);
 }
 
-TEST_F(DissipativeImpedanceControllerTest, TestComputeTaskToJointCommand) {
+TEST(DissipativeControllerTest, TestComputeJointCommand) {
+  auto controller = JointControllerFactory::create_controller(CONTROLLER_TYPE::DISSIPATIVE, 4);
   // set a desired and feeadback velocity
-  CartesianTwist desired_twist("test", Eigen::Vector3d(1, 0, 0));
-  CartesianTwist feedback_twist("test", Eigen::Vector3d(1, 1, 0));
-  // set a Jacobian matrix
-  Jacobian jac = Jacobian::Random("test_robot", 3, "test");
+  JointVelocities desired_velocities("test", Eigen::Vector4d(1, 0, 0, 0));
+  JointVelocities feedback_velocities("test", Eigen::Vector4d(1, 1, 0, 0));
   // check command
-  JointTorques command = task_controller_.compute_command(desired_twist, feedback_twist, jac);
+  JointTorques command = controller->compute_command(desired_velocities, feedback_velocities);
   // expect some non null data
   EXPECT_TRUE(command.data().norm() > 0.);
 }
 
-TEST_F(DissipativeImpedanceControllerTest, TestComputeJointCommand) {
+TEST(DissipativeControllerTest, TestComputeTaskToJointCommand) {
+  auto controller = CartesianControllerFactory::create_controller(CONTROLLER_TYPE::DISSIPATIVE);
   // set a desired and feeadback velocity
-  JointVelocities desired_velocities("test", Eigen::Vector4d(1, 0, 0, 0));
-  JointVelocities feedback_velocities("test", Eigen::Vector4d(1, 1, 0, 0));
+  CartesianTwist desired_twist("test", Eigen::Vector3d(1, 0, 0));
+  CartesianTwist feedback_twist("test", Eigen::Vector3d(1, 1, 0));
+  // set a Jacobian matrix
+  Jacobian jac = Jacobian::Random("test_robot", 3, "test");
   // check command
-  JointTorques command = joint_controller_.compute_command(desired_velocities, feedback_velocities);
+  JointTorques command = controller->compute_command(desired_twist, feedback_twist, jac);
   // expect some non null data
   EXPECT_TRUE(command.data().norm() > 0.);
 }
diff --git a/source/controllers/test/tests/test_impedance.cpp b/source/controllers/test/tests/test_impedance.cpp
index a19b129da..d7bfaa9d1 100644
--- a/source/controllers/test/tests/test_impedance.cpp
+++ b/source/controllers/test/tests/test_impedance.cpp
@@ -1,45 +1,21 @@
-#include "controllers/impedance/Impedance.hpp"
-#include "state_representation/robot/JointState.hpp"
-#include "state_representation/robot/JointTorques.hpp"
-#include "state_representation/space/cartesian/CartesianState.hpp"
-#include "state_representation/space/cartesian/CartesianWrench.hpp"
+#include <gtest/gtest.h>
+
 #include <eigen3/Eigen/Core>
 #include <eigen3/Eigen/Dense>
-#include <gtest/gtest.h>
 
-using namespace controllers::impedance;
-using namespace state_representation;
+#include "controllers/ControllerFactory.hpp"
+#include "state_representation/space/joint/JointState.hpp"
+#include "state_representation/space/joint/JointTorques.hpp"
+#include "state_representation/space/cartesian/CartesianState.hpp"
+#include "state_representation/space/cartesian/CartesianWrench.hpp"
 
-TEST(ImpedanceControllerTest, TestCopyConstructor) {
-  Impedance<CartesianState> impedance_controller(Eigen::MatrixXd::Random(6, 6),
-                                                 Eigen::MatrixXd::Random(6, 6),
-                                                 Eigen::MatrixXd::Random(6, 6));
-  Impedance<CartesianState> copy(impedance_controller);
-  double tolerance = 1e-4;
-  for (int i = 0; i < 6; ++i) {
-    EXPECT_NEAR(impedance_controller.get_damping().col(i).norm(), copy.get_damping().col(i).norm(), tolerance);
-    EXPECT_NEAR(impedance_controller.get_stiffness().col(i).norm(), copy.get_stiffness().col(i).norm(), tolerance);
-    EXPECT_NEAR(impedance_controller.get_inertia().col(i).norm(), copy.get_inertia().col(i).norm(), tolerance);
-  }
-}
 
-TEST(ImpedanceControllerTest, TestAssignmentOperator) {
-  Impedance<CartesianState> impedance_controller(Eigen::MatrixXd::Random(6, 6),
-                                                 Eigen::MatrixXd::Random(6, 6),
-                                                 Eigen::MatrixXd::Random(6, 6));
-  Impedance<CartesianState> copy = impedance_controller;
-  double tolerance = 1e-4;
-  for (int i = 0; i < 6; ++i) {
-    EXPECT_NEAR(impedance_controller.get_damping().col(i).norm(), copy.get_damping().col(i).norm(), tolerance);
-    EXPECT_NEAR(impedance_controller.get_stiffness().col(i).norm(), copy.get_stiffness().col(i).norm(), tolerance);
-    EXPECT_NEAR(impedance_controller.get_inertia().col(i).norm(), copy.get_inertia().col(i).norm(), tolerance);
-  }
-}
+using namespace controllers;
+using namespace state_representation;
 
 TEST(ImpedanceControllerTest, TestCartesianImpedance) {
-  Impedance<CartesianState> impedance_controller(Eigen::MatrixXd::Identity(6, 6),
-                                                 Eigen::MatrixXd::Identity(6, 6),
-                                                 Eigen::MatrixXd::Identity(6, 6));
+  auto controller = CartesianControllerFactory::create_controller(CONTROLLER_TYPE::IMPEDANCE);
+
   // set up a desired state6d
   CartesianState desired_state("test");
   desired_state.set_linear_velocity(Eigen::Vector3d(1, 0, 0));
@@ -48,16 +24,15 @@ TEST(ImpedanceControllerTest, TestCartesianImpedance) {
   feedback_state.set_orientation(Eigen::Quaterniond(0, 0, 1, 1));
   feedback_state.set_linear_velocity(Eigen::Vector3d(0.5, 0, 0));
   // check command
-  CartesianWrench command = impedance_controller.compute_command(desired_state, feedback_state);
+  CartesianWrench command = controller->compute_command(desired_state, feedback_state);
   // expect some non null data
   EXPECT_TRUE(command.data().norm() > 0.);
 }
 
 TEST(ImpedanceControllerTest, TestJointImpedance) {
   int nb_joints = 3;
-  Impedance<JointState> impedance_controller(Eigen::MatrixXd::Identity(nb_joints, nb_joints),
-                                             Eigen::MatrixXd::Identity(nb_joints, nb_joints),
-                                             Eigen::MatrixXd::Identity(nb_joints, nb_joints));
+  auto controller = JointControllerFactory::create_controller(CONTROLLER_TYPE::IMPEDANCE, nb_joints);
+
   // set up a desired state6d
   JointState desired_state("test", nb_joints);
   desired_state.set_velocities(Eigen::Vector3d(1, 0, 0));
@@ -66,15 +41,14 @@ TEST(ImpedanceControllerTest, TestJointImpedance) {
   feedback_state.set_positions(Eigen::Vector3d(0, 0, 1));
   feedback_state.set_velocities(Eigen::Vector3d(0.5, 0, 0));
   // check command
-  JointTorques command = impedance_controller.compute_command(desired_state, feedback_state);
+  JointTorques command = controller->compute_command(desired_state, feedback_state);
   // expect some non null data
   EXPECT_TRUE(command.data().norm() > 0.);
 }
 
 TEST(ImpedanceControllerTest, TestCartesianToJointImpedance) {
-  Impedance<CartesianState> impedance_controller(Eigen::MatrixXd::Identity(6, 6),
-                                                 Eigen::MatrixXd::Identity(6, 6),
-                                                 Eigen::MatrixXd::Identity(6, 6));
+  auto controller = CartesianControllerFactory::create_controller(CONTROLLER_TYPE::IMPEDANCE);
+
   // set up a desired state6d
   CartesianState desired_state("test");
   desired_state.set_linear_velocity(Eigen::Vector3d(1, 0, 0));
@@ -85,7 +59,7 @@ TEST(ImpedanceControllerTest, TestCartesianToJointImpedance) {
   // set a Jacobian matrix
   Jacobian jac = Jacobian::Random("test_robot", 3, "test");
   // check command
-  JointTorques command = impedance_controller.compute_command(desired_state, feedback_state, jac);
+  JointTorques command = controller->compute_command(desired_state, feedback_state, jac);
   // expect some non null data
   EXPECT_TRUE(command.data().norm() > 0.);
 }
diff --git a/source/controllers/test/tests/test_velocity_impedance.cpp b/source/controllers/test/tests/test_velocity_impedance.cpp
index c5cb9188d..dd2110fb9 100644
--- a/source/controllers/test/tests/test_velocity_impedance.cpp
+++ b/source/controllers/test/tests/test_velocity_impedance.cpp
@@ -1,35 +1,17 @@
-#include "controllers/impedance/VelocityImpedance.hpp"
-#include "state_representation/robot/JointState.hpp"
-#include "state_representation/robot/JointTorques.hpp"
+#include <gtest/gtest.h>
+
+#include "controllers/ControllerFactory.hpp"
+#include "state_representation/space/joint/JointState.hpp"
+#include "state_representation/space/joint/JointTorques.hpp"
 #include "state_representation/space/cartesian/CartesianState.hpp"
 #include "state_representation/space/cartesian/CartesianWrench.hpp"
-#include <eigen3/Eigen/Core>
-#include <gtest/gtest.h>
 
-using namespace controllers::impedance;
+using namespace controllers;
 using namespace state_representation;
 
-TEST(VelocityImpedanceControllerTest, TestCopyConstructor) {
-  VelocityImpedance<CartesianState> impedance_controller(Eigen::MatrixXd::Random(6, 6),
-                                                         Eigen::MatrixXd::Random(6, 6));
-  VelocityImpedance<CartesianState> copy(impedance_controller);
-  EXPECT_TRUE(impedance_controller.get_damping().isApprox(copy.get_damping()));
-  EXPECT_TRUE(impedance_controller.get_stiffness().isApprox(copy.get_stiffness()));
-  EXPECT_TRUE(impedance_controller.get_inertia().isApprox(copy.get_inertia()));
-}
-
-TEST(VelocityImpedanceControllerTest, TestAssignmentOperator) {
-  VelocityImpedance<CartesianState> impedance_controller(Eigen::MatrixXd::Random(6, 6),
-                                                         Eigen::MatrixXd::Random(6, 6));
-  VelocityImpedance<CartesianState> copy = impedance_controller;
-  EXPECT_TRUE(impedance_controller.get_damping().isApprox(copy.get_damping()));
-  EXPECT_TRUE(impedance_controller.get_stiffness().isApprox(copy.get_stiffness()));
-  EXPECT_TRUE(impedance_controller.get_inertia().isApprox(copy.get_inertia()));
-}
-
 TEST(VelocityImpedanceControllerTest, TestCartesianImpedance) {
-  VelocityImpedance<CartesianState> impedance_controller(Eigen::MatrixXd::Identity(6, 6),
-                                                         Eigen::MatrixXd::Identity(6, 6));
+  auto controller = CartesianControllerFactory::create_controller(CONTROLLER_TYPE::VELOCITY_IMPEDANCE);
+
   // set up a desired state6d
   CartesianState desired_state("test");
   desired_state.set_linear_velocity(Eigen::Vector3d(1, 0, 0));
@@ -37,20 +19,19 @@ TEST(VelocityImpedanceControllerTest, TestCartesianImpedance) {
   CartesianState feedback_state("test");
   feedback_state.set_linear_velocity(Eigen::Vector3d(0.5, 0, 0));
   // check command
-  CartesianWrench command = impedance_controller.compute_command(desired_state, feedback_state);
+  CartesianWrench command = controller->compute_command(desired_state, feedback_state);
   // expect some non null data
   EXPECT_GT(command.data().norm(), 0.);
   // as opposed to the normal impedance controller, even if the two velocities are the same
   // we still expect a command as the desired pose is non null
   feedback_state.set_linear_velocity(desired_state.get_linear_velocity());
-  command = impedance_controller.compute_command(desired_state, feedback_state);
-  EXPECT_GT(command.data().norm(),0.);
+  command = controller->compute_command(desired_state, feedback_state);
+  EXPECT_GT(command.data().norm(), 0.);
 }
 
 TEST(VelocityImpedanceControllerTest, TestJointImpedance) {
   int nb_joints = 3;
-  VelocityImpedance<JointState> impedance_controller(Eigen::MatrixXd::Identity(nb_joints, nb_joints),
-                                                     Eigen::MatrixXd::Identity(nb_joints, nb_joints));
+  auto controller = JointControllerFactory::create_controller(CONTROLLER_TYPE::VELOCITY_IMPEDANCE, nb_joints);
   // set up a desired state6d
   JointState desired_state("test", nb_joints);
   desired_state.set_velocities(Eigen::Vector3d(1, 0, 0));
@@ -58,19 +39,19 @@ TEST(VelocityImpedanceControllerTest, TestJointImpedance) {
   JointState feedback_state("test", nb_joints);
   feedback_state.set_velocities(Eigen::Vector3d(0.5, 0, 0));
   // check command
-  JointTorques command = impedance_controller.compute_command(desired_state, feedback_state);
+  JointTorques command = controller->compute_command(desired_state, feedback_state);
   // expect some non null data
   EXPECT_GT(command.data().norm(), 0.);
   // as opposed to the normal impedance controller, even if the two velocities are the same
   // we still expect a command as the desired positions are non null
   feedback_state.set_velocities(desired_state.get_velocities());
-  command = impedance_controller.compute_command(desired_state, feedback_state);
+  command = controller->compute_command(desired_state, feedback_state);
   EXPECT_GT(command.data().norm(), 0.);
 }
 
 TEST(VelocityImpedanceControllerTest, TestCartesianToJointImpedance) {
-  VelocityImpedance<CartesianState> impedance_controller(Eigen::MatrixXd::Identity(6, 6),
-                                                         Eigen::MatrixXd::Identity(6, 6));
+  auto controller = CartesianControllerFactory::create_controller(CONTROLLER_TYPE::VELOCITY_IMPEDANCE);
+
   // set up a desired state6d
   CartesianState desired_state("test");
   desired_state.set_linear_velocity(Eigen::Vector3d(1, 0, 0));
@@ -80,12 +61,12 @@ TEST(VelocityImpedanceControllerTest, TestCartesianToJointImpedance) {
   // set a Jacobian matrix
   Jacobian jacobian = Jacobian::Random("test_robot", 3, "test");
   // check command
-  JointTorques command = impedance_controller.compute_command(desired_state, feedback_state, jacobian);
+  JointTorques command = controller->compute_command(desired_state, feedback_state, jacobian);
   // expect some non null data
   EXPECT_GT(command.data().norm(), 0.);
   // as opposed to the normal impedance controller, even if the two velocities are the same
   // we still expect a command as the desired pose is non null
   feedback_state.set_linear_velocity(desired_state.get_linear_velocity());
-  command = impedance_controller.compute_command(desired_state, feedback_state, jacobian);
+  command = controller->compute_command(desired_state, feedback_state, jacobian);
   EXPECT_GT(command.data().norm(), 0.);
 }
diff --git a/source/dev-server.sh b/source/dev-server.sh
index 616b56105..0aed7e7c6 100755
--- a/source/dev-server.sh
+++ b/source/dev-server.sh
@@ -1,55 +1,71 @@
 #!/usr/bin/env bash
 
-IMAGE_NAME=control-libraries/remote-development
-STAGE_NAME=remote-development
-CONTAINER_NAME=control-libraries-remote-development-ssh
-CONTAINER_HOSTNAME=control-libraries-remote-development
+IMAGE_NAME=ghcr.io/epfl-lasa/control-libraries/development-dependencies
+CONTAINER_NAME=epfl-lasa-control-libraries-development-dependencies-ssh
 
 SSH_PORT=2222
-SSH_KEY_FILE="$HOME/.ssh/id_rsa.pub"
+SSH_KEY_FILE="${HOME}/.ssh/id_rsa.pub"
 
-HELP_MESSAGE="Usage: ./dev-server.sh [--port <port>] [--key-file </path/to/id_rsa.pub>]
+HELP_MESSAGE="Usage: ./dev-server.sh [-p <port>] [-k <file>]
 
 Build and run a docker container as an SSH toolchain server for remote development.
 
 The server is bound to the specified port on localhost (127.0.0.1)
 and uses passwordless RSA key-pair authentication. The host public key
 is read from the specified key file and copied to the server on startup.
+On linux hosts, the UID and GID of the specified user will also be
+set to match the UID and GID of the host user by the entry script.
 
 The server will run in the background as ${CONTAINER_NAME}.
 
-You can connect with 'ssh remote@localhost -p <port>'.
+You can connect with 'ssh developer@localhost -p <port>'.
 
-Close the server with 'docker container stop ${CONTAINER_NAME}'.
+Close the server with 'docker stop ${CONTAINER_NAME}'.
 
 Options:
-  -p, --port [XXXX]        Specify the port to bind for SSH
+  -p, --port <XXXX>        Specify the port to bind for SSH
                            connection.
                            (default: ${SSH_PORT})
-
   -k, --key-file [path]    Specify the path of the RSA
                            public key file.
                            (default: ${SSH_KEY_FILE})
-
   -h, --help               Show this help message."
 
 while [ "$#" -gt 0 ]; do
   case "$1" in
-    -p|--port) SSH_PORT=$2; shift 2;;
-    -k|--key-file) SSH_KEY_FILE=$2; shift 2;;
-    -h|--help) echo "${HELP_MESSAGE}"; exit 0;;
-    *) echo "Unknown option: $1" >&2; echo "${HELP_MESSAGE}"; exit 1;;
+  -p|--port) SSH_PORT=$2; shift 2;;
+  -k|--key-file) SSH_KEY_FILE=$2; shift 2;;
+  -h|--help) echo "${HELP_MESSAGE}"; exit 0;;
+  *) echo 'Error in command line parsing' >&2
+     echo -e "\n${HELP_MESSAGE}"
+     exit 1
   esac
 done
 
-docker pull ghcr.io/epfl-lasa/control-libraries/development-dependencies
-DOCKER_BUILDKIT=1 docker build . --file ./Dockerfile.source --target "${STAGE_NAME}" --tag "${IMAGE_NAME}"
+PUBLIC_KEY=$(cat "${SSH_KEY_FILE}")
+
+COMMAND_FLAGS=()
+COMMAND_FLAGS+=(--key "${PUBLIC_KEY}")
+COMMAND_FLAGS+=(--user developer)
+
+if [[ "${OSTYPE}" != "darwin"* ]]; then
+  USER_ID=$(id -u "${USER}")
+  GROUP_ID=$(id -g "${USER}")
+  COMMAND_FLAGS+=(--uid "${USER_ID}")
+  COMMAND_FLAGS+=(--gid "${GROUP_ID}")
+fi
+
+docker pull "${IMAGE_NAME}" || exit 1
 
 docker container stop "${CONTAINER_NAME}" >/dev/null 2>&1
 docker rm --force "${CONTAINER_NAME}" >/dev/null 2>&1
 
-docker run -d --cap-add sys_ptrace \
+echo "Starting background container with access port ${SSH_PORT} for user developer"
+docker run -d --rm --cap-add sys_ptrace \
+  --user root \
   --publish 127.0.0.1:"${SSH_PORT}":22 \
   --name "${CONTAINER_NAME}" \
-  --hostname "${CONTAINER_HOSTNAME}" \
-  "${IMAGE_NAME}" "$(cat "${SSH_KEY_FILE}")"
\ No newline at end of file
+  --hostname "${CONTAINER_NAME}" \
+  "${IMAGE_NAME}" /sshd_entrypoint.sh "${COMMAND_FLAGS[@]}"
+
+echo "${CONTAINER_NAME}"
diff --git a/source/dynamical_systems/CMakeLists.txt b/source/dynamical_systems/CMakeLists.txt
index a18395d44..31d76da09 100644
--- a/source/dynamical_systems/CMakeLists.txt
+++ b/source/dynamical_systems/CMakeLists.txt
@@ -7,9 +7,10 @@ include_directories(
 )
 
 set(CORE_SOURCES
-  src/DynamicalSystem.cpp
+  src/IDynamicalSystem.cpp
+  src/DynamicalSystemFactory.cpp
   src/Circular.cpp
-  src/Linear.cpp
+  src/PointAttractor.cpp
   src/Ring.cpp
 )
 
diff --git a/source/dynamical_systems/README.md b/source/dynamical_systems/README.md
index 01f06f3a7..5815610d6 100644
--- a/source/dynamical_systems/README.md
+++ b/source/dynamical_systems/README.md
@@ -7,9 +7,9 @@ functions which map a state to a state derivative.
 * [Base DynamicalSystem](#base-dynamicalsystem)
   * [Base frame](#base-frame)
   * [Reference frames](#reference-frames)
-* [Linear](#linear)
-  * [Configuring the Linear DS](#configuring-the-linear-ds)
-  * [Evaluating the Linear DS](#evaluating-the-linear-ds)
+* [Linear](#point-attractor)
+  * [Configuring the Linear DS](#configuring-the-point-attractor-ds)
+  * [Evaluating the Linear DS](#evaluating-the-point-attractor-ds)
 * [Circular](#circular)
   * [Configuring the Circular DS](#configuring-the-circular-ds)
 * [Ring](#ring)
@@ -17,7 +17,7 @@ functions which map a state to a state derivative.
 
 ## Base DynamicalSystem
 
-The base class DynamicalSystem defines the main public interface pattern which the derived classes follow.
+The base class IDynamicalSystem defines the main public interface pattern which the derived classes follow.
  
 It is templated for any state type, though the intention is to use the **State Representation** library
 (for example, `CartesianState` or `JointState`).
@@ -25,7 +25,7 @@ It is templated for any state type, though the intention is to use the **State R
 The main function is:
 ```c++
 template<class S>
-S DynamicalSystem<S>::evaluate(const S& state) const
+S IDynamicalSystem<S>::evaluate(const S& state) const
 ```
 where `S` is the state representation type.
 The purpose of the evaluate function is to calculate a state derivative from a state.
@@ -48,8 +48,8 @@ For example, `DynamicalSystem<CartesianState>("base")` will create a dynamical s
 expressed in its own frame "base".
 
 The `DynamicalSystem<JointState>` can only be constructed with a `state` to set the base frame. Whilst the term 
-*base frame* makes more sense for a `CartesianState` DS, it rather refers to a specific robot with corresponding name
-and joint names in the case of a `JointState` DS.
+*base frame* makes more sense for a `CartesianState` DS, it rather refers to a specific robot with corresponding 
+joint names in the case of a `JointState` DS.
 
 In most cases, the constructor for the base DynamicalSystem should not be used directly,
 and rather the derived DS classes should construct the base accordingly.
@@ -58,8 +58,8 @@ However, the `set_base_frame()` method remains useful in combination with derive
 
 ### Reference frames
 
-The following section applies to derived DS classes using the `CartesianState` type. The [Linear DS](#linear) 
-will be used as an example.
+The following section applies to derived DS classes using the `CartesianState` type. The 
+[Point Attractor DS](#point-attractor) will be used as an example.
 
 The `evaluate()` function will always return a twist expressed in the same reference frame as the input state,
 provided that the input state is compatible with the DS.
@@ -70,45 +70,48 @@ The input state must be expressed in one of two supported reference frames:
 
 The following snippet illustrates the difference in these two options.
 ```c++
-// create a linear DS with attractor B in frame A
+// create a point attractor DS with attractor B in frame A
 state_representation::CartesianState BinA = state_representation::CartesianState::Identity("B", "A");
-dynamical_systems::Linear<state_representation::CartesianState> linearDS(BinA);
+auto ds = DynamicalSystemFactory<CartesianState>::create_dynamical_system(
+DynamicalSystemFactory<CartesianState>::DYNAMICAL_SYSTEM::POINT_ATTRACTOR
+);
+ds->set_attractor_value("attractor", BinA);
 
-linearDS.get_attractor().get_name();             // "B"
-linearDS.get_attractor().get_reference_frame();  // "A"
-linearDS.get_base_frame().get_name();            // "A"
-linearDS.get_base_frame().get_reference_frame(); // "A"
+ds->get_parameter_value("attractor").get_name();             // "B"
+ds->get_parameter_value("attractor").get_reference_frame();  // "A"
+ds->get_base_frame().get_name();                             // "A"
+ds->get_base_frame().get_reference_frame();                  // "A"
 
 // evaluate a point C in frame A
 state_representation::CartesianState CinA = state_representation::CartesianState::Random("C", "A");
-auto twist0 = linearDS.evaluate(CinA); // valid, twist is expressed in frame A
+auto twist0 = ds->evaluate(CinA); // valid, twist is expressed in frame A
 
 // set the base from of the DS to be A expressed in the world frame
 state_representation::CartesianState AinWorld = state_representation::CartesianState::Identity("A", "world");
-linearDS.set_base_frame(AinWorld);
+ds->set_base_frame(AinWorld);
 
-linearDS.get_attractor().get_name();             // "B"
-linearDS.get_attractor().get_reference_frame();  // "A"
-linearDS.get_base_frame().get_name();            // "A"
-linearDS.get_base_frame().get_reference_frame(); // "world"
+ds->get_parameter_value("attractor").get_name();             // "B"
+ds->get_parameter_value("attractor").get_reference_frame();  // "A"
+ds->get_base_frame().get_name();                             // "A"
+ds->get_base_frame().get_reference_frame();                  // "world"
 
 // option 1: reference frame of the input is the same as the base frame 
 // -> reference frame of the input: "A"
 // -> DS base frame: "A"
 // -> reference frame of the output: "A"
-auto twist1 = linearDS.evaluate(CinA);
+auto twist1 = ds->evaluate(CinA);
 
 // option 2: reference frame of the input is the same as the base frame 
 // -> reference frame of the input: "world"
 // -> DS base frame reference frame: "world"
 // -> reference frame of the output: "world"
 auto CinWorld = AinWorld * CinA;
-auto twist2 = linearDS.evaluate(CinWorld);
+auto twist2 = ds->evaluate(CinWorld);
 
 // as a note, you can mix and match the approach as necessary.
 // the following is using option 1 with an additional external operation
 // to yield a final result equivalent to option 2.
-auto twist3 =  AinWorld * linearDS.evaluate(CinA);
+auto twist3 =  AinWorld * ds->evaluate(CinA);
 // twist2 === twist3
 ```
 
@@ -131,7 +134,10 @@ state_representation::CartesianState EE("end_effector", "robot");
 state_representation::CartesianState attractor = state_representation::CartesianState::Random("attractor", "task");
 state_representation::CartesianState taskInRobot("task", "robot");
 
-dynamical_systems::Linear<state_representation::CartesianState> linearDS(attractor);
+auto ds = DynamicalSystemFactory<CartesianState>::create_dynamical_system(
+DynamicalSystemFactory<CartesianState>::DYNAMICAL_SYSTEM::POINT_ATTRACTOR
+);
+ds->set_attractor_value("attractor", attractor);
 
 // control loop
 while (...) {
@@ -148,74 +154,66 @@ while (...) {
   
   // find the twist in the robot reference frame 
   // directly from the end-effector position in the robot reference frame
-  auto twist = linearDS.evaluate(EE);
+  auto twist = ds->evaluate(EE);
   
   // send twist command to controller
   update_controller(twist);
 }
 ```
 
-## Linear
+## Point Attractor
 
-The **Linear** DS can be thought of as a point attractor, with a velocity that is linearly proportional
-to the distance of the current state from the attractor.
-It is currently implemented for the `CartesianState` and `JointState` types.
+The **Point Attractor** DS generates a velocity that is linearly proportional to the distance of the current state 
+from the attractor. It is currently implemented for the `CartesianState` and `JointState` types.
 
 ```c++
-// empty construction results in empty base frame and attractor
-dynamical_systems::Linear<S> emptyDS;
-
-// construction with an attractor and default value for the gain
-state_representation::CartesianState cartesianAttractor = state_representation::CartesianState::Identity("A");
-dynamical_systems::Linear<state_representation::CartesianState> linearDS1(cartesianAttractor);
-
-state_representation::JointState jointAttractor = state_representation::JointState::Zero(6);
-dynamical_systems::Linear<state_representation::JointState> linearDS2(jointAttractor);
+// construction with the DS factory
+auto ds = DynamicalSystemFactory<CartesianState>::create_dynamical_system(
+    DynamicalSystemFactory<CartesianState>::DYNAMICAL_SYSTEM::POINT_ATTRACTOR
+    );
 ```
 
-### Configuring the Linear DS
+### Configuring the Point Attractor DS
 
-The Linear DS has the following core parameters:
+The Point Attractor DS has the following core parameters:
 - **attractor**; the `CartesianState` or `JointState` type object defining the attractor pose relative to the DS base frame
 - **gain**; the proportional gain acting towards the attractor
 
-Each parameter has corresponding `set_` and `get_` functions.
-
-To change the strength of the attractor, a gain can be passed as the second argument during construction or
-passed to the `set_gain()` member function. The gain defines the proportionality between
-a distance unit and a velocity unit, and is internally stored as a square matrix with a size corresponding
-to the degrees of freedom in the state representation. For example, the `CartesianState` has six degrees of freedom
-(XYZ in linear and angular space), while the `JointState` would have as many degrees of freedom as joints.
+The gain defines the proportionality between a distance unit and a velocity unit, and is internally stored as a 
+square matrix with a size corresponding to the degrees of freedom in the state representation. For example, 
+the `CartesianState` has six degrees of freedom (XYZ in linear and angular space), while the `JointState` would
+have as many degrees of freedom as joints.
 The gain can be defined as a matrix directly, as a diagonal vector of the appropriate
 length, or as a scalar (which sets the value along the diagonal elements of the matrix).
 ```c++
-// set a gain (scalar, vector or matrix during construction)
+// set a gain (scalar, vector or matrix)
 double gain = 10;
-state_representation::CartesianState csA = state_representation::CartesianState::Identity("A");
-dynamical_systems::Linear<state_representation::CartesianState> linear(csA, gain);
-
-// or set / update the gain for the created object
+ds->set_parameter_value("gain", gain);
+// or
 std::vector<double> gains = {1, 2, 3, 4, 5, 6};
-linear.set_gain(gains);
+ds->set_parameter_value("gain", gain);
 
 // update the attractor
 state_representation::CartesianState csB = state_representation::CartesianState::Random("B");
-linear.set_attractor(csB);
+ds->set_parameter_value("attractor", csB);
 ```
 
-### Evaluating the Linear DS
+### Evaluating the Point Attractor DS
 
 To get the velocity from a state, simply call the `evaluate()` function.
 
 ```c++
+auto ds = DynamicalSystemFactory<CartesianState>::create_dynamical_system(
+DynamicalSystemFactory<CartesianState>::DYNAMICAL_SYSTEM::POINT_ATTRACTOR
+);
 state_representation::CartesianState csA = state_representation::CartesianState::Identity("A");
-dynamical_systems::Linear<state_representation::CartesianState> linear(csA);
+ds->set_parameter_value("attractor", csA);
 
 state_representation::CartesianState csB = state_representation::CartesianState::Random("B");
 // note: the return type of evaluate() is a CartesianState, but
 // it can be directly assigned to a CartesianTwist because the =operator
 // has been defined for that purpose
-state_representation::CartesianTwist twist = linear.evaluate(csB);
+state_representation::CartesianTwist twist = ds->evaluate(csB);
 ```
 
 The returned velocity will always be expressed in the same reference frame as the input state.
@@ -235,30 +233,13 @@ The Circular DS can be constructed with a `CartesianState` state and radius as a
 the state position defines the center of the limit cycle, while the state orientation defines the inclination
 of the limit cycle plane. The radius has a default value of 1.
 
-The internal representation of the limit cycle is a `state_representation::Ellipsoid` type. When a state is used
-in the constructor, the limit cycle has a constant radius.
-If an elliptical limit cycle is desired, the DS can be constructed directly from an `Ellipsoid` type.
+The internal representation of the limit cycle is a `state_representation::Ellipsoid` type. 
 
 ```c++
-// empty construction results in empty base frame and limit cycle
-dynamical_systems::Circular emptyDS;
-emptyDS.set_limit_cycle(ellipse); // sets a null base frame according to the reference frame of the limit cycle
-
-// construct the circular DS limit cycle using a CartesianState center
-state_representation::CartesianState center = state_representation::CartesianState::Identity("center");
-
-// default constructor (radius = 1)
-dynamical_systems::Circular circularDS1(center);
-
-// constructor with radius
-double radius = 2.0;
-dynamical_systems::Circular circularDS2(center, radius);
-
-// construct the circular DS limit cycle directly using an Ellipsoid type
-state_representation::Ellipsoid ellipse("limit_cycle");
-ellipse.set_center_state(center);
-ellipse.set_axis_lengths({radius, 2 * radius});
-dynamical_systems::Circular ellipticalDS(ellipse);
+// construction with the DS factory
+auto ds = DynamicalSystemFactory<CartesianState>::create_dynamical_system(
+DynamicalSystemFactory<CartesianState>::DYNAMICAL_SYSTEM::CIRCULAR
+);
 ```
 
 ### Configuring the Circular DS
@@ -271,37 +252,22 @@ The Circular DS has the following core parameters:
 - **circular_velocity**; the expected angular orbital velocity around the local origin. 
 Setting this value negative reverses the direction of rotation. [rad/s]
 
-Each parameter has corresponding `set_` and `get_` functions.
-
-The constructor takes additional optional arguments to define the gain and circular velocity.
-The scalar value for the gain sets both the planar and normal gain of the DS. 
-
-Note that the argument for the radius is only present when a `CartesianState` is provided,
-and not when an `Ellipsoid` is provided, as the radii are already parameters of the `Ellipsoid`.
 ```c++
-// construct the circular DS with optional parameters (default values are shown)
-double radius = 1.0;
-double gain = 1.0;
-double circular_velocity = M_PI / 2;
-
-// construction with a CartesianState center
-dynamical_systems::Circular circularDS(center, radius, gain, circular_velocity);
-
-// construction with an Ellipsoid ellipse
-dynamical_systems::Circular circularDS(ellipse, gain, circular_velocity);
-```
+// update the parameters of the circular DS
+state_representation::CartesianState center = state_representation::CartesianState::Identity("center");
+double radius = 2.0;
+state_representation::Ellipsoid ellipse("limit_cycle");
+ellipse.set_center_state(center);
+ellipse.set_axis_lengths({radius, 2 * radius});
+ds->set_parameter_value("limit_cycle", ellipse);
 
-In addition, the following helper are defined to configure the limit cycle behaviour.
+double planar_gain = 1.0;
+ds->set_parameter_value("planar_gain", planar_gain);
 
-```c++
-.set_center(CartesianState("center"));  // sets the center position and orientation of the limit cycle
-.set_gain(1.0);                         // sets both planar and normal gain to the gain value
-.set_rotation_angle(0.0);               // sets a rotation offset around the local Z axis
-.set_radius(1.0);                       // sets both elliptical axes to the given radius (forces circle)
-.set_radiuses({1.0, 2.0});              // sets the length of each elliptical axis individually  
+double circular_velocity = M_PI / 2;
+ds->set_parameter_value("circular_velocity", circular_velocity);
 ```
 
-
 ## Ring
 
 The **Ring** DS is similar to the **Circular** DS but is more parameterizable.
@@ -314,12 +280,10 @@ A clockwise rotation can be achieved by rotating the ring 180 degrees about its
 It only supports the `CartesianState` type, and always acts in a circular ring. 
 
 ```c++
-// empty construction results in empty base frame and center state
-dynamical_systems::Ring emptyDS;
-
-// construction with center state and default values for parameters
-state_representation::CartesianState center = state_representation::CartesianState::Identity("center");
-dynamical_systems::Ring ringDS(center);
+// construction with the DS factory
+auto ds = DynamicalSystemFactory<CartesianState>::create_dynamical_system(
+DynamicalSystemFactory<CartesianState>::DYNAMICAL_SYSTEM::RING
+);
 ```
 
 ### Configuring the Ring DS
@@ -342,12 +306,19 @@ Each parameter has corresponding `set_` and `get_` functions.
 
 The constructor takes additional optional arguments to define the ring DS parameters.
 ```c++
-// construct the ring DS with optional parameters (default values are shown)
+// update the ring DS parameters
+state_representation::CartesianState center = state_representation::CartesianState::Identity("center");
+ds->set_parameter_value("center", center);
 double radius = 1.0;
+ds->set_parameter_value("radius", radius);
 double width = 0.5;
+ds->set_parameter_value("width", width);
 double speed = 1.0;
+ds->set_parameter_value("speed", speed);
 double field_strength = 1.0;
+ds->set_parameter_value("field_strength", field_strength);
 double normal_gain = 1.0;
+ds->set_parameter_value("normal_gain", normal_gain);
 double angular_gain = 1.0;
-dynamical_systems::Ring ringDS(center, radius, width, speed, field_strength, normal_gain, angular_gain);
+ds->set_parameter_value("angular_gain", angular_gain);
 ```
\ No newline at end of file
diff --git a/source/dynamical_systems/include/dynamical_systems/Blending.hpp b/source/dynamical_systems/include/dynamical_systems/Blending.hpp
deleted file mode 100644
index b74978a77..000000000
--- a/source/dynamical_systems/include/dynamical_systems/Blending.hpp
+++ /dev/null
@@ -1,151 +0,0 @@
-#pragma once
-
-#include "dynamical_systems/DynamicalSystem.hpp"
-#include "dynamical_systems/exceptions/NotImplementedException.hpp"
-#include "state_representation/robot/JointState.hpp"
-#include "state_representation/space/Cartesian/CartesianPose.hpp"
-#include "state_representation/space/Cartesian/CartesianState.hpp"
-#include "state_representation/space/Cartesian/CartesianTwist.hpp"
-
-namespace dynamical_systems {
-/**
- * @class Blended
- * @brief Represent a blend of several dynamical systems where the output is the weighted sum of the output of each system
- * @tparam S the type of space of the dynamical system (e.g. Cartesian or Joint)
- */
-template <class S>
-class Blending : public DynamicalSystem<S> {
-private:
-  std::vector<std::shared_ptr<DynamicalSystem<S>>> systems_;                    ///< pointer to the individual systmes
-  std::shared_ptr<state_representation::Parameter<std::vector<double>>> weights_;///< weights of each system
-
-  /**
-   * @brief Normalize the weight vector
-   */
-  void normalize_weights();
-
-protected:
-  /**
-   * @brief Compute the dynamics of the input state.
-   * Internal function, to be redefined based on the
-   * type of dynamical system, called by the evaluate
-   * function
-   * @param state the input state
-   * @return the output state
-   */
-  S compute_dynamics(const S& state) const;
-
-public:
-  /**
-   * @brief Empty coinstructor
-   */
-  explicit Blending();
-
-  /**
-   * @brief Getter of the dynamical system vector
-   * @return the dynamical system vector
-   */
-  const std::vector<std::shared_ptr<DynamicalSystem<S>>>& get_dynamical_systems() const;
-
-  /**
-   * @brief Getter of the dynamical system at desired index
-   * @param idx the index of the dynamical system
-   * @return the desired dynamical system
-   */
-  const std::shared_ptr<DynamicalSystem<S>>& get_dynamical_systems(unsigned int idx) const;
-
-  /**
-   * @brief Add a dynamical system to the blending
-   * @param ds the dynamical system to add
-   * @weight the weight associated to the ds
-   * @normalize_weights if true normalize the weight vector after adding the system
-   */
-  void add_dynamical_system(const std::shared_ptr<DynamicalSystem<S>> ds, double weight, bool normalize_weights = true);
-
-  /**
-   * @brief Add several dynamical system to the blending
-   * @param ds the dynamical systems to add
-   * @param weights the weight associated to the ds
-   * @normalize_weights if true normalize the weight vector after adding the system
-   */
-  void add_dynamical_systems(const std::vector<std::shared_ptr<DynamicalSystem<S>>>& ds, const std::vector<double>& weight, bool normalize_weights = true);
-
-  /**
-   * @brief Set the weight of the dynamical system at desired index
-   * @param idx index of the dynamical system
-   * @param weight the new weight value
-   * @normalize_weights if true normalize the weight vector after adding the system
-   */
-  void set_weight(unsigned int idx, double weight, bool normalize_weights = true);
-
-  /**
-   * @brief Set the weights of the dynamical system at desired indexes
-   * @param idx indexes of the dynamical system
-   * @param weights the new weight value
-   * @normalize_weights if true normalize the weight vector after adding the system
-   */
-  void set_weights(const std::vector<unsigned int>& idx, const std::vector<double>& weights, bool normalize_weights = true);
-};
-
-template <class S>
-Blending<S>::Blending() : DynamicalSystem<S>() {}
-
-template <class S>
-void Blending<S>::normalize_weights() {
-  double mod = 0.0;
-  for (const auto& w : this->weights_->get_value()) mod += w * w;
-  double mag = std::sqrt(mod);
-  for (auto& w : this->weights_->get_value()) w /= mag;
-}
-
-template <class S>
-inline const std::vector<std::shared_ptr<DynamicalSystem<S>>>& Blending<S>::get_dynamical_systems() const {
-  return this->systems_;
-}
-
-template <class S>
-const std::shared_ptr<DynamicalSystem<S>>& Blending<S>::get_dynamical_systems(unsigned int idx) const {
-  return this->systems_[idx];
-}
-
-template <class S>
-void Blending<S>::add_dynamical_system(const std::shared_ptr<DynamicalSystem<S>> ds, double weight, bool normalize_weights = true) {
-  this->systems_.push_back(ds);
-  this->weights_->get_value().push_back(weight);
-  if (normalize_weights) this->normalize_weights();
-}
-
-template <class S>
-void Blending<S>::add_dynamical_systems(const std::vector<std::shared_ptr<DynamicalSystem<S>>>& ds, const std::vector<double>& weights, bool normalize_weights = true) {
-  if (ds.size() != weights.size()) throw IncompatibleSizeException("The dynamical system and the weight vector have different sizes");
-  for (unsigned int i = 0; i < ds.size(); ++i) {
-    this->systems_.push_back(ds);
-    this->weights_->get_value().push_back(weight);
-  }
-  if (normalize_weights) this->normalize_weights();
-}
-
-template <class S>
-void Blending<S>::set_weight(unsigned int idx, double weight, bool normalize_weights = true) {
-  this->weights_->get_value()[idx] = weight;
-  if (normalize_weights) this->normalize_weights();
-}
-
-template <class S>
-void Blending<S>::set_weights(const std::vector<unsigned int>& idx, const std::vector<double>& weights, bool normalize_weights = true) {
-  if (idx.size() != weights.size()) throw IncompatibleSizeException("The index vector and the weight vector have different sizes");
-  for (unsigned int i = 0; i < idx.size(); ++i) {
-    this->weights_->get_value()[idx[i]] = weights[i];
-  }
-  if (normalize_weights) this->normalize_weights();
-}
-
-template <class S>
-const S Blending<S>::compute_dynamics(const S& state) const {
-  S output;
-  for (unsigned int i = 0; i < ds.size(); ++i) {
-    S += (this->weights_->get_value()[i] * this->systems_[i]->evaluate(state));
-  }
-  return output;
-}
-}// namespace dynamical_systems
diff --git a/source/dynamical_systems/include/dynamical_systems/Circular.hpp b/source/dynamical_systems/include/dynamical_systems/Circular.hpp
index 976ac8140..235c88e42 100644
--- a/source/dynamical_systems/include/dynamical_systems/Circular.hpp
+++ b/source/dynamical_systems/include/dynamical_systems/Circular.hpp
@@ -1,43 +1,16 @@
 #pragma once
 
-#include "dynamical_systems/DynamicalSystem.hpp"
+#include "dynamical_systems/IDynamicalSystem.hpp"
 #include "state_representation/geometry/Ellipsoid.hpp"
 #include "state_representation/parameters/Parameter.hpp"
-#include "state_representation/space/cartesian/CartesianPose.hpp"
-#include "state_representation/space/cartesian/CartesianState.hpp"
-#include "state_representation/space/cartesian/CartesianTwist.hpp"
-#include "state_representation/exceptions/EmptyStateException.hpp"
-#include <cmath>
-#include <vector>
 
 namespace dynamical_systems {
+
 /**
  * @class Circular
- * @brief Represent a Circular dynamical system to move around an center
+ * @brief Represent a Circular dynamical system to move around an center.
  */
-class Circular : public DynamicalSystem<state_representation::CartesianState> {
-private:
-  std::shared_ptr<state_representation::Parameter<state_representation::Ellipsoid>>
-      limit_cycle_;///< limit_cycle of the dynamical system
-  std::shared_ptr<state_representation::Parameter<double>>
-      planar_gain_;///< gain associate to the system in the plane of the circle
-  std::shared_ptr<state_representation::Parameter<double>>
-      normal_gain_;///< gain associate to the system normal to the plane of the circle
-  std::shared_ptr<state_representation::Parameter<double>>
-      circular_velocity_;///< velocity at wich to navigate the limit cycle
-
-protected:
-  /**
-   * @brief Compute the dynamics of the input state.
-   * Internal function, to be redefined based on the
-   * type of dynamical system, called by the evaluate
-   * function
-   * @param state the input state
-   * @return the output state
-   */
-  state_representation::CartesianState
-  compute_dynamics(const state_representation::CartesianState& state) const override;
-
+class Circular : public IDynamicalSystem<state_representation::CartesianState> {
 public:
   /**
    * @brief Empty constructor
@@ -45,213 +18,35 @@ class Circular : public DynamicalSystem<state_representation::CartesianState> {
   Circular();
 
   /**
-   * @brief Default constructor with center and fixed radius
-   * @param center the center of the limit cycle
-   * @param radius radius of the limit cycle
-   * @param gain gain of the dynamical system
-   * @param circular_velocity circular velocity to move around the limit cycle
+   * @copydoc IDynamicalSystem::set_parameter
    */
-  explicit Circular(const state_representation::CartesianState& center,
-                    double radius = 1.0,
-                    double gain = 1.0,
-                    double circular_velocity = M_PI / 2);
+  void set_base_frame(const state_representation::CartesianState& base_frame) override;
 
   /**
-   * @brief Constructor with an elliptic limit cycle
-   * @param limit_cycle the limit cycle as an ellipsoid
-   * @param gain gain of the dynamical system
-   * @param circular_velocity circular velocity to move around the limit cycle
+   * @copydoc IDynamicalSystem::compute_dynamics
    */
-  explicit Circular(const state_representation::Ellipsoid& limit_cycle,
-                    double gain = 1.0,
-                    double circular_velocity = M_PI / 2);
+  [[nodiscard]] state_representation::CartesianState
+  compute_dynamics(const state_representation::CartesianState& state) const override;
 
+private:
   /**
-   * @brief Getter of the center
-   * @return the center as a const reference
+   * @copydoc IDynamicalSystem::validate_and_set_parameter
    */
-  const state_representation::CartesianPose& get_center() const;
+  void validate_and_set_parameter(const std::shared_ptr<state_representation::ParameterInterface>& parameter) override;
 
   /**
    * @brief Setter of the center as a new value
    * @param center the new center
    */
-  void set_center(const state_representation::CartesianPose& center);
-
-  /**
-   * @brief Setter of the DS base frame as a new value
-   * @param base_frame the new base frame
-   */
-  void set_base_frame(const state_representation::CartesianState& base_frame) override;
-
-  /**
-   * @brief Getter of the planar gain attribute
-   * @return The gain value in the plane of the circle
-   */
-  double get_planar_gain() const;
-
-  /**
-   * @brief Getter of the normal gain attribute
-   * @return The gain value normal to the plane of the circle
-   */
-  double get_normal_gain() const;
-
-  /**
-   * @brief Setter of the gain attribute
-   */
-  void set_gain(double gain);
-
-  /**
-   * @brief Setter of the planar gain attribute
-   */
-  void set_planar_gain(double gain);
-
-  /**
-   * @brief Setter of the normal gain attribute
-   */
-  void set_normal_gain(double gain);
-
-  /**
-   * @brief Getter of the rotation angle attribute
-   * @return the radius value
-   */
-  double get_rotation_angle() const;
-
-  /**
-   * @brief Setter of the rotation angle attribute
-   * @return The rotation angle value
-   */
-  void set_rotation_angle(double angle);
-
-  /**
-   * @brief Getter of the radiuses of the limit cycle
-   * @param The rotation angle value
-   */
-  const std::vector<double>& get_radiuses() const;
-
-  /**
-   * @brief Setter of the radiuses of the limit cycle
-   * @param radiuses the new radiuses values
-   */
-  void set_radiuses(const std::vector<double>& radiuses);
-
-  /**
-   * @brief Setter of the radius of the limit cycle as a single value, i.e. perfect cycle
-   * @param radiuses the new radiuses values
-   */
-  void set_radius(double radius);
-
-  /**
-   * @brief Getter of the circular velocity attribute
-   * @return the circular velocity value
-   */
-  double get_circular_velocity() const;
+  void set_limit_cycle(state_representation::Ellipsoid& limit_cycle);
 
-  /**
-   * @brief Setter of the circular_velocity attribute
-   * @param circular_velocity the new circular_velocity value
-   */
-  void set_circular_velocity(double circular_velocity);
-
-  /**
-   * @brief Getter of the limit cycle attribute
-   * @return the limit cycle
-   */
-  const state_representation::Ellipsoid& get_limit_cycle() const;
-
-  /**
-   * @brief Setter of the limit cycle attribute
-   * @param the limit cycle value
-   */
-  void set_limit_cycle(const state_representation::Ellipsoid& limit_cycle);
-
-  /**
-   * @brief Return a list of all the parameters of the dynamical system
-   * @return the list of parameters
-   */
-  std::list<std::shared_ptr<state_representation::ParameterInterface>> get_parameters() const override;
+  std::shared_ptr<state_representation::Parameter<state_representation::Ellipsoid>>
+      limit_cycle_;///< limit_cycle of the dynamical system
+  std::shared_ptr<state_representation::Parameter<double>>
+      planar_gain_;///< gain associate to the system in the plane of the circle
+  std::shared_ptr<state_representation::Parameter<double>>
+      normal_gain_;///< gain associate to the system normal to the plane of the circle
+  std::shared_ptr<state_representation::Parameter<double>>
+      circular_velocity_;///< velocity at wich to navigate the limit cycle
 };
-
-inline const state_representation::CartesianPose& Circular::get_center() const {
-  return this->limit_cycle_->get_value().get_center_pose();
-}
-
-inline void Circular::set_center(const state_representation::CartesianPose& center) {
-  if (center.is_empty()) {
-    throw state_representation::exceptions::EmptyStateException(center.get_name() + " state is empty");
-  }
-  if (this->get_base_frame().is_empty()) {
-    DynamicalSystem<state_representation::CartesianState>::set_base_frame(state_representation::CartesianState::Identity(
-        center.get_reference_frame(),
-        center.get_reference_frame()));
-  }
-  if (center.get_reference_frame() != this->get_base_frame().get_name()) {
-    if (center.get_reference_frame() != this->get_base_frame().get_reference_frame()) {
-      throw state_representation::exceptions::IncompatibleReferenceFramesException(
-          "The reference frame of the center " + center.get_name() + " in frame " + center.get_reference_frame()
-              + " is incompatible with the base frame of the dynamical system " + this->get_base_frame().get_name()
-              + " in frame " + this->get_base_frame().get_reference_frame() + ".");
-    }
-    this->limit_cycle_->get_value().set_center_state(this->get_base_frame().inverse() * center);
-  } else {
-    this->limit_cycle_->get_value().set_center_state(center);
-  }
-}
-
-inline double Circular::get_planar_gain() const {
-  return this->planar_gain_->get_value();
-}
-
-inline double Circular::get_normal_gain() const {
-  return this->normal_gain_->get_value();
-}
-
-inline void Circular::set_gain(double gain) {
-  this->planar_gain_->set_value(gain);
-  this->normal_gain_->set_value(gain);
-}
-
-inline void Circular::set_planar_gain(double gain) {
-  this->planar_gain_->set_value(gain);
-}
-
-inline void Circular::set_normal_gain(double gain) {
-  this->normal_gain_->set_value(gain);
-}
-
-inline double Circular::get_rotation_angle() const {
-  return this->limit_cycle_->get_value().get_rotation_angle();
-}
-
-inline void Circular::set_rotation_angle(double angle) {
-  this->limit_cycle_->get_value().set_rotation_angle(angle);
-}
-
-inline const std::vector<double>& Circular::get_radiuses() const {
-  return this->limit_cycle_->get_value().get_axis_lengths();
-}
-
-inline void Circular::set_radiuses(const std::vector<double>& radiuses) {
-  this->limit_cycle_->get_value().set_axis_lengths(radiuses);
-}
-
-inline void Circular::set_radius(double radius) {
-  this->limit_cycle_->get_value().set_axis_lengths({radius, radius});
-}
-
-inline double Circular::get_circular_velocity() const {
-  return this->circular_velocity_->get_value();
-}
-
-inline void Circular::set_circular_velocity(double circular_velocity) {
-  this->circular_velocity_->set_value(circular_velocity);
-}
-
-inline const state_representation::Ellipsoid& Circular::get_limit_cycle() const {
-  return this->limit_cycle_->get_value();
-}
-
-inline void Circular::set_limit_cycle(const state_representation::Ellipsoid& limit_cycle) {
-  this->limit_cycle_->set_value(limit_cycle);
-}
-}// namespace dynamical_systems
\ No newline at end of file
+}// namespace dynamical_systems
diff --git a/source/dynamical_systems/include/dynamical_systems/DefaultDynamicalSystem.hpp b/source/dynamical_systems/include/dynamical_systems/DefaultDynamicalSystem.hpp
new file mode 100644
index 000000000..2a166ae0a
--- /dev/null
+++ b/source/dynamical_systems/include/dynamical_systems/DefaultDynamicalSystem.hpp
@@ -0,0 +1,38 @@
+#pragma once
+
+#include "dynamical_systems/IDynamicalSystem.hpp"
+#include "state_representation/exceptions/InvalidParameterException.hpp"
+
+namespace dynamical_systems {
+
+/**
+ * @class DefaultDynamicalSystem
+ * @brief A default dynamical system that just returns an empty state.
+ * @tparam S Underlying state type of the dynamical system
+ */
+template<class S>
+class DefaultDynamicalSystem : public IDynamicalSystem<S> {
+public:
+  /**
+   * @copydoc IDynamicalSystem::compute_dynamics
+   */
+  [[nodiscard]] S compute_dynamics(const S& state) const override;
+private:
+  /**
+   * @copydoc IDynamicalSystem::validate_and_set_parameter
+   */
+  void validate_and_set_parameter(const std::shared_ptr<state_representation::ParameterInterface>& parameter) override;
+};
+
+template<class S>
+void DefaultDynamicalSystem<S>::validate_and_set_parameter(
+    const std::shared_ptr<state_representation::ParameterInterface>&
+) {
+  throw state_representation::exceptions::InvalidParameterException("No parameter to be set on this type of DS.");
+}
+
+template<class S>
+S DefaultDynamicalSystem<S>::compute_dynamics(const S&) const {
+  return S();
+}
+}// namespace dynamical_systems
diff --git a/source/dynamical_systems/include/dynamical_systems/DynamicalSystem.hpp b/source/dynamical_systems/include/dynamical_systems/DynamicalSystem.hpp
deleted file mode 100644
index 6a6594630..000000000
--- a/source/dynamical_systems/include/dynamical_systems/DynamicalSystem.hpp
+++ /dev/null
@@ -1,101 +0,0 @@
-#pragma once
-
-#include "state_representation/parameters/ParameterInterface.hpp"
-#include <list>
-#include <memory>
-
-/**
- * @namespace dynamical_systems
- * @brief Systems of equations relating state variables to their derivatives
- */
-namespace dynamical_systems {
-/**
- * @class DynamicalSystem
- * @brief Abstract class to define a DynamicalSystem either in joint or cartesian spaces
- */
-template<class S>
-class DynamicalSystem {
-private:
-  S base_frame_; ///< frame in which the dynamical system is expressed
-
-protected:
-  /**
-   * @brief Compute the dynamics of the input state.
-   * Internal function, to be redefined based on the
-   * type of dynamical system, called by the evaluate
-   * function
-   * @param state the input state
-   * @return the output state
-   */
-  virtual S compute_dynamics(const S& state) const = 0;
-
-public:
-  /**
-   * @brief Empty constructor
-   */
-  explicit DynamicalSystem();
-
-  /**
-   * @brief Constructor with a provided reference frame
-   * @param base_frame the reference frame in which the dynamics is computed
-   */
-  explicit DynamicalSystem(const S& base_frame);
-
-  /**
-   * @brief Constructor with a provided reference frame name
-   * @param base_frame the name of the reference frame in which the dynamics is computed
-   */
-  explicit DynamicalSystem(const std::string& base_frame);
-
-  /**
-   * @brief Evaluate the value of the dynamical system at a given state
-   * @param state state at wich to perform the evaluation
-   * @return the state (velocity) to move toward the attractor
-   */
-  S evaluate(const S& state) const;
-
-  /**
-   * @brief Return a list of all the parameters of the dynamical system
-   * @return the list of parameters
-   */
-  virtual std::list<std::shared_ptr<state_representation::ParameterInterface>> get_parameters() const;
-
-  /**
-   * @brief Return the base frame of the dynamical system
-   * @return the base frame
-   */
-  const S& get_base_frame() const;
-
-  /**
-   * @brief Set the base frame of the dynamical system
-   * @param base_frame the new base frame
-   */
-  virtual void set_base_frame(const S& base_frame);
-
-  /**
-   * @brief Check compatibility between a state and the dynamical system
-   * @param state the state to check for compatibility
-   * @return true if the state is compatible with the dynamical system
-   */
-  virtual bool is_compatible(const S& state) const;
-};
-
-template<class S>
-DynamicalSystem<S>::DynamicalSystem(const S& base_frame) : base_frame_(base_frame) {}
-
-template<class S>
-std::list<std::shared_ptr<state_representation::ParameterInterface>> DynamicalSystem<S>::get_parameters() const {
-  std::list<std::shared_ptr<state_representation::ParameterInterface>> param_list;
-  return param_list;
-}
-
-template<class S>
-inline const S& DynamicalSystem<S>::get_base_frame() const {
-  return this->base_frame_;
-}
-
-template<class S>
-inline void DynamicalSystem<S>::set_base_frame(const S& base_frame) {
-  this->base_frame_ = base_frame;
-}
-}// namespace dynamical_systems
diff --git a/source/dynamical_systems/include/dynamical_systems/DynamicalSystemFactory.hpp b/source/dynamical_systems/include/dynamical_systems/DynamicalSystemFactory.hpp
new file mode 100644
index 000000000..77db8ce0a
--- /dev/null
+++ b/source/dynamical_systems/include/dynamical_systems/DynamicalSystemFactory.hpp
@@ -0,0 +1,29 @@
+#pragma once
+
+#include "dynamical_systems/IDynamicalSystem.hpp"
+
+namespace dynamical_systems {
+
+/**
+ * @class DynamicalSystemFactory
+ * @brief Factory to create a shared pointer to a dynamical system.
+ * @tparam S Underlying state type of the dynamical system
+ */
+template<class S>
+class DynamicalSystemFactory {
+public:
+  /**
+   * @brief Enumeration of the implemented dynamical systems
+   */
+  enum class DYNAMICAL_SYSTEM {
+    NONE, CIRCULAR, POINT_ATTRACTOR, RING
+  };
+
+  /**
+   * @brief Create a dynamical system of the desired type.
+   * @param type Underlying state type of the dynamical system
+   * @return The shared pointer to the dynamical system
+   */
+  static std::shared_ptr<IDynamicalSystem<S>> create_dynamical_system(DYNAMICAL_SYSTEM type);
+};
+}// namespace dynamical_systems
diff --git a/source/dynamical_systems/include/dynamical_systems/IDynamicalSystem.hpp b/source/dynamical_systems/include/dynamical_systems/IDynamicalSystem.hpp
new file mode 100644
index 000000000..062073057
--- /dev/null
+++ b/source/dynamical_systems/include/dynamical_systems/IDynamicalSystem.hpp
@@ -0,0 +1,78 @@
+#pragma once
+
+#include <list>
+#include <map>
+#include <memory>
+
+#include "state_representation/parameters/ParameterMap.hpp"
+
+/**
+ * @namespace dynamical_systems
+ * @brief Systems of equations relating state variables to their derivatives
+ */
+namespace dynamical_systems {
+
+/**
+ * @class IDynamicalSystem
+ * @brief Abstract class for a dynamical system.
+ * @tparam S Underlying state type of the dynamical system
+ */
+template<class S>
+class IDynamicalSystem : public state_representation::ParameterMap {
+public:
+  /**
+   * @brief Empty constructor
+   */
+  IDynamicalSystem() = default;
+
+  /**
+   * @brief Check compatibility between a state and the dynamical system.
+   * @param state The state to check for compatibility
+   * @return True if the state is compatible with the dynamical system
+   */
+  [[nodiscard]] virtual bool is_compatible(const S& state) const;
+
+  /**
+   * @brief Evaluate the value of the dynamical system at a given state.
+   * @param state State at which to perform the evaluation
+   * @return The resulting state (velocity) of the dynamical system
+   */
+  [[nodiscard]] S evaluate(const S& state) const;
+
+  /**
+   * @brief Return the base frame of the dynamical system.
+   * @return The base frame
+   */
+  [[nodiscard]] S get_base_frame() const;
+
+  /**
+   * @brief Set the base frame of the dynamical system.
+   * @param base_frame The new base frame
+   */
+  virtual void set_base_frame(const S& base_frame);
+
+protected:
+  /**
+   * @brief Compute the dynamics of the input state. Internal function,
+   * to be redefined based on the type of dynamical system, called
+   * by the evaluate function.
+   * @param state The input state
+   * @return The output state
+   */
+  [[nodiscard]] virtual S compute_dynamics(const S& state) const = 0;
+
+private:
+  S base_frame_; ///< frame in which the dynamical system is expressed
+};
+
+template<class S>
+S IDynamicalSystem<S>::get_base_frame() const {
+  return this->base_frame_;
+}
+
+template<class S>
+void IDynamicalSystem<S>::set_base_frame(const S& base_frame) {
+  this->base_frame_ = base_frame;
+}
+
+}// namespace dynamical_systems
diff --git a/source/dynamical_systems/include/dynamical_systems/Linear.hpp b/source/dynamical_systems/include/dynamical_systems/Linear.hpp
deleted file mode 100644
index c3e9b94f6..000000000
--- a/source/dynamical_systems/include/dynamical_systems/Linear.hpp
+++ /dev/null
@@ -1,218 +0,0 @@
-#pragma once
-
-#include "dynamical_systems/DynamicalSystem.hpp"
-#include "state_representation/exceptions/EmptyStateException.hpp"
-#include "state_representation/exceptions/IncompatibleReferenceFramesException.hpp"
-#include "state_representation/parameters/Parameter.hpp"
-#include "state_representation/robot/JointPositions.hpp"
-#include "state_representation/robot/JointState.hpp"
-#include "state_representation/space/cartesian/CartesianPose.hpp"
-#include "state_representation/space/cartesian/CartesianState.hpp"
-#include "state_representation/space/cartesian/CartesianTwist.hpp"
-
-namespace dynamical_systems {
-/**
- * @class Linear
- * @brief Represent a Linear dynamical system to move toward an attractor
- * @tparam S the type of space of the dynamical system (e.g. Cartesian or Joint)
- */
-template<class S>
-class Linear : public DynamicalSystem<S> {
-private:
-  std::shared_ptr<state_representation::Parameter<S>> attractor_;         ///< attractor of the dynamical system in the space
-  std::shared_ptr<state_representation::Parameter<Eigen::MatrixXd>> gain_;///< gain associate to the system
-
-protected:
-  /**
-   * @brief Compute the dynamics of the input state.
-   * Internal function, to be redefined based on the
-   * type of dynamical system, called by the evaluate
-   * function
-   * @param state the input state
-   * @return the output state
-   */
-  S compute_dynamics(const S& state) const override;
-
-public:
-  /**
-   * @brief Empty constructor
-   */
-  Linear();
-
-  /**
-   * @brief Constructor with specified attractor and iso gain
-   * @param attractor the attractor of the linear system
-   * @param iso_gain the iso gain of the system
-   */
-  explicit Linear(const S& attractor, double iso_gain = 1.0);
-
-  /**
-   * @brief Constructor with specified attractor and different gains specified as diagonal coefficients
-   * @param attractor the attractor of the linear system
-   * @param diagonal_coefficients the gains values specified as diagonal coefficients
-   */
-  Linear(const S& attractor, const std::vector<double>& diagonal_coefficients);
-
-  /**
-   * @brief Constructor with specified attractor and different gains specified as full gain matrix
-   * @param attractor the attractor of the linear system
-   * @param gain_matrix the gains values specified as a full matrix
-   */
-  Linear(const S& attractor, const Eigen::MatrixXd& gain_matrix);
-
-  /**
-   * @brief Getter of the attractor
-   * @return the attractor as a const reference
-   */
-  const S& get_attractor() const;
-
-  /**
-   * @brief Setter of the attractor as a new value
-   * @param attractor the new attractor
-   */
-  void set_attractor(const S& attractor);
-
-  /**
-   * @brief Setter of the base frame as a new value
-   * @param base_frame the new base frame
-   */
-  void set_base_frame(const S& base_frame) override;
-
-  /**
-   * @brief Getter of the gain attribute
-   * @return The gain value
-   */
-  const Eigen::MatrixXd& get_gain() const;
-
-  /**
-   * @brief Setter of the gain attribute
-   * @param iso_gain the gain value as an iso coefficient
-   */
-  void set_gain(double iso_gain);
-
-  /**
-   * @brief Setter of the gain attribute
-   * @param diagonal_coefficients the gain values as diagonal coefficients
-   */
-  void set_gain(const std::vector<double>& diagonal_coefficients);
-
-  /**
-   * @brief Setter of the gain attribute
-   * @param gain_matrix the gain values as a full gain matrix
-   */
-  void set_gain(const Eigen::MatrixXd& gain_matrix);
-
-  /**
-   * @brief Return a list of all the parameters of the dynamical system
-   * @return the list of parameters
-   */
-  std::list<std::shared_ptr<state_representation::ParameterInterface>> get_parameters() const;
-};
-
-template<>
-inline void Linear<state_representation::JointState>::set_gain(double iso_gain) {
-  int nb_joints = this->get_attractor().get_size();
-  this->gain_->set_value(iso_gain * Eigen::MatrixXd::Identity(nb_joints, nb_joints));
-}
-
-template<class S>
-inline const S& Linear<S>::get_attractor() const {
-  return this->attractor_->get_value();
-}
-
-template<class S>
-inline void Linear<S>::set_attractor(const S& attractor) {
-  this->attractor_->set_value(attractor);
-}
-
-template<>
-inline void Linear<state_representation::CartesianState>::set_attractor(const state_representation::CartesianState& attractor) {
-  if (attractor.is_empty()) {
-    throw state_representation::exceptions::EmptyStateException(attractor.get_name() + " state is empty");
-  }
-  if (this->get_base_frame().is_empty()) {
-    DynamicalSystem<state_representation::CartesianState>::set_base_frame(
-        state_representation::CartesianState::Identity(attractor.get_reference_frame(), attractor.get_reference_frame()));
-  }
-  // validate that the reference frame of the attractor is always compatible with the DS reference frame
-  if (attractor.get_reference_frame() != this->get_base_frame().get_name()) {
-    if (attractor.get_reference_frame() != this->get_base_frame().get_reference_frame()) {
-      throw state_representation::exceptions::IncompatibleReferenceFramesException(
-          "The reference frame of the attractor " + attractor.get_name() + " in frame "
-              + attractor.get_reference_frame() + " is incompatible with the base frame of the dynamical system "
-              + this->get_base_frame().get_name() + " in frame " + this->get_base_frame().get_reference_frame() + ".");
-    }
-    this->attractor_->set_value(this->get_base_frame().inverse() * attractor);
-  } else {
-    this->attractor_->set_value(attractor);
-  }
-}
-
-template<>
-inline void Linear<state_representation::JointState>::set_attractor(const state_representation::JointState& attractor) {
-  if (attractor.is_empty()) {
-    throw state_representation::exceptions::EmptyStateException(attractor.get_name() + " state is empty");
-  }
-  if (this->get_base_frame().is_empty()) {
-    DynamicalSystem<state_representation::JointState>::set_base_frame(
-        state_representation::JointState::Zero(attractor.get_name(), attractor.get_names()));
-  }
-  // validate that the attractor is compatible with the DS reference name
-  if (!this->is_compatible(attractor)) {
-    throw state_representation::exceptions::IncompatibleReferenceFramesException(
-        "The attractor " + attractor.get_name() + " is incompatible with the base frame of the dynamical system "
-            + this->get_base_frame().get_name() + ".");
-  }
-  this->attractor_->set_value(attractor);
-  if (this->get_gain().size() == 0) {
-    this->set_gain(1);
-  }
-}
-
-template<class S>
-inline void Linear<S>::set_base_frame(const S& base_frame) {
-  DynamicalSystem<S>::set_base_frame(base_frame);
-}
-
-template<>
-inline void Linear<state_representation::CartesianState>::set_base_frame(const state_representation::CartesianState& base_frame) {
-  if (base_frame.is_empty()) {
-    throw state_representation::exceptions::EmptyStateException(base_frame.get_name() + " state is empty");
-  }
-  DynamicalSystem<state_representation::CartesianState>::set_base_frame(base_frame);
-  if (!this->get_attractor().is_empty()) {
-    // update reference frame of attractor
-    auto attractor = this->get_attractor();
-    attractor.set_reference_frame(base_frame.get_name());
-    this->set_attractor(attractor);
-  }
-}
-
-template<>
-inline void Linear<state_representation::JointState>::set_base_frame(const state_representation::JointState& base_frame) {
-  if (base_frame.is_empty()) {
-    throw state_representation::exceptions::EmptyStateException(base_frame.get_name() + " state is empty");
-  }
-  DynamicalSystem<state_representation::JointState>::set_base_frame(base_frame);
-  if (!this->get_attractor().is_empty()) {
-    // update name of attractor
-    auto attractor = this->get_attractor();
-    attractor.set_name(base_frame.get_name());
-    attractor.set_names(base_frame.get_names());
-    this->set_attractor(attractor);
-  }
-}
-
-template<class S>
-inline const Eigen::MatrixXd& Linear<S>::get_gain() const {
-  return this->gain_->get_value();
-}
-
-template<class S>
-std::list<std::shared_ptr<state_representation::ParameterInterface>> Linear<S>::get_parameters() const {
-  std::list<std::shared_ptr<state_representation::ParameterInterface>> param_list;
-  param_list.push_back(this->attractor_);
-  param_list.push_back(this->gain_);
-  return param_list;
-}
-}// namespace dynamical_systems
diff --git a/source/dynamical_systems/include/dynamical_systems/PointAttractor.hpp b/source/dynamical_systems/include/dynamical_systems/PointAttractor.hpp
new file mode 100644
index 000000000..7e83b8fcf
--- /dev/null
+++ b/source/dynamical_systems/include/dynamical_systems/PointAttractor.hpp
@@ -0,0 +1,57 @@
+#pragma once
+
+#include "dynamical_systems/IDynamicalSystem.hpp"
+#include "state_representation/parameters/Parameter.hpp"
+
+namespace dynamical_systems {
+
+/**
+ * @class PointAttractor
+ * @brief Represents a dynamical system to move towards an attractor.
+ * @tparam S Underlying state type of the dynamical system
+ */
+template<class S>
+class PointAttractor : public IDynamicalSystem<S> {
+public:
+  /**
+   * @brief Empty constructor
+   */
+  PointAttractor();
+
+  /**
+   * @copydoc IDynamicalSystem::set_base_frame
+   */
+  void set_base_frame(const S& base_frame) override;
+
+  /**
+   * @copydoc IDynamicalSystem::compute_dynamics
+   */
+  [[nodiscard]] S compute_dynamics(const S& state) const override;
+
+  /**
+   * @copydoc IDynamicalSystem::is_compatible
+   */
+  [[nodiscard]] bool is_compatible(const S& state) const override;
+
+private:
+  /**
+   * @copydoc IDynamicalSystem::validate_and_set_parameter
+   */
+  void validate_and_set_parameter(const std::shared_ptr<state_representation::ParameterInterface>& parameter) override;
+
+  /**
+   * @brief Setter of the attractor as a new value
+   * @param attractor the new attractor
+   */
+  void set_attractor(const S& attractor);
+
+  /**
+   * @brief Setter of the gain as a new value
+   * @param attractor the new attractor
+   */
+  void set_gain(const std::shared_ptr<state_representation::ParameterInterface>& parameter, unsigned int expected_size);
+
+  std::shared_ptr<state_representation::Parameter<S>> attractor_; ///< attractor of the dynamical system in the space
+  std::shared_ptr<state_representation::Parameter<Eigen::MatrixXd>> gain_; ///< gain associate to the system
+};
+}// namespace dynamical_systems
diff --git a/source/dynamical_systems/include/dynamical_systems/Ring.hpp b/source/dynamical_systems/include/dynamical_systems/Ring.hpp
index 571e780a4..b62e37ace 100644
--- a/source/dynamical_systems/include/dynamical_systems/Ring.hpp
+++ b/source/dynamical_systems/include/dynamical_systems/Ring.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "dynamical_systems/DynamicalSystem.hpp"
+#include "dynamical_systems/IDynamicalSystem.hpp"
 #include "state_representation/parameters/Parameter.hpp"
 #include "state_representation/space/cartesian/CartesianPose.hpp"
 #include "state_representation/space/cartesian/CartesianState.hpp"
@@ -8,40 +8,12 @@
 #include <vector>
 
 namespace dynamical_systems {
+
 /**
  * @class Ring
- * @brief Represent a Ring dynamical system limit cycle to move around a radius within a fixed width
+ * @brief Represent a Ring dynamical system limit cycle to move around a radius within a fixed width.
  */
-class Ring : public DynamicalSystem<state_representation::CartesianState> {
-private:
-  typedef std::shared_ptr<state_representation::Parameter<double>> ptr_param_double_t;
-  std::shared_ptr<state_representation::Parameter<state_representation::CartesianPose>> center_; ///< ring center
-  std::shared_ptr<state_representation::Parameter<state_representation::CartesianPose>>
-      rotation_offset_; ///< orientation of attractor in circle frame
-  ptr_param_double_t radius_; ///< ring radius [m]
-  ptr_param_double_t width_; ///< distance around radius where field rotates [m]
-  ptr_param_double_t speed_; ///< desired linear speed when travelling along the circle radius [m/s]
-  ptr_param_double_t field_strength_; ///< scale factor for desired speed outside of radius + width
-  ptr_param_double_t normal_gain_; ///< scale factor for the speed normal to the circular plane
-  ptr_param_double_t angular_gain_; ///< scale factor for angular velocity restitution
-
-  Eigen::Vector3d calculate_local_linear_velocity(const state_representation::CartesianPose& pose,
-                                                  double& local_field_strength) const;
-  Eigen::Vector3d calculate_local_angular_velocity(const state_representation::CartesianPose& pose,
-                                                   const Eigen::Vector3d& linear_velocity,
-                                                   double local_field_strength) const;
-
-protected:
-  /**
-   * @brief Compute the dynamics of the input state.
-   * Internal function, to be redefined based on the
-   * type of dynamical system, called by the evaluate
-   * function
-   * @param state the input state
-   * @return the output state
-   */
-  state_representation::CartesianState compute_dynamics(const state_representation::CartesianState& state) const override;
-
+class Ring : public IDynamicalSystem<state_representation::CartesianState> {
 public:
   /**
    * @brief Empty constructor
@@ -49,23 +21,23 @@ class Ring : public DynamicalSystem<state_representation::CartesianState> {
   Ring();
 
   /**
-   * @brief Default constructor with center and fixed radius
-   * @param center the center of the limit cycle
-   * @param radius radius of the limit cycle
+   * @copydoc IDynamicalSystem::set_parameter
    */
-  explicit Ring(const state_representation::CartesianState& center,
-                double radius = 1.0,
-                double width = 0.5,
-                double speed = 1.0,
-                double field_strength = 1.0,
-                double normal_gain = 1.0,
-                double angular_gain = 1.0);
+  void set_base_frame(const state_representation::CartesianState& base_frame) override;
 
   /**
-   * @brief Setter of the base frame as a new value
-   * @param base_frame the new base frame
+   * @copydoc IDynamicalSystem::compute_dynamics
    */
-  void set_base_frame(const state_representation::CartesianState& base_frame) override;
+  [[nodiscard]] state_representation::CartesianState
+  compute_dynamics(const state_representation::CartesianState& state) const override;
+
+private:
+  typedef std::shared_ptr<state_representation::Parameter<double>> ptr_param_double_t;
+
+  /**
+   * @copydoc IDynamicalSystem::validate_and_set_parameter
+   */
+  void validate_and_set_parameter(const std::shared_ptr<state_representation::ParameterInterface>& parameter) override;
 
   /**
    * @brief Setter of the center as a new value
@@ -79,95 +51,29 @@ class Ring : public DynamicalSystem<state_representation::CartesianState> {
    */
   void set_rotation_offset(const Eigen::Quaterniond& rotation);
 
-  /**
-   * @brief Setter of the radius of the ring
-   * @param radius the radius [m]
-   */
-  void set_radius(double radius);
-
-  /**
-   * @brief Setter of the field width around the ring radius
-   * @param width the width [m]
-   */
-  void set_width(double width);
-
-  /**
-   * @brief Setter of the linear speed of the ring DS
-   * @param speed the linear speed [m/s]
-   */
-  void set_speed(double speed);
-
-  /**
-   * @brief Setter of the field strength
-   * @param field_strength the field strength
-   */
-  void set_field_strength(double field_strength);
-
-  /**
-   * @brief Setter of the gain normal to the ring plane
-   * @param normal_gain the normal gain
-   */
-  void set_normal_gain(double normal_gain);
-
-  /**
-   * @brief Setter of the angular restitution gain
-   * @param angular_gain the angular gain
-   */
-  void set_angular_gain(double angular_gain);
-
-  /**
-   * @brief Getter of the center
-   * @return the center as a const reference
-   */
-  const state_representation::CartesianPose& get_center() const;
-
   /**
    * @brief Getter of the rotation offset in the center frame
    * @return the rotation offset as a quaternion
    */
-  Eigen::Quaterniond get_rotation_offset() const;
+  [[nodiscard]] Eigen::Quaterniond get_rotation_offset() const;
 
-  /**
-   * @brief Getter of the radius of the ring
-   * @return the radius [m]
-   */
-  double get_radius() const;
+  [[nodiscard]] Eigen::Vector3d calculate_local_linear_velocity(
+      const state_representation::CartesianPose& pose, double& local_field_strength
+  ) const;
 
-  /**
-   * @brief Getter of the field width around the ring radius
-   * @return the width [m]
-   */
-  double get_width() const;
-
-  /**
-   * @brief Getter of the linear speed of the ring DS
-   * @return the linear speed [m/s]
-   */
-  double get_speed() const;
-
-  /**
-   * @brief Getter of the field strength
-   * @return the field strength
-   */
-  double get_field_strength() const;
+  [[nodiscard]] Eigen::Vector3d calculate_local_angular_velocity(
+      const state_representation::CartesianPose& pose, const Eigen::Vector3d& linear_velocity,
+      double local_field_strength
+  ) const;
 
-  /**
-   * @brief Getter of the gain normal to the ring plane
-   * @return the normal gain
-   */
-  double get_normal_gain() const;
-
-  /**
-   * @brief Getter of the angular restitution gain
-   * @return the angular gain
-   */
-  double get_angular_gain() const;
-
-  /**
-   * @brief Return a list of all the parameters of the dynamical system
-   * @return the list of parameters
-   */
-  std::list<std::shared_ptr<state_representation::ParameterInterface>> get_parameters() const override;
+  std::shared_ptr<state_representation::Parameter<state_representation::CartesianPose>> center_; ///< ring center
+  std::shared_ptr<state_representation::Parameter<state_representation::CartesianPose>>
+      rotation_offset_; ///< orientation of attractor in circle frame
+  ptr_param_double_t radius_; ///< ring radius [m]
+  ptr_param_double_t width_; ///< distance around radius where field rotates [m]
+  ptr_param_double_t speed_; ///< desired linear speed when travelling along the circle radius [m/s]
+  ptr_param_double_t field_strength_; ///< scale factor for desired speed outside of radius + width
+  ptr_param_double_t normal_gain_; ///< scale factor for the speed normal to the circular plane
+  ptr_param_double_t angular_gain_; ///< scale factor for angular velocity restitution
 };
-
-}// namespace dynamical_systems
\ No newline at end of file
+}// namespace dynamical_systems
diff --git a/source/dynamical_systems/src/Circular.cpp b/source/dynamical_systems/src/Circular.cpp
index fccc0c3a9..2dd6e63e0 100644
--- a/source/dynamical_systems/src/Circular.cpp
+++ b/source/dynamical_systems/src/Circular.cpp
@@ -1,88 +1,109 @@
 #include "dynamical_systems/Circular.hpp"
 
 #include "dynamical_systems/exceptions/EmptyAttractorException.hpp"
+#include "state_representation/exceptions/InvalidParameterException.hpp"
+
+#include "state_representation/exceptions/EmptyStateException.hpp"
 
 using namespace state_representation;
 
 namespace dynamical_systems {
 
 Circular::Circular() :
-    DynamicalSystem<CartesianState>(),
     limit_cycle_(std::make_shared<Parameter<Ellipsoid>>("limit_cycle", Ellipsoid("limit_cycle", "limit_cycle"))),
     planar_gain_(std::make_shared<Parameter<double>>("planar_gain", 1.0)),
     normal_gain_(std::make_shared<Parameter<double>>("normal_gain", 1.0)),
     circular_velocity_(std::make_shared<Parameter<double>>("circular_velocity", M_PI / 2)) {
   this->limit_cycle_->get_value().set_center_state(CartesianState("limit_cycle", "limit_cycle"));
+  this->parameters_.insert(std::make_pair("limit_cycle", this->limit_cycle_));
+  this->parameters_.insert(std::make_pair("planar_gain", this->planar_gain_));
+  this->parameters_.insert(std::make_pair("normal_gain", this->normal_gain_));
+  this->parameters_.insert(std::make_pair("circular_velocity", this->circular_velocity_));
+}
+
+void Circular::set_limit_cycle(Ellipsoid& limit_cycle) {
+  const auto& center = limit_cycle.get_center_state();
+  if (center.is_empty()) {
+    throw state_representation::exceptions::EmptyStateException(center.get_name() + " state is empty");
+  }
+  if (this->get_base_frame().is_empty()) {
+    IDynamicalSystem<CartesianState>::set_base_frame(
+        CartesianState::Identity(
+            center.get_reference_frame(), center.get_reference_frame()));
+  }
+  if (center.get_reference_frame() != this->get_base_frame().get_name()) {
+    if (center.get_reference_frame() != this->get_base_frame().get_reference_frame()) {
+      throw state_representation::exceptions::IncompatibleReferenceFramesException(
+          "The reference frame of the center " + center.get_name() + " in frame " + center.get_reference_frame()
+              + " is incompatible with the base frame of the dynamical system " + this->get_base_frame().get_name()
+              + " in frame " + this->get_base_frame().get_reference_frame() + ".");
+    }
+    limit_cycle.set_center_state(this->get_base_frame().inverse() * center);
+  }
+  this->limit_cycle_->set_value(limit_cycle);
 }
 
-Circular::Circular(const CartesianState& center, double radius, double gain, double circular_velocity) :
-    DynamicalSystem(center.get_reference_frame()),
-    limit_cycle_(std::make_shared<Parameter<Ellipsoid>>("limit_cycle",
-                                                        Ellipsoid(center.get_name(), center.get_reference_frame()))),
-    planar_gain_(std::make_shared<Parameter<double>>("planar_gain", gain)),
-    normal_gain_(std::make_shared<Parameter<double>>("normal_gain", gain)),
-    circular_velocity_(std::make_shared<Parameter<double>>("circular_velocity", circular_velocity)) {
-  this->limit_cycle_->get_value().set_center_state(center);
-  this->limit_cycle_->get_value().set_axis_lengths({radius, radius});
+void Circular::set_base_frame(const CartesianState& base_frame) {
+  if (base_frame.is_empty()) {
+    throw state_representation::exceptions::EmptyStateException(base_frame.get_name() + " state is empty");
+  }
+  IDynamicalSystem<CartesianState>::set_base_frame(base_frame);
+  // update reference frame of center
+  if (!this->limit_cycle_->get_value().get_center_state().is_empty()) {
+    auto center_state = this->limit_cycle_->get_value().get_center_state();
+    center_state.set_reference_frame(base_frame.get_name());
+    this->limit_cycle_->get_value().set_center_state(center_state);
+  }
 }
 
-Circular::Circular(const Ellipsoid& limit_cycle, double gain, double circular_velocity) :
-    DynamicalSystem(limit_cycle.get_center_state().get_reference_frame()),
-    limit_cycle_(std::make_shared<Parameter<Ellipsoid>>("limit_cycle", limit_cycle)),
-    planar_gain_(std::make_shared<Parameter<double>>("planar_gain", gain)),
-    normal_gain_(std::make_shared<Parameter<double>>("normal_gain", gain)),
-    circular_velocity_(std::make_shared<Parameter<double>>("circular_velocity", circular_velocity)) {}
+void Circular::validate_and_set_parameter(const std::shared_ptr<ParameterInterface>& parameter) {
+  if (parameter->get_name() == "limit_cycle") {
+    this->assert_parameter_valid(parameter);
+    this->set_limit_cycle(std::static_pointer_cast<Parameter<Ellipsoid>>(parameter)->get_value());
+  } else if (parameter->get_name() == "planar_gain") {
+    this->assert_parameter_valid(parameter);
+    this->planar_gain_->set_value(std::static_pointer_cast<Parameter<double>>(parameter)->get_value());
+  } else if (parameter->get_name() == "normal_gain") {
+    this->assert_parameter_valid(parameter);
+    this->normal_gain_->set_value(std::static_pointer_cast<Parameter<double>>(parameter)->get_value());
+  } else if (parameter->get_name() == "circular_velocity") {
+    this->assert_parameter_valid(parameter);
+    this->circular_velocity_->set_value(std::static_pointer_cast<Parameter<double>>(parameter)->get_value());
+  } else {
+    throw state_representation::exceptions::InvalidParameterException(
+        "No parameter with name '" + parameter->get_name() + "' found");
+  }
+}
 
 CartesianState Circular::compute_dynamics(const CartesianState& state) const {
-  if (this->get_limit_cycle().get_center_state().is_empty()) {
+  if (this->limit_cycle_->get_value().get_center_state().is_empty()) {
     throw exceptions::EmptyAttractorException("The limit cycle of the dynamical system is empty.");
   }
   // put the point in the reference of the center
   auto pose = CartesianPose(state);
-  pose = this->get_limit_cycle().get_rotation().inverse() * this->get_center().inverse() * pose;
+  pose = this->limit_cycle_->get_value().get_rotation().inverse()
+      * this->limit_cycle_->get_value().get_center_pose().inverse() * pose;
 
   CartesianTwist velocity(pose.get_name(), pose.get_reference_frame());
   Eigen::Vector3d linear_velocity;
-  linear_velocity(2) = -this->get_normal_gain() * pose.get_position()(2);
+  linear_velocity(2) = -this->normal_gain_->get_value() * pose.get_position()(2);
 
-  std::vector<double> radiuses = this->get_radiuses();
+  std::vector<double> radiuses = this->limit_cycle_->get_value().get_axis_lengths();
 
   double a2ratio = (pose.get_position()[0] * pose.get_position()[0]) / (radiuses[0] * radiuses[0]);
   double b2ratio = (pose.get_position()[1] * pose.get_position()[1]) / (radiuses[1] * radiuses[1]);
-  double dradius = -this->get_planar_gain() * radiuses[0] * radiuses[1] * (a2ratio + b2ratio - 1);
+  double dradius = -this->planar_gain_->get_value() * radiuses[0] * radiuses[1] * (a2ratio + b2ratio - 1);
   double tangent_velocity_x = -radiuses[0] / radiuses[1] * pose.get_position()[1];
   double tangent_velocity_y = radiuses[1] / radiuses[0] * pose.get_position()[0];
 
-  linear_velocity(0) = this->get_circular_velocity() * tangent_velocity_x + dradius * tangent_velocity_y;
-  linear_velocity(1) = this->get_circular_velocity() * tangent_velocity_y - dradius * tangent_velocity_x;
+  linear_velocity(0) = this->circular_velocity_->get_value() * tangent_velocity_x + dradius * tangent_velocity_y;
+  linear_velocity(1) = this->circular_velocity_->get_value() * tangent_velocity_y - dradius * tangent_velocity_x;
 
   velocity.set_linear_velocity(linear_velocity);
   velocity.set_angular_velocity(Eigen::Vector3d::Zero());
 
   //compute back the linear velocity in the desired frame
-  auto frame = this->get_center() * this->get_limit_cycle().get_rotation();
+  auto frame = this->limit_cycle_->get_value().get_center_pose() * this->limit_cycle_->get_value().get_rotation();
   return CartesianState(frame) * velocity;
 }
-
-std::list<std::shared_ptr<ParameterInterface>> Circular::get_parameters() const {
-  std::list<std::shared_ptr<ParameterInterface>> param_list;
-  param_list.push_back(this->limit_cycle_);
-  param_list.push_back(this->planar_gain_);
-  param_list.push_back(this->normal_gain_);
-  param_list.push_back(this->circular_velocity_);
-  return param_list;
-}
-
-void Circular::set_base_frame(const CartesianState& base_frame) {
-  if (base_frame.is_empty()) {
-    throw state_representation::exceptions::EmptyStateException(base_frame.get_name() + " state is empty");
-  }
-  DynamicalSystem<CartesianState>::set_base_frame(base_frame);
-  // update reference frame of center
-  if (!this->limit_cycle_->get_value().get_center_state().is_empty()) {
-    auto center_state = this->limit_cycle_->get_value().get_center_state();
-    center_state.set_reference_frame(base_frame.get_name());
-    this->limit_cycle_->get_value().set_center_state(center_state);
-  }
-}
-}// namespace dynamical_systems
\ No newline at end of file
+}// namespace dynamical_systems
diff --git a/source/dynamical_systems/src/DynamicalSystemFactory.cpp b/source/dynamical_systems/src/DynamicalSystemFactory.cpp
new file mode 100644
index 000000000..b5f87eb23
--- /dev/null
+++ b/source/dynamical_systems/src/DynamicalSystemFactory.cpp
@@ -0,0 +1,40 @@
+#include "dynamical_systems/DynamicalSystemFactory.hpp"
+
+#include "dynamical_systems/Circular.hpp"
+#include "dynamical_systems/DefaultDynamicalSystem.hpp"
+#include "dynamical_systems/PointAttractor.hpp"
+#include "dynamical_systems/Ring.hpp"
+#include "state_representation/space/joint/JointState.hpp"
+
+using namespace state_representation;
+
+namespace dynamical_systems {
+
+template<>
+std::shared_ptr<IDynamicalSystem<CartesianState>>
+DynamicalSystemFactory<CartesianState>::create_dynamical_system(DYNAMICAL_SYSTEM type) {
+  switch (type) {
+    case DYNAMICAL_SYSTEM::POINT_ATTRACTOR:
+      return std::make_shared<PointAttractor<CartesianState>>();
+    case DYNAMICAL_SYSTEM::CIRCULAR:
+      return std::make_shared<Circular>();
+    case DYNAMICAL_SYSTEM::RING:
+      return std::make_shared<Ring>();
+    default:
+    case DYNAMICAL_SYSTEM::NONE:
+      return std::make_shared<DefaultDynamicalSystem<CartesianState>>();
+  }
+}
+
+template<>
+std::shared_ptr<IDynamicalSystem<JointState>>
+DynamicalSystemFactory<JointState>::create_dynamical_system(DYNAMICAL_SYSTEM type) {
+  switch (type) {
+    case DYNAMICAL_SYSTEM::POINT_ATTRACTOR:
+      return std::make_shared<PointAttractor<JointState>>();
+    default:
+    case DYNAMICAL_SYSTEM::NONE:
+      return std::make_shared<DefaultDynamicalSystem<JointState>>();
+  }
+}
+}// namespace dynamical_systems
diff --git a/source/dynamical_systems/src/DynamicalSystem.cpp b/source/dynamical_systems/src/IDynamicalSystem.cpp
similarity index 50%
rename from source/dynamical_systems/src/DynamicalSystem.cpp
rename to source/dynamical_systems/src/IDynamicalSystem.cpp
index f26b6837b..1096a09a4 100644
--- a/source/dynamical_systems/src/DynamicalSystem.cpp
+++ b/source/dynamical_systems/src/IDynamicalSystem.cpp
@@ -1,62 +1,39 @@
-#include "dynamical_systems/DynamicalSystem.hpp"
-#include "state_representation/robot/JointState.hpp"
-#include "state_representation/space/cartesian/CartesianState.hpp"
-#include "state_representation/exceptions/IncompatibleReferenceFramesException.hpp"
-#include "dynamical_systems/exceptions/NotImplementedException.hpp"
+#include "dynamical_systems/IDynamicalSystem.hpp"
+
 #include "dynamical_systems/exceptions/EmptyBaseFrameException.hpp"
+#include "dynamical_systems/exceptions/NotImplementedException.hpp"
+
+#include "state_representation/exceptions/IncompatibleReferenceFramesException.hpp"
+#include "state_representation/exceptions/IncompatibleStatesException.hpp"
+#include "state_representation/space/joint/JointState.hpp"
+#include "state_representation/space/cartesian/CartesianState.hpp"
 
 using namespace state_representation;
 
 namespace dynamical_systems {
 template<class S>
-DynamicalSystem<S>::DynamicalSystem() {}
-
-template<>
-DynamicalSystem<JointState>::DynamicalSystem() : base_frame_(JointState()) {}
-
-template<>
-DynamicalSystem<CartesianState>::DynamicalSystem() : base_frame_(CartesianState()) {}
-
-template<>
-DynamicalSystem<CartesianState>::DynamicalSystem(const std::string& base_frame) :
-    base_frame_(CartesianState::Identity(base_frame, base_frame)) {}
-
-template<class S>
-bool DynamicalSystem<S>::is_compatible(const S&) const {
-  throw exceptions::NotImplementedException("is_compatible(state) not implemented for this type of state");
+bool IDynamicalSystem<S>::is_compatible(const S&) const {
+  throw exceptions::NotImplementedException("is_compatible(state) not implemented for this type of state.");
 }
 
 template<>
-bool DynamicalSystem<state_representation::CartesianState>::is_compatible(const state_representation::CartesianState& state) const {
+bool IDynamicalSystem<CartesianState>::is_compatible(const CartesianState& state) const {
   return !(state.get_reference_frame() != this->get_base_frame().get_name()
       && state.get_reference_frame() != this->get_base_frame().get_reference_frame());
 }
 
 template<>
-bool DynamicalSystem<state_representation::JointState>::is_compatible(const state_representation::JointState& state) const {
-  return this->base_frame_.is_compatible(state);
+bool IDynamicalSystem<JointState>::is_compatible(const JointState&) const {
+  return true;
 }
 
 template<class S>
-S DynamicalSystem<S>::evaluate(const S& state) const {
+S IDynamicalSystem<S>::evaluate(const S& state) const {
   return this->compute_dynamics(state);
 }
 
 template<>
-JointState DynamicalSystem<JointState>::evaluate(const JointState& state) const {
-  if (this->get_base_frame().is_empty()) {
-    throw exceptions::EmptyBaseFrameException("The base frame of the dynamical system is empty.");
-  }
-  if (!this->is_compatible(state)) {
-    throw state_representation::exceptions::IncompatibleReferenceFramesException(
-        "The evaluated state " + state.get_name() + " is incompatible with the base frame of the dynamical system "
-            + this->get_base_frame().get_name() + ".");
-  }
-  return this->compute_dynamics(state);
-}
-
-template<>
-CartesianState DynamicalSystem<CartesianState>::evaluate(const CartesianState& state) const {
+CartesianState IDynamicalSystem<CartesianState>::evaluate(const CartesianState& state) const {
   if (this->get_base_frame().is_empty()) {
     throw exceptions::EmptyBaseFrameException("The base frame of the dynamical system is empty.");
   }
@@ -65,13 +42,25 @@ CartesianState DynamicalSystem<CartesianState>::evaluate(const CartesianState& s
       throw state_representation::exceptions::IncompatibleReferenceFramesException(
           "The evaluated state " + state.get_name() + " in frame " + state.get_reference_frame()
               + " is incompatible with the base frame of the dynamical system " + this->get_base_frame().get_name()
-              + " in frame " + this->get_base_frame().get_reference_frame() + ".");
+              + " in frame " + this->get_base_frame().get_reference_frame() + "."
+      );
     }
     CartesianState result = this->get_base_frame().inverse() * state;
     result = this->compute_dynamics(result);
-    return this->get_base_frame() * result;
+    return result.is_empty() ? result : this->get_base_frame() * result;
   } else {
     return this->compute_dynamics(state);
   }
 }
-}// namespace dynamical_systems
\ No newline at end of file
+
+template<>
+JointState IDynamicalSystem<JointState>::evaluate(const JointState& state) const {
+  if (!this->is_compatible(state)) {
+    throw state_representation::exceptions::IncompatibleStatesException(
+        "The attractor and the provided state are not compatible."
+    );
+  }
+  return this->compute_dynamics(state);
+}
+
+}// namespace dynamical_systems
diff --git a/source/dynamical_systems/src/Linear.cpp b/source/dynamical_systems/src/Linear.cpp
deleted file mode 100644
index 43ef93c19..000000000
--- a/source/dynamical_systems/src/Linear.cpp
+++ /dev/null
@@ -1,158 +0,0 @@
-#include "dynamical_systems/Linear.hpp"
-
-#include "dynamical_systems/exceptions/IncompatibleSizeException.hpp"
-#include "dynamical_systems/exceptions/EmptyAttractorException.hpp"
-
-using namespace state_representation;
-
-namespace dynamical_systems {
-
-template<>
-void Linear<CartesianState>::set_gain(double iso_gain) {
-  this->gain_->set_value(iso_gain * Eigen::MatrixXd::Identity(6, 6));
-}
-
-template<>
-void Linear<CartesianState>::set_gain(const std::vector<double>& diagonal_coefficients) {
-  if (diagonal_coefficients.size() != 6) {
-    throw exceptions::IncompatibleSizeException(
-        "The provided diagonal coefficients do not correspond to the expected size of 6 elements");
-  }
-  Eigen::VectorXd diagonal = Eigen::VectorXd::Map(diagonal_coefficients.data(), 6);
-  this->gain_->set_value(diagonal.asDiagonal());
-}
-
-template<>
-void Linear<JointState>::set_gain(const std::vector<double>& diagonal_coefficients) {
-  size_t nb_joints = this->get_attractor().get_size();
-  if (diagonal_coefficients.size() != nb_joints) {
-    throw exceptions::IncompatibleSizeException(
-        "The provided diagonal coefficients do not correspond to the expected size of "
-            + std::to_string(nb_joints) + " elements");
-  }
-  Eigen::VectorXd diagonal = Eigen::VectorXd::Map(diagonal_coefficients.data(), nb_joints);
-  this->gain_->set_value(diagonal.asDiagonal());
-}
-
-template<>
-void Linear<CartesianState>::set_gain(const Eigen::MatrixXd& gain_matrix) {
-  if (gain_matrix.rows() != 6 && gain_matrix.cols() != 6) {
-    throw exceptions::IncompatibleSizeException("The provided gain matrix do not have the expected size of 6x6 elements");
-  }
-  this->gain_->set_value(gain_matrix);
-}
-
-template<>
-void Linear<JointState>::set_gain(const Eigen::MatrixXd& gain_matrix) {
-  int nb_joints = this->get_attractor().get_size();
-  if (gain_matrix.rows() != nb_joints && gain_matrix.cols() != nb_joints) {
-    throw exceptions::IncompatibleSizeException(
-        "The provided gain matrix do not have the expected size of " + std::to_string(nb_joints) + "x"
-            + std::to_string(nb_joints) + " elements");
-  }
-  this->gain_->set_value(gain_matrix);
-}
-
-template<>
-Linear<CartesianState>::Linear() :
-    DynamicalSystem<CartesianState>(),
-    attractor_(std::make_shared<Parameter<CartesianState>>(Parameter<CartesianPose>("attractor", CartesianPose()))),
-    gain_(std::make_shared<Parameter<Eigen::MatrixXd>>("gain")) {
-  this->attractor_->get_value().set_empty();
-  this->set_gain(1);
-}
-
-template<>
-Linear<JointState>::Linear() :
-    DynamicalSystem<JointState>(),
-    attractor_(std::make_shared<Parameter<JointState>>(Parameter<JointPositions>("attractor", JointPositions()))),
-    gain_(std::make_shared<Parameter<Eigen::MatrixXd>>("gain")) {
-  this->attractor_->get_value().set_empty();
-}
-
-template<>
-Linear<CartesianState>::Linear(const CartesianState& attractor, double iso_gain) :
-    DynamicalSystem<CartesianState>(attractor.get_reference_frame()),
-    attractor_(std::make_shared<Parameter<CartesianState>>(Parameter<CartesianPose>("attractor", attractor))),
-    gain_(std::make_shared<Parameter<Eigen::MatrixXd>>("gain")) {
-  if (attractor.is_empty()) {
-    throw state_representation::exceptions::EmptyStateException(attractor.get_name() + " state is empty");
-  }
-  this->set_gain(iso_gain);
-}
-
-template<>
-Linear<JointState>::Linear(const JointState& attractor, double iso_gain) :
-    DynamicalSystem<JointState>(JointState::Zero(attractor.get_name(), attractor.get_names())),
-    attractor_(std::make_shared<Parameter<JointState>>(Parameter<JointPositions>("attractor", attractor))),
-    gain_(std::make_shared<Parameter<Eigen::MatrixXd>>("gain")) {
-  if (attractor.is_empty()) {
-    throw state_representation::exceptions::EmptyStateException(attractor.get_name() + " state is empty");
-  }
-  this->set_gain(iso_gain);
-}
-
-template<>
-Linear<CartesianState>::Linear(const CartesianState& attractor, const std::vector<double>& diagonal_coefficients) :
-    DynamicalSystem<CartesianState>(attractor.get_reference_frame()),
-    attractor_(std::make_shared<Parameter<CartesianState>>(Parameter<CartesianPose>("attractor", attractor))),
-    gain_(std::make_shared<Parameter<Eigen::MatrixXd>>("gain")) {
-  if (attractor.is_empty()) {
-    throw state_representation::exceptions::EmptyStateException(attractor.get_name() + " state is empty");
-  }
-  this->set_gain(diagonal_coefficients);
-}
-
-template<>
-Linear<JointState>::Linear(const JointState& attractor, const std::vector<double>& diagonal_coefficients) :
-    DynamicalSystem<JointState>(),
-    attractor_(std::make_shared<Parameter<JointState>>(Parameter<JointPositions>("attractor", attractor))),
-    gain_(std::make_shared<Parameter<Eigen::MatrixXd>>("gain")) {
-  if (attractor.is_empty()) {
-    throw state_representation::exceptions::EmptyStateException(attractor.get_name() + " state is empty");
-  }
-  this->set_gain(diagonal_coefficients);
-}
-
-template<>
-Linear<CartesianState>::Linear(const CartesianState& attractor, const Eigen::MatrixXd& gain_matrix) :
-    DynamicalSystem<CartesianState>(attractor.get_reference_frame()),
-    attractor_(std::make_shared<Parameter<CartesianState>>(Parameter<CartesianPose>("attractor", attractor))),
-    gain_(std::make_shared<Parameter<Eigen::MatrixXd>>("gain")) {
-  if (attractor.is_empty()) {
-    throw state_representation::exceptions::EmptyStateException(attractor.get_name() + " state is empty");
-  }
-  this->set_gain(gain_matrix);
-}
-
-template<>
-Linear<JointState>::Linear(const JointState& attractor, const Eigen::MatrixXd& gain_matrix) :
-    DynamicalSystem<JointState>(),
-    attractor_(std::make_shared<Parameter<JointState>>(Parameter<JointPositions>("attractor", attractor))),
-    gain_(std::make_shared<Parameter<Eigen::MatrixXd>>("gain")) {
-  if (attractor.is_empty()) {
-    throw state_representation::exceptions::EmptyStateException(attractor.get_name() + " state is empty");
-  }
-  this->set_gain(gain_matrix);
-}
-
-template<>
-CartesianState Linear<CartesianState>::compute_dynamics(const CartesianState& state) const {
-  if (this->get_attractor().is_empty()) {
-    throw exceptions::EmptyAttractorException("The attractor of the dynamical system is empty.");
-  }
-  CartesianTwist twist = CartesianPose(this->get_attractor()) - CartesianPose(state);
-  twist *= this->get_gain();
-  return twist;
-}
-
-template<>
-JointState Linear<JointState>::compute_dynamics(const JointState& state) const {
-  if (this->get_attractor().is_empty()) {
-    throw exceptions::EmptyAttractorException("The attractor of the dynamical system is empty.");
-  }
-  JointVelocities velocities = JointPositions(this->get_attractor()) - JointPositions(state);
-  velocities *= this->get_gain();
-  return velocities;
-}
-}// namespace dynamical_systems
\ No newline at end of file
diff --git a/source/dynamical_systems/src/PointAttractor.cpp b/source/dynamical_systems/src/PointAttractor.cpp
new file mode 100644
index 000000000..3f64b16e8
--- /dev/null
+++ b/source/dynamical_systems/src/PointAttractor.cpp
@@ -0,0 +1,188 @@
+#include "dynamical_systems/PointAttractor.hpp"
+
+#include "dynamical_systems/exceptions/NotImplementedException.hpp"
+#include "dynamical_systems/exceptions/EmptyAttractorException.hpp"
+#include "state_representation/exceptions/InvalidParameterException.hpp"
+#include "dynamical_systems/exceptions/IncompatibleSizeException.hpp"
+#include "state_representation/exceptions/EmptyStateException.hpp"
+#include "state_representation/exceptions/IncompatibleReferenceFramesException.hpp"
+#include "state_representation/exceptions/IncompatibleStatesException.hpp"
+#include "state_representation/space/cartesian/CartesianPose.hpp"
+#include "state_representation/space/joint/JointPositions.hpp"
+#include "state_representation/space/joint/JointState.hpp"
+
+using namespace state_representation;
+
+namespace dynamical_systems {
+
+template<>
+PointAttractor<CartesianState>::PointAttractor() :
+    attractor_(std::make_shared<Parameter<CartesianState>>(Parameter<CartesianPose>("attractor", CartesianPose()))),
+    gain_(std::make_shared<Parameter<Eigen::MatrixXd>>("gain", Eigen::MatrixXd::Identity(6, 6))) {
+  this->parameters_.insert(std::make_pair("attractor", attractor_));
+  this->parameters_.insert(std::make_pair("gain", gain_));
+}
+
+template<>
+PointAttractor<JointState>::PointAttractor() :
+    attractor_(std::make_shared<Parameter<JointState>>(Parameter<JointPositions>("attractor"))),
+    gain_(std::make_shared<Parameter<Eigen::MatrixXd>>("gain")) {
+  this->parameters_.insert(std::make_pair("attractor", attractor_));
+  this->parameters_.insert(std::make_pair("gain", gain_));
+}
+
+template<class S>
+bool PointAttractor<S>::is_compatible(const S& state) const {
+  return IDynamicalSystem<S>::is_compatible(state);
+}
+
+template bool PointAttractor<CartesianState>::is_compatible(const CartesianState& state) const;
+
+template<>
+bool PointAttractor<JointState>::is_compatible(const JointState& state) const {
+  auto attractor = this->get_parameter_value<JointPositions>("attractor");
+  if (attractor.is_empty()) {
+    throw exceptions::EmptyAttractorException("The attractor of the dynamical system is empty.");
+  }
+  bool compatible = (attractor.get_size() == state.get_size());
+  if (compatible) {
+    for (unsigned int i = 0; i < attractor.get_size(); ++i) {
+      compatible = (compatible && attractor.get_names()[i] == state.get_names()[i]);
+    }
+  }
+  return compatible;
+}
+
+template<class S>
+void PointAttractor<S>::set_gain(const std::shared_ptr<ParameterInterface>& parameter, unsigned int expected_size) {
+  if (parameter->get_type() == StateType::PARAMETER_DOUBLE) {
+    auto gain = std::static_pointer_cast<Parameter<double>>(parameter);
+    this->gain_->set_value(gain->get_value() * Eigen::MatrixXd::Identity(expected_size, expected_size));
+  } else if (parameter->get_type() == StateType::PARAMETER_DOUBLE_ARRAY) {
+    auto gain = std::static_pointer_cast<Parameter<std::vector<double>>>(parameter);
+    if (gain->get_value().size() != expected_size) {
+      throw exceptions::IncompatibleSizeException(
+          "The provided diagonal coefficients do not correspond to the expected size of the attractor"
+      );
+    }
+    Eigen::VectorXd diagonal = Eigen::VectorXd::Map(gain->get_value().data(), expected_size);
+    this->gain_->set_value(diagonal.asDiagonal());
+  } else if (parameter->get_type() == StateType::PARAMETER_MATRIX) {
+    auto gain = std::static_pointer_cast<Parameter<Eigen::MatrixXd>>(parameter);
+    if (gain->get_value().rows() != expected_size && gain->get_value().cols() != expected_size) {
+      throw exceptions::IncompatibleSizeException(
+          "The provided gain matrix do not have the expected size (" + std::to_string(expected_size) + "x"
+              + std::to_string(expected_size) + ")"
+      );
+    }
+    this->gain_->set_value(gain->get_value());
+  } else {
+    throw state_representation::exceptions::InvalidParameterException("Parameter 'gain' has incorrect type");
+  }
+}
+
+template<class S>
+void PointAttractor<S>::set_attractor(const S&) {
+  throw exceptions::NotImplementedException("set_attractor is not implemented for this type of DS");
+}
+
+template<>
+void PointAttractor<CartesianState>::set_attractor(const CartesianState& attractor) {
+  if (attractor.is_empty()) {
+    throw state_representation::exceptions::EmptyStateException(attractor.get_name() + " state is empty");
+  }
+  if (this->get_base_frame().is_empty()) {
+    IDynamicalSystem<CartesianState>::set_base_frame(
+        CartesianState::Identity(attractor.get_reference_frame(), attractor.get_reference_frame()));
+  }
+  // validate that the reference frame of the attractor is always compatible with the DS reference frame
+  if (attractor.get_reference_frame() != this->get_base_frame().get_name()) {
+    if (attractor.get_reference_frame() != this->get_base_frame().get_reference_frame()) {
+      throw state_representation::exceptions::IncompatibleReferenceFramesException(
+          "The reference frame of the attractor " + attractor.get_name() + " in frame "
+              + attractor.get_reference_frame() + " is incompatible with the base frame of the dynamical system "
+              + this->get_base_frame().get_name() + " in frame " + this->get_base_frame().get_reference_frame() + "."
+      );
+    }
+    this->attractor_->set_value(this->get_base_frame().inverse() * attractor);
+  } else {
+    this->attractor_->set_value(attractor);
+  }
+}
+
+template<>
+void PointAttractor<JointState>::set_attractor(const JointState& attractor) {
+  if (attractor.is_empty()) {
+    throw state_representation::exceptions::EmptyStateException(attractor.get_name() + " state is empty");
+  }
+  this->attractor_->set_value(attractor);
+  if (this->gain_->get_value().size() == 0) {
+    this->gain_->set_value(Eigen::MatrixXd::Identity(attractor.get_size(), attractor.get_size()));
+  }
+}
+
+template<class S>
+void PointAttractor<S>::set_base_frame(const S& base_frame) {
+  this->IDynamicalSystem<S>::set_base_frame(base_frame);
+}
+
+template void PointAttractor<JointState>::set_base_frame(const JointState& base_frame);
+
+template<>
+void PointAttractor<CartesianState>::set_base_frame(const CartesianState& base_frame) {
+  if (base_frame.is_empty()) {
+    throw state_representation::exceptions::EmptyStateException(base_frame.get_name() + " state is empty");
+  }
+  IDynamicalSystem<CartesianState>::set_base_frame(base_frame);
+  if (!this->attractor_->get_value().is_empty()) {
+    // update reference frame of attractor
+    auto attractor = this->attractor_->get_value();
+    attractor.set_reference_frame(base_frame.get_name());
+    this->set_attractor(attractor);
+  }
+}
+
+template<>
+void PointAttractor<CartesianState>::validate_and_set_parameter(const std::shared_ptr<ParameterInterface>& parameter) {
+  if (parameter->get_name() == "attractor") {
+    this->set_attractor(std::static_pointer_cast<Parameter<CartesianPose>>(parameter)->get_value());
+  } else if (parameter->get_name() == "gain") {
+    this->set_gain(parameter, 6);
+  } else {
+    throw state_representation::exceptions::InvalidParameterException("No parameter with name '" + parameter->get_name() + "' found");
+  }
+}
+
+template<>
+void PointAttractor<JointState>::validate_and_set_parameter(const std::shared_ptr<ParameterInterface>& parameter) {
+  if (parameter->get_name() == "attractor") {
+    this->set_attractor(std::static_pointer_cast<Parameter<JointPositions>>(parameter)->get_value());
+  } else if (parameter->get_name() == "gain") {
+    this->set_gain(parameter, this->attractor_->get_value().get_size());
+  } else {
+    throw state_representation::exceptions::InvalidParameterException("No parameter with name '" + parameter->get_name() + "' found");
+  }
+}
+
+template<class S>
+S PointAttractor<S>::compute_dynamics(const S&) const {
+  throw exceptions::NotImplementedException("compute_dynamics is not implemented for this type of DS");
+}
+
+template<>
+CartesianState PointAttractor<CartesianState>::compute_dynamics(const CartesianState& state) const {
+  if (this->attractor_->get_value().is_empty()) {
+    throw exceptions::EmptyAttractorException("The attractor of the dynamical system is empty.");
+  }
+  CartesianTwist twist = CartesianPose(this->attractor_->get_value()) - CartesianPose(state);
+  twist *= this->gain_->get_value();
+  return CartesianTwist(state.get_name(), twist.get_twist(), this->attractor_->get_value().get_reference_frame());
+}
+
+template<>
+JointState PointAttractor<JointState>::compute_dynamics(const JointState& state) const {
+  JointVelocities velocities = JointPositions(this->attractor_->get_value()) - JointPositions(state);
+  velocities *= this->gain_->get_value();
+  return JointVelocities(state.get_name(), this->attractor_->get_value().get_names(), velocities.get_velocities());
+}
+}// namespace dynamical_systems
diff --git a/source/dynamical_systems/src/Ring.cpp b/source/dynamical_systems/src/Ring.cpp
index 6978f85b1..6faa00df6 100644
--- a/source/dynamical_systems/src/Ring.cpp
+++ b/source/dynamical_systems/src/Ring.cpp
@@ -1,6 +1,7 @@
 #include "dynamical_systems/Ring.hpp"
 
 #include "dynamical_systems/exceptions/EmptyAttractorException.hpp"
+#include "state_representation/exceptions/InvalidParameterException.hpp"
 #include "state_representation/space/cartesian/CartesianTwist.hpp"
 #include "state_representation/exceptions/IncompatibleReferenceFramesException.hpp"
 #include "state_representation/exceptions/EmptyStateException.hpp"
@@ -10,7 +11,6 @@ using namespace state_representation;
 namespace dynamical_systems {
 
 Ring::Ring() :
-    DynamicalSystem<CartesianState>(),
     center_(std::make_shared<Parameter<CartesianPose>>("center", CartesianPose())),
     rotation_offset_(std::make_shared<Parameter<CartesianPose>>("rotation_offset", CartesianPose())),
     radius_(std::make_shared<Parameter<double>>("radius", 1.0)),
@@ -20,48 +20,92 @@ Ring::Ring() :
     normal_gain_(std::make_shared<Parameter<double>>("normal_gain", 1.0)),
     angular_gain_(std::make_shared<Parameter<double>>("angular_gain", 1.0)) {
   this->center_->get_value().set_empty();
-  this->set_rotation_offset(Eigen::Quaterniond::Identity());
+  this->rotation_offset_->set_value(
+      CartesianPose("rotation", Eigen::Quaterniond::Identity(), this->center_->get_value().get_name()));
+  this->parameters_.insert(std::make_pair("center", this->center_));
+  this->parameters_.insert(std::make_pair("rotation_offset", this->rotation_offset_));
+  this->parameters_.insert(std::make_pair("radius", this->radius_));
+  this->parameters_.insert(std::make_pair("width", this->width_));
+  this->parameters_.insert(std::make_pair("speed", this->speed_));
+  this->parameters_.insert(std::make_pair("field_strength", this->field_strength_));
+  this->parameters_.insert(std::make_pair("normal_gain", this->normal_gain_));
+  this->parameters_.insert(std::make_pair("angular_gain", this->angular_gain_));
 }
 
-Ring::Ring(const CartesianState& center,
-           double radius,
-           double width,
-           double speed,
-           double field_strength,
-           double normal_gain,
-           double angular_gain) :
-    DynamicalSystem<CartesianState>(center.get_reference_frame()),
-    center_(std::make_shared<Parameter<CartesianPose>>("center", center)),
-    rotation_offset_(std::make_shared<Parameter<CartesianPose>>("rotation_offset", center)),
-    radius_(std::make_shared<Parameter<double>>("radius", radius)),
-    width_(std::make_shared<Parameter<double>>("width", width)),
-    speed_(std::make_shared<Parameter<double>>("speed", speed)),
-    field_strength_(std::make_shared<Parameter<double>>("field_strength", field_strength)),
-    normal_gain_(std::make_shared<Parameter<double>>("normal_gain", normal_gain)),
-    angular_gain_(std::make_shared<Parameter<double>>("angular_gain", angular_gain)) {
-  this->set_center(center);
-  this->set_rotation_offset(Eigen::Quaterniond::Identity());
+void Ring::set_center(const CartesianPose& center) {
+  if (center.is_empty()) {
+    throw state_representation::exceptions::EmptyStateException(center.get_name() + " state is empty");
+  }
+  if (this->get_base_frame().is_empty()) {
+    IDynamicalSystem<CartesianState>::set_base_frame(
+        CartesianState::Identity(center.get_reference_frame(), center.get_reference_frame()));
+  }
+  // validate that the reference frame of the center is always compatible with the DS reference frame
+  if (center.get_reference_frame() != this->get_base_frame().get_name()) {
+    if (center.get_reference_frame() != this->get_base_frame().get_reference_frame()) {
+      throw state_representation::exceptions::IncompatibleReferenceFramesException(
+          "The reference frame of the center " + center.get_name() + " in frame " + center.get_reference_frame()
+              + " is incompatible with the base frame of the dynamical system " + this->get_base_frame().get_name()
+              + " in frame " + this->get_base_frame().get_reference_frame() + ".");
+    }
+    this->center_->set_value(this->get_base_frame().inverse() * center);
+  } else {
+    this->center_->set_value(center);
+  }
+  this->set_rotation_offset(this->get_rotation_offset());
 }
 
-CartesianState Ring::compute_dynamics(const CartesianState& state) const {
-  if (this->get_center().is_empty()) {
-    throw exceptions::EmptyAttractorException("The center of the dynamical system is empty.");
-  }
-  // put the point in the reference of the center
-  CartesianPose pose(state);
-  pose = this->get_center().inverse() * pose;
-  // apply the rotation offset
-  pose.set_orientation(pose.get_orientation() * this->get_rotation_offset().conjugate());
+void Ring::set_rotation_offset(const Eigen::Quaterniond& rotation) {
+  auto pose = CartesianPose("rotation", rotation, this->center_->get_value().get_name());
+  this->rotation_offset_->set_value(pose);
+}
 
-  CartesianTwist twist(pose.get_name(), pose.get_reference_frame());
-  double local_field_strength;
-  twist.set_linear_velocity(this->calculate_local_linear_velocity(pose, local_field_strength));
-  twist.set_angular_velocity(this->calculate_local_angular_velocity(pose,
-                                                                    twist.get_linear_velocity(),
-                                                                    local_field_strength));
+Eigen::Quaterniond Ring::get_rotation_offset() const {
+  return this->rotation_offset_->get_value().get_orientation();
+}
 
-  // transform the twist back to the base reference frame
-  return CartesianState(this->get_center()) * twist;
+void Ring::set_base_frame(const CartesianState& base_frame) {
+  if (base_frame.is_empty()) {
+    throw state_representation::exceptions::EmptyStateException(base_frame.get_name() + " state is empty");
+  }
+  IDynamicalSystem<CartesianState>::set_base_frame(base_frame);
+  // update reference frame of center
+  if (!this->center_->get_value().is_empty()) {
+    auto center = this->center_->get_value();
+    center.set_reference_frame(base_frame.get_name());
+    this->center_->set_value(center);
+  }
+}
+
+void Ring::validate_and_set_parameter(const std::shared_ptr<ParameterInterface>& parameter) {
+  if (parameter->get_name() == "center") {
+    this->assert_parameter_valid(parameter);
+    this->set_center(std::static_pointer_cast<Parameter<CartesianPose>>(parameter)->get_value());
+  } else if (parameter->get_name() == "rotation_offset") {
+    this->assert_parameter_valid(parameter);
+    this->rotation_offset_->set_value(std::static_pointer_cast<Parameter<CartesianPose>>(parameter)->get_value());
+  } else if (parameter->get_name() == "radius") {
+    this->assert_parameter_valid(parameter);
+    this->radius_->set_value(std::static_pointer_cast<Parameter<double>>(parameter)->get_value());
+  } else if (parameter->get_name() == "width") {
+    this->assert_parameter_valid(parameter);
+    this->width_->set_value(std::static_pointer_cast<Parameter<double>>(parameter)->get_value());
+  } else if (parameter->get_name() == "speed") {
+    this->assert_parameter_valid(parameter);
+    this->speed_->set_value(std::static_pointer_cast<Parameter<double>>(parameter)->get_value());
+  } else if (parameter->get_name() == "field_strength") {
+    this->assert_parameter_valid(parameter);
+    this->field_strength_->set_value(std::static_pointer_cast<Parameter<double>>(parameter)->get_value());
+  } else if (parameter->get_name() == "normal_gain") {
+    this->assert_parameter_valid(parameter);
+    this->normal_gain_->set_value(std::static_pointer_cast<Parameter<double>>(parameter)->get_value());
+  } else if (parameter->get_name() == "angular_gain") {
+    this->assert_parameter_valid(parameter);
+    this->angular_gain_->set_value(std::static_pointer_cast<Parameter<double>>(parameter)->get_value());
+  } else {
+    throw state_representation::exceptions::InvalidParameterException(
+        "No parameter with name '" + parameter->get_name() + "' found");
+  }
 }
 
 Eigen::Vector3d Ring::calculate_local_linear_velocity(const CartesianPose& pose, double& local_field_strength) const {
@@ -75,7 +119,7 @@ Eigen::Vector3d Ring::calculate_local_linear_velocity(const CartesianPose& pose,
     return local_linear_velocity;
   }
 
-  double re = M_PI_2 * (d - this->get_radius()) / this->get_width();
+  double re = M_PI_2 * (d - this->radius_->get_value()) / this->width_->get_value();
   if (re > M_PI_2) {
     re = M_PI_2;
   } else if (re < -M_PI_2) {
@@ -88,24 +132,24 @@ Eigen::Vector3d Ring::calculate_local_linear_velocity(const CartesianPose& pose,
   Eigen::Vector2d velocity2d = R * position2d / d;
 
   // scale by the nominal speed
-  velocity2d *= this->get_speed();
+  velocity2d *= this->speed_->get_value();
 
   // calculate the normal velocity
-  double vz = -this->get_normal_gain() * pose.get_position().z();
+  double vz = -this->normal_gain_->get_value() * pose.get_position().z();
 
   // combine into 3D velocity
   local_linear_velocity << velocity2d, vz;
 
   // calculate the field strength and scale the velocity
-  local_field_strength = this->get_field_strength() + (1 - this->get_field_strength()) * cos(re);
+  local_field_strength = this->field_strength_->get_value() + (1 - this->field_strength_->get_value()) * cos(re);
   local_linear_velocity *= local_field_strength;
 
   return local_linear_velocity;
 }
 
-Eigen::Vector3d Ring::calculate_local_angular_velocity(const CartesianPose& pose,
-                                                       const Eigen::Vector3d& linearVelocity,
-                                                       double local_field_strength) const {
+Eigen::Vector3d Ring::calculate_local_angular_velocity(
+    const CartesianPose& pose, const Eigen::Vector3d& linearVelocity, double local_field_strength
+) const {
   Eigen::Vector3d local_angular_velocity = Eigen::Vector3d::Zero();
 
   double theta = atan2(pose.get_position().y(), pose.get_position().x());
@@ -129,7 +173,7 @@ Eigen::Vector3d Ring::calculate_local_angular_velocity(const CartesianPose& pose
   double phi = atan2(deltaQ.vec().norm(), deltaQ.w());
   deltaOmega.vec() = 2 * deltaQ.vec() * phi / sin(phi);
 
-  local_angular_velocity = get_angular_gain() * deltaOmega.vec();
+  local_angular_velocity = this->angular_gain_->get_value() * deltaOmega.vec();
   local_angular_velocity *= local_field_strength;
 
   Eigen::Vector2d position2d(pose.get_position().x(), pose.get_position().y());
@@ -153,113 +197,24 @@ Eigen::Vector3d Ring::calculate_local_angular_velocity(const CartesianPose& pose
   return local_angular_velocity;
 }
 
-void Ring::set_base_frame(const state_representation::CartesianState& base_frame) {
-  if (base_frame.is_empty()) {
-    throw state_representation::exceptions::EmptyStateException(base_frame.get_name() + " state is empty");
-  }
-  DynamicalSystem<state_representation::CartesianState>::set_base_frame(base_frame);
-  // update reference frame of center
-  if (!this->get_center().is_empty()) {
-    auto center = this->get_center();
-    center.set_reference_frame(base_frame.get_name());
-    this->set_center(center);
-  }
-}
-
-void Ring::set_center(const CartesianPose& center) {
-  if (center.is_empty()) {
-    throw state_representation::exceptions::EmptyStateException(center.get_name() + " state is empty");
-  }
-  if (this->get_base_frame().is_empty()) {
-    DynamicalSystem<CartesianState>::set_base_frame(CartesianState::Identity(center.get_reference_frame(),
-                                                                             center.get_reference_frame()));
-  }
-  // validate that the reference frame of the center is always compatible with the DS reference frame
-  if (center.get_reference_frame() != this->get_base_frame().get_name()) {
-    if (center.get_reference_frame() != this->get_base_frame().get_reference_frame()) {
-      throw state_representation::exceptions::IncompatibleReferenceFramesException(
-          "The reference frame of the center " + center.get_name() + " in frame " + center.get_reference_frame()
-              + " is incompatible with the base frame of the dynamical system " + this->get_base_frame().get_name()
-              + " in frame " + this->get_base_frame().get_reference_frame() + ".");
-    }
-    this->center_->set_value(this->get_base_frame().inverse() * center);
-  } else {
-    this->center_->set_value(center);
+CartesianState Ring::compute_dynamics(const CartesianState& state) const {
+  if (this->center_->get_value().is_empty()) {
+    throw exceptions::EmptyAttractorException("The center of the dynamical system is empty.");
   }
-  this->set_rotation_offset(this->get_rotation_offset());
-}
-
-void Ring::set_rotation_offset(const Eigen::Quaterniond& rotation) {
-  auto pose = CartesianPose("rotation", rotation, this->get_center().get_name());
-  this->rotation_offset_->set_value(pose);
-}
-
-void Ring::set_radius(double radius) {
-  this->radius_->set_value(radius);
-}
-
-void Ring::set_width(double width) {
-  this->width_->set_value(width);
-}
-
-void Ring::set_speed(double speed) {
-  this->speed_->set_value(speed);
-}
-
-void Ring::set_field_strength(double field_strength) {
-  this->field_strength_->set_value(field_strength);
-}
-
-void Ring::set_normal_gain(double normal_gain) {
-  this->normal_gain_->set_value(normal_gain);
-}
-
-void Ring::set_angular_gain(double angular_gain) {
-  this->angular_gain_->set_value(angular_gain);
-}
-
-const CartesianPose& Ring::get_center() const {
-  return this->center_->get_value();
-}
-
-Eigen::Quaterniond Ring::get_rotation_offset() const {
-  return this->rotation_offset_->get_value().get_orientation();
-}
-
-double Ring::get_radius() const {
-  return this->radius_->get_value();
-}
-
-double Ring::get_width() const {
-  return this->width_->get_value();
-}
-
-double Ring::get_speed() const {
-  return this->speed_->get_value();
-}
-
-double Ring::get_field_strength() const {
-  return this->field_strength_->get_value();
-}
-
-double Ring::get_normal_gain() const {
-  return this->normal_gain_->get_value();
-}
+  // put the point in the reference of the center
+  CartesianPose pose(state);
+  pose = this->center_->get_value().inverse() * pose;
+  // apply the rotation offset
+  pose.set_orientation(pose.get_orientation() * this->get_rotation_offset().conjugate());
 
-double Ring::get_angular_gain() const {
-  return this->angular_gain_->get_value();
-}
+  CartesianTwist twist(pose.get_name(), pose.get_reference_frame());
+  double local_field_strength;
+  twist.set_linear_velocity(this->calculate_local_linear_velocity(pose, local_field_strength));
+  twist.set_angular_velocity(
+      this->calculate_local_angular_velocity(
+          pose, twist.get_linear_velocity(), local_field_strength));
 
-std::list<std::shared_ptr<ParameterInterface>> Ring::get_parameters() const {
-  std::list<std::shared_ptr<ParameterInterface>> param_list;
-  param_list.push_back(this->center_);
-  param_list.push_back(this->rotation_offset_);
-  param_list.push_back(this->radius_);
-  param_list.push_back(this->width_);
-  param_list.push_back(this->speed_);
-  param_list.push_back(this->field_strength_);
-  param_list.push_back(this->normal_gain_);
-  param_list.push_back(this->angular_gain_);
-  return param_list;
+  // transform the twist back to the base reference frame
+  return CartesianState(this->center_->get_value()) * twist;
 }
-}// namespace dynamical_systems
\ No newline at end of file
+}// namespace dynamical_systems
diff --git a/source/dynamical_systems/test/tests/test_circular.cpp b/source/dynamical_systems/test/tests/test_circular.cpp
index cbf6ec406..efff74860 100644
--- a/source/dynamical_systems/test/tests/test_circular.cpp
+++ b/source/dynamical_systems/test/tests/test_circular.cpp
@@ -1,21 +1,32 @@
 #include <gtest/gtest.h>
 
-#include "dynamical_systems/Circular.hpp"
+#include "dynamical_systems/DynamicalSystemFactory.hpp"
 #include "dynamical_systems/exceptions/EmptyBaseFrameException.hpp"
 #include "dynamical_systems/exceptions/EmptyAttractorException.hpp"
 
+#include "state_representation/exceptions/EmptyStateException.hpp"
 #include "state_representation/exceptions/IncompatibleReferenceFramesException.hpp"
+#include "state_representation/geometry/Ellipsoid.hpp"
+#include "state_representation/parameters/Parameter.hpp"
 
+using namespace dynamical_systems;
 using namespace state_representation;
 using namespace std::literals::chrono_literals;
 
 class CircularDSTest : public testing::Test {
 protected:
   void SetUp() override {
+    ds = DynamicalSystemFactory<CartesianState>::create_dynamical_system(
+        DynamicalSystemFactory<CartesianState>::DYNAMICAL_SYSTEM::CIRCULAR
+    );
     current_pose = CartesianPose("A", 10 * Eigen::Vector3d::Random());
     center = CartesianPose::Identity("B");
+    limit_cycle.set_center_pose(center);
+    limit_cycle.set_axis_lengths({radius, radius});
   }
 
+  std::shared_ptr<IDynamicalSystem<CartesianState>> ds;
+  Ellipsoid limit_cycle = Ellipsoid("limit_cycle");
   CartesianPose current_pose;
   CartesianPose center;
   double radius = 10;
@@ -25,11 +36,10 @@ class CircularDSTest : public testing::Test {
 };
 
 TEST_F(CircularDSTest, TestPositionOnRadius) {
-  dynamical_systems::Circular circularDS(center);
-  circularDS.set_radius(radius);
+  ds->set_parameter_value("limit_cycle", limit_cycle);
 
   for (unsigned int i = 0; i < nb_steps; ++i) {
-    CartesianTwist twist = circularDS.evaluate(current_pose);
+    CartesianTwist twist = ds->evaluate(current_pose);
     twist.clamp(10, 10, 0.001, 0.001);
     current_pose += dt * twist;
   }
@@ -38,82 +48,88 @@ TEST_F(CircularDSTest, TestPositionOnRadius) {
 }
 
 TEST_F(CircularDSTest, EmptyConstructor) {
-  // construct empty cartesian state DS
-  CartesianPose center = CartesianPose::Identity("CAttractor", "A");
-  dynamical_systems::Circular ds;
   // base frame and attractor should be empty
-  EXPECT_TRUE(ds.get_center().is_empty());
-  EXPECT_TRUE(ds.get_base_frame().is_empty());
-  ds.set_center(center);
-  EXPECT_FALSE(ds.get_center().is_empty());
-  EXPECT_FALSE(ds.get_base_frame().is_empty());
+  EXPECT_TRUE(ds->get_parameter_value<Ellipsoid>("limit_cycle").get_center_pose().is_empty());
+  EXPECT_TRUE(ds->get_base_frame().is_empty());
+
+  ds->set_parameter_value("limit_cycle", limit_cycle);
+  EXPECT_FALSE(ds->get_parameter_value<Ellipsoid>("limit_cycle").get_center_pose().is_empty());
+  EXPECT_FALSE(ds->get_base_frame().is_empty());
   // when attractor was set without a base frame, expect base frame to be identity with name / reference_frame of attractor
-  EXPECT_EQ(ds.get_base_frame().get_name(), center.get_reference_frame());
-  EXPECT_EQ(ds.get_base_frame().get_reference_frame(), center.get_reference_frame());
-  EXPECT_EQ(ds.get_base_frame().get_transformation_matrix(), Eigen::Matrix4d::Identity());
+  EXPECT_EQ(ds->get_base_frame().get_name(), center.get_reference_frame());
+  EXPECT_EQ(ds->get_base_frame().get_reference_frame(), center.get_reference_frame());
+  EXPECT_EQ(ds->get_base_frame().get_transformation_matrix(), Eigen::Matrix4d::Identity());
+}
 
-  ds = dynamical_systems::Circular();
-  CartesianState state1 = CartesianState::Identity("B", "A");
+TEST_F(CircularDSTest, EvaluateCompatibility) {
+  CartesianState state1 = CartesianState::Identity("world", "A");
   CartesianState state2("D", "C");
   CartesianState state3("C", "A");
-  CartesianState state4("C", "B");
+  CartesianState state4("C", "world");
   // if no base frame is set, an exception is thrown
-  EXPECT_THROW(ds.evaluate(state1), dynamical_systems::exceptions::EmptyBaseFrameException);
-  ds.set_base_frame(state1);
+  EXPECT_THROW(ds->evaluate(state1), dynamical_systems::exceptions::EmptyBaseFrameException);
+  ds->set_base_frame(state1);
   // if cartesian state is incompatible, an exception is thrown
-  EXPECT_THROW(ds.evaluate(state2), state_representation::exceptions::IncompatibleReferenceFramesException);
+  EXPECT_THROW(ds->evaluate(state2), state_representation::exceptions::IncompatibleReferenceFramesException);
   // if cartesian state needs to be transformed to other frame first and is empty, an exception is thrown
-  EXPECT_THROW(ds.evaluate(state3), state_representation::exceptions::EmptyStateException);
+  EXPECT_THROW(ds->evaluate(state3), state_representation::exceptions::EmptyStateException);
   // if no attractor is set, an exception is thrown
-  EXPECT_THROW(ds.evaluate(state4), dynamical_systems::exceptions::EmptyAttractorException);
+  EXPECT_THROW(ds->evaluate(state4), dynamical_systems::exceptions::EmptyAttractorException);
 
-  ds.set_center(center);
-  EXPECT_TRUE(ds.is_compatible(state1));
-  EXPECT_FALSE(ds.is_compatible(state2));
-  EXPECT_TRUE(ds.is_compatible(state3));
-  EXPECT_TRUE(ds.is_compatible(state4));
+  ds->set_parameter_value("limit_cycle", limit_cycle);
+  EXPECT_TRUE(ds->is_compatible(state1));
+  EXPECT_FALSE(ds->is_compatible(state2));
+  EXPECT_TRUE(ds->is_compatible(state3));
+  EXPECT_TRUE(ds->is_compatible(state4));
 }
 
 TEST_F(CircularDSTest, TestPositionOnRadiusRandomCenter) {
-  center.set_position(Eigen::Vector3d::Random());
-  center.set_orientation(Eigen::Quaterniond::UnitRandom());
-  dynamical_systems::Circular circularDS(center);
-  circularDS.set_radius(radius);
+  limit_cycle.set_center_position(Eigen::Vector3d::Random());
+  limit_cycle.set_center_orientation(Eigen::Quaterniond::UnitRandom());
+  ds->set_parameter_value("limit_cycle", limit_cycle);
 
   for (unsigned int i = 0; i < nb_steps; ++i) {
-    state_representation::CartesianTwist twist = circularDS.evaluate(current_pose);
+    state_representation::CartesianTwist twist = ds->evaluate(current_pose);
     twist.clamp(10, 10, 0.001, 0.001);
     current_pose += dt * twist;
   }
 
-  EXPECT_NEAR(current_pose.dist(center, CartesianStateVariable::POSITION), radius, linear_tol);
+  EXPECT_NEAR(current_pose.dist(limit_cycle.get_center_pose(), CartesianStateVariable::POSITION), radius, linear_tol);
 }
 
 TEST_F(CircularDSTest, SetCenterAndBase) {
+  Ellipsoid cycle("B", "A");
   auto BinA = CartesianState::Identity("B", "A");
   auto CinA = CartesianState::Identity("C", "A");
   auto CinB = CartesianState::Identity("C", "B");
 
-  dynamical_systems::Circular circularDS(BinA);
-  EXPECT_STREQ(circularDS.get_center().get_name().c_str(), BinA.get_name().c_str());
-  EXPECT_STREQ(circularDS.get_center().get_reference_frame().c_str(), BinA.get_reference_frame().c_str());
+  ds->set_parameter_value("limit_cycle", cycle);
+  EXPECT_STREQ(ds->get_parameter_value<Ellipsoid>("limit_cycle").get_center_pose().get_name().c_str(),
+               BinA.get_name().c_str());
+  EXPECT_STREQ(ds->get_parameter_value<Ellipsoid>("limit_cycle").get_center_pose().get_reference_frame().c_str(),
+               BinA.get_reference_frame().c_str());
 
   // evaluating a state is only valid if it matches the base reference frame
-  EXPECT_NO_THROW(circularDS.evaluate(CinA));
-  EXPECT_THROW(circularDS.evaluate(CinB), state_representation::exceptions::IncompatibleReferenceFramesException);
+  EXPECT_NO_THROW(ds->evaluate(CinA));
+  EXPECT_THROW(ds->evaluate(CinB), state_representation::exceptions::IncompatibleReferenceFramesException);
 
   // setting the center is only valid if it matches the base reference frame
-  EXPECT_NO_THROW(circularDS.set_center(CinA));
-  EXPECT_THROW(circularDS.set_center(CinB), state_representation::exceptions::IncompatibleReferenceFramesException);
+  cycle.set_center_state(CinA);
+  EXPECT_NO_THROW(ds->set_parameter_value("limit_cycle", cycle));
+  Ellipsoid cycle2("C", "B");
+  EXPECT_THROW(ds->set_parameter_value("limit_cycle", cycle2),
+               state_representation::exceptions::IncompatibleReferenceFramesException);
 
   // setting the base frame should also update the reference frame of the center
-  ASSERT_NO_THROW(circularDS.set_base_frame(CinB));
-  EXPECT_STREQ(circularDS.get_base_frame().get_name().c_str(), CinB.get_name().c_str());
-  EXPECT_STREQ(circularDS.get_base_frame().get_reference_frame().c_str(), CinB.get_reference_frame().c_str());
-  EXPECT_STREQ(circularDS.get_center().get_reference_frame().c_str(), circularDS.get_base_frame().get_name().c_str());
+  ASSERT_NO_THROW(ds->set_base_frame(CinB));
+  EXPECT_STREQ(ds->get_base_frame().get_name().c_str(), CinB.get_name().c_str());
+  EXPECT_STREQ(ds->get_base_frame().get_reference_frame().c_str(), CinB.get_reference_frame().c_str());
+  EXPECT_STREQ(ds->get_parameter_value<Ellipsoid>("limit_cycle").get_center_pose().get_reference_frame().c_str(),
+               ds->get_base_frame().get_name().c_str());
 
   // now the base frame is C, setting a center should only work if the reference frame of the center is also C
-  EXPECT_THROW(circularDS.set_center(CinA), state_representation::exceptions::IncompatibleReferenceFramesException);
-  EXPECT_NO_THROW(circularDS.set_center(CinB));
-  EXPECT_NO_THROW(circularDS.set_center(CinB.inverse()));
+  EXPECT_THROW(ds->set_parameter_value("limit_cycle", cycle),
+               state_representation::exceptions::IncompatibleReferenceFramesException);
+  EXPECT_NO_THROW(ds->set_parameter_value("limit_cycle", cycle2));
+  EXPECT_NO_THROW(ds->set_parameter_value("limit_cycle", Ellipsoid("B", "C")));
 }
diff --git a/source/dynamical_systems/test/tests/test_factory.cpp b/source/dynamical_systems/test/tests/test_factory.cpp
new file mode 100644
index 000000000..c2a59882c
--- /dev/null
+++ b/source/dynamical_systems/test/tests/test_factory.cpp
@@ -0,0 +1,32 @@
+#include <gtest/gtest.h>
+
+#include "dynamical_systems/DynamicalSystemFactory.hpp"
+#include "state_representation/exceptions/InvalidParameterException.hpp"
+
+#include "state_representation/space/cartesian/CartesianState.hpp"
+#include "state_representation/space/joint/JointState.hpp"
+#include "state_representation/parameters/Parameter.hpp"
+
+using namespace state_representation;
+
+TEST(DSFactoryTest, CreateDS) {
+  std::list<std::shared_ptr<state_representation::ParameterInterface>> param_list;
+  param_list.emplace_back(make_shared_parameter("test", 1.0));
+
+  auto cart_ds = dynamical_systems::DynamicalSystemFactory<CartesianState>::create_dynamical_system(
+      dynamical_systems::DynamicalSystemFactory<CartesianState>::DYNAMICAL_SYSTEM::NONE
+  );
+  cart_ds->set_base_frame(CartesianState::Identity("A"));
+  ASSERT_NO_THROW(auto res = cart_ds->evaluate(CartesianState::Identity("C", "A")));
+  EXPECT_TRUE(cart_ds->evaluate(CartesianState::Identity("C", "A")).is_empty());
+  EXPECT_EQ(cart_ds->get_parameters().size(), 0);
+  EXPECT_THROW(cart_ds->set_parameters(param_list), exceptions::InvalidParameterException);
+
+  auto joint_ds = dynamical_systems::DynamicalSystemFactory<JointState>::create_dynamical_system(
+      dynamical_systems::DynamicalSystemFactory<JointState>::DYNAMICAL_SYSTEM::NONE
+  );
+  ASSERT_NO_THROW(auto res = joint_ds->evaluate(JointState::Random("robot", 3)));
+  EXPECT_TRUE(joint_ds->evaluate(JointState::Random("robot", 3)).is_empty());
+  EXPECT_EQ(joint_ds->get_parameters().size(), 0);
+  EXPECT_THROW(joint_ds->set_parameters(param_list), exceptions::InvalidParameterException);
+}
diff --git a/source/dynamical_systems/test/tests/test_linear.cpp b/source/dynamical_systems/test/tests/test_linear.cpp
deleted file mode 100644
index d35631251..000000000
--- a/source/dynamical_systems/test/tests/test_linear.cpp
+++ /dev/null
@@ -1,342 +0,0 @@
-#include <vector>
-#include <gtest/gtest.h>
-#include "dynamical_systems/Linear.hpp"
-#include "dynamical_systems/exceptions/EmptyBaseFrameException.hpp"
-#include "dynamical_systems/exceptions/EmptyAttractorException.hpp"
-
-#include "state_representation/exceptions/EmptyStateException.hpp"
-#include "state_representation/exceptions/IncompatibleReferenceFramesException.hpp"
-
-using namespace state_representation;
-using namespace dynamical_systems;
-using namespace std::literals::chrono_literals;
-
-class LinearDSTest : public testing::Test {
-protected:
-  void SetUp() override {
-    current_pose = CartesianPose("A", 10 * Eigen::Vector3d::Random());
-    target_pose = CartesianPose("B", 10 * Eigen::Vector3d::Random(), Eigen::Quaterniond::UnitRandom());
-  }
-  void print_current_and_target_pose() {
-    std::cout << current_pose << std::endl;
-    std::cout << target_pose << std::endl;
-    std::cout << abs(current_pose.get_orientation().dot(target_pose.get_orientation())) << std::endl;
-  }
-
-  CartesianPose current_pose;
-  CartesianPose target_pose;
-  unsigned int nb_steps = 100;
-  std::chrono::milliseconds dt = 100ms;
-  double linear_tol = 1e-3;
-  double angular_tol = 1e-3;
-};
-
-TEST_F(LinearDSTest, EmptyConstructorCartesianState) {
-  // construct empty cartesian state DS
-  CartesianPose attractor = CartesianPose::Identity("CAttractor", "A");
-  Linear<CartesianState> ds;
-  // base frame and attractor should be empty
-  EXPECT_TRUE(ds.get_attractor().is_empty());
-  EXPECT_TRUE(ds.get_base_frame().is_empty());
-  ds.set_attractor(attractor);
-  EXPECT_FALSE(ds.get_attractor().is_empty());
-  EXPECT_FALSE(ds.get_base_frame().is_empty());
-  // when attractor was set without a base frame, expect base frame to be identity with name / reference_frame of attractor
-  EXPECT_EQ(ds.get_base_frame().get_name(), attractor.get_reference_frame());
-  EXPECT_EQ(ds.get_base_frame().get_reference_frame(), attractor.get_reference_frame());
-  EXPECT_EQ(ds.get_base_frame().get_transformation_matrix(), Eigen::Matrix4d::Identity());
-
-  ds = Linear<CartesianState>();
-  CartesianState state1 = CartesianState::Identity("B", "A");
-  CartesianState state2("D", "C");
-  CartesianState state3("C", "A");
-  CartesianState state4("C", "B");
-  // if no base frame is set, an exception is thrown
-  EXPECT_THROW(ds.evaluate(state1), dynamical_systems::exceptions::EmptyBaseFrameException);
-  ds.set_base_frame(state1);
-  // if cartesian state is incompatible, an exception is thrown
-  EXPECT_THROW(ds.evaluate(state2), state_representation::exceptions::IncompatibleReferenceFramesException);
-  // if cartesian state needs to be transformed to other frame first and is empty, an exception is thrown
-  EXPECT_THROW(ds.evaluate(state3), state_representation::exceptions::EmptyStateException);
-  // if no attractor is set, an exception is thrown
-  EXPECT_THROW(ds.evaluate(state4), dynamical_systems::exceptions::EmptyAttractorException);
-
-  ds.set_attractor(attractor);
-  EXPECT_TRUE(ds.is_compatible(state1));
-  EXPECT_FALSE(ds.is_compatible(state2));
-  EXPECT_TRUE(ds.is_compatible(state3));
-  EXPECT_TRUE(ds.is_compatible(state4));
-}
-
-TEST_F(LinearDSTest, EmptyConstructorJointState) {
-  // construct empty joint state DS
-  Linear<JointState> ds;
-  JointState attractor = JointState::Zero("robot", 3);
-
-  EXPECT_TRUE(ds.get_attractor().is_empty());
-  EXPECT_TRUE(ds.get_base_frame().is_empty());
-  ds.set_attractor(attractor);
-  EXPECT_FALSE(ds.get_attractor().is_empty());
-  EXPECT_FALSE(ds.get_base_frame().is_empty());
-  // when attractor was set without a base frame, expect base frame to be zero with name of attractor
-  EXPECT_EQ(ds.get_base_frame().get_name(), attractor.get_name());
-  EXPECT_EQ(ds.get_base_frame().get_names(), attractor.get_names());
-  EXPECT_EQ(ds.get_base_frame().data(), Eigen::VectorXd::Zero(attractor.get_size() * 4));
-
-  ds = Linear<JointState>();
-  JointState state1 = JointState::Zero("robot", 2);
-  JointState state2 = JointState::Zero("robot", 3);
-  JointState state3 = JointState::Zero("dummy", 2);
-  // if no base frame is set, an exception is thrown
-  EXPECT_THROW(ds.evaluate(state1), dynamical_systems::exceptions::EmptyBaseFrameException);
-  ds.set_base_frame(state1);
-  // if joint state is incompatible (here with empty base frame), an exception is thrown
-  EXPECT_THROW(ds.evaluate(state2), state_representation::exceptions::IncompatibleReferenceFramesException);
-  // if no attractor is set, an exception is thrown
-  EXPECT_THROW(ds.evaluate(state1), dynamical_systems::exceptions::EmptyAttractorException);
-  // if attractor with incompatible robot names should be set, an exception is thrown
-  EXPECT_THROW(ds.set_attractor(state3), state_representation::exceptions::IncompatibleReferenceFramesException);
-  // if attractor with incompatible joint names should be set, an exception is thrown
-  EXPECT_THROW(ds.set_attractor(attractor), state_representation::exceptions::IncompatibleReferenceFramesException);
-  ds.set_base_frame(state2);
-  ds.set_attractor(attractor);
-  EXPECT_TRUE(ds.is_compatible(state2));
-  EXPECT_FALSE(ds.is_compatible(state3));
-  EXPECT_NO_THROW(ds.evaluate(state2));
-  EXPECT_THROW(ds.evaluate(state3), state_representation::exceptions::IncompatibleReferenceFramesException);
-}
-
-TEST_F(LinearDSTest, IsCompatible) {
-  CartesianState state1("C", "A");
-  CartesianState state2("C", "B");
-  CartesianState state3("C", "D");
-
-  CartesianState attractor_frame = CartesianState::Identity("CAttractor", "A");
-  Linear<CartesianState> ds(attractor_frame);
-  EXPECT_TRUE(ds.is_compatible(state1));
-  EXPECT_FALSE(ds.is_compatible(state2));
-  EXPECT_FALSE(ds.is_compatible(state3));
-
-  // change the base frame
-  CartesianState base_frame = CartesianState::Identity("A", "B");
-  ds.set_base_frame(base_frame);
-  EXPECT_TRUE(ds.is_compatible(state1));
-  EXPECT_TRUE(ds.is_compatible(state2));
-  EXPECT_FALSE(ds.is_compatible(state3));
-}
-
-TEST_F(LinearDSTest, PositionOnly) {
-  current_pose.set_orientation(Eigen::Quaterniond::Identity());
-  target_pose.set_orientation(Eigen::Quaterniond::Identity());
-  Linear<CartesianState> linearDS(target_pose);
-
-  for (unsigned int i = 0; i < nb_steps; ++i) {
-    CartesianTwist twist = linearDS.evaluate(current_pose);
-    current_pose += dt * twist;
-  }
-  EXPECT_NEAR(current_pose.dist(target_pose, CartesianStateVariable::POSITION), 0, linear_tol);
-}
-
-TEST_F(LinearDSTest, OrientationOnly) {
-  current_pose.set_position(Eigen::Vector3d::Zero());
-  target_pose.set_position(Eigen::Vector3d::Zero());
-
-  Linear<CartesianState> linearDS(target_pose);
-
-  for (unsigned int i = 0; i < nb_steps; ++i) {
-    CartesianTwist twist = linearDS.evaluate(current_pose);
-    current_pose += dt * twist;
-  }
-  EXPECT_NEAR(current_pose.dist(target_pose, CartesianStateVariable::ORIENTATION), 0, angular_tol);
-}
-
-TEST_F(LinearDSTest, PositionAndOrientation) {
-  Linear<CartesianState> linearDS(target_pose);
-
-  for (unsigned int i = 0; i < nb_steps; ++i) {
-    CartesianTwist twist = linearDS.evaluate(current_pose);
-    current_pose += dt * twist;
-  }
-  EXPECT_NEAR(current_pose.dist(target_pose, CartesianStateVariable::POSITION), 0, linear_tol);
-  EXPECT_NEAR(current_pose.dist(target_pose, CartesianStateVariable::ORIENTATION), 0, angular_tol);
-}
-
-TEST_F(LinearDSTest, JointState) {
-  auto current_positions = JointPositions::Zero("robot", 3);
-  auto target_positions = JointPositions::Random("robot", 3);
-  Linear<JointState> linearDS(target_positions);
-
-  for (unsigned int i = 0; i < nb_steps; ++i) {
-    JointVelocities velocities = linearDS.evaluate(current_positions);
-    current_positions += dt * velocities;
-  }
-  EXPECT_NEAR(current_positions.dist(target_positions), 0, linear_tol);
-}
-
-TEST_F(LinearDSTest, NonUniformGainValues) {
-  std::vector<double> gains(6, 0);
-  Linear<CartesianState> linearDS(target_pose, gains);
-
-  // expect no twist when DS gains are all zero
-  CartesianTwist twist = linearDS.evaluate(current_pose);
-  EXPECT_NEAR(twist.get_linear_velocity().norm(), 0, linear_tol);
-  EXPECT_NEAR(twist.get_angular_velocity().norm(), 0, angular_tol);
-
-  // check that the returned twist only applies in the dimension with a non-zero gain
-  for (unsigned int i = 0; i < gains.size(); ++i) {
-    gains.at(i) = 1;
-    linearDS.set_gain(gains);
-
-    twist = linearDS.evaluate(current_pose);
-
-    auto vec = twist.data();
-    for (unsigned int ax = 0; ax < vec.size(); ++ax) {
-      if (ax == i) {
-        EXPECT_TRUE(abs(vec(ax)) > 0);
-      } else {
-        EXPECT_NEAR(vec(ax), 0, 1e-9);
-      }
-    }
-
-    gains.at(i) = 0;
-  }
-}
-
-TEST(LinearDSTestFrames, FixedReferenceFrames) {
-  auto BinA = CartesianState::Identity("B", "A");
-  auto CinA = CartesianState::Identity("C", "A");
-  auto CinB = CartesianState::Identity("C", "B");
-  BinA.set_pose(Eigen::Vector3d::Random(), Eigen::Quaterniond::UnitRandom());
-  CinA.set_pose(Eigen::Vector3d::Random(), Eigen::Quaterniond::UnitRandom());
-  CinB.set_pose(Eigen::Vector3d::Random(), Eigen::Quaterniond::UnitRandom());
-
-
-  // initialise the linearDS with attractor at B in reference frame A
-  Linear<CartesianState> linearDS(BinA);
-
-  // evaluating a current pose B in reference frame A should give zero twist (coincident with attractor)
-  CartesianTwist twist = linearDS.evaluate(BinA);
-  EXPECT_NEAR(twist.data().norm(), 0, 1e-5);
-
-  // evaluating pose C in frame A should give some non-zero twist
-  twist = linearDS.evaluate(CinA);
-  EXPECT_GE(twist.data().norm(), 1e-5);
-
-  // evaluating a state which does not match the DS base frame A should give an error
-  EXPECT_THROW(linearDS.evaluate(CinB), state_representation::exceptions::IncompatibleReferenceFramesException);
-
-  // an inverse state (A expressed in C) should also give an error,
-  // since the reference frame does not explicitly match the DS base frame
-  EXPECT_THROW(linearDS.evaluate(CinA.inverse()),
-               state_representation::exceptions::IncompatibleReferenceFramesException);
-}
-
-TEST(LinearDSTestFrames, UpdateBaseReferenceFrames) {
-  auto BinA = CartesianState::Random("B", "A");
-
-  // initialise the linearDS with attractor at B in reference frame A
-  Linear<CartesianState> linearDS(BinA);
-
-  // the base frame of the default constructed DS should be an identity frame
-  // with the same name as the attractor reference frame
-  auto base = linearDS.get_base_frame();
-  EXPECT_STREQ(base.get_name().c_str(), BinA.get_reference_frame().c_str());
-  EXPECT_STREQ(base.get_name().c_str(), base.get_reference_frame().c_str());
-  EXPECT_NEAR(base.get_pose().norm(), 1, 1e-5);
-
-  auto AinWorld = CartesianState::Random("A", "world");
-  linearDS.set_base_frame(AinWorld);
-
-  // check the setter
-  base = linearDS.get_base_frame();
-  EXPECT_STREQ(base.get_name().c_str(), AinWorld.get_name().c_str());
-  EXPECT_STREQ(base.get_reference_frame().c_str(), AinWorld.get_reference_frame().c_str());
-  EXPECT_NEAR(base.get_pose().norm(), AinWorld.get_pose().norm(), 1e-5);
-
-  // evaluating a current pose B in reference frame A should give zero twist (coincident with attractor)
-  CartesianTwist twist = linearDS.evaluate(BinA);
-  EXPECT_STREQ(twist.get_name().c_str(), BinA.get_name().c_str());
-  EXPECT_STREQ(twist.get_reference_frame().c_str(), BinA.get_reference_frame().c_str());
-  EXPECT_NEAR(twist.data().norm(), 0, 1e-5);
-
-  // evaluating a current pose B in reference frame world should give zero twist (coincident with attractor)
-  // PLUS the twist of A in world, expressed as a twist B in world
-  auto BinWorld = AinWorld * BinA;
-  twist = linearDS.evaluate(BinWorld);
-  EXPECT_STREQ(twist.get_name().c_str(), BinWorld.get_name().c_str());
-  EXPECT_STREQ(twist.get_reference_frame().c_str(), BinWorld.get_reference_frame().c_str());
-  EXPECT_NEAR(twist.data().norm(), 0 + AinWorld.get_twist().norm(), 1e-5);
-
-  // since the base frame is set to frame A in frame world, evaluating a state with a reference frame that is neither
-  // should give an error
-  EXPECT_THROW(linearDS.evaluate(BinWorld.inverse()),
-               state_representation::exceptions::IncompatibleReferenceFramesException);
-}
-
-TEST(LinearDSTestFrames, StackedMovingReferenceFrames) {
-  auto AinWorld = CartesianState::Random("A", "world");
-  auto BinA = CartesianState::Random("B", "A");
-
-  auto CinA = CartesianState::Identity("C", "A");
-  CinA.set_pose(Eigen::Vector3d::Random(), Eigen::Quaterniond::UnitRandom());
-
-  // initialise the linearDS with attractor at B in reference frame A
-  Linear<CartesianState> linearDS(BinA);
-
-  // evaluate the twist for a fixed state C in reference frame A
-  CartesianTwist twist = linearDS.evaluate(CinA);
-
-  // the twist should be the same for a moving state C in reference frame A
-  // (the DS should always give the velocity from position, not from velocity)
-  CinA.set_linear_velocity(Eigen::Vector3d::Random());
-  CinA.set_angular_velocity(Eigen::Vector3d::Random());
-  CartesianTwist twist2 = linearDS.evaluate(CinA);
-
-  EXPECT_NEAR(twist.data().norm(), twist2.data().norm(), 1e-5);
-
-  // since reference frame A is moving with respect to the world, and DS gives a twist in reference frame A,
-  // the operation to express DS twist in the world frame should be valid.
-  ASSERT_NO_THROW(twist = AinWorld * linearDS.evaluate(CinA));
-
-  // the same operation can be done by setting the base frame of the DS
-  linearDS.set_base_frame(AinWorld);
-  auto CinWorld = AinWorld * CinA;
-  ASSERT_NO_THROW(twist2 = linearDS.evaluate(CinWorld));
-
-  // both methods should give the twist in the world frame
-  EXPECT_STREQ(twist.get_reference_frame().c_str(), AinWorld.get_reference_frame().c_str());
-  EXPECT_STREQ(twist.get_reference_frame().c_str(), twist2.get_reference_frame().c_str());
-  EXPECT_NEAR(twist.data().norm(), twist2.data().norm(), 1e-5);
-
-}
-
-TEST(LinearDSTestFrames, UpdateAttractorFrame) {
-  CartesianState A, B, C, D;
-  A = CartesianState::Random("A", "world");
-  B = CartesianState::Random("B", "world");
-  C = CartesianState::Random("C", "robot");
-  D = CartesianState::Random("D", "robot");
-
-  Linear<CartesianState> linearDS(A);
-
-  // state being evaluated must match the DS base frame, which is by default the attractor reference frame
-  EXPECT_NO_THROW(linearDS.evaluate(B));
-  EXPECT_THROW(linearDS.evaluate(D), state_representation::exceptions::IncompatibleReferenceFramesException);
-
-  // setting the attractor to another point in the same base frame should be fine,
-  // but setting it with a different base frame should give an error
-  EXPECT_NO_THROW(linearDS.set_attractor(B));
-  EXPECT_THROW(linearDS.set_attractor(C), state_representation::exceptions::IncompatibleReferenceFramesException);
-
-  // after updating the base frame, the attractor reference frame should also be updated
-  linearDS.set_base_frame(CartesianState::Identity(C.get_reference_frame(), C.get_reference_frame()));
-  EXPECT_STREQ(linearDS.get_attractor().get_reference_frame().c_str(), C.get_reference_frame().c_str());
-
-  // with the new base frame, setting the attractor should succeed / fail accordingly
-  EXPECT_THROW(linearDS.set_attractor(B), state_representation::exceptions::IncompatibleReferenceFramesException);
-  EXPECT_NO_THROW(linearDS.set_attractor(C));
-
-  // now the evaluation should also succeed when matching the updated base frame
-  EXPECT_THROW(linearDS.evaluate(B), state_representation::exceptions::IncompatibleReferenceFramesException);
-  EXPECT_NO_THROW(linearDS.evaluate(D));
-}
\ No newline at end of file
diff --git a/source/dynamical_systems/test/tests/test_point_attractor.cpp b/source/dynamical_systems/test/tests/test_point_attractor.cpp
new file mode 100644
index 000000000..92001434a
--- /dev/null
+++ b/source/dynamical_systems/test/tests/test_point_attractor.cpp
@@ -0,0 +1,324 @@
+#include <vector>
+#include <gtest/gtest.h>
+#include "dynamical_systems/DynamicalSystemFactory.hpp"
+#include "dynamical_systems/exceptions/EmptyBaseFrameException.hpp"
+#include "dynamical_systems/exceptions/EmptyAttractorException.hpp"
+
+#include "state_representation/space/cartesian/CartesianState.hpp"
+#include "state_representation/space/cartesian/CartesianPose.hpp"
+#include "state_representation/space/joint/JointState.hpp"
+#include "state_representation/space/joint/JointPositions.hpp"
+#include "state_representation/parameters/Parameter.hpp"
+#include "state_representation/exceptions/EmptyStateException.hpp"
+#include "state_representation/exceptions/IncompatibleReferenceFramesException.hpp"
+#include "state_representation/exceptions/IncompatibleStatesException.hpp"
+
+
+using namespace state_representation;
+using namespace dynamical_systems;
+using namespace std::literals::chrono_literals;
+
+class PointAttractorTest : public testing::Test {
+protected:
+  void SetUp() override {
+    current_pose = CartesianPose("A", 10 * Eigen::Vector3d::Random());
+    target_pose = CartesianPose("B", 10 * Eigen::Vector3d::Random(), Eigen::Quaterniond::UnitRandom());
+    ds = DynamicalSystemFactory<CartesianState>::create_dynamical_system(
+        DynamicalSystemFactory<CartesianState>::DYNAMICAL_SYSTEM::POINT_ATTRACTOR
+    );
+  }
+  void print_current_and_target_pose() {
+    std::cout << current_pose << std::endl;
+    std::cout << target_pose << std::endl;
+    std::cout << abs(current_pose.get_orientation().dot(target_pose.get_orientation())) << std::endl;
+  }
+
+  std::shared_ptr<IDynamicalSystem<CartesianState>> ds;
+  CartesianPose current_pose;
+  CartesianPose target_pose;
+  unsigned int nb_steps = 100;
+  std::chrono::milliseconds dt = 100ms;
+  double linear_tol = 1e-3;
+  double angular_tol = 1e-3;
+};
+
+TEST_F(PointAttractorTest, EmptyConstructorCartesianState) {
+  // construct empty cartesian state DS
+  CartesianPose attractor = CartesianPose::Identity("CAttractor", "A");
+
+  // base frame and attractor should be empty
+  EXPECT_TRUE(ds->get_parameter_value<CartesianPose>("attractor").is_empty());
+  EXPECT_TRUE(ds->get_base_frame().is_empty());
+  ds->set_parameter_value("attractor", attractor);
+  EXPECT_FALSE(ds->get_parameter_value<CartesianPose>("attractor").is_empty());
+  EXPECT_FALSE(ds->get_base_frame().is_empty());
+  // when attractor was set without a base frame, expect base frame to be identity with name / reference_frame of attractor
+  EXPECT_EQ(ds->get_base_frame().get_name(), attractor.get_reference_frame());
+  EXPECT_EQ(ds->get_base_frame().get_reference_frame(), attractor.get_reference_frame());
+  EXPECT_EQ(ds->get_base_frame().get_transformation_matrix(), Eigen::Matrix4d::Identity());
+}
+
+TEST_F(PointAttractorTest, EmptyIsCompatible) {
+  CartesianState state1 = CartesianState::Identity("B", "A");
+  CartesianState state2("D", "C");
+  CartesianState state3("C", "A");
+  CartesianState state4("C", "B");
+  // if no base frame is set, an exception is thrown
+  EXPECT_THROW(ds->evaluate(state1), dynamical_systems::exceptions::EmptyBaseFrameException);
+  ds->set_base_frame(state1);
+  // if cartesian state is incompatible, an exception is thrown
+  EXPECT_THROW(ds->evaluate(state2), state_representation::exceptions::IncompatibleReferenceFramesException);
+  // if cartesian state needs to be transformed to other frame first and is empty, an exception is thrown
+  EXPECT_THROW(ds->evaluate(state3), state_representation::exceptions::EmptyStateException);
+  // if no attractor is set, an exception is thrown
+  EXPECT_THROW(ds->evaluate(state4), dynamical_systems::exceptions::EmptyAttractorException);
+
+  ds->set_parameter_value("attractor", CartesianPose::Identity("CAttractor", "A"));
+  EXPECT_TRUE(ds->is_compatible(state1));
+  EXPECT_FALSE(ds->is_compatible(state2));
+  EXPECT_TRUE(ds->is_compatible(state3));
+  EXPECT_TRUE(ds->is_compatible(state4));
+}
+
+TEST_F(PointAttractorTest, IsCompatible) {
+  CartesianState state1("C", "A");
+  CartesianState state2("C", "B");
+  CartesianState state3("C", "D");
+
+  CartesianPose attractor_frame = CartesianPose::Identity("CAttractor", "A");
+  ds->set_parameter_value("attractor", attractor_frame);
+  EXPECT_TRUE(ds->is_compatible(state1));
+  EXPECT_FALSE(ds->is_compatible(state2));
+  EXPECT_FALSE(ds->is_compatible(state3));
+
+  // change the base frame
+  CartesianState base_frame = CartesianState::Identity("A", "B");
+  ds->set_base_frame(base_frame);
+  EXPECT_TRUE(ds->is_compatible(state1));
+  EXPECT_TRUE(ds->is_compatible(state2));
+  EXPECT_FALSE(ds->is_compatible(state3));
+}
+
+TEST_F(PointAttractorTest, PositionOnly) {
+  current_pose.set_orientation(Eigen::Quaterniond::Identity());
+  target_pose.set_orientation(Eigen::Quaterniond::Identity());
+  ds->set_parameter_value("attractor", target_pose);
+
+  for (unsigned int i = 0; i < nb_steps; ++i) {
+    CartesianTwist twist = ds->evaluate(current_pose);
+    current_pose += dt * twist;
+  }
+  EXPECT_NEAR(current_pose.dist(target_pose, CartesianStateVariable::POSITION), 0, linear_tol);
+}
+
+TEST_F(PointAttractorTest, OrientationOnly) {
+  current_pose.set_position(Eigen::Vector3d::Zero());
+  target_pose.set_position(Eigen::Vector3d::Zero());
+  ds->set_parameter_value("attractor", target_pose);
+
+  for (unsigned int i = 0; i < nb_steps; ++i) {
+    CartesianTwist twist = ds->evaluate(current_pose);
+    current_pose += dt * twist;
+  }
+  EXPECT_NEAR(current_pose.dist(target_pose, CartesianStateVariable::ORIENTATION), 0, angular_tol);
+}
+
+TEST_F(PointAttractorTest, PositionAndOrientation) {
+  ds->set_parameter_value("attractor", target_pose);
+
+  for (unsigned int i = 0; i < nb_steps; ++i) {
+    CartesianTwist twist = ds->evaluate(current_pose);
+    current_pose += dt * twist;
+  }
+  EXPECT_NEAR(current_pose.dist(target_pose, CartesianStateVariable::POSITION), 0, linear_tol);
+  EXPECT_NEAR(current_pose.dist(target_pose, CartesianStateVariable::ORIENTATION), 0, angular_tol);
+}
+
+TEST_F(PointAttractorTest, FixedReferenceFrames) {
+  auto BinA = CartesianState::Identity("B", "A");
+  auto CinA = CartesianState::Identity("C", "A");
+  auto CinB = CartesianState::Identity("C", "B");
+  BinA.set_pose(Eigen::Vector3d::Random(), Eigen::Quaterniond::UnitRandom());
+  CinA.set_pose(Eigen::Vector3d::Random(), Eigen::Quaterniond::UnitRandom());
+  CinB.set_pose(Eigen::Vector3d::Random(), Eigen::Quaterniond::UnitRandom());
+
+  ds->set_parameter_value("attractor", BinA);
+
+  // evaluating a current pose B in reference frame A should give zero twist (coincident with attractor)
+  CartesianTwist twist = ds->evaluate(BinA);
+  EXPECT_NEAR(twist.data().norm(), 0, 1e-5);
+
+  // evaluating pose C in frame A should give some non-zero twist
+  twist = ds->evaluate(CinA);
+  EXPECT_GE(twist.data().norm(), 1e-5);
+
+  // evaluating a state which does not match the DS base frame A should give an error
+  EXPECT_THROW(ds->evaluate(CinB), state_representation::exceptions::IncompatibleReferenceFramesException);
+
+  // an inverse state (A expressed in C) should also give an error,
+  // since the reference frame does not explicitly match the DS base frame
+  EXPECT_THROW(ds->evaluate(CinA.inverse()), state_representation::exceptions::IncompatibleReferenceFramesException);
+}
+
+TEST_F(PointAttractorTest, UpdateBaseReferenceFrames) {
+  auto BinA = CartesianState::Random("B", "A");
+  ds->set_parameter_value("attractor", BinA);
+
+  // the base frame of the default constructed DS should be an identity frame
+  // with the same name as the attractor reference frame
+  auto base = ds->get_base_frame();
+  EXPECT_STREQ(base.get_name().c_str(), BinA.get_reference_frame().c_str());
+  EXPECT_STREQ(base.get_name().c_str(), base.get_reference_frame().c_str());
+  EXPECT_NEAR(base.get_pose().norm(), 1, 1e-5);
+
+  auto AinWorld = CartesianState::Random("A", "world");
+  ds->set_base_frame(AinWorld);
+
+  // check the setter
+  base = ds->get_base_frame();
+  EXPECT_STREQ(base.get_name().c_str(), AinWorld.get_name().c_str());
+  EXPECT_STREQ(base.get_reference_frame().c_str(), AinWorld.get_reference_frame().c_str());
+  EXPECT_NEAR(base.get_pose().norm(), AinWorld.get_pose().norm(), 1e-5);
+
+  // evaluating a current pose B in reference frame A should give zero twist (coincident with attractor)
+  CartesianTwist twist = ds->evaluate(BinA);
+  EXPECT_STREQ(twist.get_name().c_str(), BinA.get_name().c_str());
+  EXPECT_STREQ(twist.get_reference_frame().c_str(), BinA.get_reference_frame().c_str());
+  EXPECT_NEAR(twist.data().norm(), 0, 1e-5);
+
+  // evaluating a current pose B in reference frame world should give zero twist (coincident with attractor)
+  // PLUS the twist of A in world, expressed as a twist B in world
+  auto BinWorld = AinWorld * BinA;
+  twist = ds->evaluate(BinWorld);
+  EXPECT_STREQ(twist.get_name().c_str(), BinWorld.get_name().c_str());
+  EXPECT_STREQ(twist.get_reference_frame().c_str(), BinWorld.get_reference_frame().c_str());
+  EXPECT_NEAR(twist.data().norm(), 0 + AinWorld.get_twist().norm(), 1e-5);
+
+  // since the base frame is set to frame A in frame world, evaluating a state with a reference frame that is neither
+  // should give an error
+  EXPECT_THROW(ds->evaluate(BinWorld.inverse()),
+               state_representation::exceptions::IncompatibleReferenceFramesException);
+}
+
+TEST_F(PointAttractorTest, StackedMovingReferenceFrames) {
+  auto AinWorld = CartesianState::Random("A", "world");
+  auto BinA = CartesianState::Random("B", "A");
+
+  auto CinA = CartesianState::Identity("C", "A");
+  CinA.set_pose(Eigen::Vector3d::Random(), Eigen::Quaterniond::UnitRandom());
+
+  ds->set_parameter_value("attractor", BinA);
+
+  // evaluate the twist for a fixed state C in reference frame A
+  CartesianTwist twist = ds->evaluate(CinA);
+
+  // the twist should be the same for a moving state C in reference frame A
+  // (the DS should always give the velocity from position, not from velocity)
+  CinA.set_linear_velocity(Eigen::Vector3d::Random());
+  CinA.set_angular_velocity(Eigen::Vector3d::Random());
+  CartesianTwist twist2 = ds->evaluate(CinA);
+
+  EXPECT_NEAR(twist.data().norm(), twist2.data().norm(), 1e-5);
+
+  // since reference frame A is moving with respect to the world, and DS gives a twist in reference frame A,
+  // the operation to express DS twist in the world frame should be valid.
+  ASSERT_NO_THROW(twist = AinWorld * ds->evaluate(CinA));
+
+  // the same operation can be done by setting the base frame of the DS
+  ds->set_base_frame(AinWorld);
+  auto CinWorld = AinWorld * CinA;
+  ASSERT_NO_THROW(twist2 = ds->evaluate(CinWorld));
+
+  // both methods should give the twist in the world frame
+  EXPECT_STREQ(twist.get_reference_frame().c_str(), AinWorld.get_reference_frame().c_str());
+  EXPECT_STREQ(twist.get_reference_frame().c_str(), twist2.get_reference_frame().c_str());
+  EXPECT_NEAR(twist.data().norm(), twist2.data().norm(), 1e-5);
+
+}
+
+TEST_F(PointAttractorTest, UpdateAttractorFrame) {
+  CartesianState A, B, C, D;
+  A = CartesianState::Random("A", "world");
+  B = CartesianState::Random("B", "world");
+  C = CartesianState::Random("C", "robot");
+  D = CartesianState::Random("D", "robot");
+
+  ds->set_parameter_value("attractor", A);
+
+  // state being evaluated must match the DS base frame, which is by default the attractor reference frame
+  EXPECT_NO_THROW(ds->evaluate(B));
+  EXPECT_THROW(ds->evaluate(D), state_representation::exceptions::IncompatibleReferenceFramesException);
+
+  // setting the attractor to another point in the same base frame should be fine,
+  // but setting it with a different base frame should give an error
+  EXPECT_NO_THROW(ds->set_parameter_value("attractor", B));
+  EXPECT_THROW(ds->set_parameter_value("attractor", C),
+               state_representation::exceptions::IncompatibleReferenceFramesException);
+
+  // after updating the base frame, the attractor reference frame should also be updated
+  ds->set_base_frame(CartesianState::Identity(C.get_reference_frame(), C.get_reference_frame()));
+  EXPECT_STREQ(ds->get_parameter_value<CartesianPose>("attractor").get_reference_frame().c_str(),
+               C.get_reference_frame().c_str());
+
+  // with the new base frame, setting the attractor should succeed / fail accordingly
+  EXPECT_THROW(ds->set_parameter_value("attractor", B),
+               state_representation::exceptions::IncompatibleReferenceFramesException);
+  EXPECT_NO_THROW(ds->set_parameter_value("attractor", C));
+
+  // now the evaluation should also succeed when matching the updated base frame
+  EXPECT_THROW(ds->evaluate(B), state_representation::exceptions::IncompatibleReferenceFramesException);
+  EXPECT_NO_THROW(ds->evaluate(D));
+}
+
+TEST(JointPointAttractorTest, EmptyConstructor) {
+  auto ds = DynamicalSystemFactory<JointState>::create_dynamical_system(
+      DynamicalSystemFactory<JointState>::DYNAMICAL_SYSTEM::POINT_ATTRACTOR
+  );
+  // construct empty cartesian state DS
+  auto attractor = JointPositions::Zero("robot", 3);
+
+  // base frame and attractor should be empty
+  EXPECT_TRUE(ds->get_parameter_value<JointPositions>("attractor").is_empty());
+  EXPECT_TRUE(ds->get_base_frame().is_empty());
+  ds->set_parameter_value("attractor", attractor);
+  EXPECT_FALSE(ds->get_parameter_value<JointPositions>("attractor").is_empty());
+  EXPECT_TRUE(ds->get_base_frame().is_empty());
+}
+
+TEST(JointPointAttractorTest, EmptyCompatible) {
+  auto ds = DynamicalSystemFactory<JointState>::create_dynamical_system(
+      DynamicalSystemFactory<JointState>::DYNAMICAL_SYSTEM::POINT_ATTRACTOR
+  );
+  JointState state1 = JointState::Zero("robot", 3);
+  JointState state2 = JointState("test", 3);
+  JointState state3 = JointState("robot", 4);
+  JointState state4 = JointState("robot", {"1", "2", "3"});
+
+  // if no attractor is set, an exception is thrown
+  EXPECT_THROW(ds->evaluate(state2), dynamical_systems::exceptions::EmptyAttractorException);
+  ds->set_parameter_value("attractor", state1);
+
+  EXPECT_THROW(ds->evaluate(state2), state_representation::exceptions::EmptyStateException);
+  EXPECT_THROW(ds->evaluate(state3), state_representation::exceptions::IncompatibleStatesException);
+
+  EXPECT_TRUE(ds->is_compatible(state1));
+  EXPECT_TRUE(ds->is_compatible(state2));
+  EXPECT_FALSE(ds->is_compatible(state3));
+  EXPECT_FALSE(ds->is_compatible(state4));
+}
+
+TEST(JointPointAttractorTest, Convergence) {
+  auto ds = DynamicalSystemFactory<JointState>::create_dynamical_system(
+      DynamicalSystemFactory<JointState>::DYNAMICAL_SYSTEM::POINT_ATTRACTOR
+  );
+  auto attractor = JointPositions::Random("robot", 3);
+  auto current_state = JointPositions::Random("robot", 3);
+  current_state.set_data(10 * current_state.data());
+
+  ds->set_parameter_value("attractor", attractor);
+  for (unsigned int i = 0; i < 100; ++i) {
+    JointVelocities velocities = ds->evaluate(current_state);
+    current_state += 100ms * velocities;
+  }
+  EXPECT_NEAR(current_state.dist(attractor, JointStateVariable::POSITIONS), 0, 1e-3);
+}
diff --git a/source/dynamical_systems/test/tests/test_ring.cpp b/source/dynamical_systems/test/tests/test_ring.cpp
index f718eb159..0e209315f 100644
--- a/source/dynamical_systems/test/tests/test_ring.cpp
+++ b/source/dynamical_systems/test/tests/test_ring.cpp
@@ -1,21 +1,30 @@
 #include <gtest/gtest.h>
-#include "dynamical_systems/Ring.hpp"
+
+#include "dynamical_systems/DynamicalSystemFactory.hpp"
 #include "dynamical_systems/exceptions/EmptyBaseFrameException.hpp"
 #include "dynamical_systems/exceptions/EmptyAttractorException.hpp"
 
+#include "state_representation/space/cartesian/CartesianState.hpp"
+#include "state_representation/space/cartesian/CartesianPose.hpp"
+#include "state_representation/parameters/Parameter.hpp"
 #include "state_representation/exceptions/IncompatibleReferenceFramesException.hpp"
 #include "state_representation/exceptions/EmptyStateException.hpp"
 
+using namespace dynamical_systems;
 using namespace state_representation;
 using namespace std::literals::chrono_literals;
 
 class RingDSTest : public ::testing::Test {
 protected:
   RingDSTest() {
+    ds = DynamicalSystemFactory<CartesianState>::create_dynamical_system(
+        DynamicalSystemFactory<CartesianState>::DYNAMICAL_SYSTEM::RING
+    );
     center = CartesianPose::Identity("A");
     current_pose = CartesianPose("B", radius * Eigen::Vector3d::Random());
   }
 
+  std::shared_ptr<IDynamicalSystem<CartesianState>> ds;
   CartesianPose current_pose;
   CartesianPose center;
   std::vector<double> vlim = {10, 10, 0.001, 0.001};
@@ -29,130 +38,137 @@ class RingDSTest : public ::testing::Test {
 };
 
 TEST_F(RingDSTest, EmptyConstructor) {
-  // construct empty cartesian state DS
   CartesianPose center = CartesianPose::Identity("CAttractor", "A");
-  dynamical_systems::Ring ds;
   // base frame and attractor should be empty
-  EXPECT_TRUE(ds.get_center().is_empty());
-  EXPECT_TRUE(ds.get_base_frame().is_empty());
-  ds.set_center(center);
-  EXPECT_FALSE(ds.get_center().is_empty());
-  EXPECT_FALSE(ds.get_base_frame().is_empty());
+  EXPECT_TRUE(ds->get_parameter_value<CartesianPose>("center").is_empty());
+  ds->set_parameter_value("center", center);
+  EXPECT_FALSE(ds->get_parameter_value<CartesianPose>("center").is_empty());
+  EXPECT_FALSE(ds->get_base_frame().is_empty());
   // when attractor was set without a base frame, expect base frame to be identity with name / reference_frame of attractor
-  EXPECT_EQ(ds.get_base_frame().get_name(), center.get_reference_frame());
-  EXPECT_EQ(ds.get_base_frame().get_reference_frame(), center.get_reference_frame());
-  EXPECT_EQ(ds.get_base_frame().get_transformation_matrix(), Eigen::Matrix4d::Identity());
+  EXPECT_EQ(ds->get_base_frame().get_name(), center.get_reference_frame());
+  EXPECT_EQ(ds->get_base_frame().get_reference_frame(), center.get_reference_frame());
+  EXPECT_EQ(ds->get_base_frame().get_transformation_matrix(), Eigen::Matrix4d::Identity());
+}
 
-  ds = dynamical_systems::Ring();
+TEST_F(RingDSTest, EvaluateComptability) {
+  CartesianPose center = CartesianPose::Identity("CAttractor", "A");
   CartesianState state1 = CartesianState::Identity("B", "A");
   CartesianState state2("D", "C");
   CartesianState state3("C", "A");
   CartesianState state4("C", "B");
   // if no base frame is set, an exception is thrown
-  EXPECT_THROW(ds.evaluate(state1), dynamical_systems::exceptions::EmptyBaseFrameException);
-  ds.set_base_frame(state1);
+  EXPECT_THROW(ds->evaluate(state1), dynamical_systems::exceptions::EmptyBaseFrameException);
+  ds->set_base_frame(state1);
   // if cartesian state is incompatible, an exception is thrown
-  EXPECT_THROW(ds.evaluate(state2), state_representation::exceptions::IncompatibleReferenceFramesException);
+  EXPECT_THROW(ds->evaluate(state2), state_representation::exceptions::IncompatibleReferenceFramesException);
   // if cartesian state needs to be transformed to other frame first and is empty, an exception is thrown
-  EXPECT_THROW(ds.evaluate(state3), state_representation::exceptions::EmptyStateException);
+  EXPECT_THROW(ds->evaluate(state3), state_representation::exceptions::EmptyStateException);
   // if no attractor is set, an exception is thrown
-  EXPECT_THROW(ds.evaluate(state4), dynamical_systems::exceptions::EmptyAttractorException);
+  EXPECT_THROW(ds->evaluate(state4), dynamical_systems::exceptions::EmptyAttractorException);
 
-  ds.set_center(center);
-  EXPECT_TRUE(ds.is_compatible(state1));
-  EXPECT_FALSE(ds.is_compatible(state2));
-  EXPECT_TRUE(ds.is_compatible(state3));
-  EXPECT_TRUE(ds.is_compatible(state4));
+  ds->set_parameter_value("center", center);
+  EXPECT_TRUE(ds->is_compatible(state1));
+  EXPECT_FALSE(ds->is_compatible(state2));
+  EXPECT_TRUE(ds->is_compatible(state3));
+  EXPECT_TRUE(ds->is_compatible(state4));
 }
 
 TEST_F(RingDSTest, PointsOnRadius) {
-  dynamical_systems::Ring ring(center, radius, width, speed);
+  ds->set_parameter_value("center", center);
+  ds->set_parameter_value("radius", radius);
+  ds->set_parameter_value("width", width);
+  ds->set_parameter_value("speed", speed);
   CartesianTwist twist;
 
   // zero output at center
   current_pose = center;
-  twist = ring.evaluate(current_pose);
+  twist = ds->evaluate(current_pose);
   EXPECT_NEAR(twist.data().norm(), 0, tol);
 
   current_pose.set_position(radius, 0, 0);
-  twist = ring.evaluate(current_pose);
+  twist = ds->evaluate(current_pose);
   EXPECT_NEAR(twist.get_linear_velocity().x(), 0, tol);
   EXPECT_NEAR(twist.get_linear_velocity().y(), speed, tol);
 
   current_pose.set_position(0, radius, 0);
-  twist = ring.evaluate(current_pose);
+  twist = ds->evaluate(current_pose);
   EXPECT_NEAR(twist.get_linear_velocity().x(), -speed, tol);
   EXPECT_NEAR(twist.get_linear_velocity().y(), 0, tol);
 
   current_pose.set_position(-radius, 0, 0);
-  twist = ring.evaluate(current_pose);
+  twist = ds->evaluate(current_pose);
   EXPECT_NEAR(twist.get_linear_velocity().x(), 0, tol);
   EXPECT_NEAR(twist.get_linear_velocity().y(), -speed, tol);
 
   current_pose.set_position(0, -radius, 0);
-  twist = ring.evaluate(current_pose);
+  twist = ds->evaluate(current_pose);
   EXPECT_NEAR(twist.get_linear_velocity().x(), speed, tol);
   EXPECT_NEAR(twist.get_linear_velocity().y(), 0, tol);
 
   current_pose.set_position(radius, 0, 1);
-  twist = ring.evaluate(current_pose);
+  twist = ds->evaluate(current_pose);
   EXPECT_NEAR(twist.get_linear_velocity().z(), -1, tol);
 }
 
 TEST_F(RingDSTest, PointsNearRadius) {
-  dynamical_systems::Ring ring(center, radius, width, speed, field_strength);
+  ds->set_parameter_value("center", center);
+  ds->set_parameter_value("radius", radius);
+  ds->set_parameter_value("width", width);
+  ds->set_parameter_value("speed", speed);
+  ds->set_parameter_value("field_strength", field_strength);
   CartesianTwist twist;
 
   current_pose.set_position(radius + width, 0, 0);
-  twist = ring.evaluate(current_pose);
+  twist = ds->evaluate(current_pose);
   EXPECT_NEAR(twist.get_linear_velocity().x(), -speed * field_strength, tol);
   EXPECT_NEAR(twist.get_linear_velocity().y(), 0, tol);
 
   current_pose.set_position(radius - width, 0, 0);
-  twist = ring.evaluate(current_pose);
+  twist = ds->evaluate(current_pose);
   EXPECT_NEAR(twist.get_linear_velocity().x(), speed * field_strength, tol);
   EXPECT_NEAR(twist.get_linear_velocity().y(), 0, tol);
 
   current_pose.set_position(0, radius + width, 0);
-  twist = ring.evaluate(current_pose);
+  twist = ds->evaluate(current_pose);
   EXPECT_NEAR(twist.get_linear_velocity().x(), 0, tol);
   EXPECT_NEAR(twist.get_linear_velocity().y(), -speed * field_strength, tol);
 
   current_pose.set_position(0, radius - width, 0);
-  twist = ring.evaluate(current_pose);
+  twist = ds->evaluate(current_pose);
   EXPECT_NEAR(twist.get_linear_velocity().x(), 0, tol);
   EXPECT_NEAR(twist.get_linear_velocity().y(), speed * field_strength, tol);
 
   current_pose.set_position(radius + (width * 2), 0, 0);
-  twist = ring.evaluate(current_pose);
+  twist = ds->evaluate(current_pose);
   EXPECT_NEAR(twist.get_linear_velocity().x(), -speed * field_strength, tol);
   EXPECT_NEAR(twist.get_linear_velocity().y(), 0, tol);
 }
 
 TEST_F(RingDSTest, BehaviourNearBoundaryAtHighSpeeds) {
-  radius = 1;
-  width = 0.1;
-  speed = 10;
-  field_strength = 2;
-  dynamical_systems::Ring ring(center, radius, width, speed, field_strength);
+  ds->set_parameter_value("center", center);
+  ds->set_parameter_value("radius", 1.0);
+  ds->set_parameter_value("width", 0.1);
+  ds->set_parameter_value("speed", 10.0);
+  ds->set_parameter_value("field_strength", 2.0);
   CartesianTwist twist;
 
   current_pose.set_position(0, radius + 1.001 * width, 0);
-  twist = ring.evaluate(current_pose);
+  twist = ds->evaluate(current_pose);
   double angular_speed = twist.get_angular_velocity().norm();
   current_pose.set_position(0, radius + 1.000 * width, 0);
-  twist = ring.evaluate(current_pose);
+  twist = ds->evaluate(current_pose);
   EXPECT_NEAR(twist.get_angular_velocity().norm(), angular_speed, 0.1);
   current_pose.set_position(0, radius + 0.999 * width, 0);
-  twist = ring.evaluate(current_pose);
+  twist = ds->evaluate(current_pose);
   EXPECT_NEAR(twist.get_angular_velocity().norm(), angular_speed, 0.1);
 }
 
 TEST_F(RingDSTest, ConvergenceOnRadius) {
-  dynamical_systems::Ring ring(center, radius);
+  ds->set_parameter_value("center", center);
+  ds->set_parameter_value("radius", radius);
 
   for (unsigned int i = 0; i < nb_steps; ++i) {
-    CartesianTwist twist = ring.evaluate(current_pose);
+    CartesianTwist twist = ds->evaluate(current_pose);
     twist.clamp(vlim[0], vlim[1], vlim[2], vlim[3]);
     current_pose += dt * twist;
   }
@@ -163,10 +179,11 @@ TEST_F(RingDSTest, ConvergenceOnRadius) {
 TEST_F(RingDSTest, ConvergenceOnRadiusRandomCenter) {
   center.set_position(Eigen::Vector3d::Random());
   center.set_orientation(Eigen::Quaterniond::UnitRandom());
-  dynamical_systems::Ring ring(center, radius);
+  ds->set_parameter_value("center", center);
+  ds->set_parameter_value("radius", radius);
 
   for (unsigned int i = 0; i < nb_steps; ++i) {
-    CartesianTwist twist = ring.evaluate(current_pose);
+    CartesianTwist twist = ds->evaluate(current_pose);
     twist.clamp(vlim[0], vlim[1], vlim[2], vlim[3]);
     current_pose += dt * twist;
   }
@@ -175,12 +192,12 @@ TEST_F(RingDSTest, ConvergenceOnRadiusRandomCenter) {
 }
 
 TEST_F(RingDSTest, ZeroNormalGain) {
-  dynamical_systems::Ring ring(center);
-  ring.set_normal_gain(0);
+  ds->set_parameter_value("center", center);
+  ds->set_parameter_value("normal_gain", 0.0);
 
   double startingHeight = current_pose.get_position().z();
   for (unsigned int i = 0; i < nb_steps; ++i) {
-    CartesianTwist twist = ring.evaluate(current_pose);
+    CartesianTwist twist = ds->evaluate(current_pose);
     twist.clamp(vlim[0], vlim[1], vlim[2], vlim[3]);
     current_pose += dt * twist;
   }
@@ -188,37 +205,43 @@ TEST_F(RingDSTest, ZeroNormalGain) {
 }
 
 TEST_F(RingDSTest, OrientationAroundCircle) {
-  dynamical_systems::Ring ring(center, radius, width, 0);
+  ds->set_parameter_value("center", center);
+  ds->set_parameter_value("radius", radius);
+  ds->set_parameter_value("width", width);
+  ds->set_parameter_value("speed", 0.0);
   CartesianTwist twist;
 
   // at the position {radius, 0, 0}, the orientation attractor is by default null,
   // so there should be zero angular velocity if the current pose orientation is also null
   current_pose.set_position(radius, 0, 0);
   current_pose.set_orientation(Eigen::Quaterniond::Identity());
-  twist = ring.evaluate(current_pose);
+  twist = ds->evaluate(current_pose);
   EXPECT_NEAR(twist.get_angular_velocity().norm(), 0, tol);
 
   // at the position {0, radius, 0}, the default rotation around Z is pi/2
   current_pose.set_position(0, radius, 0);
   current_pose.set_orientation(Eigen::Quaterniond(1, 0, 0, 1));
-  twist = ring.evaluate(current_pose);
+  twist = ds->evaluate(current_pose);
   EXPECT_NEAR(twist.get_angular_velocity().norm(), 0, tol);
 
   // at the position {0, radius, 0}, the default rotation around Z is pi
   current_pose.set_position(-radius, 0, 0);
   current_pose.set_orientation(Eigen::Quaterniond(0, 0, 0, 1));
-  twist = ring.evaluate(current_pose);
+  twist = ds->evaluate(current_pose);
   EXPECT_NEAR(twist.get_angular_velocity().norm(), 0, tol);
 
   // at the position {0, radius, 0}, the default rotation around Z is 3 * pi/2
   current_pose.set_position(0, -radius, 0);
   current_pose.set_orientation(Eigen::Quaterniond(1, 0, 0, -1));
-  twist = ring.evaluate(current_pose);
+  twist = ds->evaluate(current_pose);
   EXPECT_NEAR(twist.get_angular_velocity().norm(), 0, tol);
 }
 
 TEST_F(RingDSTest, OrientationRestitutionAtZeroAngle) {
-  dynamical_systems::Ring ring(center, radius, width, 0);
+  ds->set_parameter_value("center", center);
+  ds->set_parameter_value("radius", radius);
+  ds->set_parameter_value("width", width);
+  ds->set_parameter_value("speed", 0.0);
   CartesianTwist twist;
 
   // at the position {radius, 0, 0}, the orientation attractor is by default null (angle around circle is 0)
@@ -226,28 +249,31 @@ TEST_F(RingDSTest, OrientationRestitutionAtZeroAngle) {
 
   // rotate the current pose around local X
   current_pose.set_orientation(Eigen::Quaterniond(1, 1, 0, 0));
-  twist = ring.evaluate(current_pose);
-  EXPECT_NEAR(twist.get_angular_velocity().x(), -M_PI_2 * ring.get_angular_gain(), tol);
+  twist = ds->evaluate(current_pose);
+  EXPECT_NEAR(twist.get_angular_velocity().x(), -M_PI_2 * ds->get_parameter_value<double>("angular_gain"), tol);
   EXPECT_NEAR(twist.get_angular_velocity().y(), 0, tol);
   EXPECT_NEAR(twist.get_angular_velocity().z(), 0, tol);
 
   // rotate the current pose around local Y
   current_pose.set_orientation(Eigen::Quaterniond(1, 0, 1, 0));
-  twist = ring.evaluate(current_pose);
+  twist = ds->evaluate(current_pose);
   EXPECT_NEAR(twist.get_angular_velocity().x(), 0, tol);
-  EXPECT_NEAR(twist.get_angular_velocity().y(), -M_PI_2 * ring.get_angular_gain(), tol);
+  EXPECT_NEAR(twist.get_angular_velocity().y(), -M_PI_2 * ds->get_parameter_value<double>("angular_gain"), tol);
   EXPECT_NEAR(twist.get_angular_velocity().z(), 0, tol);
 
   // rotate the current pose around local Z
   current_pose.set_orientation(Eigen::Quaterniond(1, 0, 0, 1));
-  twist = ring.evaluate(current_pose);
+  twist = ds->evaluate(current_pose);
   EXPECT_NEAR(twist.get_angular_velocity().x(), 0, tol);
   EXPECT_NEAR(twist.get_angular_velocity().y(), 0, tol);
-  EXPECT_NEAR(twist.get_angular_velocity().z(), -M_PI_2 * ring.get_angular_gain(), tol);
+  EXPECT_NEAR(twist.get_angular_velocity().z(), -M_PI_2 * ds->get_parameter_value<double>("angular_gain"), tol);
 }
 
 TEST_F(RingDSTest, OrientationRotationOffset) {
-  dynamical_systems::Ring ring(center, radius, width, 0);
+  ds->set_parameter_value("center", center);
+  ds->set_parameter_value("radius", radius);
+  ds->set_parameter_value("width", width);
+  ds->set_parameter_value("speed", 0.0);
   CartesianTwist twist;
 
   current_pose.set_position(radius, 0, 0);
@@ -257,121 +283,129 @@ TEST_F(RingDSTest, OrientationRotationOffset) {
   // if the rotation offset is the same as the current orientation, the angular velocity at
   // position {radius, 0, 0} is always zero
   current_pose.set_orientation(rotation);
-  ring.set_rotation_offset(rotation);
-  twist = ring.evaluate(current_pose);
+  ds->set_parameter_value("rotation_offset", current_pose);
+  twist = ds->evaluate(current_pose);
   EXPECT_NEAR(twist.get_angular_velocity().norm(), 0, tol);
 
   // now if the current pose has some orientation relative to the rotation offset,
   // it will yield the expected angular velocity of only that difference
-  current_pose.set_orientation(Eigen::Quaterniond(1, 1, 0, 0).normalized() * ring.get_rotation_offset());
-  twist = ring.evaluate(current_pose);
-  EXPECT_NEAR(twist.get_angular_velocity().x(), -M_PI_2 * ring.get_angular_gain(), tol);
+  current_pose.set_orientation(
+      Eigen::Quaterniond(1, 1, 0, 0).normalized()
+          * ds->get_parameter_value<CartesianPose>("rotation_offset").get_orientation());
+  twist = ds->evaluate(current_pose);
+  EXPECT_NEAR(twist.get_angular_velocity().x(), -M_PI_2 * ds->get_parameter_value<double>("angular_gain"), tol);
   EXPECT_NEAR(twist.get_angular_velocity().y(), 0, tol);
   EXPECT_NEAR(twist.get_angular_velocity().z(), 0, tol);
 
   // rotate the center plane in the base frame, and set the current position to have the same relative
   // offset that gives a zero command (no rotation offset)
   center.set_orientation(Eigen::Quaterniond::UnitRandom());
-  ring.set_center(center);
+  ds->set_parameter_value("center", center);
   current_pose = CartesianPose("B", Eigen::Vector3d(radius, 0, 0), "A");
   current_pose = center * current_pose;
-  ring.set_rotation_offset(Eigen::Quaterniond::Identity());
-  twist = ring.evaluate(current_pose);
+  ds->set_parameter_value("rotation_offset", CartesianPose::Identity("offset"));
+  twist = ds->evaluate(current_pose);
   EXPECT_NEAR(twist.get_angular_velocity().norm(), 0, tol);
 
   // for any rotation offset in a rotated center plane, the output will
   // still be zero if the current position and orientation matches the rotation offset
   rotation = Eigen::Quaterniond::UnitRandom();
-  ring.set_rotation_offset(rotation);
-  current_pose = CartesianPose("B", Eigen::Vector3d(radius, 0, 0), ring.get_rotation_offset(), "A");
+  ds->set_parameter_value("rotation_offset", CartesianPose("offset", rotation));
+  current_pose = CartesianPose(
+      "B", Eigen::Vector3d(radius, 0, 0), ds->get_parameter_value<CartesianPose>("rotation_offset").get_orientation(),
+      "A"
+  );
   current_pose = center * current_pose;
-  twist = ring.evaluate(current_pose);
+  twist = ds->evaluate(current_pose);
   EXPECT_NEAR(twist.get_angular_velocity().norm(), 0, tol);
 
   // any additional orientation in the ring frame on top of the rotation offset
   // should give the same local command, regardless of the center frame
-  current_pose = CartesianPose("B",
-                               Eigen::Vector3d(radius, 0, 0),
-                               Eigen::Quaterniond(1, 1, 0, 0).normalized() * ring.get_rotation_offset(),
-                               "A");
+  current_pose = CartesianPose(
+      "B", Eigen::Vector3d(radius, 0, 0), Eigen::Quaterniond(1, 1, 0, 0).normalized()
+          * ds->get_parameter_value<CartesianPose>("rotation_offset").get_orientation(), "A"
+  );
   current_pose = center * current_pose;
-  twist = ring.evaluate(current_pose);
+  twist = ds->evaluate(current_pose);
 
   // check the twist in the local frame
   twist = CartesianState(center).inverse() * twist;
-  EXPECT_NEAR(twist.get_angular_velocity().x(), -M_PI_2 * ring.get_angular_gain(), tol);
+  EXPECT_NEAR(twist.get_angular_velocity().x(), -M_PI_2 * ds->get_parameter_value<double>("angular_gain"), tol);
   EXPECT_NEAR(twist.get_angular_velocity().y(), 0, tol);
   EXPECT_NEAR(twist.get_angular_velocity().z(), 0, tol);
 }
 
 TEST_F(RingDSTest, BaseFrameBehaviours) {
-  auto AinB = CartesianState::Random("A", "B");
-  dynamical_systems::Ring ring(AinB);
+  auto AinB = CartesianPose::Random("A", "B");
+  ds->set_parameter_value("center", AinB);
 
   // setting the center through the constructor should also set the base frame (as Identity frame)
-  EXPECT_STREQ(ring.get_center().get_name().c_str(), "A");
-  EXPECT_STREQ(ring.get_center().get_reference_frame().c_str(), "B");
-  EXPECT_STREQ(ring.get_base_frame().get_name().c_str(), "B");
-  EXPECT_STREQ(ring.get_base_frame().get_reference_frame().c_str(), "B");
-  EXPECT_NEAR(ring.get_base_frame().get_pose().norm(), 1, tol);
+  EXPECT_STREQ(ds->get_parameter_value<CartesianPose>("center").get_name().c_str(), "A");
+  EXPECT_STREQ(ds->get_parameter_value<CartesianPose>("center").get_reference_frame().c_str(), "B");
+  EXPECT_STREQ(ds->get_base_frame().get_name().c_str(), "B");
+  EXPECT_STREQ(ds->get_base_frame().get_reference_frame().c_str(), "B");
+  EXPECT_NEAR(ds->get_base_frame().get_pose().norm(), 1, tol);
 
   // setting the center should fail if it is incompatible with the base frame
-  auto CinD = CartesianState::Random("C", "D");
-  EXPECT_THROW(ring.set_center(CinD), state_representation::exceptions::IncompatibleReferenceFramesException);
+  auto CinD = CartesianPose::Random("C", "D");
+  EXPECT_THROW(ds->set_parameter_value("center", CartesianPose(CinD)),
+               state_representation::exceptions::IncompatibleReferenceFramesException);
 
   // updating the base frame should "move" the center frame but not change its magnitude
-  auto centerNorm = ring.get_center().get_pose().norm();
-  ring.set_base_frame(CinD);
+  auto centerNorm = ds->get_parameter_value<CartesianPose>("center").get_pose().norm();
+  ds->set_base_frame(CinD);
 
-  EXPECT_STREQ(ring.get_center().get_name().c_str(), "A");
-  EXPECT_STREQ(ring.get_center().get_reference_frame().c_str(), "C");
-  EXPECT_STREQ(ring.get_base_frame().get_name().c_str(), "C");
-  EXPECT_STREQ(ring.get_base_frame().get_reference_frame().c_str(), "D");
-  EXPECT_NEAR(ring.get_center().get_pose().norm(), centerNorm, tol);
+  EXPECT_STREQ(ds->get_parameter_value<CartesianPose>("center").get_name().c_str(), "A");
+  EXPECT_STREQ(ds->get_parameter_value<CartesianPose>("center").get_reference_frame().c_str(), "C");
+  EXPECT_STREQ(ds->get_base_frame().get_name().c_str(), "C");
+  EXPECT_STREQ(ds->get_base_frame().get_reference_frame().c_str(), "D");
+  EXPECT_NEAR(ds->get_parameter_value<CartesianPose>("center").get_pose().norm(), centerNorm, tol);
 
   // setting the center should succeed if it is expressed relative to the base frame
-  auto BinC = CartesianState::Random("B", "C");
-  EXPECT_NO_THROW(ring.set_center(BinC));
-  EXPECT_STREQ(ring.get_center().get_name().c_str(), "B");
-  EXPECT_STREQ(ring.get_center().get_reference_frame().c_str(), "C");
+  auto BinC = CartesianPose::Random("B", "C");
+  EXPECT_NO_THROW(ds->set_parameter_value("center", BinC));
+  EXPECT_STREQ(ds->get_parameter_value<CartesianPose>("center").get_name().c_str(), "B");
+  EXPECT_STREQ(ds->get_parameter_value<CartesianPose>("center").get_reference_frame().c_str(), "C");
 
   // setting the center should also succeed if it shares the same reference frame as the base frame
-  auto BinD = CartesianState::Random("B", "D");
-  EXPECT_NO_THROW(ring.set_center(BinD));
-  EXPECT_STREQ(ring.get_center().get_name().c_str(), "B");
+  auto BinD = CartesianPose::Random("B", "D");
+  EXPECT_NO_THROW(ds->set_parameter_value("center", BinD));
+  EXPECT_STREQ(ds->get_parameter_value<CartesianPose>("center").get_name().c_str(), "B");
   // the reference frame is still C, not D, because the center is internally represented relative to the base frame (C)
-  EXPECT_STREQ(ring.get_center().get_reference_frame().c_str(), "C");
+  EXPECT_STREQ(ds->get_parameter_value<CartesianPose>("center").get_reference_frame().c_str(), "C");
 }
 
 TEST_F(RingDSTest, SettersAndGetters) {
-  dynamical_systems::Ring ring(center);
+  ds->set_parameter_value("center", center);
 
   auto pose = CartesianState::Random("C");
-  ring.set_center(pose);
-  auto pose2 = ring.get_center();
+  ds->set_parameter_value("center", CartesianPose(pose));
+  auto pose2 = ds->get_parameter_value<CartesianPose>("center");
   EXPECT_STREQ(pose.get_name().c_str(), pose2.get_name().c_str());
   EXPECT_STREQ(pose.get_reference_frame().c_str(), pose2.get_reference_frame().c_str());
   EXPECT_NEAR(pose.get_pose().norm(), pose2.get_pose().norm(), tol);
 
   // all other setters should store the value
-  ring.set_rotation_offset(Eigen::Quaterniond(1, 2, 3, 4).normalized());
-  EXPECT_NEAR(ring.get_rotation_offset().angularDistance(Eigen::Quaterniond(1, 2, 3, 4).normalized()), 0, tol);
+  ds->set_parameter_value(
+      "rotation_offset", CartesianPose("offset", Eigen::Quaterniond(1, 2, 3, 4).normalized()));
+  EXPECT_NEAR(ds->get_parameter_value<CartesianPose>("rotation_offset").get_orientation().angularDistance(
+      Eigen::Quaterniond(1, 2, 3, 4).normalized()), 0, tol);
 
-  ring.set_radius(1);
-  EXPECT_NEAR(ring.get_radius(), 1, tol);
+  ds->set_parameter_value("radius", 1.0);
+  EXPECT_NEAR(ds->get_parameter_value<double>("radius"), 1.0, tol);
 
-  ring.set_width(2);
-  EXPECT_NEAR(ring.get_width(), 2, tol);
+  ds->set_parameter_value("width", 2.0);
+  EXPECT_NEAR(ds->get_parameter_value<double>("width"), 2.0, tol);
 
-  ring.set_speed(3);
-  EXPECT_NEAR(ring.get_speed(), 3, tol);
+  ds->set_parameter_value("speed", 3.0);
+  EXPECT_NEAR(ds->get_parameter_value<double>("speed"), 3.0, tol);
 
-  ring.set_field_strength(4);
-  EXPECT_NEAR(ring.get_field_strength(), 4, tol);
+  ds->set_parameter_value("field_strength", 4.0);
+  EXPECT_NEAR(ds->get_parameter_value<double>("field_strength"), 4.0, tol);
 
-  ring.set_normal_gain(5);
-  EXPECT_NEAR(ring.get_normal_gain(), 5, tol);
+  ds->set_parameter_value("normal_gain", 5.0);
+  EXPECT_NEAR(ds->get_parameter_value<double>("normal_gain"), 5.0, tol);
 
-  ring.set_angular_gain(6);
-  EXPECT_NEAR(ring.get_angular_gain(), 6, tol);
-}
\ No newline at end of file
+  ds->set_parameter_value("angular_gain", 6.0);
+  EXPECT_NEAR(ds->get_parameter_value<double>("angular_gain"), 6.0, tol);
+}
diff --git a/source/install.sh b/source/install.sh
index 334bb9251..cecf8f8eb 100755
--- a/source/install.sh
+++ b/source/install.sh
@@ -71,14 +71,24 @@ while [ "$#" -gt 0 ]; do
   esac
 done
 
+if [ "${BUILD_CONTROLLERS}" == "ON" ] && [ "${BUILD_ROBOT_MODEL}" == "OFF" ]; then
+  echo "The robot model library is required to build the controllers library!"
+  echo "Either disable controller installation with '--no-controllers' or enable"
+  echo "the robot model installation by removing the '--no-robot-model' flag."
+  exit 1
+fi
+
 # install base dependencies
 echo ">>> INSTALLING BASE DEPENDENCIES"
-apt-get update && apt-get install "${AUTO_INSTALL}" libeigen3-dev || exit 1
+mkdir -p "${SOURCE_PATH}"/tmp/lib
+cd "${SOURCE_PATH}"/tmp/lib || exit 1
+wget -c https://gitlab.com/libeigen/eigen/-/archive/3.4.0/eigen-3.4.0.tar.gz -O - | tar -xz
+cd eigen-3.4.0 && mkdir build && cd build && cmake .. && make install
 
 # install module-specific dependencies
 if [ "${BUILD_ROBOT_MODEL}" == "ON" ]; then
   echo ">>> INSTALLING ROBOT MODEL DEPENDENCIES"
-  apt-get install "${AUTO_INSTALL}" lsb-release gnupg2 curl || exit 1
+  apt-get update && apt-get install "${AUTO_INSTALL}" lsb-release gnupg2 curl || exit 1
 
   # install pinocchio
   echo "deb [arch=amd64] http://robotpkg.openrobots.org/packages/debian/pub $(lsb_release -cs) robotpkg" \
@@ -93,7 +103,6 @@ if [ "${BUILD_ROBOT_MODEL}" == "ON" ]; then
   export CMAKE_PREFIX_PATH=/opt/openrobots:$CMAKE_PREFIX_PATH
 
   # install osqp
-  mkdir -p "${SOURCE_PATH}"/tmp/lib
   cd "${SOURCE_PATH}"/tmp/lib || exit 1
   git clone --recursive https://github.com/oxfordcontrol/osqp
   cd "${SOURCE_PATH}"/tmp/lib/osqp/ && git checkout "${OSQP_TAG}" && mkdir -p build && cd build || exit 1
diff --git a/source/robot_model/include/robot_model/Model.hpp b/source/robot_model/include/robot_model/Model.hpp
index d53c01279..f8f9f6555 100644
--- a/source/robot_model/include/robot_model/Model.hpp
+++ b/source/robot_model/include/robot_model/Model.hpp
@@ -9,8 +9,8 @@
 #include <pinocchio/parsers/urdf.hpp>
 #include <state_representation/parameters/Parameter.hpp>
 #include <state_representation/parameters/ParameterInterface.hpp>
-#include <state_representation/robot/Jacobian.hpp>
-#include <state_representation/robot/JointState.hpp>
+#include <state_representation/space/Jacobian.hpp>
+#include <state_representation/space/joint/JointState.hpp>
 #include <state_representation/space/cartesian/CartesianState.hpp>
 
 using namespace std::chrono_literals;
diff --git a/source/robot_model/test/tests/test_dynamics.cpp b/source/robot_model/test/tests/test_dynamics.cpp
index f91f6e6bb..12bf048d3 100644
--- a/source/robot_model/test/tests/test_dynamics.cpp
+++ b/source/robot_model/test/tests/test_dynamics.cpp
@@ -25,39 +25,39 @@ class RobotModelDynamicsTest : public testing::Test {
   void set_test_configurations() {
     // Random test configuration 1:
     state_representation::JointState config1(franka->get_robot_name(), 7);
-    config1.set_positions({-1.957518, 1.037530, -1.093933, -1.485144, -1.937432, 2.251972, -1.373487});
-    config1.set_velocities({0.308158, 0.378429, 0.496303, -0.098917, -0.832357, -0.542046, 0.826675});
-    config1.set_accelerations({-0.695244, 0.651634, 0.076685, 0.992269, -0.843649, -0.114643, -0.786694});
+    config1.set_positions(std::vector<double>{-1.957518, 1.037530, -1.093933, -1.485144, -1.937432, 2.251972, -1.373487});
+    config1.set_velocities(std::vector<double>{0.308158, 0.378429, 0.496303, -0.098917, -0.832357, -0.542046, 0.826675});
+    config1.set_accelerations(std::vector<double>{-0.695244, 0.651634, 0.076685, 0.992269, -0.843649, -0.114643, -0.786694});
     test_configs.push_back(config1);
 
     // Expected results for configuration 1:
-    test_gravity_expects.push_back({-0.000000, -36.985759, -18.785455, 11.384067, -0.532842, -1.346848, -0.071370});
-    test_coriolis_expects.push_back({-0.049325, -0.064489, -0.060717, -0.295963, -0.009998, 0.026109, 0.003887});
-    test_inertia_expects.push_back({-0.733398, 0.568876, -0.066627, -0.156614, -0.030068, -0.025849, -0.006774});
+    test_gravity_expects.push_back(std::vector<double>{-0.000000, -36.985759, -18.785455, 11.384067, -0.532842, -1.346848, -0.071370});
+    test_coriolis_expects.push_back(std::vector<double>{-0.049325, -0.064489, -0.060717, -0.295963, -0.009998, 0.026109, 0.003887});
+    test_inertia_expects.push_back(std::vector<double>{-0.733398, 0.568876, -0.066627, -0.156614, -0.030068, -0.025849, -0.006774});
 
     // Random test configuration 2:
     state_representation::JointState config2(franka->get_robot_name(), 7);
-    config2.set_positions({2.676515, -1.746462, 1.592996, -0.618256, 2.136438, 0.300823, -0.580719});
-    config2.set_velocities({-0.480259, 0.600137, -0.137172, 0.821295, -0.636306, -0.472394, -0.708922});
-    config2.set_accelerations({-0.727863, 0.738584, 0.159409, 0.099720, -0.710090, 0.706062, 0.244110});
+    config2.set_positions(std::vector<double>{2.676515, -1.746462, 1.592996, -0.618256, 2.136438, 0.300823, -0.580719});
+    config2.set_velocities(std::vector<double>{-0.480259, 0.600137, -0.137172, 0.821295, -0.636306, -0.472394, -0.708922});
+    config2.set_accelerations(std::vector<double>{-0.727863, 0.738584, 0.159409, 0.099720, -0.710090, 0.706062, 0.244110});
     test_configs.push_back(config2);
 
     // Expected results for configuration 2:
-    test_gravity_expects.push_back({0.000000, 46.737623, -11.062411, -0.418143, 1.394652, -0.410398, -0.080678});
-    test_coriolis_expects.push_back({-0.681592, 0.045743, -0.095830, -0.334480, -0.048538, -0.035243, 0.004909});
-    test_inertia_expects.push_back({-1.852231, 1.722144, -0.507043, -0.848135, 0.017090, 0.061230, -0.000671});
+    test_gravity_expects.push_back(std::vector<double>{0.000000, 46.737623, -11.062411, -0.418143, 1.394652, -0.410398, -0.080678});
+    test_coriolis_expects.push_back(std::vector<double>{-0.681592, 0.045743, -0.095830, -0.334480, -0.048538, -0.035243, 0.004909});
+    test_inertia_expects.push_back(std::vector<double>{-1.852231, 1.722144, -0.507043, -0.848135, 0.017090, 0.061230, -0.000671});
 
     // Random test configuration 3:
     state_representation::JointState config3(franka->get_robot_name(), 7);
-    config3.set_positions({-0.863671, 0.046713, -0.568983, -2.843748, -1.507082, 0.447412, -1.831628});
-    config3.set_velocities({-0.520095, -0.165466, -0.900691, 0.805432, 0.889574, -0.018272, -0.021495});
-    config3.set_accelerations({-0.324561, 0.800108, -0.261506, -0.777594, 0.560504, -0.220522, -0.516617});
+    config3.set_positions(std::vector<double>{-0.863671, 0.046713, -0.568983, -2.843748, -1.507082, 0.447412, -1.831628});
+    config3.set_velocities(std::vector<double>{-0.520095, -0.165466, -0.900691, 0.805432, 0.889574, -0.018272, -0.021495});
+    config3.set_accelerations(std::vector<double>{-0.324561, 0.800108, -0.261506, -0.777594, 0.560504, -0.220522, -0.516617});
     test_configs.push_back(config3);
 
     // Expected results for configuration 3:
-    test_gravity_expects.push_back({-0.000000, -13.069054, -0.438318, 8.176336, -0.407568, -1.650201, -0.039456});
-    test_coriolis_expects.push_back({-0.740733, -0.448481, -0.753723, -0.730530, 0.025492, -0.069786, 0.003485});
-    test_inertia_expects.push_back({-0.280448, 0.700827, -0.252397, -0.716163, 0.087168, 0.006495, -0.009142});
+    test_gravity_expects.push_back(std::vector<double>{-0.000000, -13.069054, -0.438318, 8.176336, -0.407568, -1.650201, -0.039456});
+    test_coriolis_expects.push_back(std::vector<double>{-0.740733, -0.448481, -0.753723, -0.730530, 0.025492, -0.069786, 0.003485});
+    test_inertia_expects.push_back(std::vector<double>{-0.280448, 0.700827, -0.252397, -0.716163, 0.087168, 0.006495, -0.009142});
   }
 };
 
diff --git a/source/robot_model/test/tests/test_kinematics.cpp b/source/robot_model/test/tests/test_kinematics.cpp
index b8a3fc0eb..930a666bf 100644
--- a/source/robot_model/test/tests/test_kinematics.cpp
+++ b/source/robot_model/test/tests/test_kinematics.cpp
@@ -39,8 +39,8 @@ class RobotModelKinematicsTest : public testing::Test {
   void set_test_configurations() {
     // Random test configuration 1:
     state_representation::JointState config1(franka->get_robot_name(), franka->get_joint_frames());
-    config1.set_positions({-1.957518, 1.037530, -1.093933, -1.485144, -1.937432, 2.251972, -1.373487});
-    config1.set_velocities({0.308158, 0.378429, 0.496303, -0.098917, -0.832357, -0.542046, 0.826675});
+    config1.set_positions(std::vector<double>{-1.957518, 1.037530, -1.093933, -1.485144, -1.937432, 2.251972, -1.373487});
+    config1.set_velocities(std::vector<double>{0.308158, 0.378429, 0.496303, -0.098917, -0.832357, -0.542046, 0.826675});
     test_configs.push_back(config1);
 
     // Expected results for configuration 1:
@@ -73,8 +73,8 @@ class RobotModelKinematicsTest : public testing::Test {
 
     // Random test configuration 2:
     state_representation::JointState config2(franka->get_robot_name(), franka->get_joint_frames());
-    config2.set_positions({-2.014330, 1.148700, 0.222179, -0.081404, -2.444304, 1.651397, -2.279290});
-    config2.set_velocities({0.923796, -0.990732, 0.549821, 0.634606, 0.737389, -0.831128, -0.200435});
+    config2.set_positions(std::vector<double>{-2.014330, 1.148700, 0.222179, -0.081404, -2.444304, 1.651397, -2.279290});
+    config2.set_velocities(std::vector<double>{0.923796, -0.990732, 0.549821, 0.634606, 0.737389, -0.831128, -0.200435});
     test_configs.push_back(config2);
 
     // Expected results for configuration 2:
@@ -107,8 +107,8 @@ class RobotModelKinematicsTest : public testing::Test {
 
     // Random test configuration 3:
     state_representation::JointState config3(franka->get_robot_name(), franka->get_joint_frames());
-    config3.set_positions({-1.391455, 1.057921, -0.397429, -0.338036, -1.843569, 0.977037, -2.053960});
-    config3.set_velocities({-0.727863, 0.738584, 0.159409, 0.099720, -0.710090, 0.706062, 0.244110});
+    config3.set_positions(std::vector<double>{-1.391455, 1.057921, -0.397429, -0.338036, -1.843569, 0.977037, -2.053960});
+    config3.set_velocities(std::vector<double>{-0.727863, 0.738584, 0.159409, 0.099720, -0.710090, 0.706062, 0.244110});
     test_configs.push_back(config3);
 
     // Expected results for configuration 3:
@@ -223,27 +223,27 @@ TEST_F(RobotModelKinematicsTest, TestInRange) {
   state_representation::JointTorques joint_torques("robot", franka->get_joint_frames());
   state_representation::JointState joint_state("robot", franka->get_joint_frames());
 
-  joint_positions.set_positions({2.648782, -0.553976, 0.801067, -2.042097, -1.642935, 2.946476, 1.292717});
-  joint_velocities.set_velocities({-0.059943, 1.667088, 1.439900, -1.367141, -1.164922, 0.948034, 2.239983});
-  joint_torques.set_torques({-0.329909, -0.235174, -1.881858, -2.491807, 0.674615, 0.996670, 0.345810});
+  joint_positions.set_positions(std::vector<double>{2.648782, -0.553976, 0.801067, -2.042097, -1.642935, 2.946476, 1.292717});
+  joint_velocities.set_velocities(std::vector<double>{-0.059943, 1.667088, 1.439900, -1.367141, -1.164922, 0.948034, 2.239983});
+  joint_torques.set_torques(std::vector<double>{-0.329909, -0.235174, -1.881858, -2.491807, 0.674615, 0.996670, 0.345810});
 
-  joint_state.set_positions({2.648782, -0.553976, 0.801067, -2.042097, -1.642935, 2.946476, 1.292717});
-  joint_state.set_velocities({-0.059943, 1.667088, 1.439900, -1.367141, -1.164922, 0.948034, 2.239983});
-  joint_state.set_torques({-0.329909, -0.235174, -1.881858, -2.491807, 0.674615, 0.996670, 0.345810});
+  joint_state.set_positions(std::vector<double>{2.648782, -0.553976, 0.801067, -2.042097, -1.642935, 2.946476, 1.292717});
+  joint_state.set_velocities(std::vector<double>{-0.059943, 1.667088, 1.439900, -1.367141, -1.164922, 0.948034, 2.239983});
+  joint_state.set_torques(std::vector<double>{-0.329909, -0.235174, -1.881858, -2.491807, 0.674615, 0.996670, 0.345810});
 
   EXPECT_TRUE(franka->in_range(joint_positions));
   EXPECT_TRUE(franka->in_range(joint_velocities));
   EXPECT_TRUE(franka->in_range(joint_torques));
   EXPECT_TRUE(franka->in_range(joint_state));
 
-  joint_positions.set_positions({-0.059943, 1.667088, 1.439900, -1.367141, -1.164922, 0.948034, 1000});
-  joint_state.set_positions({-0.059943, 1.667088, 1.439900, -1000, -1.164922, 0.948034, 1.292717});
+  joint_positions.set_positions(std::vector<double>{-0.059943, 1.667088, 1.439900, -1.367141, -1.164922, 0.948034, 1000});
+  joint_state.set_positions(std::vector<double>{-0.059943, 1.667088, 1.439900, -1000, -1.164922, 0.948034, 1.292717});
 
   EXPECT_FALSE(franka->in_range(joint_positions));
   EXPECT_FALSE(franka->in_range(joint_state));
 
-  joint_velocities.set_velocities({-0.059943, 31.667088, 1.439900, -1.367141, -1.164922, 0.948034, 2.239983});
-  joint_torques.set_torques({-0.329909, -0.235174, -1.881858, -922.491807, 0.674615, 0.996670, 0.345810});
+  joint_velocities.set_velocities(std::vector<double>{-0.059943, 31.667088, 1.439900, -1.367141, -1.164922, 0.948034, 2.239983});
+  joint_torques.set_torques(std::vector<double>{-0.329909, -0.235174, -1.881858, -922.491807, 0.674615, 0.996670, 0.345810});
 
   EXPECT_FALSE(franka->in_range(joint_velocities));
   EXPECT_FALSE(franka->in_range(joint_torques));
@@ -255,13 +255,13 @@ TEST_F(RobotModelKinematicsTest, TestClamp) {
   state_representation::JointTorques joint_torques("robot", franka->get_joint_frames());
   state_representation::JointState joint_state("robot", franka->get_joint_frames());
 
-  joint_positions.set_positions({-0.059943, 1.667088, 1.439900, -1.367141, -1.164922, 0.948034, 1000});
-  joint_velocities.set_velocities({-0.059943, 31.667088, 1.439900, -1.367141, -1.164922, 0.948034, 2.239983});
-  joint_torques.set_torques({-0.329909, -0.235174, -1.881858, -922.491807, 0.674615, 0.996670, 0.345810});
+  joint_positions.set_positions(std::vector<double>{-0.059943, 1.667088, 1.439900, -1.367141, -1.164922, 0.948034, 1000});
+  joint_velocities.set_velocities(std::vector<double>{-0.059943, 31.667088, 1.439900, -1.367141, -1.164922, 0.948034, 2.239983});
+  joint_torques.set_torques(std::vector<double>{-0.329909, -0.235174, -1.881858, -922.491807, 0.674615, 0.996670, 0.345810});
 
-  joint_state.set_positions({-0.059943, 1.667088, 1.439900, -1000, -1.164922, 0.948034, 1.292717});
-  joint_state.set_velocities({-0.059943, 1.667088, 1.439900, -1.367141, -1.164922, 0.948034, 2.239983});
-  joint_state.set_torques({-0.329909, -0.235174, -1.881858, -2.491807, 0.674615, 0.996670, 0.345810});
+  joint_state.set_positions(std::vector<double>{-0.059943, 1.667088, 1.439900, -1000, -1.164922, 0.948034, 1.292717});
+  joint_state.set_velocities(std::vector<double>{-0.059943, 1.667088, 1.439900, -1.367141, -1.164922, 0.948034, 2.239983});
+  joint_state.set_torques(std::vector<double>{-0.329909, -0.235174, -1.881858, -2.491807, 0.674615, 0.996670, 0.345810});
 
   EXPECT_FALSE(franka->in_range(joint_positions));
   EXPECT_FALSE(franka->in_range(joint_velocities));
@@ -279,9 +279,9 @@ TEST_F(RobotModelKinematicsTest, TestInverseKinematics) {
   state_representation::JointState config2("robot", franka->get_joint_frames());
   state_representation::JointState config3("robot", franka->get_joint_frames());
   // Random test configurations
-  config1.set_positions({-0.059943, 1.667088, 1.439900, -1.367141, -1.164922, 0.948034, 2.239983});
-  config2.set_positions({2.648782, -0.553976, 0.801067, -2.042097, -1.642935, 2.946476, 1.292717});
-  config3.set_positions({-0.329909, -0.235174, -1.881858, -2.491807, 0.674615, 0.996670, 0.345810});
+  config1.set_positions(std::vector<double>{-0.059943, 1.667088, 1.439900, -1.367141, -1.164922, 0.948034, 2.239983});
+  config2.set_positions(std::vector<double>{2.648782, -0.553976, 0.801067, -2.042097, -1.642935, 2.946476, 1.292717});
+  config3.set_positions(std::vector<double>{-0.329909, -0.235174, -1.881858, -2.491807, 0.674615, 0.996670, 0.345810});
 
   std::vector<state_representation::JointState> test_configs = {config1, config2, config3};
   double tol = 1e-3;
@@ -300,7 +300,7 @@ TEST_F(RobotModelKinematicsTest, TestInverseKinematics) {
 TEST_F(RobotModelKinematicsTest, TestInverseKinematicsIKDoesNotConverge) {
   state_representation::JointState config("robot", franka->get_joint_frames());
   // Random test configuration
-  config.set_positions({-0.059943, 1.667088, 1.439900, -1.367141, -1.164922, 0.948034, 2.239983});
+  config.set_positions(std::vector<double>{-0.059943, 1.667088, 1.439900, -1.367141, -1.164922, 0.948034, 2.239983});
   InverseKinematicsParameters param = InverseKinematicsParameters();
   param.max_number_of_iterations = 1;
 
diff --git a/source/state_representation/CMakeLists.txt b/source/state_representation/CMakeLists.txt
index 8178ff5bf..b83f750d1 100644
--- a/source/state_representation/CMakeLists.txt
+++ b/source/state_representation/CMakeLists.txt
@@ -9,17 +9,19 @@ set(CORE_SOURCES
   src/space/cartesian/CartesianState.cpp
   src/space/cartesian/CartesianPose.cpp
   src/space/cartesian/CartesianTwist.cpp
+  src/space/cartesian/CartesianAcceleration.cpp
   src/space/cartesian/CartesianWrench.cpp
-  src/robot/JointState.cpp
-  src/robot/JointPositions.cpp
-  src/robot/JointVelocities.cpp
-  src/robot/JointAccelerations.cpp
-  src/robot/JointTorques.cpp
-  src/robot/Jacobian.cpp
-  src/parameters/ParameterInterface.cpp
+  src/space/joint/JointState.cpp
+  src/space/joint/JointPositions.cpp
+  src/space/joint/JointVelocities.cpp
+  src/space/joint/JointAccelerations.cpp
+  src/space/joint/JointTorques.cpp
+  src/space/Jacobian.cpp
+  src/parameters/Event.cpp
   src/parameters/Parameter.cpp
+  src/parameters/ParameterInterface.cpp
+  src/parameters/ParameterMap.cpp
   src/parameters/Predicate.cpp
-  src/parameters/Event.cpp
   src/geometry/Shape.cpp
   src/geometry/Ellipsoid.cpp
 )
diff --git a/source/state_representation/README.md b/source/state_representation/README.md
index a7739bd91..26c4d2286 100644
--- a/source/state_representation/README.md
+++ b/source/state_representation/README.md
@@ -116,7 +116,7 @@ i.e. if `wSa` has a `twist` or `acceleration` it will affect the state variables
 Full `CartesianState` can be difficult to handle as they contain all the dynamics of the frame when, sometime,
 you just want to express a `pose` without `twist`, `accelerations` or `wrench`.
 Therefore, extra classes representing only those specific state variables have been defined, `CartesianPose`,
-`CartesianTwist` and `CartesianWrench`.
+`CartesianTwist`, `CartesianAcceleration` and `CartesianWrench`.
 Effectively, they all extend from `CartesianState` hence they can be intertwined as will.
 
 ```cpp
diff --git a/source/state_representation/include/state_representation/exceptions/InvalidParameterException.hpp b/source/state_representation/include/state_representation/exceptions/InvalidParameterException.hpp
new file mode 100644
index 000000000..edd31f137
--- /dev/null
+++ b/source/state_representation/include/state_representation/exceptions/InvalidParameterException.hpp
@@ -0,0 +1,11 @@
+#pragma once
+
+#include <exception>
+#include <string>
+
+namespace state_representation::exceptions {
+class InvalidParameterException : public std::runtime_error {
+public:
+  explicit InvalidParameterException(const std::string& msg) : runtime_error(msg) {};
+};
+}
diff --git a/source/state_representation/include/state_representation/geometry/Ellipsoid.hpp b/source/state_representation/include/state_representation/geometry/Ellipsoid.hpp
index ec8b86714..e9987b375 100644
--- a/source/state_representation/include/state_representation/geometry/Ellipsoid.hpp
+++ b/source/state_representation/include/state_representation/geometry/Ellipsoid.hpp
@@ -18,6 +18,10 @@ class Ellipsoid : public Shape {
   double rotation_angle_; ///< angle of rotation around z axis of the reference frame
 
 public:
+  /**
+   * @brief Empty constructor
+   */
+  Ellipsoid();
   /**
    * @brief Constructor with name but empty state
    * @param name name of the ellipsoid
@@ -166,6 +170,9 @@ inline void Ellipsoid::set_rotation_angle(double rotation_angle) {
 }
 
 inline const std::vector<double> Ellipsoid::to_std_vector() const {
+  if (this->get_center_state().is_empty()) {
+    throw exceptions::EmptyStateException("The center state of the Ellipsoid is not set yet.");
+  }
   std::vector<double> representation(6);
   // position
   representation[0] = this->get_center_position()(0);
@@ -180,6 +187,9 @@ inline const std::vector<double> Ellipsoid::to_std_vector() const {
 }
 
 inline const CartesianPose Ellipsoid::get_rotation() const {
+  if (this->get_center_state().is_empty()) {
+    throw exceptions::EmptyStateException("The center state of the Ellipsoid is not set yet.");
+  }
   Eigen::Quaterniond rotation(Eigen::AngleAxisd(this->rotation_angle_, Eigen::Vector3d::UnitZ()));
   return CartesianPose(
       this->get_center_pose().get_name() + "_rotated", Eigen::Vector3d::Zero(), rotation,
diff --git a/source/state_representation/include/state_representation/geometry/Shape.hpp b/source/state_representation/include/state_representation/geometry/Shape.hpp
index 02f69aff9..6abdb05f2 100644
--- a/source/state_representation/include/state_representation/geometry/Shape.hpp
+++ b/source/state_representation/include/state_representation/geometry/Shape.hpp
@@ -5,6 +5,7 @@
 #include "state_representation/space/cartesian/CartesianState.hpp"
 #include "state_representation/space/cartesian/CartesianPose.hpp"
 #include "state_representation/space/cartesian/CartesianTwist.hpp"
+#include "state_representation/exceptions/EmptyStateException.hpp"
 #include "state_representation/exceptions/IncompatibleStatesException.hpp"
 #include "state_representation/exceptions/IncompatibleReferenceFramesException.hpp"
 
@@ -17,6 +18,12 @@ class Shape : public State {
   CartesianState center_state_; ///< pose and potentially velocities and accelerations of the shape if moving
 
 public:
+  /**
+   * @brief Constructor with a type
+   * @param type the type of shape as a StateType
+   */
+  explicit Shape(const StateType& type);
+
   /**
    * @brief Constructor with name but empty state
    * @param type the type of shape as a StateType
@@ -94,7 +101,7 @@ class Shape : public State {
 
   /**
     * @brief Overload the ostream operator for printing
-    * @param os the ostream to happend the string representing the Shape to
+    * @param os the ostream to append the string representing the Shape to
     * @param shape the Shape to print
     * @return the appended ostream
      */
@@ -128,11 +135,12 @@ inline const CartesianTwist& Shape::get_center_twist() const {
 }
 
 inline void Shape::set_center_state(const CartesianState& state) {
+  this->set_name(state.get_name());
   this->center_state_ = state;
 }
 
 inline void Shape::set_center_pose(const CartesianPose& pose) {
-  if (this->center_state_.get_reference_frame() != pose.get_reference_frame()) {
+  if (!this->center_state_.is_empty() && this->center_state_.get_reference_frame() != pose.get_reference_frame()) {
     throw exceptions::IncompatibleReferenceFramesException(
         "The shape state and the given pose are not expressed in the same reference frame");
   }
@@ -140,10 +148,16 @@ inline void Shape::set_center_pose(const CartesianPose& pose) {
 }
 
 inline void Shape::set_center_position(const Eigen::Vector3d& position) {
+  if (this->get_center_state().is_empty()) {
+    throw exceptions::EmptyStateException("The center state of the Shape is not set yet.");
+  }
   this->center_state_.set_position(position);
 }
 
 inline void Shape::set_center_orientation(const Eigen::Quaterniond& orientation) {
+  if (this->get_center_state().is_empty()) {
+    throw exceptions::EmptyStateException("The center state of the Shape is not set yet.");
+  }
   this->center_state_.set_orientation(orientation);
 }
 }
\ No newline at end of file
diff --git a/source/state_representation/include/state_representation/parameters/Event.hpp b/source/state_representation/include/state_representation/parameters/Event.hpp
index e1e75015a..3358be1c6 100644
--- a/source/state_representation/include/state_representation/parameters/Event.hpp
+++ b/source/state_representation/include/state_representation/parameters/Event.hpp
@@ -3,12 +3,13 @@
 #include "state_representation/parameters/Predicate.hpp"
 
 namespace state_representation {
+
 /**
  * @class Event
  * @brief An event is a predicate with memory. Its purpose is
  * to be true only once and change value only when the underlying
  * predicate has changed from true to false and back to true
- * since last reading
+ * since last reading.
  */
 class Event : public Predicate {
 private:
@@ -16,7 +17,7 @@ class Event : public Predicate {
 
 public:
   /**
-   * @brief Constructor with name of the predicate and default false value
+   * @brief Constructor with name of the predicate and default false value.
    */
   explicit Event(const std::string& name);
 
@@ -27,24 +28,24 @@ class Event : public Predicate {
   bool read_value();
 
   /**
-   * @brief Setter of the value attribute
-   * @param the new value attribute
+   * @brief Setter of the value attribute.
+   * @param value The new value attribute
    */
   void set_value(const bool& value) override;
 
   /**
    * @brief Getter of the previous value. Does not
-   * affect the behavior of the event (as opposed to read_value)
+   * affect the behavior of the event (as opposed to read_value).
    */
   bool get_previous_value() const;
 
   /**
-    * @brief Overload the ostream operator for printing
-    * @param os the ostream to happened the string representing the State to
-    * @param predicate the Predicate to print
-    * @return the appended ostream
+    * @brief Overload the ostream operator for printing.
+    * @param os The ostream to append the string representing the Event to
+    * @param predicate The Event to print
+    * @return The appended ostream
      */
-  friend std::ostream& operator<<(std::ostream& os, const Predicate& predicate);
+  friend std::ostream& operator<<(std::ostream& os, const Event& event);
 };
 
 inline bool Event::read_value() {
@@ -63,4 +64,4 @@ inline void Event::set_value(const bool& value) {
 inline bool Event::get_previous_value() const {
   return this->previous_predicate_value_;
 }
-}// namespace state_representation
\ No newline at end of file
+}// namespace state_representation
diff --git a/source/state_representation/include/state_representation/parameters/Parameter.hpp b/source/state_representation/include/state_representation/parameters/Parameter.hpp
index ff3b5e4e2..561823e41 100644
--- a/source/state_representation/include/state_representation/parameters/Parameter.hpp
+++ b/source/state_representation/include/state_representation/parameters/Parameter.hpp
@@ -1,92 +1,116 @@
 #pragma once
 
+#include <memory>
+
 #include "state_representation/parameters/ParameterInterface.hpp"
 
 namespace state_representation {
-template <typename T>
+
+template<typename T>
 class Parameter : public ParameterInterface {
 private:
-  T value;///< Value of the parameter
+  T value_;///< Value of the parameter
 
 public:
   /**
-   * @brief Constructor with name of the parameter
+   * @brief Constructor with name of the parameter.
+   * @param name The name of the parameter
    */
   explicit Parameter(const std::string& name);
 
   /**
-   * @brief Constructor with a value
-   * @param name the name of the parameter
-   * @param value value of the parameter
+   * @brief Constructor with a name and a value.
+   * @param name The name of the parameter
+   * @param value The value of the parameter
    */
   explicit Parameter(const std::string& name, const T& value);
 
   /**
    * @brief Copy constructor
-   * @param parameter the parameter to copy
+   * @param parameter The parameter to copy
    */
-  template <typename U>
+  template<typename U>
   Parameter(const Parameter<U>& parameter);
 
   /**
    * @brief Conversion equality
    */
-  template <typename U>
+  template<typename U>
   Parameter<T>& operator=(const Parameter<U>& parameter);
 
   /**
-   * @brief Getter of the value attribute
-   * @return the value attribute
+   * @brief Getter of the value attribute.
+   * @tparam U The expected type of the parameter
+   * @return The value attribute
+   */
+  template<typename U>
+  U get_value();
+
+  /**
+   * @brief Getter of the value attribute.
+   * @return The value attribute
    */
   const T& get_value() const;
 
   /**
-   * @brief Getter of the value attribute
-   * @return the value attribute
+   * @brief Getter of the value attribute.
+   * @return The value attribute
    */
   T& get_value();
 
   /**
-   * @brief Setter of the value attribute
-   * @param the new value attribute
+   * @brief Setter of the value attribute.
+   * @param The new value attribute
    */
   virtual void set_value(const T& value);
 
   /**
-   * @brief Overload the ostream operator for printing
-   * @param os the ostream to append the string representing the State to
-   * @param parameter the Parameter to print
-   * @return the appended ostream
+   * @brief Overload the ostream operator for printing.
+   * @param os The ostream to append the string representing the State to
+   * @param parameter The Parameter to print
+   * @return The appended ostream
    */
-  template <typename U>
+  template<typename U>
   friend std::ostream& operator<<(std::ostream& os, const Parameter<U>& parameter);
 };
 
-template <typename T>
-template <typename U>
-Parameter<T>::Parameter(const Parameter<U>& parameter) : ParameterInterface(parameter), value(parameter.get_value()) {}
+template<typename T>
+template<typename U>
+Parameter<T>::Parameter(const Parameter<U>& parameter) :
+    Parameter<T>(parameter.get_name(), static_cast<T>(parameter.get_value())) {}
 
-template <typename T>
-template <typename U>
+template<typename T>
+template<typename U>
 Parameter<T>& Parameter<T>::operator=(const Parameter<U>& parameter) {
   Parameter<T> temp(parameter);
   *this = temp;
   return *this;
 }
 
-template <typename T>
+template<typename T>
+template<typename U>
+U Parameter<T>::get_value() {
+  return static_cast<U>(this->value_);
+}
+
+template<typename T>
 inline const T& Parameter<T>::get_value() const {
-  return this->value;
+  return this->value_;
 }
 
-template <typename T>
+template<typename T>
 inline T& Parameter<T>::get_value() {
-  return this->value;
+  return this->value_;
 }
 
-template <typename T>
+template<typename T>
 inline void Parameter<T>::set_value(const T& value) {
   this->set_filled();
-  this->value = value;
+  this->value_ = value;
+}
+
+template<typename T>
+static std::shared_ptr<Parameter<T>> make_shared_parameter(const std::string& name, const T& param_value) {
+  return std::make_shared<Parameter<T>>(name, param_value);
 }
 }// namespace state_representation
diff --git a/source/state_representation/include/state_representation/parameters/ParameterInterface.hpp b/source/state_representation/include/state_representation/parameters/ParameterInterface.hpp
index f514fb9eb..3205dcaf8 100644
--- a/source/state_representation/include/state_representation/parameters/ParameterInterface.hpp
+++ b/source/state_representation/include/state_representation/parameters/ParameterInterface.hpp
@@ -3,31 +3,28 @@
 #include "state_representation/State.hpp"
 
 namespace state_representation {
+
 class ParameterInterface : public State {
 public:
   /**
-   * @brief Constructor with parameter name and type of the parameter
-   * @param type the type of the parameter
-   * @param name the name of the parameter
+   * @brief Constructor with parameter name and type of the parameter.
+   * @param type The type of the parameter
+   * @param name The name of the parameter
    */
   explicit ParameterInterface(const StateType& type, const std::string& name);
 
   /**
    * @brief Copy constructor
-   * @param parameter the parameter to copy
+   * @param parameter The parameter to copy
    */
   ParameterInterface(const ParameterInterface& parameter);
 
   /**
-   * @brief Copy assignement operator that have to be defined to the custom assignement operator
-   * @param state the state with value to assign
-   * @return reference to the current state with new values
+   * @brief Copy assignment operator that has to be defined
+   * to the custom assignment operator.
+   * @param state The state with value to assign
+   * @return Reference to the current state with new values
    */
   ParameterInterface& operator=(const ParameterInterface& state);
 };
-
-inline ParameterInterface& ParameterInterface::operator=(const ParameterInterface& state) {
-  State::operator=(state);
-  return (*this);
-}
 }// namespace state_representation
diff --git a/source/state_representation/include/state_representation/parameters/ParameterMap.hpp b/source/state_representation/include/state_representation/parameters/ParameterMap.hpp
new file mode 100644
index 000000000..204a5b983
--- /dev/null
+++ b/source/state_representation/include/state_representation/parameters/ParameterMap.hpp
@@ -0,0 +1,126 @@
+#pragma once
+
+#include <list>
+#include <map>
+#include <memory>
+
+#include "state_representation/exceptions/InvalidParameterException.hpp"
+#include "state_representation/parameters/Parameter.hpp"
+
+namespace state_representation {
+
+/**
+ * @class ParameterMap
+ * @brief A wrapper class to contain a map of Parameter pointers by name and provide robust access methods
+ */
+class ParameterMap {
+public:
+
+  /**
+   * @brief Empty constructor
+   */
+  ParameterMap() = default;
+
+  /**
+   * @brief Construct the parameter map with an initial list of parameters
+   * @param parameters A list of Parameter pointers
+   */
+  explicit ParameterMap(const std::list<std::shared_ptr<state_representation::ParameterInterface>>& parameters);
+
+  /**
+   * @brief Construct the parameter map with an initial map of parameters
+   * @param parameters A amp of Parameter pointers
+   */
+  explicit ParameterMap(
+      const std::map<std::string, std::shared_ptr<state_representation::ParameterInterface>>& parameters
+  );
+
+  /**
+   * @brief Get a parameter by its name.
+   * @param name The name of the parameter
+   * @return The parameter, if it exists
+   */
+  [[nodiscard]] std::shared_ptr<state_representation::ParameterInterface> get_parameter(const std::string& name) const;
+
+  /**
+   * @brief Get a map of all the <name, parameter> pairs.
+   * @return The map of parameters
+   */
+  [[nodiscard]] std::map<std::string, std::shared_ptr<state_representation::ParameterInterface>> get_parameters() const;
+
+  /**
+   * @brief Get a parameter value by its name.
+   * @tparam T Type of the parameter value
+   * @param name The name of the parameter
+   * @return The value of the parameter, if the parameter exists
+   */
+  template<typename T>
+  [[nodiscard]] T get_parameter_value(const std::string& name) const;
+
+  /**
+   * @brief Get a list of all the parameters.
+   * @return The list of parameters
+   */
+  [[nodiscard]] std::list<std::shared_ptr<state_representation::ParameterInterface>> get_parameter_list() const;
+
+  /**
+   * @brief Set a parameter.
+   * @param parameter The new parameter
+   */
+  void set_parameter(const std::shared_ptr<state_representation::ParameterInterface>& parameter);
+
+  /**
+   * @brief Set parameters from a list of parameters.
+   * @param parameters The list of parameters
+   */
+  void set_parameters(const std::list<std::shared_ptr<state_representation::ParameterInterface>>& parameters);
+
+  /**
+   * @brief Set parameters from a map with <name, parameter> pairs.
+   * @param parameters The map of parameters
+   */
+  void
+  set_parameters(const std::map<std::string, std::shared_ptr<state_representation::ParameterInterface>>& parameters);
+
+  /**
+   * @brief Set a parameter value by its name.
+   * @tparam T Type of the parameter value
+   * @param name The name of the parameter
+   * @param value The new value of the parameter
+   */
+  template<typename T>
+  void set_parameter_value(const std::string& name, const T& value);
+
+protected:
+
+  /**
+   * @brief Validate and set a parameter in the map.
+   * @details This virtual function should be redefined in any base class to provide proper validation of parameters
+   * by name, value and type. In the base form, it allows any type of parameter name to be added to the map.
+   * @param parameter The parameter to be validated
+   */
+  virtual void validate_and_set_parameter(const std::shared_ptr<state_representation::ParameterInterface>& parameter);
+
+  /**
+   * @brief Check if a parameter has the expected type, throw an exception otherwise.
+   * @param parameter The parameter to be validated
+   */
+  void assert_parameter_valid(const std::shared_ptr<state_representation::ParameterInterface>& parameter);
+
+  std::map<std::string, std::shared_ptr<state_representation::ParameterInterface>>
+      parameters_; ///< map of parameters by name
+
+};
+
+template<typename T>
+inline T ParameterMap::get_parameter_value(const std::string& name) const {
+  return std::static_pointer_cast<state_representation::Parameter<T>>(this->get_parameter(name))->get_value();
+}
+
+template<typename T>
+inline void ParameterMap::set_parameter_value(const std::string& name, const T& value) {
+  using namespace state_representation;
+  this->validate_and_set_parameter(std::make_shared<Parameter<T>>(Parameter<T>(name, value)));
+}
+
+}
\ No newline at end of file
diff --git a/source/state_representation/include/state_representation/parameters/Predicate.hpp b/source/state_representation/include/state_representation/parameters/Predicate.hpp
index d2d4ac5c5..08865084c 100644
--- a/source/state_representation/include/state_representation/parameters/Predicate.hpp
+++ b/source/state_representation/include/state_representation/parameters/Predicate.hpp
@@ -3,6 +3,7 @@
 #include "state_representation/parameters/Parameter.hpp"
 
 namespace state_representation {
+
 /**
  * @class Predicate
  * @brief A predicate is a boolean parameter as in the logic formalism.
@@ -10,23 +11,23 @@ namespace state_representation {
 class Predicate : public Parameter<bool> {
 public:
   /**
-   * @brief Constructor with name of the predicate and default false value
+   * @brief Constructor with name of the predicate and default false value.
    */
   explicit Predicate(const std::string& name);
 
   /**
-   * @brief Constructor with a value
-   * @param name the name of the predicate
-   * @param value initial value of the predicate
+   * @brief Constructor with a value.
+   * @param name The name of the predicate
+   * @param value Initial value of the predicate
    */
   explicit Predicate(const std::string& name, bool value);
 
   /**
-   * @brief Overload the ostream operator for printing
-   * @param os the ostream to happend the string representing the State to
-   * @param predicate the Predicate to print
+   * @brief Overload the ostream operator for printing.
+   * @param os The ostream to append the string representing the Predicate to
+   * @param predicate The Predicate to print
    * @return the appended ostream
    */
   friend std::ostream& operator<<(std::ostream& os, const Predicate& predicate);
 };
-}// namespace state_representation
\ No newline at end of file
+}// namespace state_representation
diff --git a/source/state_representation/include/state_representation/robot/Jacobian.hpp b/source/state_representation/include/state_representation/space/Jacobian.hpp
similarity index 99%
rename from source/state_representation/include/state_representation/robot/Jacobian.hpp
rename to source/state_representation/include/state_representation/space/Jacobian.hpp
index 7e11c8b4f..e772d744d 100644
--- a/source/state_representation/include/state_representation/robot/Jacobian.hpp
+++ b/source/state_representation/include/state_representation/space/Jacobian.hpp
@@ -2,8 +2,8 @@
 
 #include "state_representation/State.hpp"
 #include "state_representation/exceptions/IncompatibleSizeException.hpp"
-#include "state_representation/robot/JointTorques.hpp"
-#include "state_representation/robot/JointVelocities.hpp"
+#include "state_representation/space/joint/JointTorques.hpp"
+#include "state_representation/space/joint/JointVelocities.hpp"
 #include "state_representation/space/cartesian/CartesianTwist.hpp"
 #include "state_representation/space/cartesian/CartesianWrench.hpp"
 
diff --git a/source/state_representation/include/state_representation/space/cartesian/CartesianAcceleration.hpp b/source/state_representation/include/state_representation/space/cartesian/CartesianAcceleration.hpp
new file mode 100644
index 000000000..abc545b88
--- /dev/null
+++ b/source/state_representation/include/state_representation/space/cartesian/CartesianAcceleration.hpp
@@ -0,0 +1,307 @@
+#pragma once
+
+#include "state_representation/space/cartesian/CartesianState.hpp"
+#include "state_representation/space/cartesian/CartesianTwist.hpp"
+
+namespace state_representation {
+class CartesianTwist;
+
+/**
+ * @class CartesianAcceleration
+ * @brief Class to define acceleration in cartesian space as 3D linear and angular acceleration vectors
+ */
+class CartesianAcceleration : public CartesianState {
+private:
+  using CartesianState::clamp_state_variable;
+
+public:
+  // delete inaccessible getter and setters
+  const Eigen::Vector3d& get_position() const = delete;
+  const Eigen::Quaterniond& get_orientation() const = delete;
+  Eigen::Vector4d get_orientation_coefficients() const = delete;
+  Eigen::Matrix<double, 7, 1> get_pose() const = delete;
+  Eigen::Matrix4d get_transformation_matrix() const = delete;
+  const Eigen::Vector3d& get_linear_velocity() const = delete;
+  const Eigen::Vector3d& get_angular_velocity() const = delete;
+  Eigen::Matrix<double, 6, 1> get_twist() const = delete;
+  const Eigen::Vector3d& get_force() const = delete;
+  const Eigen::Vector3d& get_torque() const = delete;
+  Eigen::Matrix<double, 6, 1> get_wrench() const = delete;
+  void set_position(const Eigen::Vector3d& position) = delete;
+  void set_position(const std::vector<double>& position) = delete;
+  void set_position(const double& x, const double& y, const double& z) = delete;
+  void set_orientation(const Eigen::Quaterniond& orientation) = delete;
+  void set_orientation(const Eigen::Vector4d& orientation) = delete;
+  void set_orientation(const std::vector<double>& orientation) = delete;
+  void set_pose(const Eigen::Vector3d& position, const Eigen::Quaterniond& orientation) = delete;
+  void set_pose(const Eigen::Matrix<double, 7, 1>& pose) = delete;
+  void set_pose(const std::vector<double>& pose) = delete;
+  void set_linear_velocity(const Eigen::Vector3d& linear_acceleration) = delete;
+  void set_angular_velocity(const Eigen::Vector3d& angular_acceleration) = delete;
+  void set_twist(const Eigen::Matrix<double, 6, 1>& acceleration) = delete;
+  void set_force(const Eigen::Vector3d& force) = delete;
+  void set_torque(const Eigen::Vector3d& torque) = delete;
+  void set_wrench(const Eigen::Matrix<double, 6, 1>& wrench) = delete;
+  CartesianState operator*=(const CartesianState& state) = delete;
+  CartesianState operator*(const CartesianState& state) = delete;
+  friend CartesianState operator*=(const CartesianState& state, const CartesianAcceleration& acceleration) = delete;
+
+  /**
+   * @brief Empty constructor
+   */
+  explicit CartesianAcceleration() = default;
+
+  /**
+   * @brief Constructor with name and reference frame provided
+   * @param name the name of the state
+   * @param reference the name of the reference frame
+   */
+  explicit CartesianAcceleration(const std::string& name, const std::string& reference = "world");
+
+  /**
+   * @brief Copy constructor
+   */
+  CartesianAcceleration(const CartesianAcceleration& acceleration);
+
+  /**
+   * @brief Copy constructor from a CartesianState
+   */
+  CartesianAcceleration(const CartesianState& state);
+
+  /**
+   * @brief Copy constructor from a CartesianTwist by considering that it is equivalent to dividing the twist by 1 second
+   */
+  CartesianAcceleration(const CartesianTwist& pose);
+
+  /**
+   * @brief Construct a CartesianAcceleration from a linear acceleration given as a vector.
+   */
+  explicit CartesianAcceleration(
+      const std::string& name, const Eigen::Vector3d& linear_acceleration, const std::string& reference = "world"
+  );
+
+  /**
+   * @brief Construct a CartesianAcceleration from a linear acceleration and angular acceleration given as vectors.
+   */
+  explicit CartesianAcceleration(
+      const std::string& name, const Eigen::Vector3d& linear_acceleration, const Eigen::Vector3d& angular_acceleration,
+      const std::string& reference = "world"
+  );
+
+  /**
+   * @brief Construct a CartesianAcceleration from a single 6d acceleration vector
+   */
+  explicit CartesianAcceleration(
+      const std::string& name, const Eigen::Matrix<double, 6, 1>& acceleration, const std::string& reference = "world"
+  );
+
+  /**
+   * @brief Constructor for the zero acceleration
+   * @param name the name of the state
+   * @param reference the name of the reference frame
+   * @return CartesianAcceleration with zero values
+   */
+  static CartesianAcceleration Zero(const std::string& name, const std::string& reference = "world");
+
+  /**
+   * @brief Constructor for a random acceleration
+   * @param name the name of the state
+   * @param reference the name of the reference frame
+   * @return CartesianAcceleration random acceleration
+   */
+  static CartesianAcceleration Random(const std::string& name, const std::string& reference = "world");
+
+  /**
+   * @brief Copy assignment operator that have to be defined to the custom assignment operator
+   * @param acceleration the acceleration with value to assign
+   * @return reference to the current acceleration with new values
+   */
+  CartesianAcceleration& operator=(const CartesianAcceleration& acceleration) = default;
+
+  /**
+   * @brief Overload the += operator
+   * @param acceleration CartesianAcceleration to add to
+   * @return the current CartesianAcceleration added the CartesianAcceleration given in argument
+   */
+  CartesianAcceleration& operator+=(const CartesianAcceleration& acceleration);
+
+  /**
+   * @brief Overload the + operator with an acceleration
+   * @param acceleration CartesianAcceleration to add to
+   * @return the current CartesianAcceleration added the CartesianAcceleration given in argument
+   */
+  CartesianAcceleration operator+(const CartesianAcceleration& acceleration) const;
+
+  /**
+   * @brief Overload the -= operator
+   * @param acceleration CartesianAcceleration to subtract
+   * @return the current CartesianAcceleration minus the CartesianAcceleration given in argument
+   */
+  CartesianAcceleration& operator-=(const CartesianAcceleration& acceleration);
+
+  /**
+   * @brief Overload the - operator with an acceleration
+   * @param acceleration CartesianAcceleration to subtract
+   * @return the current CartesianAcceleration minus the CartesianAcceleration given in argument
+   */
+  CartesianAcceleration operator-(const CartesianAcceleration& acceleration) const;
+
+  /**
+   * @brief Overload the *= operator with a scalar
+   * @param lambda the scalar to multiply with
+   * @return the CartesianAcceleration multiplied by lambda
+   */
+  CartesianAcceleration& operator*=(double lambda);
+
+  /**
+   * @brief Overload the * operator with a scalar
+   * @param lambda the scalar to multiply with
+   * @return the CartesianAcceleration multiplied by lambda
+   */
+  CartesianAcceleration operator*(double lambda) const;
+
+  /**
+   * @brief Overload the /= operator with a scalar
+   * @param lambda the scalar to divide with
+   * @return the CartesianAcceleration divided by lambda
+   */
+  CartesianAcceleration& operator/=(double lambda);
+
+  /**
+   * @brief Overload the / operator with a scalar
+   * @param lambda the scalar to divide with
+   * @return the CartesianAcceleration divided by lambda
+   */
+  CartesianAcceleration operator/(double lambda) const;
+
+  /**
+   * @brief Overload the *= operator with a gain matrix
+   * @param lambda the matrix to multiply with
+   * @return the CartesianAcceleration multiplied by lambda
+   */
+  CartesianAcceleration& operator*=(const Eigen::Matrix<double, 6, 6>& lambda);
+
+  /**
+   * @brief Overload the * operator with a time period
+   * @param dt the time period to multiply with
+   * @return the CartesianTwist corresponding to the twist over the time period
+   */
+  CartesianTwist operator*(const std::chrono::nanoseconds& dt) const;
+
+  /**
+   * @brief Clamp inplace the magnitude of the acceleration to the values in argument
+   * @param max_linear the maximum magnitude of the linear acceleration
+   * @param max_angular the maximum magnitude of the angular acceleration
+   * @param linear_noise_ratio if provided, this value will be used to apply a deadzone under which
+   * the linear acceleration will be set to 0
+   * @param angular_noise_ratio if provided, this value will be used to apply a deadzone under which
+   * the angular acceleration will be set to 0
+   */
+  void clamp(double max_linear, double max_angular, double linear_noise_ratio = 0, double angular_noise_ratio = 0);
+
+  /**
+   * @brief Return the clamped twist
+   * @param max_linear the maximum magnitude of the linear acceleration
+   * @param max_angular the maximum magnitude of the angular acceleration
+   * @param noise_ratio if provided, this value will be used to apply a deadzone under which
+   * the linear acceleration will be set to 0
+   * @param angular_noise_ratio if provided, this value will be used to apply a deadzone under which
+   * the angular acceleration will be set to 0
+   * @return the clamped acceleration
+   */
+  CartesianAcceleration clamped(
+      double max_linear, double max_angular, double noise_ratio = 0, double angular_noise_ratio = 0
+  ) const;
+
+  /**
+   * @brief Return a copy of the CartesianAcceleration
+   * @return the copy
+   */
+  CartesianAcceleration copy() const;
+
+  /**
+   * @brief Returns the acceleration data as an Eigen vector
+   * @return the acceleration data vector
+   */
+  Eigen::VectorXd data() const override;
+
+  /**
+   * @brief Set the acceleration data from an Eigen vector
+   * @param the acceleration data vector
+   */
+  void set_data(const Eigen::VectorXd& data) override;
+
+  /**
+   * @brief Set the acceleration data from a std vector
+   * @param the acceleration data vector
+   */
+  void set_data(const std::vector<double>& data) override;
+
+  /**
+   * @brief Compute the inverse of the current CartesianAcceleration
+   * @return the inverse corresponding to b_S_f (assuming this is f_S_b)
+   */
+  CartesianAcceleration inverse() const;
+
+  /**
+   * @brief Compute the norms of the state variable specified by the input type (default is full twist)
+   * @param state_variable_type the type of state variable to compute the norms on
+   * @return the norms of the state variables as a vector
+   */
+  std::vector<double>
+  norms(const CartesianStateVariable& state_variable_type = CartesianStateVariable::ACCELERATION) const override;
+
+  /**
+   * @brief Compute the normalized acceleration at the state variable given in argument (default is full acceleration)
+   * @param state_variable_type the type of state variable to compute the norms on
+   * @return the normalized acceleration
+   */
+  CartesianAcceleration
+  normalized(const CartesianStateVariable& state_variable_type = CartesianStateVariable::ACCELERATION) const;
+
+  /**
+   * @brief Overload the ostream operator for printing
+   * @param os the ostream to append the string representing the CartesianAcceleration to
+   * @param CartesianAcceleration the CartesianAcceleration to print
+   * @return the appended ostream
+   */
+  friend std::ostream& operator<<(std::ostream& os, const CartesianAcceleration& acceleration);
+
+  /**
+   * @brief Overload the * operator with a CartesianState
+   * @param state the state to multiply with
+   * @return the CartesianAcceleration provided multiplied by the state
+   */
+  friend CartesianAcceleration operator*(const CartesianState& state, const CartesianAcceleration& acceleration);
+
+  /**
+   * @brief Overload the * operator with a scalar
+   * @param lambda the scalar to multiply with
+   * @return the CartesianAcceleration provided multiplied by lambda
+   */
+  friend CartesianAcceleration operator*(double lambda, const CartesianAcceleration& acceleration);
+
+  /**
+   * @brief Overload the * operator with a gain matrix
+   * @param lambda the matrix to multiply with
+   * @return the CartesianAcceleration provided multiplied by lambda
+   */
+  friend CartesianAcceleration
+  operator*(const Eigen::Matrix<double, 6, 6>& lambda, const CartesianAcceleration& acceleration);
+
+  /**
+   * @brief Overload the * operator with a time period
+   * @param dt the time period to multiply with
+   * @return the CartesianTwist corresponding to the velocity over the time period
+   */
+  friend CartesianTwist operator*(const std::chrono::nanoseconds& dt, const CartesianAcceleration& acceleration);
+};
+
+inline std::vector<double> CartesianAcceleration::norms(const CartesianStateVariable& state_variable_type) const {
+  return CartesianState::norms(state_variable_type);
+}
+
+inline CartesianAcceleration CartesianAcceleration::normalized(const CartesianStateVariable& state_variable_type) const {
+  return CartesianState::normalized(state_variable_type);
+}
+}// namespace state_representation
diff --git a/source/state_representation/include/state_representation/space/cartesian/CartesianPose.hpp b/source/state_representation/include/state_representation/space/cartesian/CartesianPose.hpp
index ba36d0a7b..b9031ef39 100644
--- a/source/state_representation/include/state_representation/space/cartesian/CartesianPose.hpp
+++ b/source/state_representation/include/state_representation/space/cartesian/CartesianPose.hpp
@@ -2,10 +2,12 @@
 
 #include "state_representation/space/cartesian/CartesianState.hpp"
 #include "state_representation/space/cartesian/CartesianTwist.hpp"
+#include "state_representation/space/cartesian/CartesianAcceleration.hpp"
 #include "state_representation/space/cartesian/CartesianWrench.hpp"
 
 namespace state_representation {
 class CartesianTwist;
+class CartesianAcceleration;
 class CartesianWrench;
 
 /**
@@ -23,7 +25,7 @@ class CartesianPose : public CartesianState {
   Eigen::Matrix<double, 6, 1> get_twist() const = delete;
   const Eigen::Vector3d& get_linear_acceleration() const = delete;
   const Eigen::Vector3d& get_angular_acceleration() const = delete;
-  Eigen::Matrix<double, 6, 1> get_accelerations() const = delete;
+  Eigen::Matrix<double, 6, 1> get_acceleration() const = delete;
   const Eigen::Vector3d& get_force() const = delete;
   const Eigen::Vector3d& get_torque() const = delete;
   Eigen::Matrix<double, 6, 1> get_wrench() const = delete;
@@ -32,7 +34,7 @@ class CartesianPose : public CartesianState {
   void set_twist(const Eigen::Matrix<double, 6, 1>& twist) = delete;
   void set_linear_acceleration(const Eigen::Vector3d& linear_acceleration) = delete;
   void set_angular_acceleration(const Eigen::Vector3d& angular_acceleration) = delete;
-  void set_accelerations(const Eigen::Matrix<double, 6, 1>& accelerations) = delete;
+  void set_acceleration(const Eigen::Matrix<double, 6, 1>& acceleration) = delete;
   void set_force(const Eigen::Vector3d& force) = delete;
   void set_torque(const Eigen::Vector3d& torque) = delete;
   void set_wrench(const Eigen::Matrix<double, 6, 1>& wrench) = delete;
@@ -168,6 +170,13 @@ class CartesianPose : public CartesianState {
    */
   CartesianTwist operator*(const CartesianTwist& twist) const;
 
+  /**
+   * @brief Overload the * operator
+   * @param acceleration CartesianAcceleration to multiply with
+   * @return the current CartesianPose multiplied by the CartesianAcceleration given in argument
+   */
+  CartesianAcceleration operator*(const CartesianAcceleration& acceleration) const;
+
   /**
    * @brief Overload the * operator
    * @param wrench CartesianWrench to multiply with
diff --git a/source/state_representation/include/state_representation/space/cartesian/CartesianState.hpp b/source/state_representation/include/state_representation/space/cartesian/CartesianState.hpp
index d2a95a5f5..ba64d3ec6 100644
--- a/source/state_representation/include/state_representation/space/cartesian/CartesianState.hpp
+++ b/source/state_representation/include/state_representation/space/cartesian/CartesianState.hpp
@@ -20,7 +20,7 @@ enum class CartesianStateVariable {
   TWIST,
   LINEAR_ACCELERATION,
   ANGULAR_ACCELERATION,
-  ACCELERATIONS,
+  ACCELERATION,
   FORCE,
   TORQUE,
   WRENCH,
@@ -62,21 +62,21 @@ class CartesianState : public SpatialState {
   void set_all_state_variables(const Eigen::VectorXd& new_values);
 
   /**
-   * @brief Set new_value in the provided state_variable (positions, velocities, accelerations or torques)
+   * @brief Set new_value in the provided state_variable (position, velocity, acceleration, force or torque)
    * @param state_variable the state variable to fill
    * @param new_value the new value of the state variable
    */
   void set_state_variable(Eigen::Vector3d& state_variable, const Eigen::Vector3d& new_value);
 
   /**
-   * @brief Set new_value in the provided state_variable (positions, velocities, accelerations or torques)
+   * @brief Set new_value in the provided state_variable (position, velocity, acceleration, force or torque)
    * @param state_variable the state variable to fill
    * @param new_value the new value of the state variable
    */
   void set_state_variable(Eigen::Vector3d& state_variable, const std::vector<double>& new_value);
 
   /**
-   * @brief Set new_value in the provided state_variable (twist, accelerations or wrench)
+   * @brief Set new_value in the provided state_variable (twist, acceleration or wrench)
    * @param linear_state_variable the linear part of the state variable to fill
    * @param angular_state_variable the angular part of the state variable to fill
    * @param new_value the new value of the state variable
@@ -87,7 +87,7 @@ class CartesianState : public SpatialState {
   );
 
   /**
-   * @brief Set new_value in the provided state_variable (twist, accelerations or wrench)
+   * @brief Set new_value in the provided state_variable (twist, acceleration or wrench)
    * @param linear_state_variable the linear part of the state variable to fill
    * @param angular_state_variable the angular part of the state variable to fill
    * @param new_value the new value of the state variable
@@ -217,7 +217,7 @@ class CartesianState : public SpatialState {
   /**
    * @brief Getter of the 6d acceleration from linear and angular acceleration attributes
    */
-  Eigen::Matrix<double, 6, 1> get_accelerations() const;
+  Eigen::Matrix<double, 6, 1> get_acceleration() const;
 
   /**
    * @brief Getter of the force attribute
@@ -315,9 +315,9 @@ class CartesianState : public SpatialState {
   void set_angular_acceleration(const Eigen::Vector3d& angular_acceleration);
 
   /**
-   * @brief Setter of the linear and angular accelerations from a 6d acceleration vector
+   * @brief Setter of the linear and angular acceleration from a 6d acceleration vector
    */
-  void set_accelerations(const Eigen::Matrix<double, 6, 1>& accelerations);
+  void set_acceleration(const Eigen::Matrix<double, 6, 1>& acceleration);
 
   /**
    * @brief Setter of the force attribute
@@ -595,10 +595,10 @@ inline const Eigen::Vector3d& CartesianState::get_angular_acceleration() const {
   return this->angular_acceleration_;
 }
 
-inline Eigen::Matrix<double, 6, 1> CartesianState::get_accelerations() const {
-  Eigen::Matrix<double, 6, 1> accelerations;
-  accelerations << this->get_linear_acceleration(), this->get_angular_acceleration();
-  return accelerations;
+inline Eigen::Matrix<double, 6, 1> CartesianState::get_acceleration() const {
+  Eigen::Matrix<double, 6, 1> acceleration;
+  acceleration << this->get_linear_acceleration(), this->get_angular_acceleration();
+  return acceleration;
 }
 
 inline const Eigen::Vector3d& CartesianState::get_force() const {
@@ -641,8 +641,8 @@ inline Eigen::VectorXd CartesianState::get_state_variable(const CartesianStateVa
     case CartesianStateVariable::ANGULAR_ACCELERATION:
       return this->get_angular_acceleration();
 
-    case CartesianStateVariable::ACCELERATIONS:
-      return this->get_accelerations();
+    case CartesianStateVariable::ACCELERATION:
+      return this->get_acceleration();
 
     case CartesianStateVariable::FORCE:
       return this->get_force();
@@ -655,7 +655,7 @@ inline Eigen::VectorXd CartesianState::get_state_variable(const CartesianStateVa
 
     case CartesianStateVariable::ALL:
       Eigen::VectorXd all_fields(25);
-      all_fields << this->get_pose(), this->get_twist(), this->get_accelerations(), this->get_wrench();
+      all_fields << this->get_pose(), this->get_twist(), this->get_acceleration(), this->get_wrench();
       return all_fields;
   }
   // this never goes here but is compulsory to avoid a warning
@@ -669,7 +669,7 @@ inline void CartesianState::set_all_state_variables(const Eigen::VectorXd& new_v
   }
   this->set_pose(new_values.segment(0, 7));
   this->set_twist(new_values.segment(7, 6));
-  this->set_accelerations(new_values.segment(13, 6));
+  this->set_acceleration(new_values.segment(13, 6));
   this->set_wrench(new_values.segment(19, 6));
 }
 
@@ -764,8 +764,8 @@ inline void CartesianState::set_angular_acceleration(const Eigen::Vector3d& angu
   this->set_state_variable(this->angular_acceleration_, angular_acceleration);
 }
 
-inline void CartesianState::set_accelerations(const Eigen::Matrix<double, 6, 1>& accelerations) {
-  this->set_state_variable(this->linear_acceleration_, this->angular_acceleration_, accelerations);
+inline void CartesianState::set_acceleration(const Eigen::Matrix<double, 6, 1>& acceleration) {
+  this->set_state_variable(this->linear_acceleration_, this->angular_acceleration_, acceleration);
 }
 
 inline void CartesianState::set_force(const Eigen::Vector3d& force) {
@@ -816,8 +816,8 @@ inline void CartesianState::set_state_variable(
       this->set_angular_acceleration(new_value);
       break;
 
-    case CartesianStateVariable::ACCELERATIONS:
-      this->set_accelerations(new_value);
+    case CartesianStateVariable::ACCELERATION:
+      this->set_acceleration(new_value);
       break;
 
     case CartesianStateVariable::FORCE:
@@ -835,7 +835,7 @@ inline void CartesianState::set_state_variable(
     case CartesianStateVariable::ALL:
       this->set_pose(new_value.segment(0, 7));
       this->set_twist(new_value.segment(7, 6));
-      this->set_accelerations(new_value.segment(13, 6));
+      this->set_acceleration(new_value.segment(13, 6));
       this->set_wrench(new_value.segment(19, 6));
       break;
   }
diff --git a/source/state_representation/include/state_representation/space/cartesian/CartesianTwist.hpp b/source/state_representation/include/state_representation/space/cartesian/CartesianTwist.hpp
index 69b689689..8efa82f6d 100644
--- a/source/state_representation/include/state_representation/space/cartesian/CartesianTwist.hpp
+++ b/source/state_representation/include/state_representation/space/cartesian/CartesianTwist.hpp
@@ -2,11 +2,11 @@
 
 #include "state_representation/space/cartesian/CartesianState.hpp"
 #include "state_representation/space/cartesian/CartesianPose.hpp"
-#include "state_representation/space/cartesian/CartesianWrench.hpp"
+#include "state_representation/space/cartesian/CartesianAcceleration.hpp"
 
 namespace state_representation {
 class CartesianPose;
-class CartesianWrench;
+class CartesianAcceleration;
 
 /**
  * @class CartesianTwist
@@ -25,7 +25,7 @@ class CartesianTwist : public CartesianState {
   Eigen::Matrix4d get_transformation_matrix() const = delete;
   const Eigen::Vector3d& get_linear_acceleration() const = delete;
   const Eigen::Vector3d& get_angular_acceleration() const = delete;
-  Eigen::Matrix<double, 6, 1> get_accelerations() const = delete;
+  Eigen::Matrix<double, 6, 1> get_acceleration() const = delete;
   const Eigen::Vector3d& get_force() const = delete;
   const Eigen::Vector3d& get_torque() const = delete;
   Eigen::Matrix<double, 6, 1> get_wrench() const = delete;
@@ -40,7 +40,7 @@ class CartesianTwist : public CartesianState {
   void set_pose(const std::vector<double>& pose) = delete;
   void set_linear_acceleration(const Eigen::Vector3d& linear_acceleration) = delete;
   void set_angular_acceleration(const Eigen::Vector3d& angular_acceleration) = delete;
-  void set_accelerations(const Eigen::Matrix<double, 6, 1>& accelerations) = delete;
+  void set_acceleration(const Eigen::Matrix<double, 6, 1>& acceleration) = delete;
   void set_force(const Eigen::Vector3d& force) = delete;
   void set_torque(const Eigen::Vector3d& torque) = delete;
   void set_wrench(const Eigen::Matrix<double, 6, 1>& wrench) = delete;
@@ -75,6 +75,11 @@ class CartesianTwist : public CartesianState {
    */
   CartesianTwist(const CartesianPose& pose);
 
+  /**
+   * @brief Copy constructor from a CartesianAcceleration by considering that it is a twist over 1 second
+   */
+  CartesianTwist(const CartesianAcceleration& acceleration);
+
   /**
    * @brief Construct a CartesianTwist from a linear velocity given as a vector.
    */
@@ -190,6 +195,13 @@ class CartesianTwist : public CartesianState {
    */
   CartesianPose operator*(const std::chrono::nanoseconds& dt) const;
 
+  /**
+   * @brief Overload the / operator with a time period
+   * @param dt the time period to divide by
+   * @return the corresponding CartesianAcceleration
+   */
+  CartesianAcceleration operator/(const std::chrono::nanoseconds& dt) const;
+
   /**
    * @brief Clamp inplace the magnitude of the twist to the values in argument
    * @param max_linear the maximum magnitude of the linear velocity
diff --git a/source/state_representation/include/state_representation/space/cartesian/CartesianWrench.hpp b/source/state_representation/include/state_representation/space/cartesian/CartesianWrench.hpp
index 00d3a4ba6..182e88fd2 100644
--- a/source/state_representation/include/state_representation/space/cartesian/CartesianWrench.hpp
+++ b/source/state_representation/include/state_representation/space/cartesian/CartesianWrench.hpp
@@ -27,7 +27,7 @@ class CartesianWrench : public CartesianState {
   Eigen::Matrix4d get_transformation_matrix() const = delete;
   const Eigen::Vector3d& get_linear_acceleration() const = delete;
   const Eigen::Vector3d& get_angular_acceleration() const = delete;
-  Eigen::Matrix<double, 6, 1> get_accelerations() const = delete;
+  Eigen::Matrix<double, 6, 1> get_acceleration() const = delete;
   void set_position(const Eigen::Vector3d& position) = delete;
   void set_position(const std::vector<double>& position) = delete;
   void set_position(const double& x, const double& y, const double& z) = delete;
@@ -42,7 +42,7 @@ class CartesianWrench : public CartesianState {
   void set_twist(const Eigen::Matrix<double, 6, 1>& twist) = delete;
   void set_linear_acceleration(const Eigen::Vector3d& linear_acceleration) = delete;
   void set_angular_acceleration(const Eigen::Vector3d& angular_acceleration) = delete;
-  void set_accelerations(const Eigen::Matrix<double, 6, 1>& accelerations) = delete;
+  void set_acceleration(const Eigen::Matrix<double, 6, 1>& acceleration) = delete;
   CartesianState operator*=(const CartesianState& state) = delete;
   CartesianState operator*(const CartesianState& state) = delete;
   friend CartesianState operator*=(const CartesianState& state, const CartesianWrench& wrench) = delete;
diff --git a/source/state_representation/include/state_representation/robot/JointAccelerations.hpp b/source/state_representation/include/state_representation/space/joint/JointAccelerations.hpp
similarity index 98%
rename from source/state_representation/include/state_representation/robot/JointAccelerations.hpp
rename to source/state_representation/include/state_representation/space/joint/JointAccelerations.hpp
index 87fdc7e96..d63703754 100644
--- a/source/state_representation/include/state_representation/robot/JointAccelerations.hpp
+++ b/source/state_representation/include/state_representation/space/joint/JointAccelerations.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
-#include "state_representation/robot/JointState.hpp"
-#include "state_representation/robot/JointVelocities.hpp"
+#include "state_representation/space/joint/JointState.hpp"
+#include "state_representation/space/joint/JointVelocities.hpp"
 
 namespace state_representation {
 class JointVelocities;
diff --git a/source/state_representation/include/state_representation/robot/JointPositions.hpp b/source/state_representation/include/state_representation/space/joint/JointPositions.hpp
similarity index 98%
rename from source/state_representation/include/state_representation/robot/JointPositions.hpp
rename to source/state_representation/include/state_representation/space/joint/JointPositions.hpp
index 431d2d5b0..3ed0042ef 100644
--- a/source/state_representation/include/state_representation/robot/JointPositions.hpp
+++ b/source/state_representation/include/state_representation/space/joint/JointPositions.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
-#include "state_representation/robot/JointState.hpp"
-#include "state_representation/robot/JointVelocities.hpp"
+#include "state_representation/space/joint/JointState.hpp"
+#include "state_representation/space/joint/JointVelocities.hpp"
 
 namespace state_representation {
 class JointVelocities;
diff --git a/source/state_representation/include/state_representation/robot/JointState.hpp b/source/state_representation/include/state_representation/space/joint/JointState.hpp
similarity index 100%
rename from source/state_representation/include/state_representation/robot/JointState.hpp
rename to source/state_representation/include/state_representation/space/joint/JointState.hpp
diff --git a/source/state_representation/include/state_representation/robot/JointTorques.hpp b/source/state_representation/include/state_representation/space/joint/JointTorques.hpp
similarity index 99%
rename from source/state_representation/include/state_representation/robot/JointTorques.hpp
rename to source/state_representation/include/state_representation/space/joint/JointTorques.hpp
index 35aac58f8..561826229 100644
--- a/source/state_representation/include/state_representation/robot/JointTorques.hpp
+++ b/source/state_representation/include/state_representation/space/joint/JointTorques.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "state_representation/robot/JointState.hpp"
+#include "state_representation/space/joint/JointState.hpp"
 
 namespace state_representation {
 /**
diff --git a/source/state_representation/include/state_representation/robot/JointVelocities.hpp b/source/state_representation/include/state_representation/space/joint/JointVelocities.hpp
similarity index 98%
rename from source/state_representation/include/state_representation/robot/JointVelocities.hpp
rename to source/state_representation/include/state_representation/space/joint/JointVelocities.hpp
index d2205ba9a..3a35ee979 100644
--- a/source/state_representation/include/state_representation/robot/JointVelocities.hpp
+++ b/source/state_representation/include/state_representation/space/joint/JointVelocities.hpp
@@ -1,8 +1,8 @@
 #pragma once
 
-#include "state_representation/robot/JointState.hpp"
-#include "state_representation/robot/JointPositions.hpp"
-#include "state_representation/robot/JointAccelerations.hpp"
+#include "state_representation/space/joint/JointState.hpp"
+#include "state_representation/space/joint/JointPositions.hpp"
+#include "state_representation/space/joint/JointAccelerations.hpp"
 
 namespace state_representation {
 class JointPositions;
diff --git a/source/state_representation/src/geometry/Ellipsoid.cpp b/source/state_representation/src/geometry/Ellipsoid.cpp
index 8c4c150e6..072c17057 100644
--- a/source/state_representation/src/geometry/Ellipsoid.cpp
+++ b/source/state_representation/src/geometry/Ellipsoid.cpp
@@ -2,21 +2,26 @@
 #include "state_representation/exceptions/NoSolutionToFitException.hpp"
 #include "state_representation/exceptions/IncompatibleSizeException.hpp"
 
+#include "state_representation/exceptions/EmptyStateException.hpp"
+
 namespace state_representation {
+Ellipsoid::Ellipsoid() : Shape(StateType::GEOMETRY_ELLIPSOID), axis_lengths_({1., 1.}), rotation_angle_(0) {}
+
 Ellipsoid::Ellipsoid(const std::string& name, const std::string& reference_frame) :
-    Shape(StateType::GEOMETRY_ELLIPSOID, name, reference_frame),
-    axis_lengths_({1., 1.}) {
+    Shape(StateType::GEOMETRY_ELLIPSOID, name, reference_frame), axis_lengths_({1., 1.}), rotation_angle_(0) {
   this->set_filled();
 }
 
 Ellipsoid::Ellipsoid(const Ellipsoid& ellipsoid) :
-    Shape(ellipsoid),
-    axis_lengths_(ellipsoid.axis_lengths_) {
+    Shape(ellipsoid), axis_lengths_(ellipsoid.axis_lengths_), rotation_angle_(0) {
   this->set_filled();
 }
 
 const std::list<CartesianPose> Ellipsoid::sample_from_parameterization(unsigned int nb_samples) const {
-  // use a linespace to have a full rotation angle between [0, 2pi]
+  if (this->get_center_state().is_empty()) {
+    throw exceptions::EmptyStateException("The center state of the Ellipsoid is not set yet.");
+  }
+  // use a linspace to have a full rotation angle between [0, 2pi]
   std::vector<double> alpha = math_tools::linspace(0, 2 * M_PI, nb_samples);
 
   std::list<CartesianPose> samples;
@@ -33,14 +38,14 @@ const std::list<CartesianPose> Ellipsoid::sample_from_parameterization(unsigned
   return samples;
 }
 
-const Ellipsoid Ellipsoid::from_algebraic_equation(const std::string& name,
-                                                   const std::vector<double>& coefficients,
-                                                   const std::string& reference_frame) {
+const Ellipsoid Ellipsoid::from_algebraic_equation(
+    const std::string& name, const std::vector<double>& coefficients, const std::string& reference_frame
+) {
   // extract all the components from the coefficients vector
   double b2 = coefficients[1] * coefficients[1];
   double delta = b2 - 4 * coefficients[0] * coefficients[2];
 
-  // store intermediate calcualtions
+  // store intermediate calculations
   double tmp1 = coefficients[0] * coefficients[4] * coefficients[4] // AE2
       + coefficients[2] * coefficients[3] * coefficients[3] // CD2
       - coefficients[1] * coefficients[3] * coefficients[4] // BDE
@@ -79,10 +84,10 @@ const Ellipsoid Ellipsoid::from_algebraic_equation(const std::string& name,
   return result;
 }
 
-const Ellipsoid Ellipsoid::fit(const std::string& name,
-                               const std::list<CartesianPose>& points,
-                               const std::string& reference_frame,
-                               double noise_level) {
+const Ellipsoid Ellipsoid::fit(
+    const std::string& name, const std::list<CartesianPose>& points, const std::string& reference_frame,
+    double noise_level
+) {
   // define the constraint matrix
   Eigen::SparseMatrix<double> constraint_matrix(6, 6);
   constraint_matrix.insert(1, 1) = -1;
@@ -103,7 +108,7 @@ const Ellipsoid Ellipsoid::fit(const std::string& name,
   std::normal_distribution<double> dist(0., noise_level);
   do {
     unsigned int i = 0;
-    for (const auto& p : points) {
+    for (const auto& p: points) {
       x_value[i] = p.get_position()(0) + dist(generator);
       y_value[i] = p.get_position()(1) + dist(generator);
       ++i;
@@ -154,12 +159,8 @@ const Ellipsoid Ellipsoid::fit(const std::string& name,
     coefficients[2] = solution(2) * sx2;
     coefficients[3] = -2 * solution(0) * sy2 * kx - solution(1) * sx * sy * ky + solution(3) * sx * sy2;
     coefficients[4] = -solution(1) * sx * sy * kx - 2 * solution(2) * sx2 * ky + solution(4) * sx2 * sy;
-    coefficients[5] = solution(0) * sy2 * kx * kx
-        + solution(1) * sx * sy * kx * ky
-        + solution(2) * sx2 * ky * ky
-        - solution(3) * sx * sy2 * kx
-        - solution(4) * sx2 * sy * ky
-        + solution(5) * sx2 * sy2;
+    coefficients[5] = solution(0) * sy2 * kx * kx + solution(1) * sx * sy * kx * ky + solution(2) * sx2 * ky * ky
+        - solution(3) * sx * sy2 * kx - solution(4) * sx2 * sy * ky + solution(5) * sx2 * sy2;
 
     delta = coefficients[1] * coefficients[1] - 4 * coefficients[0] * coefficients[2];
   } while (delta > 0);
@@ -167,6 +168,9 @@ const Ellipsoid Ellipsoid::fit(const std::string& name,
 }
 
 void Ellipsoid::set_data(const Eigen::VectorXd& data) {
+  if (this->get_center_state().is_empty()) {
+    throw exceptions::EmptyStateException("The center state of the Ellipsoid is not set yet.");
+  }
   if (data.size() != 6) {
     throw exceptions::IncompatibleSizeException(
         "Input is of incorrect size: expected 6, given " + std::to_string(data.size()));
diff --git a/source/state_representation/src/geometry/Shape.cpp b/source/state_representation/src/geometry/Shape.cpp
index 03ec4aa8e..265276a0e 100644
--- a/source/state_representation/src/geometry/Shape.cpp
+++ b/source/state_representation/src/geometry/Shape.cpp
@@ -1,13 +1,13 @@
 #include "state_representation/geometry/Shape.hpp"
 
 namespace state_representation {
+Shape::Shape(const StateType& type) : State(type) {}
+
 Shape::Shape(const StateType& type, const std::string& name, const std::string& reference_frame) :
     State(type, name),
     center_state_(CartesianPose(name, Eigen::Vector3d::Zero(), Eigen::Quaterniond::Identity(), reference_frame)) {}
 
-Shape::Shape(const Shape& shape) :
-    State(shape),
-    center_state_(shape.center_state_) {}
+Shape::Shape(const Shape& shape) : State(shape), center_state_(shape.center_state_) {}
 
 std::ostream& operator<<(std::ostream& os, const Shape& shape) {
   os << "Shape " << shape.get_name() << " with state:" << std::endl;
diff --git a/source/state_representation/src/parameters/Event.cpp b/source/state_representation/src/parameters/Event.cpp
index 922c28a75..38a1d2016 100644
--- a/source/state_representation/src/parameters/Event.cpp
+++ b/source/state_representation/src/parameters/Event.cpp
@@ -1,10 +1,11 @@
 #include "state_representation/parameters/Event.hpp"
 
 namespace state_representation {
+
 Event::Event(const std::string& name) : Predicate(name), previous_predicate_value_(false) {}
 
 std::ostream& operator<<(std::ostream& os, const Event& event) {
   os << " Event " << event.get_name() << ": " << event.get_value();
   return os;
 }
-}// namespace state_representation
\ No newline at end of file
+}// namespace state_representation
diff --git a/source/state_representation/src/parameters/Parameter.cpp b/source/state_representation/src/parameters/Parameter.cpp
index 7662a6a06..83a2811e9 100644
--- a/source/state_representation/src/parameters/Parameter.cpp
+++ b/source/state_representation/src/parameters/Parameter.cpp
@@ -1,16 +1,18 @@
 #include "state_representation/parameters/Parameter.hpp"
+
 #include "state_representation/geometry/Ellipsoid.hpp"
-#include "state_representation/robot/JointPositions.hpp"
+#include "state_representation/space/joint/JointPositions.hpp"
 #include "state_representation/space/cartesian/CartesianPose.hpp"
 
 namespace state_representation {
+
 template<>
 Parameter<int>::Parameter(const std::string& name) :
     ParameterInterface(StateType::PARAMETER_INT, name) {}
 
 template<>
 Parameter<int>::Parameter(const std::string& name, const int& value) :
-    ParameterInterface(StateType::PARAMETER_INT, name), value(value) {
+    ParameterInterface(StateType::PARAMETER_INT, name), value_(value) {
   this->set_filled();
 }
 
@@ -20,7 +22,7 @@ Parameter<std::vector<int>>::Parameter(const std::string& name) :
 
 template<>
 Parameter<std::vector<int>>::Parameter(const std::string& name, const std::vector<int>& value) :
-    ParameterInterface(StateType::PARAMETER_INT_ARRAY, name), value(value) {
+    ParameterInterface(StateType::PARAMETER_INT_ARRAY, name), value_(value) {
   this->set_filled();
 }
 
@@ -30,7 +32,7 @@ Parameter<double>::Parameter(const std::string& name) :
 
 template<>
 Parameter<double>::Parameter(const std::string& name, const double& value) :
-    ParameterInterface(StateType::PARAMETER_DOUBLE, name), value(value) {
+    ParameterInterface(StateType::PARAMETER_DOUBLE, name), value_(value) {
   this->set_filled();
 }
 
@@ -40,7 +42,7 @@ Parameter<std::vector<double>>::Parameter(const std::string& name) :
 
 template<>
 Parameter<std::vector<double>>::Parameter(const std::string& name, const std::vector<double>& value) :
-    ParameterInterface(StateType::PARAMETER_DOUBLE_ARRAY, name), value(value) {
+    ParameterInterface(StateType::PARAMETER_DOUBLE_ARRAY, name), value_(value) {
   this->set_filled();
 }
 
@@ -49,7 +51,7 @@ Parameter<bool>::Parameter(const std::string& name) : ParameterInterface(StateTy
 
 template<>
 Parameter<bool>::Parameter(const std::string& name, const bool& value) :
-    ParameterInterface(StateType::PARAMETER_BOOL, name), value(value) {
+    ParameterInterface(StateType::PARAMETER_BOOL, name), value_(value) {
   this->set_filled();
 }
 
@@ -60,7 +62,7 @@ Parameter<std::vector<bool>>::Parameter(const std::string& name) :
 
 template<>
 Parameter<std::vector<bool>>::Parameter(const std::string& name, const std::vector<bool>& value) :
-    ParameterInterface(StateType::PARAMETER_BOOL_ARRAY, name), value(value) {
+    ParameterInterface(StateType::PARAMETER_BOOL_ARRAY, name), value_(value) {
   this->set_filled();
 }
 
@@ -70,7 +72,7 @@ Parameter<std::string>::Parameter(const std::string& name) :
 
 template<>
 Parameter<std::string>::Parameter(const std::string& name, const std::string& value) :
-    ParameterInterface(StateType::PARAMETER_STRING, name), value(value) {
+    ParameterInterface(StateType::PARAMETER_STRING, name), value_(value) {
   this->set_filled();
 }
 
@@ -80,7 +82,7 @@ Parameter<std::vector<std::string>>::Parameter(const std::string& name) :
 
 template<>
 Parameter<std::vector<std::string>>::Parameter(const std::string& name, const std::vector<std::string>& value) :
-    ParameterInterface(StateType::PARAMETER_STRING_ARRAY, name), value(value) {
+    ParameterInterface(StateType::PARAMETER_STRING_ARRAY, name), value_(value) {
   this->set_filled();
 }
 
@@ -90,7 +92,7 @@ Parameter<CartesianState>::Parameter(const std::string& name) :
 
 template<>
 Parameter<CartesianState>::Parameter(const std::string& name, const CartesianState& value) :
-    ParameterInterface(StateType::PARAMETER_CARTESIANSTATE, name), value(value) {
+    ParameterInterface(StateType::PARAMETER_CARTESIANSTATE, name), value_(value) {
   this->set_filled();
 }
 
@@ -100,7 +102,7 @@ Parameter<CartesianPose>::Parameter(const std::string& name) :
 
 template<>
 Parameter<CartesianPose>::Parameter(const std::string& name, const CartesianPose& value) :
-    ParameterInterface(StateType::PARAMETER_CARTESIANPOSE, name), value(value) {
+    ParameterInterface(StateType::PARAMETER_CARTESIANPOSE, name), value_(value) {
   this->set_filled();
 }
 
@@ -110,7 +112,7 @@ Parameter<JointState>::Parameter(const std::string& name) :
 
 template<>
 Parameter<JointState>::Parameter(const std::string& name, const JointState& value) :
-    ParameterInterface(StateType::PARAMETER_JOINTSTATE, name), value(value) {
+    ParameterInterface(StateType::PARAMETER_JOINTSTATE, name), value_(value) {
   this->set_filled();
 }
 
@@ -120,13 +122,13 @@ Parameter<JointPositions>::Parameter(const std::string& name) :
 
 template<>
 Parameter<JointPositions>::Parameter(const std::string& name, const JointPositions& value) :
-    ParameterInterface(StateType::PARAMETER_JOINTPOSITIONS, name), value(value) {
+    ParameterInterface(StateType::PARAMETER_JOINTPOSITIONS, name), value_(value) {
   this->set_filled();
 }
 
 template<>
 Parameter<Ellipsoid>::Parameter(const std::string& name, const Ellipsoid& value) :
-    ParameterInterface(StateType::PARAMETER_ELLIPSOID, name), value(value) {
+    ParameterInterface(StateType::PARAMETER_ELLIPSOID, name), value_(value) {
   this->set_filled();
 }
 
@@ -136,7 +138,7 @@ Parameter<Eigen::MatrixXd>::Parameter(const std::string& name) :
 
 template<>
 Parameter<Eigen::MatrixXd>::Parameter(const std::string& name, const Eigen::MatrixXd& value) :
-    ParameterInterface(StateType::PARAMETER_MATRIX, name), value(value) {
+    ParameterInterface(StateType::PARAMETER_MATRIX, name), value_(value) {
   this->set_filled();
 }
 
@@ -146,7 +148,7 @@ Parameter<Eigen::VectorXd>::Parameter(const std::string& name) :
 
 template<>
 Parameter<Eigen::VectorXd>::Parameter(const std::string& name, const Eigen::VectorXd& value) :
-    ParameterInterface(StateType::PARAMETER_VECTOR, name), value(value) {
+    ParameterInterface(StateType::PARAMETER_VECTOR, name), value_(value) {
   this->set_filled();
 }
 
@@ -155,7 +157,7 @@ std::ostream& operator<<(std::ostream& os, const Parameter<T>& parameter) {
   if (parameter.is_empty()) {
     os << " Parameter " << parameter.get_name() << " is empty";
   } else {
-    os << " Parameter " << parameter.get_name() << ": " << parameter.value;
+    os << " Parameter " << parameter.get_name() << ": " << parameter.get_value();
   }
   return os;
 }
@@ -178,7 +180,7 @@ std::ostream& operator<<(std::ostream& os, const Parameter<std::vector<int>>& pa
     os << " Parameter " << parameter.get_name() << " is empty" << std::endl;
   } else {
     os << " Parameter " << parameter.get_name() << ": ";
-    for (auto& v: parameter.value) {
+    for (auto& v: parameter.get_value()) {
       os << v << " | ";
     }
     os << std::endl;
@@ -192,7 +194,7 @@ std::ostream& operator<<(std::ostream& os, const Parameter<std::vector<double>>&
     os << " Parameter " << parameter.get_name() << " is empty" << std::endl;
   } else {
     os << " Parameter " << parameter.get_name() << ": ";
-    for (auto& v: parameter.value) {
+    for (auto& v: parameter.get_value()) {
       os << v << " | ";
     }
     os << std::endl;
@@ -206,7 +208,7 @@ std::ostream& operator<<(std::ostream& os, const Parameter<std::vector<bool>>& p
     os << " Parameter " << parameter.get_name() << " is empty" << std::endl;
   } else {
     os << " Parameter " << parameter.get_name() << ": ";
-    for (auto v: parameter.value) {
+    for (auto v: parameter.get_value()) {
       os << v << " | ";
     }
     os << std::endl;
@@ -220,11 +222,11 @@ std::ostream& operator<<(std::ostream& os, const Parameter<std::vector<std::stri
     os << " Parameter " << parameter.get_name() << " is empty" << std::endl;
   } else {
     os << " Parameter " << parameter.get_name() << ": ";
-    for (auto& v: parameter.value) {
+    for (auto& v: parameter.get_value()) {
       os << v << " | ";
     }
     os << std::endl;
   }
   return os;
 }
-}// namespace state_representation
\ No newline at end of file
+}// namespace state_representation
diff --git a/source/state_representation/src/parameters/ParameterInterface.cpp b/source/state_representation/src/parameters/ParameterInterface.cpp
index ed129faf9..ce22e7e3c 100644
--- a/source/state_representation/src/parameters/ParameterInterface.cpp
+++ b/source/state_representation/src/parameters/ParameterInterface.cpp
@@ -1,7 +1,13 @@
 #include "state_representation/parameters/ParameterInterface.hpp"
 
 namespace state_representation {
+
 ParameterInterface::ParameterInterface(const StateType& type, const std::string& name) : State(type, name) {}
 
 ParameterInterface::ParameterInterface(const ParameterInterface& parameter) : State(parameter) {}
-}// namespace state_representation
\ No newline at end of file
+
+ParameterInterface& ParameterInterface::operator=(const ParameterInterface& state) {
+  State::operator=(state);
+  return (*this);
+}
+}// namespace state_representation
diff --git a/source/state_representation/src/parameters/ParameterMap.cpp b/source/state_representation/src/parameters/ParameterMap.cpp
new file mode 100644
index 000000000..a89845934
--- /dev/null
+++ b/source/state_representation/src/parameters/ParameterMap.cpp
@@ -0,0 +1,68 @@
+#include "state_representation/parameters/ParameterMap.hpp"
+
+namespace state_representation {
+
+ParameterMap::ParameterMap(const std::list<std::shared_ptr<state_representation::ParameterInterface>>& parameters) {
+  this->set_parameters(parameters);
+}
+
+ParameterMap::ParameterMap(
+    const std::map<std::string, std::shared_ptr<state_representation::ParameterInterface>>& parameters
+) {
+  this->set_parameters(parameters);
+}
+
+std::shared_ptr<state_representation::ParameterInterface> ParameterMap::get_parameter(const std::string& name) const {
+  if (this->parameters_.find(name) == this->parameters_.cend()) {
+    throw exceptions::InvalidParameterException("Could not find a parameter named '" + name + "'.");
+  }
+  return this->parameters_.at(name);
+}
+
+std::map<std::string, std::shared_ptr<state_representation::ParameterInterface>> ParameterMap::get_parameters() const {
+  return this->parameters_;
+}
+
+std::list<std::shared_ptr<state_representation::ParameterInterface>> ParameterMap::get_parameter_list() const {
+  std::list<std::shared_ptr<state_representation::ParameterInterface>> param_list;
+  for (const auto& param_it: this->parameters_) {
+    param_list.template emplace_back(param_it.second);
+  }
+  return param_list;
+}
+
+void ParameterMap::set_parameter(const std::shared_ptr<state_representation::ParameterInterface>& parameter) {
+  this->validate_and_set_parameter(parameter);
+}
+
+void ParameterMap::set_parameters(
+    const std::list<std::shared_ptr<state_representation::ParameterInterface>>& parameters
+) {
+  for (const auto& param: parameters) {
+    this->set_parameter(param);
+  }
+}
+
+void ParameterMap::set_parameters(
+    const std::map<std::string, std::shared_ptr<state_representation::ParameterInterface>>& parameters
+) {
+  for (const auto& param_it: parameters) {
+    this->set_parameter(param_it.second);
+  }
+}
+
+void ParameterMap::assert_parameter_valid(
+    const std::shared_ptr<state_representation::ParameterInterface>& parameter
+) {
+  if (this->parameters_.at(parameter->get_name())->get_type() != parameter->get_type()) {
+    throw exceptions::InvalidParameterException(
+        "Parameter '" + parameter->get_name() + "' exists, but has unexpected type.");
+  }
+}
+
+void
+ParameterMap::validate_and_set_parameter(const std::shared_ptr<state_representation::ParameterInterface>& parameter) {
+  this->parameters_[parameter->get_name()] = parameter;
+}
+
+}
\ No newline at end of file
diff --git a/source/state_representation/src/parameters/Predicate.cpp b/source/state_representation/src/parameters/Predicate.cpp
index 0daab6a2d..10a0a7790 100644
--- a/source/state_representation/src/parameters/Predicate.cpp
+++ b/source/state_representation/src/parameters/Predicate.cpp
@@ -1,6 +1,7 @@
 #include "state_representation/parameters/Predicate.hpp"
 
 namespace state_representation {
+
 Predicate::Predicate(const std::string& name) : Parameter<bool>(name, false) {}
 
 Predicate::Predicate(const std::string& name, bool value) : Parameter<bool>(name, value) {}
@@ -9,4 +10,4 @@ std::ostream& operator<<(std::ostream& os, const Predicate& predicate) {
   os << " Predicate " << predicate.get_name() << ": " << predicate.get_value();
   return os;
 }
-}// namespace state_representation
\ No newline at end of file
+}// namespace state_representation
diff --git a/source/state_representation/src/robot/Jacobian.cpp b/source/state_representation/src/space/Jacobian.cpp
similarity index 99%
rename from source/state_representation/src/robot/Jacobian.cpp
rename to source/state_representation/src/space/Jacobian.cpp
index 7d62eb98e..90653920b 100644
--- a/source/state_representation/src/robot/Jacobian.cpp
+++ b/source/state_representation/src/space/Jacobian.cpp
@@ -1,4 +1,4 @@
-#include "state_representation/robot/Jacobian.hpp"
+#include "state_representation/space/Jacobian.hpp"
 
 #include "state_representation/exceptions/EmptyStateException.hpp"
 #include "state_representation/exceptions/IncompatibleStatesException.hpp"
diff --git a/source/state_representation/src/space/cartesian/CartesianAcceleration.cpp b/source/state_representation/src/space/cartesian/CartesianAcceleration.cpp
new file mode 100644
index 000000000..55074f1cd
--- /dev/null
+++ b/source/state_representation/src/space/cartesian/CartesianAcceleration.cpp
@@ -0,0 +1,190 @@
+#include "state_representation/space/cartesian/CartesianAcceleration.hpp"
+#include "state_representation/exceptions/EmptyStateException.hpp"
+
+using namespace state_representation::exceptions;
+
+namespace state_representation {
+CartesianAcceleration::CartesianAcceleration(const std::string& name, const std::string& reference) :
+    CartesianState(name, reference) {}
+
+CartesianAcceleration::CartesianAcceleration(
+    const std::string& name, const Eigen::Vector3d& linear_acceleration, const std::string& reference
+) : CartesianState(name, reference) {
+  this->set_linear_acceleration(linear_acceleration);
+}
+
+CartesianAcceleration::CartesianAcceleration(
+    const std::string& name, const Eigen::Vector3d& linear_acceleration, const Eigen::Vector3d& angular_acceleration,
+    const std::string& reference
+) : CartesianState(name, reference) {
+  this->set_linear_acceleration(linear_acceleration);
+  this->set_angular_acceleration(angular_acceleration);
+}
+
+CartesianAcceleration::CartesianAcceleration(
+    const std::string& name, const Eigen::Matrix<double, 6, 1>& acceleration, const std::string& reference
+) : CartesianState(name, reference) {
+  this->set_acceleration(acceleration);
+}
+
+CartesianAcceleration::CartesianAcceleration(const CartesianState& state) : CartesianState(state) {
+  // set all the state variables to 0 except linear and angular velocities
+  this->set_zero();
+  this->set_acceleration(state.get_acceleration());
+  this->set_empty(state.is_empty());
+}
+
+CartesianAcceleration::CartesianAcceleration(const CartesianAcceleration& acceleration) :
+    CartesianAcceleration(static_cast<const CartesianState&>(acceleration)) {}
+
+CartesianAcceleration::CartesianAcceleration(const CartesianTwist& twist) : CartesianAcceleration(twist / std::chrono::seconds(1)) {}
+
+CartesianAcceleration CartesianAcceleration::Zero(const std::string& name, const std::string& reference) {
+  return CartesianState::Identity(name, reference);
+}
+
+CartesianAcceleration CartesianAcceleration::Random(const std::string& name, const std::string& reference) {
+  // separating in the two lines in needed to avoid compilation error due to ambiguous constructor call
+  Eigen::Matrix<double, 6, 1> random = Eigen::Matrix<double, 6, 1>::Random();
+  return CartesianAcceleration(name, random, reference);
+}
+
+CartesianAcceleration& CartesianAcceleration::operator+=(const CartesianAcceleration& acceleration) {
+  this->CartesianState::operator+=(acceleration);
+  return (*this);
+}
+
+CartesianAcceleration CartesianAcceleration::operator+(const CartesianAcceleration& acceleration) const {
+  return this->CartesianState::operator+(acceleration);
+}
+
+CartesianAcceleration& CartesianAcceleration::operator-=(const CartesianAcceleration& acceleration) {
+  this->CartesianState::operator-=(acceleration);
+  return (*this);
+}
+
+CartesianAcceleration CartesianAcceleration::operator-(const CartesianAcceleration& acceleration) const {
+  return this->CartesianState::operator-(acceleration);
+}
+
+CartesianAcceleration& CartesianAcceleration::operator*=(double lambda) {
+  this->CartesianState::operator*=(lambda);
+  return (*this);
+}
+
+CartesianAcceleration CartesianAcceleration::operator*(double lambda) const {
+  return this->CartesianState::operator*(lambda);
+}
+
+CartesianAcceleration& CartesianAcceleration::operator/=(double lambda) {
+  this->CartesianState::operator/=(lambda);
+  return (*this);
+}
+
+CartesianAcceleration CartesianAcceleration::operator/(double lambda) const {
+  return this->CartesianState::operator/(lambda);
+}
+
+CartesianAcceleration& CartesianAcceleration::operator*=(const Eigen::Matrix<double, 6, 6>& lambda) {
+  // sanity check
+  if (this->is_empty()) {
+    throw EmptyStateException(this->get_name() + " state is empty");
+  }
+  // operation
+  this->set_linear_acceleration(lambda.block<3, 3>(0, 0) * this->get_linear_acceleration());
+  this->set_angular_acceleration(lambda.block<3, 3>(3, 3) * this->get_angular_acceleration());
+  return (*this);
+}
+
+CartesianTwist CartesianAcceleration::operator*(const std::chrono::nanoseconds& dt) const {
+  // sanity check
+  if (this->is_empty()) {
+    throw EmptyStateException(this->get_name() + " state is empty");
+  }
+  // operations
+  CartesianTwist twist(this->get_name(), this->get_reference_frame());
+  // convert the period to a double with the second as reference
+  double period = dt.count();
+  period /= 1e9;
+  // convert the acceleration into a twist
+  twist.set_linear_velocity(period * this->get_linear_acceleration());
+  twist.set_angular_velocity(period * this->get_angular_acceleration());
+  return twist;
+}
+
+void CartesianAcceleration::clamp(
+    double max_linear, double max_angular, double linear_noise_ratio, double angular_noise_ratio
+) {
+  // clamp linear
+  this->clamp_state_variable(max_linear, CartesianStateVariable::LINEAR_ACCELERATION, linear_noise_ratio);
+  // clamp angular
+  this->clamp_state_variable(max_angular, CartesianStateVariable::ANGULAR_ACCELERATION, angular_noise_ratio);
+}
+
+CartesianAcceleration CartesianAcceleration::clamped(
+    double max_linear, double max_angular, double linear_noise_ratio, double angular_noise_ratio
+) const {
+  CartesianAcceleration result(*this);
+  result.clamp(max_linear, max_angular, linear_noise_ratio, angular_noise_ratio);
+  return result;
+}
+
+CartesianAcceleration CartesianAcceleration::copy() const {
+  CartesianAcceleration result(*this);
+  return result;
+}
+
+Eigen::VectorXd CartesianAcceleration::data() const {
+  return this->get_acceleration();
+}
+
+void CartesianAcceleration::set_data(const Eigen::VectorXd& data) {
+  if (data.size() != 6) {
+    throw IncompatibleSizeException(
+        "Input is of incorrect size: expected 6, given " + std::to_string(data.size()));
+  }
+  this->set_acceleration(data);
+}
+
+void CartesianAcceleration::set_data(const std::vector<double>& data) {
+  this->set_data(Eigen::VectorXd::Map(data.data(), data.size()));
+}
+
+CartesianAcceleration CartesianAcceleration::inverse() const {
+  return this->CartesianState::inverse();
+}
+
+std::ostream& operator<<(std::ostream& os, const CartesianAcceleration& acceleration) {
+  if (acceleration.is_empty()) {
+    os << "Empty CartesianAcceleration";
+  } else {
+    os << acceleration.get_name() << " CartesianTwist expressed in " << acceleration.get_reference_frame() << " frame"
+       << std::endl;
+    os << "linear_velocity: (" << acceleration.get_linear_acceleration()(0) << ", ";
+    os << acceleration.get_linear_acceleration()(1) << ", ";
+    os << acceleration.get_linear_acceleration()(2) << ")" << std::endl;
+    os << "angular_velocity: (" << acceleration.get_angular_acceleration()(0) << ", ";
+    os << acceleration.get_angular_acceleration()(1) << ", ";
+    os << acceleration.get_angular_acceleration()(2) << ")";
+  }
+  return os;
+}
+
+CartesianAcceleration operator*(const CartesianState& state, const CartesianAcceleration& acceleration) {
+  return state.operator*(acceleration);
+}
+
+CartesianAcceleration operator*(double lambda, const CartesianAcceleration& acceleration) {
+  return acceleration * lambda;
+}
+
+CartesianAcceleration operator*(const Eigen::Matrix<double, 6, 6>& lambda, const CartesianAcceleration& acceleration) {
+  CartesianAcceleration result(acceleration);
+  result *= lambda;
+  return result;
+}
+
+CartesianTwist operator*(const std::chrono::nanoseconds& dt, const CartesianAcceleration& acceleration) {
+  return acceleration * dt;
+}
+}// namespace state_representation
diff --git a/source/state_representation/src/space/cartesian/CartesianPose.cpp b/source/state_representation/src/space/cartesian/CartesianPose.cpp
index 1cf1a062f..2259c3c52 100644
--- a/source/state_representation/src/space/cartesian/CartesianPose.cpp
+++ b/source/state_representation/src/space/cartesian/CartesianPose.cpp
@@ -72,6 +72,10 @@ CartesianTwist CartesianPose::operator*(const CartesianTwist& twist) const {
   return this->CartesianState::operator*(twist);
 }
 
+CartesianAcceleration CartesianPose::operator*(const CartesianAcceleration& acceleration) const {
+  return this->CartesianState::operator*(acceleration);
+}
+
 CartesianWrench CartesianPose::operator*(const CartesianWrench& wrench) const {
   return this->CartesianState::operator*(wrench);
 }
diff --git a/source/state_representation/src/space/cartesian/CartesianState.cpp b/source/state_representation/src/space/cartesian/CartesianState.cpp
index 39802bfff..a593c4659 100644
--- a/source/state_representation/src/space/cartesian/CartesianState.cpp
+++ b/source/state_representation/src/space/cartesian/CartesianState.cpp
@@ -58,7 +58,7 @@ CartesianState& CartesianState::operator*=(double lambda) {
   this->set_orientation(math_tools::exp(w, lambda / 2.));
   // calculate the other vectors normally
   this->set_twist(lambda * this->get_twist());
-  this->set_accelerations(lambda * this->get_accelerations());
+  this->set_acceleration(lambda * this->get_acceleration());
   this->set_wrench(lambda * this->get_wrench());
   return (*this);
 }
@@ -173,8 +173,8 @@ CartesianState& CartesianState::operator+=(const CartesianState& state) {
   this->set_orientation(this->get_orientation() * orientation);
   // operation on twist
   this->set_twist(this->get_twist() + state.get_twist());
-  // operation on accelerations
-  this->set_accelerations(this->get_accelerations() + state.get_accelerations());
+  // operation on acceleration
+  this->set_acceleration(this->get_acceleration() + state.get_acceleration());
   // operation on wrench
   this->set_wrench(this->get_wrench() + state.get_wrench());
   return (*this);
@@ -205,8 +205,8 @@ CartesianState& CartesianState::operator-=(const CartesianState& state) {
   this->set_orientation(this->get_orientation() * orientation.conjugate());
   // operation on twist
   this->set_twist(this->get_twist() - state.get_twist());
-  // operation on accelerations
-  this->set_accelerations(this->get_accelerations() - state.get_accelerations());
+  // operation on acceleration
+  this->set_acceleration(this->get_acceleration() - state.get_acceleration());
   // operation on wrench
   this->set_wrench(this->get_wrench() - state.get_wrench());
   return (*this);
@@ -301,12 +301,12 @@ double CartesianState::dist(const CartesianState& state, const CartesianStateVar
     result += (this->get_angular_velocity() - state.get_angular_velocity()).norm();
   }
   if (state_variable_type == CartesianStateVariable::LINEAR_ACCELERATION
-      || state_variable_type == CartesianStateVariable::ACCELERATIONS
+      || state_variable_type == CartesianStateVariable::ACCELERATION
       || state_variable_type == CartesianStateVariable::ALL) {
     result += (this->get_linear_acceleration() - state.get_linear_acceleration()).norm();
   }
   if (state_variable_type == CartesianStateVariable::ANGULAR_ACCELERATION
-      || state_variable_type == CartesianStateVariable::ACCELERATIONS
+      || state_variable_type == CartesianStateVariable::ACCELERATION
       || state_variable_type == CartesianStateVariable::ALL) {
     result += (this->get_angular_acceleration() - state.get_angular_acceleration()).norm();
   }
@@ -341,12 +341,12 @@ std::vector<double> CartesianState::norms(const CartesianStateVariable& state_va
     norms.push_back(this->get_angular_velocity().norm());
   }
   if (state_variable_type == CartesianStateVariable::LINEAR_ACCELERATION
-      || state_variable_type == CartesianStateVariable::ACCELERATIONS
+      || state_variable_type == CartesianStateVariable::ACCELERATION
       || state_variable_type == CartesianStateVariable::ALL) {
     norms.push_back(this->get_linear_acceleration().norm());
   }
   if (state_variable_type == CartesianStateVariable::ANGULAR_ACCELERATION
-      || state_variable_type == CartesianStateVariable::ACCELERATIONS
+      || state_variable_type == CartesianStateVariable::ACCELERATION
       || state_variable_type == CartesianStateVariable::ALL) {
     norms.push_back(this->get_angular_acceleration().norm());
   }
@@ -380,12 +380,12 @@ void CartesianState::normalize(const CartesianStateVariable& state_variable_type
     this->angular_velocity_.normalize();
   }
   if (state_variable_type == CartesianStateVariable::LINEAR_ACCELERATION
-      || state_variable_type == CartesianStateVariable::ACCELERATIONS
+      || state_variable_type == CartesianStateVariable::ACCELERATION
       || state_variable_type == CartesianStateVariable::ALL) {
     this->linear_acceleration_.normalize();
   }
   if (state_variable_type == CartesianStateVariable::ANGULAR_ACCELERATION
-      || state_variable_type == CartesianStateVariable::ACCELERATIONS
+      || state_variable_type == CartesianStateVariable::ACCELERATION
       || state_variable_type == CartesianStateVariable::ALL) {
     this->angular_acceleration_.normalize();
   }
diff --git a/source/state_representation/src/space/cartesian/CartesianTwist.cpp b/source/state_representation/src/space/cartesian/CartesianTwist.cpp
index 49ee70f13..f63745de6 100644
--- a/source/state_representation/src/space/cartesian/CartesianTwist.cpp
+++ b/source/state_representation/src/space/cartesian/CartesianTwist.cpp
@@ -39,6 +39,9 @@ CartesianTwist::CartesianTwist(const CartesianTwist& twist) :
 
 CartesianTwist::CartesianTwist(const CartesianPose& pose) : CartesianTwist(pose / std::chrono::seconds(1)) {}
 
+CartesianTwist::CartesianTwist(const CartesianAcceleration& acceleration) :
+    CartesianTwist(acceleration * std::chrono::seconds(1)) {}
+
 CartesianTwist CartesianTwist::Zero(const std::string& name, const std::string& reference) {
   return CartesianState::Identity(name, reference);
 }
@@ -119,6 +122,19 @@ CartesianPose CartesianTwist::operator*(const std::chrono::nanoseconds& dt) cons
   return displacement;
 }
 
+CartesianAcceleration CartesianTwist::operator/(const std::chrono::nanoseconds& dt) const {
+  if (this->is_empty()) {
+    throw EmptyStateException(this->get_name() + " state is empty");
+  }
+  CartesianAcceleration acceleration(this->get_name(), this->get_reference_frame());
+  // convert the period to a double with the second as reference
+  double period = dt.count();
+  period /= 1e9;
+  acceleration.set_linear_acceleration(this->get_linear_velocity() / period);
+  acceleration.set_angular_acceleration(this->get_angular_velocity() / period);
+  return acceleration;
+}
+
 void CartesianTwist::clamp(
     double max_linear, double max_angular, double linear_noise_ratio, double angular_noise_ratio
 ) {
diff --git a/source/state_representation/src/robot/JointAccelerations.cpp b/source/state_representation/src/space/joint/JointAccelerations.cpp
similarity index 99%
rename from source/state_representation/src/robot/JointAccelerations.cpp
rename to source/state_representation/src/space/joint/JointAccelerations.cpp
index 359637210..52b99ffe8 100644
--- a/source/state_representation/src/robot/JointAccelerations.cpp
+++ b/source/state_representation/src/space/joint/JointAccelerations.cpp
@@ -1,4 +1,4 @@
-#include "state_representation/robot/JointAccelerations.hpp"
+#include "state_representation/space/joint/JointAccelerations.hpp"
 #include "state_representation/exceptions/EmptyStateException.hpp"
 
 using namespace state_representation::exceptions;
diff --git a/source/state_representation/src/robot/JointPositions.cpp b/source/state_representation/src/space/joint/JointPositions.cpp
similarity index 99%
rename from source/state_representation/src/robot/JointPositions.cpp
rename to source/state_representation/src/space/joint/JointPositions.cpp
index d8da10bce..767222cf3 100644
--- a/source/state_representation/src/robot/JointPositions.cpp
+++ b/source/state_representation/src/space/joint/JointPositions.cpp
@@ -1,4 +1,4 @@
-#include "state_representation/robot/JointPositions.hpp"
+#include "state_representation/space/joint/JointPositions.hpp"
 
 #include "state_representation/exceptions/EmptyStateException.hpp"
 
diff --git a/source/state_representation/src/robot/JointState.cpp b/source/state_representation/src/space/joint/JointState.cpp
similarity index 95%
rename from source/state_representation/src/robot/JointState.cpp
rename to source/state_representation/src/space/joint/JointState.cpp
index ddea1a0b8..fbf14d639 100644
--- a/source/state_representation/src/robot/JointState.cpp
+++ b/source/state_representation/src/space/joint/JointState.cpp
@@ -1,4 +1,4 @@
-#include "state_representation/robot/JointState.hpp"
+#include "state_representation/space/joint/JointState.hpp"
 
 #include "state_representation/exceptions/EmptyStateException.hpp"
 #include "state_representation/exceptions/JointNotFoundException.hpp"
@@ -105,11 +105,13 @@ void JointState::set_positions(const std::vector<double>& positions) {
 }
 
 void JointState::set_position(double position, const std::string& joint_name) {
+  this->set_filled();
   this->positions_(this->get_joint_index(joint_name)) = position;
 }
 
 void JointState::set_position(double position, unsigned int joint_index) {
   assert_index_in_range(joint_index, this->get_size());
+  this->set_filled();
   this->positions_(joint_index) = position;
 }
 
@@ -135,11 +137,13 @@ void JointState::set_velocities(const std::vector<double>& velocities) {
 }
 
 void JointState::set_velocity(double velocity, const std::string& joint_name) {
+  this->set_filled();
   this->velocities_(this->get_joint_index(joint_name)) = velocity;
 }
 
 void JointState::set_velocity(double velocity, unsigned int joint_index) {
   assert_index_in_range(joint_index, this->get_size());
+  this->set_filled();
   this->velocities_(joint_index) = velocity;
 }
 
@@ -165,11 +169,13 @@ void JointState::set_accelerations(const std::vector<double>& accelerations) {
 }
 
 void JointState::set_acceleration(double acceleration, const std::string& joint_name) {
+  this->set_filled();
   this->accelerations_(this->get_joint_index(joint_name)) = acceleration;
 }
 
 void JointState::set_acceleration(double acceleration, unsigned int joint_index) {
   assert_index_in_range(joint_index, this->get_size());
+  this->set_filled();
   this->accelerations_(joint_index) = acceleration;
 }
 
@@ -195,15 +201,24 @@ void JointState::set_torques(const std::vector<double>& torques) {
 }
 
 void JointState::set_torque(double torque, const std::string& joint_name) {
+  this->set_filled();
   this->torques_(this->get_joint_index(joint_name)) = torque;
 }
 
 void JointState::set_torque(double torque, unsigned int joint_index) {
   assert_index_in_range(joint_index, this->get_size());
+  this->set_filled();
   this->torques_(joint_index) = torque;
 }
 
 JointState& JointState::operator+=(const JointState& state) {
+  // sanity check
+  if (this->is_empty()) {
+    throw EmptyStateException(this->get_name() + " state is empty");
+  }
+  if (state.is_empty()) {
+    throw EmptyStateException(state.get_name() + " state is empty");
+  }
   if (!this->is_compatible(state)) {
     throw IncompatibleStatesException(
         "The two joint states are incompatible, check name, joint names and order or size"
@@ -220,6 +235,13 @@ JointState JointState::operator+(const JointState& state) const {
 }
 
 JointState& JointState::operator-=(const JointState& state) {
+  // sanity check
+  if (this->is_empty()) {
+    throw EmptyStateException(this->get_name() + " state is empty");
+  }
+  if (state.is_empty()) {
+    throw EmptyStateException(state.get_name() + " state is empty");
+  }
   if (!this->is_compatible(state)) {
     throw IncompatibleStatesException(
         "The two joint states are incompatible, check name, joint names and order or size"
@@ -236,7 +258,9 @@ JointState JointState::operator-(const JointState& state) const {
 }
 
 JointState& JointState::operator*=(double lambda) {
-  if (this->is_empty()) { throw EmptyStateException(this->get_name() + " state is empty"); }
+  if (this->is_empty()) {
+    throw EmptyStateException(this->get_name() + " state is empty");
+  }
   this->set_all_state_variables(lambda * this->get_all_state_variables());
   return (*this);
 }
diff --git a/source/state_representation/src/robot/JointTorques.cpp b/source/state_representation/src/space/joint/JointTorques.cpp
similarity index 98%
rename from source/state_representation/src/robot/JointTorques.cpp
rename to source/state_representation/src/space/joint/JointTorques.cpp
index fe496e6c6..bf6f8a1b8 100644
--- a/source/state_representation/src/robot/JointTorques.cpp
+++ b/source/state_representation/src/space/joint/JointTorques.cpp
@@ -1,4 +1,4 @@
-#include "state_representation/robot/JointTorques.hpp"
+#include "state_representation/space/joint/JointTorques.hpp"
 
 using namespace state_representation::exceptions;
 
diff --git a/source/state_representation/src/robot/JointVelocities.cpp b/source/state_representation/src/space/joint/JointVelocities.cpp
similarity index 99%
rename from source/state_representation/src/robot/JointVelocities.cpp
rename to source/state_representation/src/space/joint/JointVelocities.cpp
index 62a8eb3ec..33fdd9759 100644
--- a/source/state_representation/src/robot/JointVelocities.cpp
+++ b/source/state_representation/src/space/joint/JointVelocities.cpp
@@ -1,4 +1,4 @@
-#include "state_representation/robot/JointVelocities.hpp"
+#include "state_representation/space/joint/JointVelocities.hpp"
 #include "state_representation/exceptions/EmptyStateException.hpp"
 
 using namespace state_representation::exceptions;
diff --git a/source/state_representation/test/tests/space/cartesian/test_cartesian_acceleration.cpp b/source/state_representation/test/tests/space/cartesian/test_cartesian_acceleration.cpp
new file mode 100644
index 000000000..667a166bf
--- /dev/null
+++ b/source/state_representation/test/tests/space/cartesian/test_cartesian_acceleration.cpp
@@ -0,0 +1,111 @@
+#include <gtest/gtest.h>
+
+#include "state_representation/space/cartesian/CartesianAcceleration.hpp"
+
+using namespace state_representation;
+
+static void expect_only_acceleration(CartesianAcceleration& acceleration) {
+  EXPECT_EQ(static_cast<CartesianState&>(acceleration).get_position().norm(), 0);
+  EXPECT_EQ(static_cast<CartesianState&>(acceleration).get_orientation().norm(), 1);
+  EXPECT_EQ(static_cast<CartesianState&>(acceleration).get_orientation().w(), 1);
+  EXPECT_EQ(static_cast<CartesianState&>(acceleration).get_twist().norm(), 0);
+  EXPECT_EQ(static_cast<CartesianState&>(acceleration).get_wrench().norm(), 0);
+}
+
+TEST(CartesianAccelerationTest, RandomAccelerationInitialization) {
+  CartesianAcceleration random = CartesianAcceleration::Random("test");
+  EXPECT_GT(random.get_acceleration().norm(), 0);
+  expect_only_acceleration(random);
+}
+
+TEST(CartesianAccelerationTest, CopyAcceleration) {
+  CartesianAcceleration acc1 = CartesianAcceleration::Random("test");
+  CartesianAcceleration acc2(acc1);
+  EXPECT_EQ(acc1.get_name(), acc2.get_name());
+  EXPECT_EQ(acc1.get_reference_frame(), acc2.get_reference_frame());
+  EXPECT_EQ(acc1.data(), acc2.data());
+  expect_only_acceleration(acc2);
+
+  CartesianAcceleration acc3 = acc1;
+  EXPECT_EQ(acc1.get_name(), acc3.get_name());
+  EXPECT_EQ(acc1.get_reference_frame(), acc3.get_reference_frame());
+  EXPECT_EQ(acc1.data(), acc3.data());
+  expect_only_acceleration(acc3);
+
+  // try to change non pose variables prior to the copy, those should be discarded
+  static_cast<CartesianState&>(acc1).set_pose(Eigen::VectorXd::Random(7));
+  static_cast<CartesianState&>(acc1).set_acceleration(Eigen::VectorXd::Random(6));
+  static_cast<CartesianState&>(acc1).set_wrench(Eigen::VectorXd::Random(6));
+  CartesianAcceleration acc4 = acc1;
+  EXPECT_EQ(acc1.data(), acc4.data());
+  expect_only_acceleration(acc4);
+
+  // copy a state, only the pose variables should be non 0
+  CartesianAcceleration acc5 = CartesianState::Random("test");
+  expect_only_acceleration(acc5);
+
+  CartesianAcceleration acc6;
+  EXPECT_TRUE(acc6.is_empty());
+  CartesianAcceleration acc7 = acc6;
+  EXPECT_TRUE(acc7.is_empty());
+}
+
+TEST(CartesianAccelerationTest, SetData) {
+  CartesianAcceleration ca1 = CartesianAcceleration::Zero("test");
+  CartesianAcceleration ca2 = CartesianAcceleration::Random("test");
+  ca1.set_data(ca2.data());
+  EXPECT_TRUE(ca2.data().isApprox(ca2.data()));
+
+  auto acc_vec = ca2.to_std_vector();
+  ca1.set_data(acc_vec);
+  for (std::size_t j = 0; j < acc_vec.size(); ++j) {
+    EXPECT_FLOAT_EQ(acc_vec.at(j), ca1.data()(j));
+  }
+  std::vector<double> acc{1, 2, 3, 4, 5};
+  EXPECT_THROW(ca1.set_data(acc), exceptions::IncompatibleSizeException);
+}
+
+TEST(CartesianAccelerationTest, CartesianAccelerationToStdVector) {
+  CartesianAcceleration ca = CartesianAcceleration::Random("test");
+  std::vector<double> vec_data = ca.to_std_vector();
+  EXPECT_EQ(vec_data.size(), 6);
+  for (size_t i = 0; i < vec_data.size(); ++i) {
+    EXPECT_EQ(ca.data()(i), vec_data[i]);
+  }
+}
+
+TEST(CartesianAccelerationTest, TestAccelerationClamping) {
+  CartesianAcceleration acc("test", Eigen::Vector3d(1, -2, 3), Eigen::Vector3d(1, 2, -3));
+  acc.clamp(1, 0.5);
+  EXPECT_LE(acc.get_linear_acceleration().norm(), 1);
+  EXPECT_LE(acc.get_angular_acceleration().norm(), 0.5);
+  acc *= 0.01;
+  for (int i = 0; i < 3; ++i) {
+    EXPECT_EQ(acc.clamped(1, 0.5, 0.1, 0.1).get_linear_acceleration()(i), 0);
+    EXPECT_EQ(acc.clamped(1, 0.5, 0.1, 0.1).get_angular_acceleration()(i), 0);
+  }
+}
+
+TEST(CartesianAccelerationTest, TestAccelerationNorms) {
+  std::vector<double> norms;
+  double tolerance = 1e-4;
+  CartesianState cs = CartesianState::Random("cs");
+  // independent variables first
+  norms = cs.norms(CartesianStateVariable::LINEAR_ACCELERATION);
+  EXPECT_TRUE(norms.size() == 1);
+  EXPECT_NEAR(norms[0], cs.get_linear_acceleration().norm(), tolerance);
+  norms = cs.norms(CartesianStateVariable::ANGULAR_ACCELERATION);
+  EXPECT_TRUE(norms.size() == 1);
+  EXPECT_NEAR(norms[0], cs.get_angular_acceleration().norm(), tolerance);
+  // then grouped by two
+  norms = cs.norms(CartesianStateVariable::ACCELERATION);
+  EXPECT_TRUE(norms.size() == 2);
+  EXPECT_NEAR(norms[0], cs.get_linear_acceleration().norm(), tolerance);
+  EXPECT_NEAR(norms[1], cs.get_angular_acceleration().norm(), tolerance);
+  // test with CartesianAcceleration default variable
+  CartesianAcceleration ct = CartesianTwist::Random("ct");
+  std::vector<double> twist_norms = ct.norms();
+  EXPECT_TRUE(twist_norms.size() == 2);
+  EXPECT_NEAR(twist_norms[0], ct.get_linear_acceleration().norm(), tolerance);
+  EXPECT_NEAR(twist_norms[1], ct.get_angular_acceleration().norm(), tolerance);
+}
diff --git a/source/state_representation/test/tests/space/cartesian/test_cartesian_pose.cpp b/source/state_representation/test/tests/space/cartesian/test_cartesian_pose.cpp
index f723475a0..80a1ea4dd 100644
--- a/source/state_representation/test/tests/space/cartesian/test_cartesian_pose.cpp
+++ b/source/state_representation/test/tests/space/cartesian/test_cartesian_pose.cpp
@@ -5,9 +5,8 @@
 using namespace state_representation;
 
 static void expect_only_pose(CartesianPose& pose) {
-  EXPECT_EQ(static_cast<CartesianState&>(pose).get_orientation().norm(), 1);
   EXPECT_EQ(static_cast<CartesianState&>(pose).get_twist().norm(), 0);
-  EXPECT_EQ(static_cast<CartesianState&>(pose).get_accelerations().norm(), 0);
+  EXPECT_EQ(static_cast<CartesianState&>(pose).get_acceleration().norm(), 0);
   EXPECT_EQ(static_cast<CartesianState&>(pose).get_wrench().norm(), 0);
 }
 
@@ -61,7 +60,7 @@ TEST(CartesianPoseTest, CopyPose) {
 
   // try to change non pose variables prior to the copy, those should be discarded
   static_cast<CartesianState&>(pose1).set_twist(Eigen::VectorXd::Random(6));
-  static_cast<CartesianState&>(pose1).set_accelerations(Eigen::VectorXd::Random(6));
+  static_cast<CartesianState&>(pose1).set_acceleration(Eigen::VectorXd::Random(6));
   static_cast<CartesianState&>(pose1).set_wrench(Eigen::VectorXd::Random(6));
   CartesianPose pose4 = pose1;
   EXPECT_EQ(pose1.data(), pose4.data());
diff --git a/source/state_representation/test/tests/space/cartesian/test_cartesian_state.cpp b/source/state_representation/test/tests/space/cartesian/test_cartesian_state.cpp
index 87f11d729..8e99fb564 100644
--- a/source/state_representation/test/tests/space/cartesian/test_cartesian_state.cpp
+++ b/source/state_representation/test/tests/space/cartesian/test_cartesian_state.cpp
@@ -64,7 +64,7 @@ TEST(CartesianStateTest, IdentityInitialization) {
   EXPECT_FLOAT_EQ(identity.get_orientation().norm(), 1);
   EXPECT_FLOAT_EQ(identity.get_orientation().w(), 1);
   EXPECT_FLOAT_EQ(identity.get_twist().norm(), 0);
-  EXPECT_FLOAT_EQ(identity.get_accelerations().norm(), 0);
+  EXPECT_FLOAT_EQ(identity.get_acceleration().norm(), 0);
   EXPECT_FLOAT_EQ(identity.get_wrench().norm(), 0);
 }
 
@@ -77,7 +77,7 @@ TEST(CartesianStateTest, RandomStateInitialization) {
   EXPECT_NE(random.get_orientation().y(), 0);
   EXPECT_NE(random.get_orientation().z(), 0);
   EXPECT_NE(random.get_twist().norm(), 0);
-  EXPECT_NE(random.get_accelerations().norm(), 0);
+  EXPECT_NE(random.get_acceleration().norm(), 0);
   EXPECT_NE(random.get_wrench().norm(), 0);
 }
 
@@ -163,8 +163,8 @@ TEST(CartesianStateTest, GetSetFields) {
   cs.set_angular_acceleration(angular_acceleration);
   EXPECT_TRUE(cs.get_angular_acceleration().isApprox(angular_acceleration));
   Eigen::VectorXd accerlerations = Eigen::VectorXd::Random(6);
-  cs.set_accelerations(accerlerations);
-  EXPECT_TRUE(cs.get_accelerations().isApprox(accerlerations));
+  cs.set_acceleration(accerlerations);
+  EXPECT_TRUE(cs.get_acceleration().isApprox(accerlerations));
 
   // wrench
   Eigen::Vector3d force = Eigen::Vector3d::Random();
@@ -209,7 +209,7 @@ TEST(CartesianStateTest, GetSetData) {
   CartesianState cs1 = CartesianState::Identity("test");
   CartesianState cs2 = CartesianState::Random("test");
   Eigen::VectorXd concatenated_state(25);
-  concatenated_state << cs1.get_pose(), cs1.get_twist(), cs1.get_accelerations(), cs1.get_wrench();
+  concatenated_state << cs1.get_pose(), cs1.get_twist(), cs1.get_acceleration(), cs1.get_wrench();
   EXPECT_TRUE(concatenated_state.isApprox(cs1.data()));
   for (std::size_t i = 0; i < 25; ++i) {
     EXPECT_FLOAT_EQ(concatenated_state.array()(i), cs1.array()(i));
@@ -264,9 +264,9 @@ TEST(CartesianStateTest, ClampVariable) {
       CartesianStateVariable::ANGULAR_ACCELERATION
   );
   test_clamping<6>(
-      state, [](const CartesianState& state) -> Eigen::MatrixXd { return state.get_accelerations(); },
-      [](CartesianState& state, const Eigen::MatrixXd& data) { state.set_accelerations(data); },
-      CartesianStateVariable::ACCELERATIONS
+      state, [](const CartesianState& state) -> Eigen::MatrixXd { return state.get_acceleration(); },
+      [](CartesianState& state, const Eigen::MatrixXd& data) { state.set_acceleration(data); },
+      CartesianStateVariable::ACCELERATION
   );
   test_clamping<3>(
       state, [](const CartesianState& state) -> const Eigen::Vector3d& { return state.get_force(); },
@@ -340,7 +340,7 @@ TEST(CartesianStateTest, Distance) {
   EXPECT_FLOAT_EQ(cs1.dist(cs3, CartesianStateVariable::ORIENTATION), orient_dist);
   EXPECT_FLOAT_EQ(cs1.dist(cs3, CartesianStateVariable::POSE), pos_dist + orient_dist);
   EXPECT_FLOAT_EQ(cs1.dist(cs3, CartesianStateVariable::TWIST), lin_vel_dist + ang_vel_dist);
-  EXPECT_FLOAT_EQ(cs1.dist(cs3, CartesianStateVariable::ACCELERATIONS), lin_acc_dist + ang_acc_dist);
+  EXPECT_FLOAT_EQ(cs1.dist(cs3, CartesianStateVariable::ACCELERATION), lin_acc_dist + ang_acc_dist);
   EXPECT_FLOAT_EQ(cs1.dist(cs3, CartesianStateVariable::WRENCH), force_dist + torque_dist);
   EXPECT_FLOAT_EQ(cs1.dist(cs3, CartesianStateVariable::ALL), total_dist);
   EXPECT_FLOAT_EQ(cs1.dist(cs3), cs3.dist(cs1));
@@ -364,7 +364,7 @@ TEST(CartesianStateTest, Addition) {
   orientation = cs1.get_orientation() * orientation;
   EXPECT_TRUE(csum.get_orientation().coeffs().isApprox(orientation.coeffs()));
   EXPECT_TRUE(csum.get_twist().isApprox(cs1.get_twist() + cs2.get_twist()));
-  EXPECT_TRUE(csum.get_accelerations().isApprox(cs1.get_accelerations() + cs2.get_accelerations()));
+  EXPECT_TRUE(csum.get_acceleration().isApprox(cs1.get_acceleration() + cs2.get_acceleration()));
   EXPECT_TRUE(csum.get_wrench().isApprox(cs1.get_wrench() + cs2.get_wrench()));
 
   cs1 += cs2;
@@ -385,7 +385,7 @@ TEST(CartesianStateTest, Subtraction) {
   orientation = cs1.get_orientation() * orientation.conjugate();
   EXPECT_TRUE(cdiff.get_orientation().coeffs().isApprox(orientation.coeffs()));
   EXPECT_TRUE(cdiff.get_twist().isApprox(cs1.get_twist() - cs2.get_twist()));
-  EXPECT_TRUE(cdiff.get_accelerations().isApprox(cs1.get_accelerations() - cs2.get_accelerations()));
+  EXPECT_TRUE(cdiff.get_acceleration().isApprox(cs1.get_acceleration() - cs2.get_acceleration()));
   EXPECT_TRUE(cdiff.get_wrench().isApprox(cs1.get_wrench() - cs2.get_wrench()));
 
   cs1 -= cs2;
@@ -400,7 +400,7 @@ TEST(CartesianStateTest, ScalarMultiplication) {
   Eigen::Quaterniond qscaled = math_tools::exp(math_tools::log(cs.get_orientation()), scalar / 2.);
   EXPECT_TRUE(cscaled.get_orientation().coeffs().isApprox(qscaled.coeffs()));
   EXPECT_TRUE(cscaled.get_twist().isApprox(scalar * cs.get_twist()));
-  EXPECT_TRUE(cscaled.get_accelerations().isApprox(scalar * cs.get_accelerations()));
+  EXPECT_TRUE(cscaled.get_acceleration().isApprox(scalar * cs.get_acceleration()));
   EXPECT_TRUE(cscaled.get_wrench().isApprox(scalar * cs.get_wrench()));
   EXPECT_TRUE((cs * scalar).data().isApprox(cscaled.data()));
   cs *= scalar;
@@ -418,7 +418,7 @@ TEST(CartesianStateTest, ScalarDivision) {
   Eigen::Quaterniond qscaled = math_tools::exp(math_tools::log(cs.get_orientation()), 1.0 / (2. * scalar));
   EXPECT_TRUE(cscaled.get_orientation().coeffs().isApprox(qscaled.coeffs()));
   EXPECT_TRUE(cscaled.get_twist().isApprox(cs.get_twist() / scalar));
-  EXPECT_TRUE(cscaled.get_accelerations().isApprox(cs.get_accelerations() / scalar));
+  EXPECT_TRUE(cscaled.get_acceleration().isApprox(cs.get_acceleration() / scalar));
   EXPECT_TRUE(cscaled.get_wrench().isApprox(cs.get_wrench() / scalar));
   cs /= scalar;
   EXPECT_TRUE(cscaled.data().isApprox(cs.data()));
diff --git a/source/state_representation/test/tests/space/cartesian/test_cartesian_twist.cpp b/source/state_representation/test/tests/space/cartesian/test_cartesian_twist.cpp
index 7cafe1f8c..b630bc2f2 100644
--- a/source/state_representation/test/tests/space/cartesian/test_cartesian_twist.cpp
+++ b/source/state_representation/test/tests/space/cartesian/test_cartesian_twist.cpp
@@ -8,7 +8,7 @@ static void expect_only_twist(CartesianTwist& twist) {
   EXPECT_EQ(static_cast<CartesianState&>(twist).get_position().norm(), 0);
   EXPECT_EQ(static_cast<CartesianState&>(twist).get_orientation().norm(), 1);
   EXPECT_EQ(static_cast<CartesianState&>(twist).get_orientation().w(), 1);
-  EXPECT_EQ(static_cast<CartesianState&>(twist).get_accelerations().norm(), 0);
+  EXPECT_EQ(static_cast<CartesianState&>(twist).get_acceleration().norm(), 0);
   EXPECT_EQ(static_cast<CartesianState&>(twist).get_wrench().norm(), 0);
 }
 
@@ -34,7 +34,7 @@ TEST(CartesianTwistTest, CopyTwist) {
 
   // try to change non pose variables prior to the copy, those should be discarded
   static_cast<CartesianState&>(twist1).set_pose(Eigen::VectorXd::Random(7));
-  static_cast<CartesianState&>(twist1).set_accelerations(Eigen::VectorXd::Random(6));
+  static_cast<CartesianState&>(twist1).set_acceleration(Eigen::VectorXd::Random(6));
   static_cast<CartesianState&>(twist1).set_wrench(Eigen::VectorXd::Random(6));
   CartesianTwist twist4 = twist1;
   EXPECT_EQ(twist1.data(), twist4.data());
@@ -109,3 +109,24 @@ TEST(CartesianTwistTest, TestTwistNorms) {
   EXPECT_NEAR(twist_norms[0], ct.get_linear_velocity().norm(), tolerance);
   EXPECT_NEAR(twist_norms[1], ct.get_angular_velocity().norm(), tolerance);
 }
+
+TEST(CartesianTwistTest, TestVelocityToAcceleration) {
+  auto twist = CartesianTwist::Random("test");
+  std::chrono::seconds dt1(1);
+  std::chrono::milliseconds dt2(100);
+  auto res1 = twist / dt1;
+  EXPECT_EQ(res1.get_linear_acceleration(), twist.get_linear_velocity());
+  EXPECT_EQ(res1.get_angular_acceleration(), twist.get_angular_velocity());
+  auto res2 = twist / dt2;
+  EXPECT_TRUE(res2.get_linear_acceleration().isApprox(10 * twist.get_linear_velocity()));
+  EXPECT_TRUE(res2.get_angular_acceleration().isApprox(10 * twist.get_angular_velocity()));
+}
+
+TEST(CartesianTwistTest, TestImplicitConversion) {
+  CartesianAcceleration acc("test");
+  acc.set_linear_acceleration(Eigen::Vector3d(0.1, 0.1, 0.1));
+  acc.set_linear_acceleration(Eigen::Vector3d(M_PI, 0, 0));
+  CartesianTwist twist(acc);
+  EXPECT_EQ(twist.get_linear_velocity(), acc.get_linear_acceleration());
+  EXPECT_EQ(twist.get_angular_velocity(), acc.get_angular_acceleration());
+}
diff --git a/source/state_representation/test/tests/space/cartesian/test_cartesian_wrench.cpp b/source/state_representation/test/tests/space/cartesian/test_cartesian_wrench.cpp
index 85d31b944..6a002dc1a 100644
--- a/source/state_representation/test/tests/space/cartesian/test_cartesian_wrench.cpp
+++ b/source/state_representation/test/tests/space/cartesian/test_cartesian_wrench.cpp
@@ -9,7 +9,7 @@ static void expect_only_wrench(CartesianWrench& wrench) {
   EXPECT_EQ(static_cast<CartesianState&>(wrench).get_orientation().norm(), 1);
   EXPECT_EQ(static_cast<CartesianState&>(wrench).get_orientation().w(), 1);
   EXPECT_EQ(static_cast<CartesianState&>(wrench).get_twist().norm(), 0);
-  EXPECT_EQ(static_cast<CartesianState&>(wrench).get_accelerations().norm(), 0);
+  EXPECT_EQ(static_cast<CartesianState&>(wrench).get_acceleration().norm(), 0);
 }
 
 TEST(CartesianWrenchTest, RandomWrenchInitialization) {
@@ -35,7 +35,7 @@ TEST(CartesianWrenchTest, CopyWrench) {
   // try to change non pose variables prior to the copy, those should be discarded
   static_cast<CartesianState&>(wrench1).set_pose(Eigen::VectorXd::Random(7));
   static_cast<CartesianState&>(wrench1).set_twist(Eigen::VectorXd::Random(6));
-  static_cast<CartesianState&>(wrench1).set_accelerations(Eigen::VectorXd::Random(6));
+  static_cast<CartesianState&>(wrench1).set_acceleration(Eigen::VectorXd::Random(6));
   CartesianWrench wrench4 = wrench1;
   EXPECT_EQ(wrench1.data(), wrench4.data());
   expect_only_wrench(wrench4);
diff --git a/source/state_representation/test/tests/robot/test_joint_accelerations.cpp b/source/state_representation/test/tests/space/joint/test_joint_accelerations.cpp
similarity index 99%
rename from source/state_representation/test/tests/robot/test_joint_accelerations.cpp
rename to source/state_representation/test/tests/space/joint/test_joint_accelerations.cpp
index b0d18b87d..272c28638 100644
--- a/source/state_representation/test/tests/robot/test_joint_accelerations.cpp
+++ b/source/state_representation/test/tests/space/joint/test_joint_accelerations.cpp
@@ -1,5 +1,5 @@
 #include <gtest/gtest.h>
-#include "state_representation/robot/JointAccelerations.hpp"
+#include "state_representation/space/joint/JointAccelerations.hpp"
 #include "state_representation/exceptions/EmptyStateException.hpp"
 
 using namespace state_representation;
diff --git a/source/state_representation/test/tests/robot/test_joint_positions.cpp b/source/state_representation/test/tests/space/joint/test_joint_positions.cpp
similarity index 99%
rename from source/state_representation/test/tests/robot/test_joint_positions.cpp
rename to source/state_representation/test/tests/space/joint/test_joint_positions.cpp
index 41bbfeb98..b5bed40b2 100644
--- a/source/state_representation/test/tests/robot/test_joint_positions.cpp
+++ b/source/state_representation/test/tests/space/joint/test_joint_positions.cpp
@@ -1,5 +1,5 @@
 #include <gtest/gtest.h>
-#include "state_representation/robot/JointPositions.hpp"
+#include "state_representation/space/joint/JointPositions.hpp"
 #include "state_representation/exceptions/EmptyStateException.hpp"
 
 using namespace state_representation;
diff --git a/source/state_representation/test/tests/robot/test_joint_state.cpp b/source/state_representation/test/tests/space/joint/test_joint_state.cpp
similarity index 99%
rename from source/state_representation/test/tests/robot/test_joint_state.cpp
rename to source/state_representation/test/tests/space/joint/test_joint_state.cpp
index 155f64d2d..3ca46a4b3 100644
--- a/source/state_representation/test/tests/robot/test_joint_state.cpp
+++ b/source/state_representation/test/tests/space/joint/test_joint_state.cpp
@@ -1,6 +1,6 @@
 #include <fstream>
 #include <gtest/gtest.h>
-#include "state_representation/robot/JointState.hpp"
+#include "state_representation/space/joint/JointState.hpp"
 #include "state_representation/exceptions/IncompatibleSizeException.hpp"
 #include "state_representation/exceptions/IncompatibleStatesException.hpp"
 #include "state_representation/exceptions/JointNotFoundException.hpp"
diff --git a/source/state_representation/test/tests/robot/test_joint_torques.cpp b/source/state_representation/test/tests/space/joint/test_joint_torques.cpp
similarity index 98%
rename from source/state_representation/test/tests/robot/test_joint_torques.cpp
rename to source/state_representation/test/tests/space/joint/test_joint_torques.cpp
index dbc6c113c..9f60846e7 100644
--- a/source/state_representation/test/tests/robot/test_joint_torques.cpp
+++ b/source/state_representation/test/tests/space/joint/test_joint_torques.cpp
@@ -1,5 +1,5 @@
 #include <gtest/gtest.h>
-#include "state_representation/robot/JointTorques.hpp"
+#include "state_representation/space/joint/JointTorques.hpp"
 #include "state_representation/exceptions/EmptyStateException.hpp"
 
 using namespace state_representation;
diff --git a/source/state_representation/test/tests/robot/test_joint_velocities.cpp b/source/state_representation/test/tests/space/joint/test_joint_velocities.cpp
similarity index 99%
rename from source/state_representation/test/tests/robot/test_joint_velocities.cpp
rename to source/state_representation/test/tests/space/joint/test_joint_velocities.cpp
index decd727df..14d640e96 100644
--- a/source/state_representation/test/tests/robot/test_joint_velocities.cpp
+++ b/source/state_representation/test/tests/space/joint/test_joint_velocities.cpp
@@ -1,5 +1,5 @@
 #include <gtest/gtest.h>
-#include "state_representation/robot/JointVelocities.hpp"
+#include "state_representation/space/joint/JointVelocities.hpp"
 #include "state_representation/exceptions/EmptyStateException.hpp"
 
 using namespace state_representation;
diff --git a/source/state_representation/test/tests/robot/test_jacobian.cpp b/source/state_representation/test/tests/space/test_jacobian.cpp
similarity index 99%
rename from source/state_representation/test/tests/robot/test_jacobian.cpp
rename to source/state_representation/test/tests/space/test_jacobian.cpp
index f0b7096ba..a9926446b 100644
--- a/source/state_representation/test/tests/robot/test_jacobian.cpp
+++ b/source/state_representation/test/tests/space/test_jacobian.cpp
@@ -1,4 +1,4 @@
-#include "state_representation/robot/Jacobian.hpp"
+#include "state_representation/space/Jacobian.hpp"
 #include "state_representation/exceptions/IncompatibleStatesException.hpp"
 #include <gtest/gtest.h>
 
diff --git a/source/state_representation/test/tests/test_ellipsoid.cpp b/source/state_representation/test/tests/test_ellipsoid.cpp
index 5deaf4a4f..9c373f1a6 100644
--- a/source/state_representation/test/tests/test_ellipsoid.cpp
+++ b/source/state_representation/test/tests/test_ellipsoid.cpp
@@ -3,6 +3,17 @@
 
 using namespace state_representation;
 
+TEST(EllipsoidTest, EmptyConstructor) {
+  Ellipsoid ellipse;
+  EXPECT_TRUE(ellipse.get_name().empty());
+  EXPECT_TRUE(ellipse.get_center_state().is_empty());
+  EXPECT_THROW(ellipse.set_data(Eigen::Vector3d::Zero()), exceptions::EmptyStateException);
+
+  ellipse.set_center_state(CartesianState::Identity("A"));
+  EXPECT_EQ(ellipse.get_name(), "A");
+  EXPECT_FALSE(ellipse.get_center_state().is_empty());
+}
+
 TEST(EllipsoidTest, Sampling) {
   Ellipsoid ellipse("test");
 
@@ -15,7 +26,7 @@ TEST(EllipsoidTest, Sampling) {
     EXPECT_TRUE(abs(d) < 1e-3);
   }
 
-  // change the axis lenghts
+  // change the axis lengths
   ellipse.set_axis_lengths({3., 0.5, 0.});
   points = ellipse.sample_from_parameterization(100);
   for (const auto& p : points) {
diff --git a/source/state_representation/test/tests/test_parameter.cpp b/source/state_representation/test/tests/test_parameter.cpp
index 0a45629ec..fd907e612 100644
--- a/source/state_representation/test/tests/test_parameter.cpp
+++ b/source/state_representation/test/tests/test_parameter.cpp
@@ -12,6 +12,12 @@ TEST(ParameterTest, Conversion) {
   EXPECT_EQ(int_param.get_type(), StateType::PARAMETER_INT);
   int_param.set_value(2);
   EXPECT_EQ(int_param.get_value(), 2);
+  EXPECT_EQ(typeid(int_param.get_value<double>()).name(), typeid(2.0).name());
+  Parameter<double> double_param("double");
+  EXPECT_NO_THROW(double_param = int_param);
+  EXPECT_EQ(double_param.get_type(), StateType::PARAMETER_DOUBLE);
+  EXPECT_EQ(double_param.get_name(), int_param.get_name());
+  EXPECT_EQ(double_param.get_value(), 2.0);
 
   std::vector<int> values{1, 2, 3};
   Parameter<std::vector<int>> int_array_param("test", values);
@@ -23,11 +29,11 @@ TEST(ParameterTest, Conversion) {
 
   Parameter<CartesianPose> test1("test", CartesianPose::Random("test"));
   Parameter<CartesianState> test2(test1);
-  EXPECT_EQ(test2.get_type(), StateType::PARAMETER_CARTESIANPOSE);
+  EXPECT_EQ(test2.get_type(), StateType::PARAMETER_CARTESIANSTATE);
 
   std::shared_ptr<Parameter<CartesianState>> test3 =
       std::make_shared<Parameter<CartesianState>>(Parameter<CartesianPose>("test", CartesianPose::Random("test")));
-  EXPECT_EQ(test3->get_type(), StateType::PARAMETER_CARTESIANPOSE);
+  EXPECT_EQ(test3->get_type(), StateType::PARAMETER_CARTESIANSTATE);
 }
 
 TEST(ParameterTest, Event) {
@@ -67,3 +73,14 @@ TEST(ParameterTest, Event) {
   ptr_e->set_value(true);
   EXPECT_TRUE(ptr_e->get_value());
 }
+
+TEST(ParameterTest, MakeShared) {
+  auto pose = CartesianPose::Random("A", "B");
+  auto param = make_shared_parameter("name", pose);
+  EXPECT_EQ(param->get_name(), "name");
+  EXPECT_EQ(param->get_type(), StateType::PARAMETER_CARTESIANPOSE);
+  EXPECT_EQ(param->is_empty(), false);
+  EXPECT_EQ(param->get_value().get_name(), "A");
+  EXPECT_EQ(param->get_value().get_reference_frame(), "B");
+  EXPECT_TRUE(param->get_value().data().isApprox(pose.data()));
+}
diff --git a/source/state_representation/test/tests/test_trajectory.cpp b/source/state_representation/test/tests/test_trajectory.cpp
index 91c54d9d0..e35b6639b 100644
--- a/source/state_representation/test/tests/test_trajectory.cpp
+++ b/source/state_representation/test/tests/test_trajectory.cpp
@@ -3,7 +3,7 @@
 #include <unistd.h>
 #include "state_representation/trajectories/Trajectory.hpp"
 #include "state_representation/space/cartesian/CartesianState.hpp"
-#include "state_representation/robot/JointState.hpp"
+#include "state_representation/space/joint/JointState.hpp"
 
 TEST(TrajectoryTest, CreateTrajectory) {
   state_representation::Trajectory<state_representation::JointState> trajectory;