diff --git a/interface/src/avatar/MyAvatar.cpp b/interface/src/avatar/MyAvatar.cpp
index c1ebd10f81..dfc95a1d8a 100755
--- a/interface/src/avatar/MyAvatar.cpp
+++ b/interface/src/avatar/MyAvatar.cpp
@@ -3308,14 +3308,14 @@ glm::vec3 MyAvatar::scaleMotorSpeed(const glm::vec3 forward, const glm::vec3 rig
             direction = (zSpeed * forward) + (xSpeed * right);
             // Normalize direction.
             direction /= glm::length(direction);
-            return getSensorToWorldScale() * direction * _sprintSpeed.get();
+            return getSensorToWorldScale() * direction * getSprintSpeed();
         } else {
             return Vectors::ZERO;
         }
     case CONTROLS_ANALOG:
         if (zSpeed || xSpeed) {
-            glm::vec3 scaledForward = getSensorToWorldScale() * zSpeed * ((zSpeed >= stickFullOn) ? _sprintSpeed.get() : _walkSpeed.get()) * forward;
-            glm::vec3 scaledRight = getSensorToWorldScale() * xSpeed * ((xSpeed > stickFullOn) ? _sprintSpeed.get() : _walkSpeed.get()) * right;
+            glm::vec3 scaledForward = getSensorToWorldScale() * zSpeed * ((zSpeed >= stickFullOn) ? getSprintSpeed() : getWalkSpeed()) * forward;
+            glm::vec3 scaledRight = getSensorToWorldScale() * xSpeed * ((xSpeed > stickFullOn) ? getSprintSpeed() : getWalkSpeed()) * right;
             direction = scaledForward + scaledRight;
             return direction;
         } else {
@@ -3323,8 +3323,8 @@ glm::vec3 MyAvatar::scaleMotorSpeed(const glm::vec3 forward, const glm::vec3 rig
         }
     case CONTROLS_ANALOG_PLUS:
         if (zSpeed || xSpeed) {
-            glm::vec3 scaledForward = getSensorToWorldScale() * zSpeed * ((zSpeed >= stickFullOn) ? _sprintSpeed.get() : _walkSpeed.get()) * forward;
-            glm::vec3 scaledRight = getSensorToWorldScale() * xSpeed * ((xSpeed > stickFullOn) ? _sprintSpeed.get() : _walkSpeed.get()) * right;
+            glm::vec3 scaledForward = getSensorToWorldScale() * zSpeed * ((zSpeed >= stickFullOn) ? getSprintSpeed() : getWalkSpeed()) * forward;
+            glm::vec3 scaledRight = getSensorToWorldScale() * xSpeed * ((xSpeed > stickFullOn) ? getSprintSpeed() : getWalkSpeed()) * right;
             direction = scaledForward + scaledRight;
             return direction;
         } else {
@@ -4590,11 +4590,27 @@ bool MyAvatar::getIsSitStandStateLocked() const {
 }
 
 float MyAvatar::getWalkSpeed() const {
-    return _walkSpeed.get() * _walkSpeedScalar;
+    switch(_controlSchemeIndex) {
+    case CONTROLS_ANALOG:
+        return _analogWalkSpeed.get() * _walkSpeedScalar;
+    case CONTROLS_ANALOG_PLUS:
+        return _analogPlusWalkSpeed.get() * _walkSpeedScalar;
+    case CONTROLS_DEFAULT:
+    default:
+        return _defaultWalkSpeed.get() * _walkSpeedScalar;
+    }
 }
 
 float MyAvatar::getWalkBackwardSpeed() const {
-    return _walkSpeed.get() * _walkSpeedScalar;
+    switch(_controlSchemeIndex) {
+    case CONTROLS_ANALOG:
+        return _analogWalkBackwardSpeed.get() * _walkSpeedScalar;
+    case CONTROLS_ANALOG_PLUS:
+        return _analogPlusWalkBackwardSpeed.get() * _walkSpeedScalar;
+    case CONTROLS_DEFAULT:
+    default:
+        return _defaultWalkBackwardSpeed.get() * _walkSpeedScalar;
+    }
 }
 
 bool MyAvatar::isReadyForPhysics() const {
@@ -4602,7 +4618,19 @@ bool MyAvatar::isReadyForPhysics() const {
 }
 
 void MyAvatar::setSprintMode(bool sprint) {
-    _walkSpeedScalar = sprint ? _sprintSpeed.get() : AVATAR_WALK_SPEED_SCALAR;
+    float value = AVATAR_WALK_SPEED_SCALAR;
+    if (sprint) {
+        switch(_controlSchemeIndex) {
+        case CONTROLS_ANALOG:
+            value = _analogSprintSpeed.get() * _walkSpeedScalar;
+        case CONTROLS_ANALOG_PLUS:
+            value = _analogPlusSprintSpeed.get() * _walkSpeedScalar;
+        case CONTROLS_DEFAULT:
+        default:
+            value = _defaultSprintSpeed.get() * _walkSpeedScalar;
+        }
+    }
+    _walkSpeedScalar = value;
 }
 
 void MyAvatar::setIsInWalkingState(bool isWalking) {
@@ -4665,19 +4693,63 @@ void MyAvatar::setIsSitStandStateLocked(bool isLocked) {
 }
 
 void MyAvatar::setWalkSpeed(float value) {
-    _walkSpeed.set(value);
+    switch(_controlSchemeIndex) {
+    case CONTROLS_DEFAULT:
+        _defaultWalkSpeed.set(value);
+        break;
+    case CONTROLS_ANALOG:
+        _analogWalkSpeed.set(value);
+        break;
+    case CONTROLS_ANALOG_PLUS:
+        _analogPlusWalkSpeed.set(value);
+        break;
+    default:
+        break;
+    }
 }
 
 void MyAvatar::setWalkBackwardSpeed(float value) {
-    _walkBackwardSpeed.set(value);
+    switch(_controlSchemeIndex) {
+    case CONTROLS_DEFAULT:
+        _defaultWalkBackwardSpeed.set(value);
+        break;
+    case CONTROLS_ANALOG:
+        _analogWalkBackwardSpeed.set(value);
+        break;
+    case CONTROLS_ANALOG_PLUS:
+        _analogPlusWalkBackwardSpeed.set(value);
+        break;
+    default:
+        break;
+    }
 }
 
 void MyAvatar::setSprintSpeed(float value) {
-    _sprintSpeed.set(value);
+    switch(_controlSchemeIndex) {
+    case CONTROLS_DEFAULT:
+        _defaultSprintSpeed.set(value);
+        break;
+    case CONTROLS_ANALOG:
+        _analogSprintSpeed.set(value);
+        break;
+    case CONTROLS_ANALOG_PLUS:
+        _analogPlusSprintSpeed.set(value);
+        break;
+    default:
+        break;
+    }
 }
 
 float MyAvatar::getSprintSpeed() const {
-    return _sprintSpeed.get();
+    switch(_controlSchemeIndex) {
+    case CONTROLS_ANALOG:
+        return _analogSprintSpeed.get();
+    case CONTROLS_ANALOG_PLUS:
+        return _analogPlusSprintSpeed.get();
+    case CONTROLS_DEFAULT:
+    default:
+        return _defaultSprintSpeed.get();
+    }
 }
 
 void MyAvatar::setSitStandStateChange(bool stateChanged) {
diff --git a/interface/src/avatar/MyAvatar.h b/interface/src/avatar/MyAvatar.h
index e6f967e563..eee8036235 100644
--- a/interface/src/avatar/MyAvatar.h
+++ b/interface/src/avatar/MyAvatar.h
@@ -2047,9 +2047,16 @@ private:
     ThreadSafeValueCache<bool> _lockSitStandState { false };
 
     // max unscaled forward movement speed
-    ThreadSafeValueCache<float> _walkSpeed { DEFAULT_AVATAR_MAX_WALKING_SPEED };
-    ThreadSafeValueCache<float> _walkBackwardSpeed { DEFAULT_AVATAR_MAX_WALKING_BACKWARD_SPEED };
-    ThreadSafeValueCache<float> _sprintSpeed { AVATAR_SPRINT_SPEED_SCALAR };
+    ThreadSafeValueCache<float> _defaultWalkSpeed { DEFAULT_AVATAR_MAX_WALKING_SPEED };
+    ThreadSafeValueCache<float> _defaultWalkBackwardSpeed { DEFAULT_AVATAR_MAX_WALKING_BACKWARD_SPEED };
+    ThreadSafeValueCache<float> _defaultSprintSpeed { DEFAULT_AVATAR_MAX_SPRINT_SPEED };
+    ThreadSafeValueCache<float> _analogWalkSpeed { ANALOG_AVATAR_MAX_WALKING_SPEED };
+    ThreadSafeValueCache<float> _analogWalkBackwardSpeed { ANALOG_AVATAR_MAX_WALKING_BACKWARD_SPEED };
+    ThreadSafeValueCache<float> _analogSprintSpeed { ANALOG_AVATAR_MAX_SPRINT_SPEED };
+    ThreadSafeValueCache<float> _analogPlusWalkSpeed { ANALOG_PLUS_AVATAR_MAX_WALKING_SPEED };
+    ThreadSafeValueCache<float> _analogPlusWalkBackwardSpeed { ANALOG_PLUS_AVATAR_MAX_WALKING_BACKWARD_SPEED };
+    ThreadSafeValueCache<float> _analogPlusSprintSpeed { ANALOG_PLUS_AVATAR_MAX_SPRINT_SPEED };
+
     float _walkSpeedScalar { AVATAR_WALK_SPEED_SCALAR };
     bool _isInWalkingState { false };
     ThreadSafeValueCache<bool> _isInSittingState { false };
diff --git a/libraries/shared/src/AvatarConstants.h b/libraries/shared/src/AvatarConstants.h
index 87da47a27a..d4af94e68c 100644
--- a/libraries/shared/src/AvatarConstants.h
+++ b/libraries/shared/src/AvatarConstants.h
@@ -68,7 +68,18 @@ const glm::quat DEFAULT_AVATAR_RIGHTFOOT_ROT { -0.4016716778278351f, 0.915461599
 const float DEFAULT_AVATAR_MAX_WALKING_SPEED = 2.6f; // meters / second
 const float DEFAULT_AVATAR_MAX_WALKING_BACKWARD_SPEED = 2.2f; // meters / second
 const float DEFAULT_AVATAR_MAX_FLYING_SPEED = 30.0f; // meters / second
-const float DEFAULT_AVATAR_WALK_SPEED_THRESHOLD = 0.15f;
+const float DEFAULT_AVATAR_MAX_SPRINT_SPEED = 3.0f; // meters / second
+const float DEFAULT_AVATAR_WALK_SPEED_THRESHOLD = 0.15f; // meters / second
+
+const float ANALOG_AVATAR_MAX_WALKING_SPEED = 2.6f; // meters / second
+const float ANALOG_AVATAR_MAX_WALKING_BACKWARD_SPEED = 2.2f; // meters / second
+const float ANALOG_AVATAR_MAX_FLYING_SPEED = 30.0f; // meters / second
+const float ANALOG_AVATAR_MAX_SPRINT_SPEED = 3.0f; // meters / second
+
+const float ANALOG_PLUS_AVATAR_MAX_WALKING_SPEED = 3.3f; // meters / second
+const float ANALOG_PLUS_AVATAR_MAX_WALKING_BACKWARD_SPEED = 2.42f; // meters / second
+const float ANALOG_PLUS_AVATAR_MAX_FLYING_SPEED = 30.0f; // meters / second
+const float ANALOG_PLUS_AVATAR_MAX_SPRINT_SPEED = 4.0f; // meters / second
 
 const float DEFAULT_AVATAR_GRAVITY = -5.0f; // meters / second^2 (world)
 const float DEFAULT_AVATAR_JUMP_SPEED = 3.5f; // meters / second (sensor)