diff --git a/external-control/.gitignore b/external-control/.gitignore
new file mode 100644
index 00000000000..dfbfeb0c6bb
--- /dev/null
+++ b/external-control/.gitignore
@@ -0,0 +1 @@
+cppbuild/
\ No newline at end of file
diff --git a/external-control/CMakeLists.txt b/external-control/CMakeLists.txt
new file mode 100644
index 00000000000..dd0cbdb9c0a
--- /dev/null
+++ b/external-control/CMakeLists.txt
@@ -0,0 +1,23 @@
+cmake_minimum_required(VERSION 3.5)
+set(CMAKE_CXX_STANDARD 17)
+
+project(external-control CXX)
+
+find_package(Eigen3 3.3 REQUIRED NO_MODULE)
+
+file(GLOB_RECURSE SOURCES
+    "src/main/cpp/*.cpp"
+    "src/main/cpp/*.hpp"
+)
+
+add_library(external-control SHARED ${SOURCES})
+target_include_directories(external-control PUBLIC
+        src/main/cpp)
+
+install(TARGETS external-control
+    RUNTIME DESTINATION bin
+    LIBRARY DESTINATION lib
+    ARCHIVE DESTINATION lib)
+install(DIRECTORY src/main/cpp/ DESTINATION ${CMAKE_INSTALL_PREFIX}/include FILES_MATCHING PATTERN "*.hpp")
+
+target_link_libraries(external-control Eigen3::Eigen zmq)
diff --git a/external-control/README.md b/external-control/README.md
new file mode 100644
index 00000000000..e53ec67bf29
--- /dev/null
+++ b/external-control/README.md
@@ -0,0 +1,81 @@
+# IHMC-External Control
+
+**NOTE: We currently ONLY support Ubuntu 22.04. Other versions of Ubuntu, and Windows / macOS operating systems are not supported and are almost certain to break.**
+
+After reading this and installing, be sure to read [ARCHITECTURE.md](ARCHITECTURE.md) and [CONTRIBUTING.md](CONTRIBUTING.md) for more information on how the code in this repository is structured, and how to contribute effectively.
+
+## Contents
+
+* [Overview](#overview)
+* [Dependencies](#dependencies)
+* [Install](#install)
+* [Development](#development)
+* [Troubleshooting](#troubleshooting)
+    * [Failed Docker container creation](#failed-docker-container-creation)
+    * [Annoying permissions issues in generated-java](#annoying-permissions-issues-in-generated-java)
+
+## Overview
+
+* This project contains a thin C++ wrapper to allow setting up calls to a custom controller on the C++ side, and then interfacing with it from Java
+* We create JNI bindings for the C++ wrapper library
+
+## Dependencies
+
+* Docker (check with `docker --version`). You'll want to run `docker` commands without having to prefix `sudo` all the
+  time, follow the instructions [here](https://askubuntu.com/questions/477551/how-can-i-use-docker-without-sudo).
+
+## Install
+
+Starting from a typical IHMC setup consisting of a `repository-group` workspace
+with `ihmc-open-robotics-software`, perform the following steps:
+
+1. Clone this repository into `repository-group`.
+
+(NOTE: you may need to `chmod +x <script>` to run the following scripts)
+
+2. From the command line or your IDE terminal, navigate to `external-control` and run the
+   script `./createDockerImage.sh` to create the docker image used for isolated building of the dependencies.
+3. From the command line or your IDE terminal, navigate to `external-control` and run the
+   script `./generateJavaBindingsCI.sh` (if building for development) or `./generateJavaBindingsRelease.sh` (if building
+   for robot deployment, this is in-development). This builds the C++ wrapper in the docker container, and
+   is subsequently used to generate the Java bindings. The native Java bindings are generated inside the docker
+   container, and then everything is copied (including the required shared libraries) from inside the docker container
+   to the `src/main/resources` directory of this project to be used by IHMC's native library loader. *NOTE: this step
+   may take a short while*.
+
+## Development
+
+* If using JetBrains IDEs (IntelliJ for Java, CLion for C++), they will not play nice if they are opened in the same
+  directory. To combat this, open IntelliJ in the overall `repository-group` workspace, and CLion in
+  the `ihmc-open-robotics-software` directory. This way, the `.idea` directories are separate and won't conflict with each
+  other.
+* When developing the wrapper in CLion, set up a Docker CMake toolchain to build the project, the image must be set to
+  the image created when `createDockerImage.sh` was
+  run: https://www.jetbrains.com/help/clion/clion-toolchains-in-docker.html
+* When working in C++, please use [this style guide](IHMC-MPC-CodeStyle.xml). You can import the XML into CLion so that
+  you can auto-format your code.
+
+## Troubleshooting
+
+### Failed Docker container creation
+
+If running `createDockerImage.sh` fails for any reason, it is highly likely that docker will cache some image
+layers that are incorrect and will cause future attempts at image creation to fail.
+
+Before running `createDockerImage.sh` again:
+
+1. run `docker image remove ihmc-external-wrapper:0.1` (or whatever version of the wrapper you're using)
+2. run `docker container prune` and `docker image prune`
+3. verify that `docker image list -a` is empty, this means all the cached images have been deleted
+4. run `createDockerImage.sh` again
+
+
+### Annoying permissions issues in `generated-java`
+
+Due to the way our shell scripts build the wrapper and generate the bindings, it is quite likely that the `src/main/generated-java`
+and `src/main/resources` directories will be owned by `root`. This is annoying because it means that you can't delete or rollback
+the changes in git. To fix this, run this from the project root:
+
+```bash
+sudo chown -R $USER:$USER ihmc-mpc-core ihmc-mpc-nadia
+```
diff --git a/external-control/build.gradle.kts b/external-control/build.gradle.kts
new file mode 100644
index 00000000000..8e7ad72d7d5
--- /dev/null
+++ b/external-control/build.gradle.kts
@@ -0,0 +1,15 @@
+plugins {
+   id("us.ihmc.ihmc-build")
+   id("us.ihmc.log-tools-plugin") version "0.6.3"
+}
+
+ihmc {
+   loadProductProperties("../product.properties")
+   
+   configureDependencyResolution()
+   configurePublications()
+}
+
+mainDependencies {
+   api("us.ihmc:ihmc-avatar-interfaces:source")
+}
diff --git a/external-control/cppbuild.bash b/external-control/cppbuild.bash
new file mode 100755
index 00000000000..b1a69cafdab
--- /dev/null
+++ b/external-control/cppbuild.bash
@@ -0,0 +1,51 @@
+#!/bin/bash
+rm -rf cppbuild
+mkdir cppbuild
+cd cppbuild
+
+#### Installing Eigen headers ####
+EIGEN_VERSION=3.4.0
+curl https://gitlab.com/libeigen/eigen/-/archive/3.4.0/eigen-$EIGEN_VERSION.zip -O
+unzip -n eigen-$EIGEN_VERSION.zip
+cd eigen-$EIGEN_VERSION
+mkdir build
+cd build
+cmake -DCMAKE_INSTALL_PREFIX=../../ ..
+cmake --install .
+cd ../../
+
+# Build external-control
+cmake -DCMAKE_INSTALL_PREFIX=. ..
+cmake --build . --config Release --target install
+
+### Java generation ####
+cp -r ../src/main/java/* .
+
+# Clone and checkout JavaCPP from specific tag; should update periodically
+JAVACPP_VERSION=1.5.10
+# Download and unzip javacpp into the java source directory
+# Check if the javacpp.jar already exists -- we can skip the fetching step if it does
+if [ ! -f javacpp.jar ]; then
+  curl -L https://github.com/bytedeco/javacpp/releases/download/$JAVACPP_VERSION/javacpp-platform-$JAVACPP_VERSION-bin.zip -o javacpp-platform-$JAVACPP_VERSION-bin.zip
+  unzip -j javacpp-platform-$JAVACPP_VERSION-bin.zip
+fi
+
+# This will generate the JNI shared library and place it in the classpath resources dir
+java -jar javacpp.jar us/ihmc/externalControl/ExternalControlInfoMapper.java
+java -jar javacpp.jar us/ihmc/externalControl/global/ExternalControlWrapper.java -d javainstall
+
+# Copy newly generated Java into global
+cp us/ihmc/externalControl/*.java ../src/main/java/us/ihmc/externalControl
+cp us/ihmc/externalControl/global/*.java ../src/main/java/us/ihmc/externalControl/global
+
+
+
+##### Copy shared libs to resources ####
+# Linux
+mkdir -p ../src/main/resources/externalControl/native/linux-x86_64
+if [ -f "javainstall/libjniExternalControlWrapper.so" ]; then
+  cp javainstall/libjniExternalControlWrapper.so ../src/main/resources/externalControl/native/linux-x86_64
+fi
+if [ -f "lib/libexternal-control.so" ]; then
+  cp lib/libexternal-control.so ../src/main/resources/externalControl/native/linux-x86_64
+fi
diff --git a/external-control/gradle.properties b/external-control/gradle.properties
new file mode 100644
index 00000000000..665c13cea63
--- /dev/null
+++ b/external-control/gradle.properties
@@ -0,0 +1,6 @@
+kebabCasedName = external-control
+pascalCasedName = ExternalControl
+extraSourceSets = ["test"]
+publishUrl = local
+compositeSearchHeight = 2
+excludeFromCompositeBuild = false
\ No newline at end of file
diff --git a/external-control/settings.gradle.kts b/external-control/settings.gradle.kts
new file mode 100644
index 00000000000..1bb33db1262
--- /dev/null
+++ b/external-control/settings.gradle.kts
@@ -0,0 +1,23 @@
+pluginManagement {
+   plugins {
+      id("us.ihmc.ihmc-build") version "1.1.0"
+   }
+}
+
+buildscript {
+   repositories {
+      maven { url = uri("https://plugins.gradle.org/m2/") }
+      mavenLocal()
+   }
+   dependencies {
+      classpath("us.ihmc:ihmc-build:1.1.0")
+   }
+}
+
+/**
+ * Browse source at https://github.com/ihmcrobotics/ihmc-build
+ */
+val ihmcSettingsConfigurator = us.ihmc.build.IHMCSettingsConfigurator(settings, logger, extra)
+ihmcSettingsConfigurator.checkRequiredPropertiesAreSet()
+ihmcSettingsConfigurator.configureExtraSourceSets()
+ihmcSettingsConfigurator.findAndIncludeCompositeBuilds()
diff --git a/external-control/src/main/cpp/controllers/constant-position-controller.cpp b/external-control/src/main/cpp/controllers/constant-position-controller.cpp
new file mode 100644
index 00000000000..14a8ebf0ebd
--- /dev/null
+++ b/external-control/src/main/cpp/controllers/constant-position-controller.cpp
@@ -0,0 +1,76 @@
+#include "constant-position-controller.hpp"
+
+#include <iostream>
+
+namespace ihmc
+{
+    ConstantPositionController::ConstantPositionController(const double default_stiffness, const double default_damping, const int number_of_joints)
+    {
+        number_of_joints_ = number_of_joints;
+        desired_joint_velocities_.resize(number_of_joints_);
+        desired_joint_torques_.resize(number_of_joints_);
+        desired_joint_stiffnesses_.resize(number_of_joints_);
+        desired_joint_damping_.resize(number_of_joints_);
+
+        desired_joint_velocities_.setZero();
+        desired_joint_torques_.setZero();
+        desired_joint_stiffnesses_.fill(default_stiffness);
+        desired_joint_damping_.fill(default_damping);
+    }
+
+    void ConstantPositionController::resize(const double default_stiffness, const double default_damping, const int number_of_joints)
+    {
+        std::cout << "resizing constant position controller" << std::endl;
+        number_of_joints_ = number_of_joints;
+        desired_joint_velocities_.resize(number_of_joints_);
+        desired_joint_torques_.resize(number_of_joints_);
+        desired_joint_stiffnesses_.resize(number_of_joints_);
+        desired_joint_damping_.resize(number_of_joints_);
+
+        desired_joint_velocities_.setZero();
+        desired_joint_torques_.setZero();
+        desired_joint_stiffnesses_.fill(default_stiffness);
+        desired_joint_damping_.fill(default_damping);
+    }
+
+    bool ConstantPositionController::setHomeJointConfiguration(const double* configuration_data, int configuration_rows)
+    {
+        if (configuration_rows != number_of_joints_)
+        {
+            std::cout << "The size of the home configuration is incorrect" << std::endl;
+            return false;
+        }
+
+        const VectorViewReadOnly configuration(configuration_data, configuration_rows);
+        home_configuration_ = configuration;
+
+        std::cout << "home configuration is set" << std::endl;
+
+        return true;
+    }
+
+    Eigen::VectorXd ConstantPositionController::get_desired_joint_positions() const
+    {
+        return home_configuration_;
+    }
+
+    Eigen::VectorXd ConstantPositionController::get_desired_joint_velocities() const
+    {
+        return desired_joint_velocities_;
+    }
+
+    Eigen::VectorXd ConstantPositionController::get_desired_joint_torques() const
+    {
+        return desired_joint_torques_;
+    }
+
+    Eigen::VectorXd ConstantPositionController::get_desired_joint_stiffnesses() const
+    {
+        return desired_joint_stiffnesses_;
+    }
+
+    Eigen::VectorXd ConstantPositionController::get_desired_joint_damping() const
+    {
+        return desired_joint_damping_;
+    }
+}
\ No newline at end of file
diff --git a/external-control/src/main/cpp/controllers/constant-position-controller.hpp b/external-control/src/main/cpp/controllers/constant-position-controller.hpp
new file mode 100644
index 00000000000..698ee188e18
--- /dev/null
+++ b/external-control/src/main/cpp/controllers/constant-position-controller.hpp
@@ -0,0 +1,40 @@
+#pragma once
+
+#include "types.hpp"
+
+namespace ihmc
+{
+    class ConstantPositionController
+    {
+    public:
+
+        ConstantPositionController() = default;
+
+        explicit ConstantPositionController(const double default_stiffness, const double default_damping, const int number_of_joints);
+
+        virtual ~ConstantPositionController() = default;
+
+        void resize(const double default_stiffness, const double default_damping, const int number_of_joints);
+
+        bool setHomeJointConfiguration(const double* configuration_data, int rows);
+
+        Eigen::VectorXd get_desired_joint_positions() const;
+
+        Eigen::VectorXd get_desired_joint_velocities() const;
+
+        Eigen::VectorXd get_desired_joint_torques() const;
+
+        Eigen::VectorXd get_desired_joint_stiffnesses() const;
+
+        Eigen::VectorXd get_desired_joint_damping() const;
+
+    private:
+        int number_of_joints_;
+
+        Eigen::VectorXd home_configuration_;
+        Eigen::VectorXd desired_joint_velocities_;
+        Eigen::VectorXd desired_joint_torques_;
+        Eigen::VectorXd desired_joint_stiffnesses_;
+        Eigen::VectorXd desired_joint_damping_;
+    };
+}
\ No newline at end of file
diff --git a/external-control/src/main/cpp/controllers/zmq-controller.cpp b/external-control/src/main/cpp/controllers/zmq-controller.cpp
new file mode 100644
index 00000000000..5bc4452ee3f
--- /dev/null
+++ b/external-control/src/main/cpp/controllers/zmq-controller.cpp
@@ -0,0 +1,109 @@
+#include "zmq-controller.hpp"
+
+#include <iostream>
+
+namespace ihmc
+{
+    ZMQController::ZMQController(const double default_stiffness, const double default_damping, const int number_of_joints)
+    {
+        number_of_joints_ = number_of_joints;
+        desired_joint_velocities_.resize(number_of_joints_);
+        desired_joint_torques_.resize(number_of_joints_);
+        desired_joint_stiffnesses_.resize(number_of_joints_);
+        desired_joint_damping_.resize(number_of_joints_);
+
+        desired_joint_velocities_.setZero();
+        desired_joint_torques_.setZero();
+        desired_joint_stiffnesses_.fill(default_stiffness);
+        desired_joint_damping_.fill(default_damping);
+
+        // Init ZMQ
+        context = zmq::context_t(1);
+        socket_cpp = zmq::socket_t(context, zmq::socket_type::req);
+
+        socket_cpp.bind("tcp://*:5555");
+    }
+
+    void ZMQController::resize(const double default_stiffness, const double default_damping, const int number_of_joints)
+    {
+        std::cout << "resizing constant position controller" << std::endl;
+        number_of_joints_ = number_of_joints;
+        desired_joint_velocities_.resize(number_of_joints_);
+        desired_joint_torques_.resize(number_of_joints_);
+        desired_joint_stiffnesses_.resize(number_of_joints_);
+        desired_joint_damping_.resize(number_of_joints_);
+
+        desired_joint_velocities_.setZero();
+        desired_joint_torques_.setZero();
+        desired_joint_stiffnesses_.fill(default_stiffness);
+        desired_joint_damping_.fill(default_damping);
+    }
+
+    bool ZMQController::setHomeJointConfiguration(const double* configuration_data, int configuration_rows)
+    {
+        if (configuration_rows != number_of_joints_)
+        {
+            std::cout << "The size of the home configuration is incorrect" << std::endl;
+            return false;
+        }
+
+        const VectorViewReadOnly configuration(configuration_data, configuration_rows);
+        home_configuration_ = configuration;
+
+        std::cout << "home configuration is set" << std::endl;
+
+        return true;
+    }
+
+    void ZMQController::compute(const double current_time,
+                               const double* x_data, int x_rows,
+                               const double* u_data, int u_rows) {
+        // Send zmq message
+        std::vector<double> zmq_outgoing_msg(1 + x_rows + u_rows);
+        zmq_outgoing_msg[0] = current_time;
+        std::copy(x_data, x_data + x_rows, zmq_outgoing_msg.begin() + 1);
+        std::copy(u_data, u_data + u_rows, zmq_outgoing_msg.begin() + 1 + x_rows);
+        socket_cpp.send(zmq_outgoing_msg.data(), zmq_outgoing_msg.size() * sizeof(double));
+
+        // Receive reply
+        zmq::message_t zmq_incoming_msg;
+        socket_cpp.recv(zmq_incoming_msg);
+        const double* receivedData = static_cast<double*>(zmq_incoming_msg.data());
+        size_t receivedSize = zmq_incoming_msg.size() / sizeof(double);
+        std::vector<double> values(receivedData, receivedData + receivedSize);
+
+        // Pull out reply into elements it is ([t; x_d; u_d; Kp; Kd])
+        Eigen::VectorXd data = Eigen::Map<Eigen::VectorXd>(values.data(), values.size());
+        home_configuration_ = data.segment<23>(1 + 7); // pull joint position out of x_d
+        desired_joint_velocities_ = data.segment<23>(1 + 30 + 6); // pull joint velocities out of x_d
+        desired_joint_torques_= data.segment<23>(1 + 30 + 29);
+        desired_joint_stiffnesses_ = data.segment<23>(1 + 30 + 29 + 23);
+        desired_joint_damping_ = data.segment<23>(1 + 30 + 29 + 23 + 23);
+
+    }
+
+    Eigen::VectorXd ZMQController::get_desired_joint_positions() const
+    {
+        return home_configuration_;
+    }
+
+    Eigen::VectorXd ZMQController::get_desired_joint_velocities() const
+    {
+        return desired_joint_velocities_;
+    }
+
+    Eigen::VectorXd ZMQController::get_desired_joint_torques() const
+    {
+        return desired_joint_torques_;
+    }
+
+    Eigen::VectorXd ZMQController::get_desired_joint_stiffnesses() const
+    {
+        return desired_joint_stiffnesses_;
+    }
+
+    Eigen::VectorXd ZMQController::get_desired_joint_damping() const
+    {
+        return desired_joint_damping_;
+    }
+}
\ No newline at end of file
diff --git a/external-control/src/main/cpp/controllers/zmq-controller.hpp b/external-control/src/main/cpp/controllers/zmq-controller.hpp
new file mode 100644
index 00000000000..df959287f70
--- /dev/null
+++ b/external-control/src/main/cpp/controllers/zmq-controller.hpp
@@ -0,0 +1,50 @@
+#pragma once
+
+#include "types.hpp"
+#include "zmq.hpp"
+
+namespace ihmc
+{
+    class ZMQController
+    {
+    public:
+
+        explicit ZMQController(const double default_stiffness, const double default_damping, const int number_of_joints);
+
+        virtual ~ZMQController() = default;
+
+        void resize(const double default_stiffness, const double default_damping, const int number_of_joints);
+
+        bool setHomeJointConfiguration(const double* configuration_data, int rows);
+
+        void compute(const double current_time,
+                    const double* x_data, int x_rows,
+                    const double* u_data, int u_rows);
+
+        Eigen::VectorXd get_desired_joint_positions() const;
+
+        Eigen::VectorXd get_desired_joint_velocities() const;
+
+        Eigen::VectorXd get_desired_joint_torques() const;
+
+        Eigen::VectorXd get_desired_joint_stiffnesses() const;
+
+        Eigen::VectorXd get_desired_joint_damping() const;
+
+    private:
+        int number_of_joints_;
+
+        Eigen::VectorXd home_configuration_;
+        Eigen::VectorXd desired_joint_velocities_;
+        Eigen::VectorXd desired_joint_torques_;
+        Eigen::VectorXd desired_joint_stiffnesses_;
+        Eigen::VectorXd desired_joint_damping_;
+
+        // zmq
+        zmq::context_t context;
+        zmq::socket_t socket_cpp;
+        zmq::pollitem_t items[1];
+
+
+    };
+}
\ No newline at end of file
diff --git a/external-control/src/main/cpp/external-control.cpp b/external-control/src/main/cpp/external-control.cpp
new file mode 100644
index 00000000000..b8e490fbcf9
--- /dev/null
+++ b/external-control/src/main/cpp/external-control.cpp
@@ -0,0 +1,125 @@
+#include "external-control.hpp"
+
+#include <iostream>
+#include "types.hpp"
+
+namespace ihmc
+{
+    ExternalControlImpl::ExternalControlImpl(const double default_stiffness, const double default_damping, const int number_of_joints)
+        : zmq_controller_(default_stiffness, default_damping, number_of_joints)
+    {
+       std::cout << "Creating external control object." << std::endl;
+
+        constant_position_controller_.resize(default_stiffness, default_damping, number_of_joints);
+        desired_state_data_.resize(13 + 2 * number_of_joints);
+        desired_control_data_.resize(number_of_joints);
+        p_gains_.resize(number_of_joints);
+        d_gains_.resize(number_of_joints);
+        number_of_joints_ = number_of_joints;
+
+        std::cout << "Created external control object." << std::endl;
+    }
+
+
+
+    bool ExternalControlImpl::updateRobotState(const double current_time,
+                                               const double* x_data, int x_rows,
+                                               const double* u_data, int u_rows,
+                                               const bool left_in_contact, const bool right_in_contact,
+                                               const double* foot_locations, int foot_locations_rows,
+                                               const int hardware_status)
+    {
+        if (x_rows != 13 + 2 * number_of_joints_)
+        {
+            std::cout << "The size of the state vector is incorrect" << std::endl;
+            return false;
+        }
+        if (u_rows != number_of_joints_)
+        {
+            std::cout << "The size of the control vector is incorrect" << std::endl;
+            return false;
+        }
+        if (foot_locations_rows != 6)
+        {
+            std::cout << "The size of the foot location rows is incorrect" << std::endl;
+            return false;
+        }
+
+        if (hardware_status == 0)
+        {
+
+
+            const VectorViewReadOnly state(x_data, x_rows);
+            const Eigen::Vector3d base_position = state.head(3);
+            const Eigen::Vector4d base_orientation = state.segment(3, 4);
+            const Eigen::VectorXd joint_positions = state.segment(7, number_of_joints_);
+            const Eigen::Vector3d base_linear_velocity = state.segment(7 + number_of_joints_, 3);
+            const Eigen::Vector3d base_angular_velocity = state.segment(10 + number_of_joints_, 3);
+            const Eigen::VectorXd joint_velocities = state.tail(number_of_joints_);
+
+            desired_state_data_.head(7) << base_position, base_orientation;
+            desired_state_data_.segment(7, number_of_joints_) = constant_position_controller_.get_desired_joint_positions();
+            desired_state_data_.segment(7 + number_of_joints_, 6) << base_linear_velocity, base_angular_velocity;
+            desired_state_data_.tail(number_of_joints_) = constant_position_controller_.get_desired_joint_velocities();
+
+            desired_control_data_ = constant_position_controller_.get_desired_joint_torques();
+            p_gains_ = constant_position_controller_.get_desired_joint_stiffnesses();
+            d_gains_ = constant_position_controller_.get_desired_joint_damping();
+
+            return true;
+        }
+        else if (hardware_status == 1)
+        {
+            const VectorViewReadOnly state(x_data, x_rows);
+            const Eigen::Vector3d base_position = state.head(3);
+            const Eigen::Vector4d base_orientation = state.segment(3, 4);
+            const Eigen::VectorXd joint_positions = state.segment(7, number_of_joints_);
+            const Eigen::Vector3d base_linear_velocity = state.segment(7 + number_of_joints_, 3);
+            const Eigen::Vector3d base_angular_velocity = state.segment(10 + number_of_joints_, 3);
+            const Eigen::VectorXd joint_velocities = state.tail(number_of_joints_);
+
+            desired_state_data_.head(7) << base_position, base_orientation;
+            desired_state_data_.segment(7, number_of_joints_) = zmq_controller_.get_desired_joint_positions();
+            desired_state_data_.segment(7 + number_of_joints_, 6) << base_linear_velocity, base_angular_velocity;
+            desired_state_data_.tail(number_of_joints_) = zmq_controller_.get_desired_joint_velocities();
+
+            zmq_controller_.compute(current_time, x_data, x_rows, u_data, u_rows);
+
+            desired_control_data_ = zmq_controller_.get_desired_joint_torques();
+            p_gains_ = zmq_controller_.get_desired_joint_stiffnesses();
+            d_gains_ = zmq_controller_.get_desired_joint_damping();
+
+            return true;
+        }
+        else
+        {
+            std::cout << "There is no control mode defined for " << hardware_status << std::endl;
+            return false;
+        }
+    }
+
+    bool ExternalControlImpl::getSolution(double* state_data_to_pack, int state_rows,
+                         double* control_data_to_pack, int control_rows,
+                         double* p_gains_to_pack, int p_gain_rows,
+                         double* d_gains_to_pack, int d_gain_rows) const
+    {
+        VectorView state_data(state_data_to_pack, state_rows);
+        VectorView control_data(control_data_to_pack, control_rows);
+        VectorView p_gains(p_gains_to_pack, p_gain_rows);
+        VectorView d_gains(d_gains_to_pack, d_gain_rows);
+
+        state_data = desired_state_data_;
+        control_data = desired_control_data_;
+        p_gains = p_gains_;
+        d_gains = d_gains_;
+
+        return true;
+    }
+
+    bool ExternalControlImpl::setHomeJointConfiguration(const double* configuration_data, int rows)
+    {
+        std::cout << "Setting home configuration" << std::endl;
+        zmq_controller_.setHomeJointConfiguration(configuration_data, rows);
+        return constant_position_controller_.setHomeJointConfiguration(configuration_data, rows);
+    }
+}
diff --git a/external-control/src/main/cpp/external-control.hpp b/external-control/src/main/cpp/external-control.hpp
new file mode 100644
index 00000000000..a9891ef1f97
--- /dev/null
+++ b/external-control/src/main/cpp/external-control.hpp
@@ -0,0 +1,49 @@
+#pragma once
+
+#include <Eigen/Core>
+
+#include "controllers/constant-position-controller.hpp"
+#include "controllers/zmq-controller.hpp"
+
+namespace ihmc
+{
+    class ExternalControlImpl
+    {
+    public:
+        explicit ExternalControlImpl(const double default_stiffness, const double default_damping, const int number_of_joints);
+
+        virtual ~ExternalControlImpl() = default;
+
+        ExternalControlImpl(const ExternalControlImpl&) = delete;
+
+        ExternalControlImpl& operator=(const ExternalControlImpl&) = delete;
+
+        ExternalControlImpl(ExternalControlImpl&&) = delete;
+
+        ExternalControlImpl& operator=(ExternalControlImpl&&) = delete;
+
+        bool setHomeJointConfiguration(const double* configuration_data, int rows);
+
+        bool updateRobotState(const double current_time,
+                              const double* x_data, int x_rows,
+                              const double* u_data, int u_rows,
+                              const bool left_in_contact, const bool right_in_contact,
+                              const double* foot_locations, int foot_locations_rows,
+                              const int hardware_status);
+
+        bool getSolution(double* state_data_to_pack, int state_rows,
+                         double* control_data_to_pack, int control_rows,
+                         double* p_gains_to_pack, int p_gain_rows,
+                         double* d_gains_to_pack, int d_gain_rows) const;
+
+    private:
+        ConstantPositionController constant_position_controller_;
+        ZMQController zmq_controller_;
+
+        int number_of_joints_;
+        Eigen::VectorXd desired_state_data_;
+        Eigen::VectorXd desired_control_data_;
+        Eigen::VectorXd p_gains_;
+        Eigen::VectorXd d_gains_;
+    };
+}
diff --git a/external-control/src/main/cpp/types.hpp b/external-control/src/main/cpp/types.hpp
new file mode 100644
index 00000000000..5753647dcd1
--- /dev/null
+++ b/external-control/src/main/cpp/types.hpp
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <Eigen/Core>
+
+namespace ihmc
+{
+    /** Linear Algebra */
+    // DO NOT USE -- FOR INTEROP WITH EJML DMATRIXRMAJ, WE MUST CONSIDER ALL MATRICES TO BE ROW-MAJOR
+    // using MatrixView = Eigen::Map<Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>, Eigen::AlignedMax>;
+    // using MatrixViewReadOnly = Eigen::Map<const Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>, Eigen::AlignedMax>;
+    // using RotationView = Eigen::Map<Eigen::Matrix<double, 3, 3>, Eigen::AlignedMax>;
+    // using RotationViewReadOnly = Eigen::Map<const Eigen::Matrix<double, 3, 3>, Eigen::AlignedMax>;
+
+    // Alias for mocking a DMatrixRMaj from EJML in API
+    using MatrixRowMajor = Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
+
+    // Mutable
+    using MatrixViewRowMajor = Eigen::Map<Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>,
+        Eigen::AlignedMax>;
+    using VectorView = Eigen::Map<Eigen::Vector<double, Eigen::Dynamic>, Eigen::AlignedMax>;
+    // Immutable
+    using MatrixViewRowMajorReadOnly = Eigen::Map<const Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>,
+        Eigen::AlignedMax>;
+    using VectorViewReadOnly = Eigen::Map<const Eigen::Vector<double, Eigen::Dynamic>, Eigen::AlignedMax>;
+    // Sized Mutable
+    using RotationViewRowMajor = Eigen::Map<Eigen::Matrix<double, 3, 3, Eigen::RowMajor>, Eigen::AlignedMax>;
+    using TranslationView = Eigen::Map<Eigen::Matrix<double, 3, 1>, Eigen::AlignedMax>;
+    using SpatialVectorView = Eigen::Map<Eigen::Matrix<double, 6, 1>, Eigen::AlignedMax>;
+    // Sized Immutable
+    using RotationViewRowMajorReadOnly = Eigen::Map<const Eigen::Matrix<double, 3, 3, Eigen::RowMajor>, Eigen::AlignedMax>;
+    using TranslationViewReadOnly = Eigen::Map<const Eigen::Matrix<double, 3, 1>, Eigen::AlignedMax>;
+    using SpatialVectorViewReadOnly = Eigen::Map<const Eigen::Matrix<double, 6, 1>, Eigen::AlignedMax>;
+
+    /** Robot */
+    // x and y in foot frame
+    using ContactSurfaceDimensions = std::pair<double, double>;
+    // Kp and Kd for Baumgarte stabilization
+    using ContactStabilizationGains = std::pair<double, double>;
+}
diff --git a/external-control/src/main/java/us/ihmc/externalControl/ExternalControl.java b/external-control/src/main/java/us/ihmc/externalControl/ExternalControl.java
new file mode 100644
index 00000000000..0620ba78807
--- /dev/null
+++ b/external-control/src/main/java/us/ihmc/externalControl/ExternalControl.java
@@ -0,0 +1,179 @@
+package us.ihmc.externalControl;
+
+import org.ejml.data.DMatrixRMaj;
+import us.ihmc.commonWalkingControlModules.highLevelHumanoidControl.highLevelStates.WholeBodySetpointParameters;
+import us.ihmc.euclid.referenceFrame.FramePose3D;
+import us.ihmc.euclid.referenceFrame.FrameVector3D;
+import us.ihmc.euclid.referenceFrame.ReferenceFrame;
+import us.ihmc.externalControl.global.ExternalControlWrapper;
+import us.ihmc.log.LogTools;
+import us.ihmc.mecano.multiBodySystem.interfaces.OneDoFJointReadOnly;
+import us.ihmc.mecano.multiBodySystem.interfaces.RigidBodyBasics;
+import us.ihmc.robotics.robotSide.RobotSide;
+import us.ihmc.robotics.robotSide.SideDependentList;
+import us.ihmc.sensorProcessing.outputData.JointDesiredOutputBasics;
+
+import java.util.HashMap;
+
+public class ExternalControl
+{
+   private final ExternalControlWrapper.ExternalControlImpl externalControlImpl;
+   private final DMatrixRMaj robotState;
+   private final DMatrixRMaj robotControl;
+   private final DMatrixRMaj feetPositions;
+   private boolean leftInContact;
+   private boolean rightInContact;
+   private final DMatrixRMaj solutionRobotState;
+   private final DMatrixRMaj solutionTorqueVector;
+   private final DMatrixRMaj solutionStiffnessVector;
+   private final DMatrixRMaj solutionDampingVector;
+   private final RigidBodyBasics baseBody;
+   private final OneDoFJointReadOnly[] joints;
+   private final FramePose3D basePose = new FramePose3D();
+   private final FrameVector3D tempVector = new FrameVector3D();
+   private final FrameVector3D tempPoint = new FrameVector3D();
+   private final FramePose3D solutionBasePose = new FramePose3D();
+   private final HashMap<OneDoFJointReadOnly, SolutionJointData> solutionJointData = new HashMap<>();
+
+   public ExternalControl(RigidBodyBasics baseBody, WholeBodySetpointParameters homeConfiguration, OneDoFJointReadOnly[] joints, double defaultStiffness, double defaultDamping)
+   {
+      this.baseBody = baseBody;
+      this.joints = joints;
+      robotState = new DMatrixRMaj(2 * joints.length + 13, 1);
+      robotControl = new DMatrixRMaj(joints.length, 1);
+      feetPositions = new DMatrixRMaj(6, 1);
+      solutionRobotState = new DMatrixRMaj(2 * joints.length + 13, 1);
+      solutionTorqueVector = new DMatrixRMaj(joints.length, 1);
+      solutionStiffnessVector = new DMatrixRMaj(joints.length, 1);
+      solutionDampingVector = new DMatrixRMaj(joints.length, 1);
+      for (OneDoFJointReadOnly joint : joints)
+         solutionJointData.put(joint, new SolutionJointData());
+      externalControlImpl = new ExternalControlWrapper.ExternalControlImpl(defaultStiffness, defaultDamping, joints.length);
+
+      DMatrixRMaj homeConfigurationVector = new DMatrixRMaj(joints.length, 1);
+      for (int i = 0; i < joints.length; i++)
+         homeConfigurationVector.set(i, 0, homeConfiguration.getSetpoint(joints[i].getName()));
+      externalControlImpl.setHomeJointConfiguration(homeConfigurationVector.data, homeConfigurationVector.numRows);
+   }
+
+   public void setFootStates(SideDependentList<? extends ReferenceFrame> soleFrames, boolean leftInContact, boolean rightInContact)
+   {
+      int start = 0;
+      for (RobotSide robotSide : RobotSide.values)
+      {
+         tempPoint.setToZero(soleFrames.get(robotSide));
+         tempPoint.changeFrame(ReferenceFrame.getWorldFrame());
+         tempPoint.get(start, feetPositions);
+         start += 3;
+      }
+      this.leftInContact = leftInContact;
+      this.rightInContact = rightInContact;
+   }
+
+   public void writeRobotState(double currentTime, int hardwareStatus)
+   {
+      setRobotState();
+      setRobotControl();
+      if (!externalControlImpl.updateRobotState(currentTime,
+                                                robotState.data,
+                                                robotState.getNumRows(),
+                                                robotControl.data,
+                                                robotControl.getNumRows(),
+                                                leftInContact,
+                                                rightInContact,
+                                                feetPositions.data,
+                                                feetPositions.getNumRows(),
+                                                hardwareStatus))
+         throw new RuntimeException("Failed to successfully write the hardware state across the barrier.");
+   }
+
+   public void readControlSolution()
+   {
+      if (!externalControlImpl.getSolution(solutionRobotState.data,
+                                           solutionRobotState.numRows,
+                                           solutionTorqueVector.data,
+                                           solutionTorqueVector.numRows,
+                                           solutionStiffnessVector.data,
+                                           solutionStiffnessVector.numRows,
+                                           solutionDampingVector.data,
+                                           solutionDampingVector.numRows))
+      {
+         throw new RuntimeException("Failed to retrieve solution data.");
+      }
+      solutionBasePose.getPosition().set(solutionRobotState);
+      solutionBasePose.getOrientation().set(3, 0, solutionRobotState);
+      int positionStart = 7;
+      int velocityStart = 7 + 6 + joints.length;
+      for (int i = 0; i < joints.length; i++)
+      {
+         SolutionJointData data = solutionJointData.get(joints[i]);
+         data.desiredPosition = solutionRobotState.get(positionStart + i, 0);
+         data.desiredVelocity = solutionRobotState.get(velocityStart + i, 0);
+         data.torque = solutionTorqueVector.get(i, 0);
+         data.stiffness = solutionStiffnessVector.get(i, 0);
+         data.damping = solutionDampingVector.get(i, 0);
+      }
+//      LogTools.info("returned stiffness" + solutionStiffnessVector);
+   }
+
+   public SolutionJointData getSolutionData(OneDoFJointReadOnly joint)
+   {
+      return solutionJointData.get(joint);
+   }
+
+   private void setRobotState()
+   {
+      basePose.setToZero(baseBody.getBodyFixedFrame());
+      basePose.changeFrame(ReferenceFrame.getWorldFrame());
+      // set the configuration state for the robot
+      basePose.getPosition().get(0, robotState);
+      basePose.getOrientation().get(3, robotState);
+      int start = 7;
+      for (int i = 0; i < joints.length; i++)
+      {
+         robotState.set(start + i, joints[i].getQ());
+      }
+      // set linear velocity in body frame
+      start += joints.length;
+      tempVector.setIncludingFrame(baseBody.getBodyFixedFrame().getTwistOfFrame().getLinearPart());
+      tempVector.changeFrame(baseBody.getBodyFixedFrame());
+      tempVector.get(start, robotState);
+      // set angular velocity in body frame
+      start += 3;
+      tempVector.setIncludingFrame(baseBody.getBodyFixedFrame().getTwistOfFrame().getAngularPart());
+      tempVector.changeFrame(baseBody.getBodyFixedFrame());
+      tempVector.get(start, robotState);
+      // set joint velocity
+      start += 3;
+      for (int i = 0; i < joints.length; i++)
+      {
+         robotState.set(start + i, joints[i].getQd());
+      }
+   }
+
+   private void setRobotControl()
+   {
+      for (int i = 0; i < joints.length; i++)
+      {
+         robotControl.set(i, joints[i].getTau());
+      }
+   }
+
+   public static class SolutionJointData
+   {
+      double desiredPosition;
+      double desiredVelocity;
+      double stiffness;
+      double damping;
+      double torque;
+
+      public void getJointDesiredOutput(JointDesiredOutputBasics jointDesiredOutputToPack)
+      {
+         jointDesiredOutputToPack.setDesiredPosition(desiredPosition);
+         jointDesiredOutputToPack.setDesiredVelocity(desiredVelocity);
+         jointDesiredOutputToPack.setDesiredTorque(torque);
+         jointDesiredOutputToPack.setStiffness(stiffness);
+         jointDesiredOutputToPack.setDamping(damping);
+      }
+   }
+}
\ No newline at end of file
diff --git a/external-control/src/main/java/us/ihmc/externalControl/ExternalControlInfoMapper.java b/external-control/src/main/java/us/ihmc/externalControl/ExternalControlInfoMapper.java
new file mode 100644
index 00000000000..a5f7cd8d2eb
--- /dev/null
+++ b/external-control/src/main/java/us/ihmc/externalControl/ExternalControlInfoMapper.java
@@ -0,0 +1,42 @@
+package us.ihmc.externalControl;
+
+import org.bytedeco.javacpp.annotation.Platform;
+import org.bytedeco.javacpp.annotation.Properties;
+import org.bytedeco.javacpp.tools.Info;
+import org.bytedeco.javacpp.tools.InfoMap;
+import org.bytedeco.javacpp.tools.InfoMapper;
+
+// @formatter:off
+@Properties(value =
+      @Platform(value = "linux",
+                includepath = {"include", "include/eigen3"},
+                include = {"external-control.hpp"},
+                linkpath = "lib",
+                link = "external-control",
+                preload = {"external-control", "jniExternalControlWrapper"}
+      ),
+      target = "us.ihmc.externalControl.global.ExternalControlWrapper"
+)
+// @formatter:onExtWra
+
+public class ExternalControlInfoMapper implements InfoMapper
+{
+   public void map(InfoMap infoMap)
+   {
+
+      // Types
+
+
+      // Renaming, example: infoMap.put(new Info("ihmc::Frame").pointerTypes("FrameImpl"));
+
+      // Enums
+
+      // Abstract
+      infoMap.put(new Info("ihmc::ExternalControl").pointerTypes("ExternalControlImpl"));
+
+      // Skipping some parts of the headers
+//      String skipStartRegex = "^ *// JAVACPP START SKIP *$";
+//      String skipEndRegex = "^ *// JAVACPP END SKIP *$";
+//      infoMap.put(new Info("external-control.hpp").linePatterns(skipStartRegex, skipEndRegex).skip());
+   }
+}
diff --git a/external-control/src/main/java/us/ihmc/externalControl/ExternalControllerState.java b/external-control/src/main/java/us/ihmc/externalControl/ExternalControllerState.java
new file mode 100644
index 00000000000..a36b3b3069c
--- /dev/null
+++ b/external-control/src/main/java/us/ihmc/externalControl/ExternalControllerState.java
@@ -0,0 +1,177 @@
+package us.ihmc.externalControl;
+
+import org.ejml.data.DMatrixRMaj;
+import us.ihmc.commonWalkingControlModules.configurations.HighLevelControllerParameters;
+import us.ihmc.commonWalkingControlModules.controllerCore.command.lowLevel.LowLevelOneDoFJointDesiredDataHolder;
+import us.ihmc.commonWalkingControlModules.highLevelHumanoidControl.highLevelStates.HighLevelControllerState;
+import us.ihmc.commonWalkingControlModules.highLevelHumanoidControl.highLevelStates.JointControlBlender;
+import us.ihmc.commonWalkingControlModules.highLevelHumanoidControl.highLevelStates.WholeBodySetpointParameters;
+import us.ihmc.commonWalkingControlModules.momentumBasedController.HighLevelHumanoidControllerToolbox;
+import us.ihmc.commons.MathTools;
+import us.ihmc.commons.lists.PairList;
+import us.ihmc.communication.controllerAPI.CommandInputManager;
+import us.ihmc.externalControl.library.ExternalControlNativeLibrary;
+import us.ihmc.humanoidRobotics.communication.packets.dataobjects.HighLevelControllerName;
+import us.ihmc.mecano.multiBodySystem.interfaces.OneDoFJointBasics;
+import us.ihmc.robotics.robotSide.RobotSide;
+import us.ihmc.sensorProcessing.outputData.JointDesiredOutputBasics;
+import us.ihmc.sensorProcessing.outputData.JointDesiredOutputListReadOnly;
+import us.ihmc.sensorProcessing.outputData.JointDesiredOutputReadOnly;
+import us.ihmc.yoVariables.registry.YoRegistry;
+import us.ihmc.yoVariables.variable.YoDouble;
+import us.ihmc.yoVariables.variable.YoEnum;
+
+public class ExternalControllerState extends HighLevelControllerState
+{
+   public static boolean REDUCE_YOVARIABLES = false;
+
+   private enum DesiredMode {HOLD_POSITION, REXXXXXXX}
+
+   private final YoDouble blendRatioCurrentValue;
+
+   private final PairList<OneDoFJointBasics, JointControlBlender> jointCommandBlenders = new PairList<>();
+   private final JointDesiredOutputListReadOnly highLevelControllerOutput;
+
+   private final LowLevelOneDoFJointDesiredDataHolder lowLevelOneDoFJointDesiredDataHolder = new LowLevelOneDoFJointDesiredDataHolder();
+   private final LowLevelOneDoFJointDesiredDataHolder frozenJointDataHolder = new LowLevelOneDoFJointDesiredDataHolder();
+   private final LowLevelOneDoFJointDesiredDataHolder externalJointDataHolder = new LowLevelOneDoFJointDesiredDataHolder();
+
+   private final YoEnum<DesiredMode> desiredMode = new YoEnum<>("DesiredExternalMode", registry, DesiredMode.class);
+
+   private final CommandInputManager commandInputManager;
+
+   private final PairList<OneDoFJointBasics, YoDouble> frozenJointDesireds = new PairList<>();
+
+   private final HighLevelHumanoidControllerToolbox controllerToolbox;
+
+   private final ExternalControl externalControl;
+
+   public ExternalControllerState(HighLevelControllerParameters highLevelControllerParameters,
+                                  HighLevelHumanoidControllerToolbox controllerToolbox,
+                                  OneDoFJointBasics[] controlledJoints,
+                                  JointDesiredOutputListReadOnly highLevelControllerOutput,
+                                  CommandInputManager commandInputManager)
+   {
+      super("externalControl", HighLevelControllerName.EXTERNAL, highLevelControllerParameters, controlledJoints);
+
+      this.highLevelControllerOutput = highLevelControllerOutput;
+      this.controllerToolbox = controllerToolbox;
+
+      this.commandInputManager = commandInputManager;
+
+      blendRatioCurrentValue = new YoDouble("ExternalControlBlendRatioCurrentValue", registry);
+
+      ExternalControlNativeLibrary.load();
+
+      desiredMode.set(DesiredMode.HOLD_POSITION);
+      externalControl = new ExternalControl(controllerToolbox.getFullRobotModel().getRootBody(), highLevelControllerParameters.getStandPrepParameters(),
+                                            controlledJoints, 1000.0, 5.0);
+
+
+      lowLevelOneDoFJointDesiredDataHolder.registerJointsWithEmptyData(controlledJoints);
+      frozenJointDataHolder.registerJointsWithEmptyData(controlledJoints);
+      externalJointDataHolder.registerJointsWithEmptyData(controlledJoints);
+
+      YoRegistry registryForBlenders = REDUCE_YOVARIABLES ? null : registry;
+
+      for (OneDoFJointBasics controlledJoint : controlledJoints)
+      {
+         String jointName = controlledJoint.getName();
+
+         YoDouble freezePosition = new YoDouble(jointName + "_frozen_qDesired", registry);
+         freezePosition.setToNaN();
+         frozenJointDesireds.add(controlledJoint, freezePosition);
+
+         JointControlBlender jointControlBlender = new JointControlBlender("_ExternalBlender", controlledJoint, registryForBlenders);
+         jointCommandBlenders.add(controlledJoint, jointControlBlender);
+      }
+   }
+
+   @Override
+   public void onEntry()
+   {
+      for (int jointIndex = 0; jointIndex < frozenJointDesireds.size(); jointIndex++)
+      {
+         OneDoFJointBasics joint = frozenJointDesireds.get(jointIndex).getLeft();
+         YoDouble setpoint = frozenJointDesireds.get(jointIndex).getRight();
+         JointDesiredOutputReadOnly lowLevelJointData = highLevelControllerOutput.getJointDesiredOutput(joint);
+         if (lowLevelJointData != null && lowLevelJointData.hasDesiredPosition())
+            setpoint.set(lowLevelJointData.getDesiredPosition());
+         else
+            setpoint.set(joint.getQ());
+      }
+
+      blendRatioCurrentValue.set(0.0);
+
+      commandInputManager.clearAllCommands();
+      commandInputManager.setEnabled(false);
+   }
+
+   @Override
+   public void doAction(double timeInState)
+   {
+      controllerToolbox.update();
+
+      externalControl.setFootStates(controllerToolbox.getReferenceFrames().getSoleFrames(),
+                                    controllerToolbox.getFootSwitches().get(RobotSide.LEFT).hasFootHitGroundFiltered(),
+                                    controllerToolbox.getFootSwitches().get(RobotSide.RIGHT).hasFootHitGroundFiltered());
+      externalControl.writeRobotState(controllerToolbox.getYoTime().getDoubleValue(), desiredMode.getOrdinal());
+
+      externalControl.readControlSolution();
+
+
+      double gainRatio = blendRatioCurrentValue.getValue();
+
+      if (Double.isNaN(gainRatio))
+         gainRatio = 0.0;
+      else
+         gainRatio = MathTools.clamp(gainRatio, 0.0, 1.0);
+
+      for (int jointIndex = 0; jointIndex < jointCommandBlenders.size(); jointIndex++)
+      {
+         OneDoFJointBasics joint = jointCommandBlenders.get(jointIndex).getLeft();
+
+         YoDouble frozenDesiredPosition = frozenJointDesireds.get(jointIndex).getRight();
+
+         JointDesiredOutputBasics frozenJointData = frozenJointDataHolder.getJointDesiredOutput(joint);
+         frozenJointData.clear();
+         frozenJointData.setDesiredPosition(frozenDesiredPosition.getDoubleValue());
+         frozenJointData.setDesiredVelocity(0.0);
+         frozenJointData.setDesiredAcceleration(0.0);
+      }
+      frozenJointDataHolder.completeWith(getStateSpecificJointSettings());
+
+      for (int jointIndex = 0; jointIndex < jointCommandBlenders.size(); jointIndex++)
+      {
+         OneDoFJointBasics joint = jointCommandBlenders.get(jointIndex).getLeft();
+
+         JointDesiredOutputBasics externalJointData = externalJointDataHolder.getJointDesiredOutput(joint);
+         externalControl.getSolutionData(joint).getJointDesiredOutput(externalJointData);
+
+         JointDesiredOutputBasics frozenJointData = frozenJointDataHolder.getJointDesiredOutput(joint);
+
+         JointDesiredOutputBasics lowLevelJointData = lowLevelOneDoFJointDesiredDataHolder.getJointDesiredOutput(joint);
+         lowLevelJointData.clear();
+
+         JointControlBlender jointControlBlender = jointCommandBlenders.get(jointIndex).getRight();
+         jointControlBlender.computeAndUpdateJointControl(lowLevelJointData,
+                                                          frozenJointData,
+                                                          externalJointData,
+                                                          gainRatio);
+      }
+
+      lowLevelOneDoFJointDesiredDataHolder.completeWith(getStateSpecificJointSettings());
+   }
+
+   @Override
+   public void onExit(double timeInState)
+   {
+      commandInputManager.setEnabled(true);
+   }
+
+   @Override
+   public JointDesiredOutputListReadOnly getOutputForLowLevelController()
+   {
+      return lowLevelOneDoFJointDesiredDataHolder;
+   }
+}
diff --git a/external-control/src/main/java/us/ihmc/externalControl/ExternalControllerStateFactory.java b/external-control/src/main/java/us/ihmc/externalControl/ExternalControllerStateFactory.java
new file mode 100644
index 00000000000..902e08c77fe
--- /dev/null
+++ b/external-control/src/main/java/us/ihmc/externalControl/ExternalControllerStateFactory.java
@@ -0,0 +1,41 @@
+package us.ihmc.externalControl;
+
+import us.ihmc.commonWalkingControlModules.highLevelHumanoidControl.HighLevelControllerFactoryHelper;
+import us.ihmc.commonWalkingControlModules.highLevelHumanoidControl.factories.HighLevelControllerStateFactory;
+import us.ihmc.commonWalkingControlModules.highLevelHumanoidControl.highLevelStates.HighLevelControllerState;
+import us.ihmc.communication.controllerAPI.CommandInputManager;
+import us.ihmc.humanoidRobotics.communication.packets.dataobjects.HighLevelControllerName;
+import us.ihmc.mecano.multiBodySystem.interfaces.OneDoFJointBasics;
+
+public class ExternalControllerStateFactory implements HighLevelControllerStateFactory
+{
+   private ExternalControllerState externalControlState;
+
+   public ExternalControllerStateFactory()
+   {
+   }
+
+   @Override
+   public HighLevelControllerState getOrCreateControllerState(HighLevelControllerFactoryHelper controllerFactoryHelper)
+   {
+      if (externalControlState == null)
+      {
+         OneDoFJointBasics[] controlledJoints = controllerFactoryHelper.getHighLevelHumanoidControllerToolbox().getControlledOneDoFJoints();
+         CommandInputManager commandInputManager = controllerFactoryHelper.getCommandInputManager();
+
+         externalControlState = new ExternalControllerState(controllerFactoryHelper.getHighLevelControllerParameters(),
+                                                            controllerFactoryHelper.getHighLevelHumanoidControllerToolbox(),
+                                                            controlledJoints,
+                                                            controllerFactoryHelper.getLowLevelControllerOutput(),
+                                                            commandInputManager);
+      }
+
+      return externalControlState;
+   }
+
+   @Override
+   public HighLevelControllerName getStateEnum()
+   {
+      return HighLevelControllerName.EXTERNAL;
+   }
+}
diff --git a/external-control/src/main/java/us/ihmc/externalControl/global/ExternalControlWrapper.java b/external-control/src/main/java/us/ihmc/externalControl/global/ExternalControlWrapper.java
new file mode 100644
index 00000000000..e0201531abb
--- /dev/null
+++ b/external-control/src/main/java/us/ihmc/externalControl/global/ExternalControlWrapper.java
@@ -0,0 +1,75 @@
+// Targeted by JavaCPP version 1.5.10: DO NOT EDIT THIS FILE
+
+package us.ihmc.externalControl.global;
+
+import java.nio.*;
+import org.bytedeco.javacpp.*;
+import org.bytedeco.javacpp.annotation.*;
+
+public class ExternalControlWrapper extends us.ihmc.externalControl.ExternalControlInfoMapper {
+    static { Loader.load(); }
+
+// Parsed from external-control.hpp
+
+// #pragma once
+
+// #include <Eigen/Core>
+
+// #include "controllers/constant-position-controller.hpp"
+// #include "controllers/zmq-controller.hpp"
+    @Namespace("ihmc") @NoOffset public static class ExternalControlImpl extends Pointer {
+        static { Loader.load(); }
+        /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */
+        public ExternalControlImpl(Pointer p) { super(p); }
+    
+        public ExternalControlImpl(double default_stiffness, double default_damping, int number_of_joints) { super((Pointer)null); allocate(default_stiffness, default_damping, number_of_joints); }
+        private native void allocate(double default_stiffness, double default_damping, int number_of_joints);
+
+        
+
+        
+
+        
+
+        
+
+        public native @Cast("bool") boolean setHomeJointConfiguration(@Const DoublePointer configuration_data, int rows);
+        public native @Cast("bool") boolean setHomeJointConfiguration(@Const DoubleBuffer configuration_data, int rows);
+        public native @Cast("bool") boolean setHomeJointConfiguration(@Const double[] configuration_data, int rows);
+
+        public native @Cast("bool") boolean updateRobotState(double current_time,
+                                      @Const DoublePointer x_data, int x_rows,
+                                      @Const DoublePointer u_data, int u_rows,
+                                      @Cast("const bool") boolean left_in_contact, @Cast("const bool") boolean right_in_contact,
+                                      @Const DoublePointer foot_locations, int foot_locations_rows,
+                                      int hardware_status);
+        public native @Cast("bool") boolean updateRobotState(double current_time,
+                                      @Const DoubleBuffer x_data, int x_rows,
+                                      @Const DoubleBuffer u_data, int u_rows,
+                                      @Cast("const bool") boolean left_in_contact, @Cast("const bool") boolean right_in_contact,
+                                      @Const DoubleBuffer foot_locations, int foot_locations_rows,
+                                      int hardware_status);
+        public native @Cast("bool") boolean updateRobotState(double current_time,
+                                      @Const double[] x_data, int x_rows,
+                                      @Const double[] u_data, int u_rows,
+                                      @Cast("const bool") boolean left_in_contact, @Cast("const bool") boolean right_in_contact,
+                                      @Const double[] foot_locations, int foot_locations_rows,
+                                      int hardware_status);
+
+        public native @Cast("bool") boolean getSolution(DoublePointer state_data_to_pack, int state_rows,
+                                 DoublePointer control_data_to_pack, int control_rows,
+                                 DoublePointer p_gains_to_pack, int p_gain_rows,
+                                 DoublePointer d_gains_to_pack, int d_gain_rows);
+        public native @Cast("bool") boolean getSolution(DoubleBuffer state_data_to_pack, int state_rows,
+                                 DoubleBuffer control_data_to_pack, int control_rows,
+                                 DoubleBuffer p_gains_to_pack, int p_gain_rows,
+                                 DoubleBuffer d_gains_to_pack, int d_gain_rows);
+        public native @Cast("bool") boolean getSolution(double[] state_data_to_pack, int state_rows,
+                                 double[] control_data_to_pack, int control_rows,
+                                 double[] p_gains_to_pack, int p_gain_rows,
+                                 double[] d_gains_to_pack, int d_gain_rows);
+    }
+
+
+
+}
diff --git a/external-control/src/main/java/us/ihmc/externalControl/library/ExternalControlNativeLibrary.java b/external-control/src/main/java/us/ihmc/externalControl/library/ExternalControlNativeLibrary.java
new file mode 100644
index 00000000000..b90dc93a745
--- /dev/null
+++ b/external-control/src/main/java/us/ihmc/externalControl/library/ExternalControlNativeLibrary.java
@@ -0,0 +1,56 @@
+package us.ihmc.externalControl.library;
+
+import us.ihmc.externalControl.global.ExternalControlWrapper;
+import us.ihmc.tools.nativelibraries.NativeLibraryDescription;
+import us.ihmc.tools.nativelibraries.NativeLibraryLoader;
+import us.ihmc.tools.nativelibraries.NativeLibraryWithDependencies;
+
+public class ExternalControlNativeLibrary implements NativeLibraryDescription
+{
+   @Override
+   public String getPackage(OperatingSystem os, Architecture arch)
+   {
+      String archPackage = "";
+      if (arch == Architecture.x64)
+      {
+         archPackage = switch (os)
+         {
+            case WIN64 -> "windows-x86_64";
+            case LINUX64 -> "linux-x86_64";
+            case MACOSX64 -> "macos-x86_64";
+         };
+      }
+      else if (arch == Architecture.arm64)
+      {
+         archPackage = switch (os)
+         {
+            case WIN64 -> "windows-arm64";
+            case LINUX64 -> "linux-arm64";
+            case MACOSX64 -> "macos-arm64";
+         };
+      }
+
+      return "externalControl.native." + archPackage;
+   }
+
+   @Override
+   public NativeLibraryWithDependencies getLibraryWithDependencies(OperatingSystem os, Architecture arch)
+   {
+      if (os == OperatingSystem.LINUX64 && arch == Architecture.x64)
+         return NativeLibraryWithDependencies.fromFilename("libjniExternalControlWrapper.so", "libexternal-control.so");
+
+      throw new RuntimeException("Unsupported platform: " + os.name() + "-" + arch.name());
+   }
+
+   private static boolean loaded = false;
+
+   public static boolean load()
+   {
+      if (!loaded)
+      {
+         ExternalControlNativeLibrary lib = new ExternalControlNativeLibrary();
+         loaded = NativeLibraryLoader.loadLibrary(lib);
+      }
+      return loaded;
+   }
+}
\ No newline at end of file
diff --git a/external-control/src/main/resources/externalControl/native/linux-x86_64/libexternal-control.so b/external-control/src/main/resources/externalControl/native/linux-x86_64/libexternal-control.so
new file mode 100644
index 00000000000..77bd0053794
--- /dev/null
+++ b/external-control/src/main/resources/externalControl/native/linux-x86_64/libexternal-control.so
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b37ceed65df67534f81ef6d0bc376fd61849ba2b16d203b9f3acd89fd39b5e2a
+size 480384
diff --git a/external-control/src/main/resources/externalControl/native/linux-x86_64/libjniExternalControlWrapper.so b/external-control/src/main/resources/externalControl/native/linux-x86_64/libjniExternalControlWrapper.so
new file mode 100755
index 00000000000..f11e2ad1934
--- /dev/null
+++ b/external-control/src/main/resources/externalControl/native/linux-x86_64/libjniExternalControlWrapper.so
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c6128c07cfe305ff8b6a20bef768658a37e47535d10131a36349a66ae8d93cc1
+size 84752
diff --git a/external-control/src/test/java/us/ihmc/externalControl/ExternalControlImplTest.java b/external-control/src/test/java/us/ihmc/externalControl/ExternalControlImplTest.java
new file mode 100644
index 00000000000..738e4615967
--- /dev/null
+++ b/external-control/src/test/java/us/ihmc/externalControl/ExternalControlImplTest.java
@@ -0,0 +1,79 @@
+package us.ihmc.externalControl;
+
+import org.ejml.EjmlUnitTests;
+import org.ejml.data.DMatrixRMaj;
+import org.ejml.dense.row.CommonOps_DDRM;
+import org.junit.jupiter.api.Test;
+import us.ihmc.euclid.tools.EuclidCoreRandomTools;
+import us.ihmc.externalControl.global.ExternalControlWrapper;
+import us.ihmc.externalControl.library.ExternalControlNativeLibrary;
+import us.ihmc.matrixlib.MatrixTools;
+
+import java.util.Random;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class ExternalControlImplTest
+{
+   @Test
+   public void testSizes()
+   {
+      ExternalControlNativeLibrary.load();
+
+      Random random = new Random(1738L);
+      double stiffness = 5.0;
+      double damping = 1.0;
+      int joints = 10;
+      ExternalControlWrapper.ExternalControlImpl externalControl = new ExternalControlWrapper.ExternalControlImpl(stiffness, damping, joints);
+
+      for (int i = 0; i < 100; i++)
+      {
+         DMatrixRMaj homeConfiguration = EuclidCoreRandomTools.nextDMatrixRMaj(random, joints, 1);
+         boolean success = externalControl.setHomeJointConfiguration(homeConfiguration.data, homeConfiguration.numRows);
+         assertTrue(success, "Failed to set home configuration.");
+
+         int controlSize = joints;
+         int stateSize = joints * 2 + 13;
+         DMatrixRMaj state = new DMatrixRMaj(stateSize, 1);
+         DMatrixRMaj control = new DMatrixRMaj(controlSize, 1);
+         DMatrixRMaj feet = new DMatrixRMaj(6, 1);
+         success = externalControl.updateRobotState(24.0,
+                                                            state.data,
+                                                            state.numRows,
+                                                            control.data,
+                                                            control.numRows,
+                                                            true,
+                                                            true,
+                                                            feet.data,
+                                                            feet.numRows,
+                                                            0);
+         assertTrue(success, "Failed to successfully compute.");
+
+         DMatrixRMaj returnedState = new DMatrixRMaj(stateSize, 1);
+         DMatrixRMaj returnedControl = new DMatrixRMaj(controlSize, 1);
+         DMatrixRMaj returnedStiffness = new DMatrixRMaj(controlSize, 1);
+         DMatrixRMaj returnedDamping = new DMatrixRMaj(controlSize, 1);
+         success = externalControl.getSolution(returnedState.data, returnedState.numRows,
+                                               returnedControl.data, returnedControl.numRows,
+                                               returnedStiffness.data, returnedStiffness.numRows,
+                                               returnedDamping.data, returnedDamping.numRows);
+         assertTrue(success, "Failed to get the solution");
+
+         DMatrixRMaj expectedState = new DMatrixRMaj(stateSize, 1);
+         DMatrixRMaj expectedControl = new DMatrixRMaj(controlSize, 1);
+         DMatrixRMaj expectedStiffness = new DMatrixRMaj(controlSize, 1);
+         DMatrixRMaj expectedDamping = new DMatrixRMaj(controlSize, 1);
+         CommonOps_DDRM.fill(expectedStiffness, stiffness);
+         CommonOps_DDRM.fill(expectedDamping, damping);
+         MatrixTools.setMatrixBlock(expectedState, 7, 0, homeConfiguration, 0, 0, joints, 1, 1.0);
+
+         double epsilon = 1e-4;
+         EjmlUnitTests.assertEquals(expectedState, returnedState, epsilon);
+         EjmlUnitTests.assertEquals(expectedControl, returnedControl, epsilon);
+         EjmlUnitTests.assertEquals(expectedStiffness, returnedStiffness, epsilon);
+         EjmlUnitTests.assertEquals(expectedDamping, returnedDamping, epsilon);
+      }
+
+   }
+
+}