diff --git a/interface/src/avatar/AvatarManager.cpp b/interface/src/avatar/AvatarManager.cpp
index c0dbca7829..947559d5bd 100644
--- a/interface/src/avatar/AvatarManager.cpp
+++ b/interface/src/avatar/AvatarManager.cpp
@@ -83,20 +83,10 @@ AvatarManager::AvatarManager(QObject* parent) :
     const int AVATAR_TRANSIT_FRAME_COUNT = 11; // Based on testing
     const int AVATAR_TRANSIT_FRAMES_PER_METER = 1; // Based on testing
 
-    const QString START_ANIMATION_URL = "https://hifi-content.s3.amazonaws.com/luis/test_scripts/transitApp/animations/teleport01_warp.fbx";
-    const QString MIDDLE_ANIMATION_URL = "https://hifi-content.s3.amazonaws.com/luis/test_scripts/transitApp/animations/teleport01_warp.fbx";
-    const QString END_ANIMATION_URL = "https://hifi-content.s3.amazonaws.com/luis/test_scripts/transitApp/animations/teleport01_warp.fbx";
-
     _transitConfig._totalFrames = AVATAR_TRANSIT_FRAME_COUNT;
     _transitConfig._triggerDistance = AVATAR_TRANSIT_TRIGGER_DISTANCE;
     _transitConfig._framesPerMeter = AVATAR_TRANSIT_FRAMES_PER_METER;
     _transitConfig._isDistanceBased = true;
-    
-    _transitConfig._startTransitAnimation = AvatarTransit::TransitAnimation(START_ANIMATION_URL, 0, 14);
-    _transitConfig._middleTransitAnimation = AvatarTransit::TransitAnimation(MIDDLE_ANIMATION_URL, 15, 0);
-    _transitConfig._endTransitAnimation = AvatarTransit::TransitAnimation(END_ANIMATION_URL, 16, 38);    
-    
-    setAvatarTransitEffectDefaultProperties();
 }
 
 AvatarSharedPointer AvatarManager::addAvatar(const QUuid& sessionUUID, const QWeakPointer<Node>& mixerWeakPointer) {
@@ -144,57 +134,13 @@ void AvatarManager::setSpace(workload::SpacePointer& space ) {
     _space = space;
 }
 
-void AvatarManager::playTransitAnimations(AvatarTransit::Status status) {
-    auto startAnimation = _transitConfig._startTransitAnimation;
-    auto middleAnimation = _transitConfig._middleTransitAnimation;
-    auto endAnimation = _transitConfig._endTransitAnimation;
-    
-    const float REFERENCE_FPS = 30.0f;
-
-    switch (status) {
-    case AvatarTransit::Status::START_FRAME:
-        qDebug() << "START_FRAME";
-        _myAvatar->overrideAnimation(startAnimation._animationUrl, REFERENCE_FPS, false, startAnimation._firstFrame, startAnimation._firstFrame + startAnimation._frameCount);
-        break;
-    case AvatarTransit::Status::START_TRANSIT:
-        qDebug() << "START_TRANSIT";
-        _myAvatar->overrideAnimation(middleAnimation._animationUrl, REFERENCE_FPS, false, middleAnimation._firstFrame, middleAnimation._firstFrame + middleAnimation._frameCount);
-        break;
-    case AvatarTransit::Status::END_TRANSIT:
-        qDebug() << "END_TRANSIT";
-        _myAvatar->overrideAnimation(endAnimation._animationUrl, REFERENCE_FPS, false, endAnimation._firstFrame, endAnimation._firstFrame + endAnimation._frameCount);
-        break;
-    case AvatarTransit::Status::END_FRAME:
-        qDebug() << "END_FRAME";
-        _myAvatar->restoreAnimation();
-        break;
-    case AvatarTransit::Status::IDLE:
-        break;
-    case AvatarTransit::Status::TRANSITING:
-        break;
-    }
-
-}
-
 void AvatarManager::updateMyAvatar(float deltaTime) {
     bool showWarnings = Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings);
     PerformanceWarning warn(showWarnings, "AvatarManager::updateMyAvatar()");
 
     AvatarTransit::Status status = _myAvatar->updateTransit(deltaTime, _myAvatar->getNextPosition(), _transitConfig);
     bool sendFirstTransitPackage = (status == AvatarTransit::Status::START_TRANSIT);
-    bool sendAllTransitPackages = (status == AvatarTransit::Status::TRANSITING && _transitConfig._showAnimation);
-    bool blockTransitData = (status == AvatarTransit::Status::TRANSITING && !_transitConfig._showAnimation);
-    
-    if (status != AvatarTransit::Status::IDLE) {
-        if (_transitConfig._showAnimation) {
-            blockTransitData = false;
-            playTransitAnimations(status);
-        }
-        if (status != AvatarTransit::Status::TRANSITING) {
-            QUuid& transitEffectID = _myAvatar->getTransitEffectID();
-            changeAvatarTransitState(status, _myAvatar->getID(), transitEffectID);
-        }
-    }
+    bool blockTransitData = (status == AvatarTransit::Status::TRANSITING);
 
     _myAvatar->update(deltaTime);
     render::Transaction transaction;
@@ -210,9 +156,7 @@ void AvatarManager::updateMyAvatar(float deltaTime) {
         PerformanceTimer perfTimer("send");
         if (sendFirstTransitPackage) {
             _myAvatar->overrideNextPackagePositionData(_myAvatar->getTransit()->getEndPosition());
-        } else if (sendAllTransitPackages) {
-            _myAvatar->overrideNextPackagePositionData(_myAvatar->getTransit()->getCurrentPosition());
-        }        
+        }       
         _myAvatar->sendAvatarDataPacket();
         _lastSendAvatarDataTime = now;
         _myAvatarSendRate.increment();
@@ -334,11 +278,6 @@ void AvatarManager::updateOtherAvatars(float deltaTime) {
             // smooth other avatars positions
             {
                 auto status = avatar->_transit.update(deltaTime, avatar->_globalPosition, _transitConfig);
-                if (status != AvatarTransit::Status::IDLE && status != AvatarTransit::Status::TRANSITING) {
-                    QUuid& transitEffectID = avatar->getTransitEffectID();
-                    changeAvatarTransitState(status, avatar->getID(), transitEffectID);
-                }
-
             }
             
             avatar->simulate(deltaTime, inView);
@@ -940,9 +879,7 @@ QVariantMap AvatarManager::getAvatarTransitData() {
     result["framesPerMeter"] = _transitConfig._framesPerMeter;
     result["isDistanceBased"] = _transitConfig._isDistanceBased;
     result["triggerDistance"] = _transitConfig._triggerDistance;
-    result["showAnimation"] = _transitConfig._showAnimation;
     result["easeType"] = (int)_transitConfig._easeType;
-    result["showParticles"] = _transitConfig._showParticles;
 
     return result;
 }
@@ -960,251 +897,7 @@ void AvatarManager::setAvatarTransitData(const QVariantMap& data) {
     if (data.contains("triggerDistance")) {
         _transitConfig._triggerDistance = data["triggerDistance"].toDouble();
     }
-    if (data.contains("showAnimation")) {
-        _transitConfig._showAnimation = data["showAnimation"].toBool();
-    }
     if (data.contains("easeType")) {
         _transitConfig._easeType = (AvatarTransit::EaseType)data["easeType"].toInt();
     }
-    if (data.contains("showParticles")) {
-        _transitConfig._showParticles = data["showParticles"].toBool();
-    }
-}
-
-AvatarTransit::TransitAnimation AvatarManager::getAnimationFromJsonObject(const QJsonObject& object) {
-    QString animationUrl;
-    int firstFrame = 0;
-    int frameCount = 0;
-    if (object.contains("animationUrl")) {
-        animationUrl = object["animationUrl"].toString();
-    }
-    if (object.contains("firstFrame")) {
-        firstFrame = object["firstFrame"].toInt();
-    }
-    if (object.contains("frameCount")) {
-        frameCount = object["frameCount"].toInt();
-    }
-    return AvatarTransit::TransitAnimation(animationUrl, firstFrame, frameCount);
-}
-
-void AvatarManager::setAvatarTransitAnimationData(const QVariantMap& data) {
-    AvatarTransit::TransitAnimation startAnimation, middleAnimation, endAnimation;
-
-    if (data.contains("startAnimation")) {
-        QJsonObject object = data["startAnimation"].toJsonObject();
-        _transitConfig._startTransitAnimation = getAnimationFromJsonObject(object);
-    }
-    if (data.contains("middleAnimation")) {
-        QJsonObject object = data["middleAnimation"].toJsonObject();
-        _transitConfig._middleTransitAnimation = getAnimationFromJsonObject(object);
-    }
-    if (data.contains("endAnimation")) {
-        QJsonObject object = data["endAnimation"].toJsonObject();
-        _transitConfig._endTransitAnimation = getAnimationFromJsonObject(object);
-    }
-}
-
-void AvatarManager::changeAvatarTransitState(AvatarTransit::Status status, const QUuid& avatarID, QUuid& effectID) {
-
-    if (!_transitConfig._showParticles) {
-        return;
-    }
-    _transitEffectProperties.setParentID(avatarID);
-    std::shared_ptr<Avatar> avatar;
-    avatar = (avatarID != _myAvatar->getID()) ? std::static_pointer_cast<Avatar>(getAvatarBySessionID(avatarID)) : _myAvatar;
-
-    _transitEffectProperties.setLifetime(_transitEffectProperties.getLifespan() + avatar->getTransit()->getTransitTime());
-    float feetOffset = glm::length(avatar->getWorldPosition() - avatar->getWorldFeetPosition());        
-    _transitEffectProperties.setLocalPosition(glm::vec3(0.0f, -feetOffset, 0.0f));
-
-    EntityItemProperties props;
-    switch (status) {
-    case AvatarTransit::Status::IDLE:
-    case AvatarTransit::Status::TRANSITING:
-    case AvatarTransit::Status::START_FRAME:
-    case AvatarTransit::Status::END_FRAME:
-        break;
-    case AvatarTransit::Status::START_TRANSIT:
-        effectID = DependencyManager::get<EntityScriptingInterface>()->addEntity(_transitEffectProperties);
-        break;
-    case AvatarTransit::Status::END_TRANSIT:
-        props = DependencyManager::get<EntityScriptingInterface>()->getEntityProperties(effectID);
-        props.setIsEmitting(false);
-        auto nid = DependencyManager::get<EntityScriptingInterface>()->editEntity(effectID, props);
-        break;
-    }
-}
-
-void AvatarManager::setAvatarTransitEffectData(const QVariantMap& data) {
-    auto jsonToVector = [](const QJsonObject& object) {
-        if (object.contains("x") && object.contains("y") && object.contains("z")) {
-            float x = (float)object["x"].toDouble();
-            float y = (float)object["y"].toDouble();
-            float z = (float)object["z"].toDouble();
-            return glm::vec3(x, y, z);
-        }
-        return glm::vec3(0.0f, 0.0f, 0.0f);
-    };
-    
-    auto jsonToQuat = [jsonToVector](const QJsonObject& object) {
-        glm::vec3 components = jsonToVector(object);
-        if (object.contains("w")) {
-            float w = (float)object["w"].toDouble();
-            return glm::quat(components.x, components.y, components.z, w);
-        }
-        return Quaternions::IDENTITY;
-    };
-
-    auto jsonToColor = [jsonToVector](const QJsonObject& object) {
-        glm::vec3 components = jsonToVector(object);
-        return xColor(components.x, components.y, components.z);
-    };
-        
-    _transitEffectProperties.setType(EntityTypes::ParticleEffect);
-
-    if (data.contains("isEmitting")) {
-        _transitEffectProperties.setIsEmitting(data["isEmitting"].toBool());
-    }
-    if (data.contains("lifetime")) {
-        _transitEffectProperties.setLifetime(data["lifetime"].toFloat());
-    }
-    if (data.contains("lifespan")) {
-        _transitEffectProperties.setLifespan(data["lifespan"].toFloat());
-    }
-    if (data.contains("maxParticles")) {
-        _transitEffectProperties.setMaxParticles(data["maxParticles"].toFloat());
-    }
-    if (data.contains("emitRate")) {
-        _transitEffectProperties.setEmitRate(data["emitRate"].toFloat());
-    }
-    if (data.contains("emitSpeed")) {
-        _transitEffectProperties.setEmitSpeed(data["emitSpeed"].toFloat());
-    }
-    if (data.contains("speedSpread")) {
-        _transitEffectProperties.setSpeedSpread(data["speedSpread"].toFloat());
-    }
-    if (data.contains("localPosition")) {
-        _transitEffectProperties.setLocalPosition(jsonToVector(data["localPosition"].toJsonObject()));
-    }
-    if (data.contains("emitDimensions")) {
-        _transitEffectProperties.setEmitDimensions(jsonToVector(data["emitDimensions"].toJsonObject()));
-    }
-    if (data.contains("emitOrientation")) {
-        _transitEffectProperties.setEmitOrientation(jsonToQuat(data["emitOrientation"].toJsonObject()));
-    }
-    if (data.contains("emitterShouldTrail")) {
-        _transitEffectProperties.setEmitterShouldTrail(data["emitterShouldTrail"].toBool());
-    }
-    if (data.contains("particleRadius")) {
-        _transitEffectProperties.setParticleRadius(data["particleRadius"].toFloat());
-    }
-    if (data.contains("radiusSpread")) {
-        _transitEffectProperties.setRadiusSpread(data["radiusSpread"].toFloat());
-    }
-    if (data.contains("radiusStart")) {
-        _transitEffectProperties.setRadiusStart(data["radiusStart"].toFloat());
-    }
-    if (data.contains("radiusFinish")) {
-        _transitEffectProperties.setRadiusFinish(data["radiusFinish"].toFloat());
-    }
-    if (data.contains("color")) {
-        _transitEffectProperties.setColor(jsonToColor(data["color"].toJsonObject()));
-    }
-    if (data.contains("colorStart")) {
-        _transitEffectProperties.setColorStart(jsonToVector(data["colorStart"].toJsonObject()));
-    }
-    if (data.contains("colorFinish")) {
-        _transitEffectProperties.setColorFinish(jsonToVector(data["colorFinish"].toJsonObject()));
-    }
-    if (data.contains("emitAcceleration")) {
-        _transitEffectProperties.setEmitAcceleration(jsonToVector(data["emitAcceleration"].toJsonObject()));
-    }
-    if (data.contains("alpha")) {
-        _transitEffectProperties.setAlpha(data["alpha"].toFloat());
-    }
-    if (data.contains("accelerationSpread")) {
-        _transitEffectProperties.setAccelerationSpread(jsonToVector(data["accelerationSpread"].toJsonObject()));
-    }
-    if (data.contains("alphaSpread")) {
-        _transitEffectProperties.setAlphaSpread(data["alphaSpread"].toFloat());
-    }
-    if (data.contains("alphaStart")) {
-        _transitEffectProperties.setAlphaStart(data["alphaStart"].toFloat());
-    }
-    if (data.contains("alphaFinish")) {
-        _transitEffectProperties.setAlphaFinish(data["alphaFinish"].toFloat());
-    }
-    if (data.contains("particleSpin")) {
-        _transitEffectProperties.setParticleSpin(data["particleSpin"].toFloat());
-    }
-    if (data.contains("textures")) {
-        _transitEffectProperties.setTextures(data["textures"].toString());
-    }
-    if (data.contains("spinSpread")) {
-        _transitEffectProperties.setSpinSpread(data["spinSpread"].toFloat());
-    }
-    if (data.contains("spinStart")) {
-        _transitEffectProperties.setSpinStart(data["spinStart"].toFloat());
-    }
-    if (data.contains("spinFinish")) {
-        _transitEffectProperties.setSpinFinish(data["spinFinish"].toFloat());
-    }
-    if (data.contains("rotateWithEntity")) {
-        _transitEffectProperties.setRotateWithEntity(data["rotateWithEntity"].toBool());
-    }
-    if (data.contains("polarStart")) {
-        _transitEffectProperties.setPolarStart(data["polarStart"].toFloat());
-    }
-    if (data.contains("polarFinish")) {
-        _transitEffectProperties.setPolarFinish(data["polarFinish"].toFloat());
-    }
-    if (data.contains("azimuthStart")) {
-        _transitEffectProperties.setAzimuthStart(data["azimuthStart"].toFloat());
-    }
-    if (data.contains("azimuthFinish")) {
-        _transitEffectProperties.setAzimuthFinish(data["azimuthFinish"].toFloat());
-    }
-    if (data.contains("userData")) {
-        _transitEffectProperties.setUserData(data["userData"].toString());
-    } else {
-        _transitEffectProperties.setUserData("{\"grabbableKey\":{\"grabbable\":false}}");
-    }
-}
-
-void AvatarManager::setAvatarTransitEffectDefaultProperties() {
-    _transitEffectProperties.setIsEmitting(true);
-    _transitEffectProperties.setLifespan(2.7f);
-    _transitEffectProperties.setMaxParticles(200.0f);
-    _transitEffectProperties.setEmitRate(200.0);
-    _transitEffectProperties.setEmitSpeed(2.8f);
-    _transitEffectProperties.setSpeedSpread(0.2f);
-    _transitEffectProperties.setEmitDimensions(glm::vec3(0.0f, 0.0f, 0.0f));
-    _transitEffectProperties.setEmitOrientation(Quaternions::X_180);
-    _transitEffectProperties.setEmitterShouldTrail(true);
-    _transitEffectProperties.setParticleRadius(0.24f);
-    _transitEffectProperties.setRadiusSpread(0.0f);
-    _transitEffectProperties.setRadiusStart(0.0f);
-    _transitEffectProperties.setRadiusFinish(0.21f);
-    _transitEffectProperties.setColor(xColor(0.0f, 180.0f, 239.0f));
-    _transitEffectProperties.setColorStart(glm::vec3(200.0f, 200.0f, 200.0f));
-    _transitEffectProperties.setColorFinish(glm::vec3(0.0f, 0.0f, 0.0f));
-    _transitEffectProperties.setEmitAcceleration(glm::vec3(0.0f, 0.0f, 0.0f));
-    _transitEffectProperties.setAlpha(0.15f);
-    _transitEffectProperties.setAccelerationSpread(glm::vec3(0.5f, 1.0f, 0.5f));
-    _transitEffectProperties.setAlphaSpread(0.0f);
-    _transitEffectProperties.setAlphaStart(0.3f);
-    _transitEffectProperties.setAlphaFinish(0.0f);
-    _transitEffectProperties.setParticleSpin(4.78f);
-    _transitEffectProperties.setType(EntityTypes::ParticleEffect);
-    _transitEffectProperties.setTextures("http://hifi-content.s3.amazonaws.com/alexia/Particles/spark.png");
-    _transitEffectProperties.setSpinSpread(0.0f);
-    _transitEffectProperties.setSpinStart(-4.57f);
-    _transitEffectProperties.setSpinFinish(4.67f);
-    _transitEffectProperties.setRotateWithEntity(false);
-    _transitEffectProperties.setPolarStart(0.0f);
-    _transitEffectProperties.setPolarFinish(0.0f);
-    _transitEffectProperties.setAzimuthStart(-3.1415f);
-    _transitEffectProperties.setAzimuthFinish(3.1415f);
-    _transitEffectProperties.setRotateWithEntity(true);
-    _transitEffectProperties.setUserData("{\"grabbableKey\":{\"grabbable\":false}}");
 }
diff --git a/interface/src/avatar/AvatarManager.h b/interface/src/avatar/AvatarManager.h
index 73e350ebe5..9fdc33b096 100644
--- a/interface/src/avatar/AvatarManager.h
+++ b/interface/src/avatar/AvatarManager.h
@@ -184,8 +184,6 @@ public:
 
     Q_INVOKABLE QVariantMap getAvatarTransitData();
     Q_INVOKABLE void setAvatarTransitData(const QVariantMap& data);
-    Q_INVOKABLE void setAvatarTransitAnimationData(const QVariantMap& data);
-    Q_INVOKABLE void setAvatarTransitEffectData(const QVariantMap& data);
 
     float getMyAvatarSendRate() const { return _myAvatarSendRate.rate(); }
     int getIdentityRequestsSent() const { return _identityRequestsSent; }
@@ -209,14 +207,9 @@ private:
     explicit AvatarManager(const AvatarManager& other);
 
     void simulateAvatarFades(float deltaTime);
-    void changeAvatarTransitState(AvatarTransit::Status status, const QUuid& avatarID, QUuid& effectID);
 
     AvatarSharedPointer newSharedAvatar() override;
     void handleRemovedAvatar(const AvatarSharedPointer& removedAvatar, KillAvatarReason removalReason = KillAvatarReason::NoReason) override;
-    void playTransitAnimations(AvatarTransit::Status status);
-
-    AvatarTransit::TransitAnimation getAnimationFromJsonObject(const QJsonObject& object);
-    void AvatarManager::setAvatarTransitEffectDefaultProperties();
 
     QVector<AvatarSharedPointer> _avatarsToFade;
     QVector<AvatarSharedPointer> _avatarsToCopy;
diff --git a/interface/src/avatar/MyAvatar.cpp b/interface/src/avatar/MyAvatar.cpp
index ee5512c63a..362fc90a0e 100755
--- a/interface/src/avatar/MyAvatar.cpp
+++ b/interface/src/avatar/MyAvatar.cpp
@@ -616,8 +616,6 @@ void MyAvatar::updateChildCauterization(SpatiallyNestablePointer object, bool ca
 void MyAvatar::simulate(float deltaTime) {
     PerformanceTimer perfTimer("simulate");
     animateScaleChanges(deltaTime);
-    // CameraMode mode = qApp->getCamera().getMode();
-    // bool shouldTransit = (mode == CAMERA_MODE_THIRD_PERSON || mode == CAMERA_MODE_INDEPENDENT);
     if (_transit.isTransiting() && _showTransit) {
         glm::vec3 nextPosition;
         if (_transit.getNextPosition(nextPosition)) {
diff --git a/interface/src/avatar/MyAvatar.h b/interface/src/avatar/MyAvatar.h
index d7bbe64fb4..c77f1e781d 100644
--- a/interface/src/avatar/MyAvatar.h
+++ b/interface/src/avatar/MyAvatar.h
@@ -1797,7 +1797,6 @@ private:
     ThreadSafeValueCache<float> _userHeight { DEFAULT_AVATAR_HEIGHT };
 
     void updateChildCauterization(SpatiallyNestablePointer object, bool cauterize);
-    void playTransitAnimations(AvatarTransit::Status status);
 
     bool _showTransit { false };
     // max unscaled forward movement speed
diff --git a/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp b/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp
index e124b533a2..b4b213dc87 100644
--- a/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp
+++ b/libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp
@@ -133,18 +133,10 @@ void AvatarTransit::start(float deltaTime, const glm::vec3& startPosition, const
     _transitLine = endPosition - startPosition;
     _totalDistance = glm::length(_transitLine);
     _easeType = config._easeType;
-    _showAnimation = config._showAnimation;
-    _showParticles = config._showParticles;
     const float REFERENCE_FRAMES_PER_SECOND = 30.0f;
-
-    int framesBefore = _showAnimation ? config._startTransitAnimation._frameCount : 0;
-    int framesAfter = _showAnimation ? config._endTransitAnimation._frameCount : 0;
-    _timeBefore = (float)framesBefore / REFERENCE_FRAMES_PER_SECOND;
-    _timeAfter = (float)framesAfter / REFERENCE_FRAMES_PER_SECOND;
         
     int transitFrames = (!config._isDistanceBased) ? config._totalFrames : config._framesPerMeter * _totalDistance;
-    _transitTime = (float)transitFrames / REFERENCE_FRAMES_PER_SECOND;
-    _totalTime = _transitTime + _timeBefore + _timeAfter;
+    _totalTime = (float)transitFrames / REFERENCE_FRAMES_PER_SECOND;
     _currentTime = 0.0f;
     _isTransiting = true;
 }
@@ -172,29 +164,19 @@ AvatarTransit::Status AvatarTransit::updatePosition(float deltaTime) {
     if (_isTransiting) {
         float nextTime = _currentTime + deltaTime;
         glm::vec3 newPosition;
-        if (nextTime < _timeBefore) {
-            _currentPosition = _startPosition;
-            if (_currentTime == 0) {
-                status = Status::START_FRAME;
-            }
-        } else if (nextTime >= _totalTime - _timeAfter) {
-            if (_currentTime < _totalTime - _timeAfter) {
-                status = Status::END_TRANSIT;
-            } else if (nextTime >= _totalTime) {
-                status = Status::END_FRAME;
-                _isTransiting = false;
-            }
+        if (nextTime >= _totalTime) {
             _currentPosition = _endPosition;
+            _isTransiting = false;
+            status = Status::END_TRANSIT;
         } else {
-            if (_currentTime <= _timeBefore) {
+            if (_currentTime == 0) {
                 status = Status::START_TRANSIT;
             } else {
                 status = Status::TRANSITING;
             }
-            float percentageIntoTransit = (nextTime - _timeBefore) / _transitTime;
-            
+            float percentageIntoTransit = nextTime / _totalTime;
             _currentPosition = _startPosition + getEaseValue(_easeType, percentageIntoTransit) * _transitLine;
-        } 
+        }
         _currentTime = nextTime;
     }
     return status;
diff --git a/libraries/avatars-renderer/src/avatars-renderer/Avatar.h b/libraries/avatars-renderer/src/avatars-renderer/Avatar.h
index 9de1127391..fe5d310812 100644
--- a/libraries/avatars-renderer/src/avatars-renderer/Avatar.h
+++ b/libraries/avatars-renderer/src/avatars-renderer/Avatar.h
@@ -54,11 +54,9 @@ class AvatarTransit {
 public:
     enum Status {
         IDLE = 0,
-        START_FRAME,
         START_TRANSIT,
         TRANSITING,
-        END_TRANSIT,
-        END_FRAME
+        END_TRANSIT
     };
 
     enum EaseType {
@@ -68,27 +66,13 @@ public:
         EASE_IN_OUT
     };
 
-    struct TransitAnimation {
-        TransitAnimation() {};
-        TransitAnimation(const QString& animationUrl, int firstFrame, int frameCount) :
-            _firstFrame(firstFrame), _frameCount(frameCount), _animationUrl(animationUrl) {};
-        int _firstFrame;
-        int _frameCount;
-        QString _animationUrl;
-    };
-
     struct TransitConfig {
         TransitConfig() {};
         int _totalFrames { 0 };
         int _framesPerMeter { 0 };
         bool _isDistanceBased { false };
         float _triggerDistance { 0 };
-        bool _showAnimation { false };
         EaseType _easeType { EaseType::EASE_OUT };
-        bool _showParticles { false };
-        TransitAnimation _startTransitAnimation;
-        TransitAnimation _middleTransitAnimation;
-        TransitAnimation _endTransitAnimation;
     };
 
     AvatarTransit() {};
@@ -117,13 +101,8 @@ private:
     float _totalDistance { 0.0f };
     float _totalTime { 0.0f };
     float _currentTime { 0.0f };
-    float _transitTime { 0.0f };
-    float _timeBefore { 0.0f };
-    float _timeAfter { 0.0f };
     EaseType _easeType { EaseType::EASE_OUT };
     Status _status { Status::IDLE };
-    bool _showAnimation { false };
-    bool _showParticles { false };
     float _scale { 1.0f };
 };
 
@@ -452,7 +431,6 @@ public:
     AvatarTransit::Status updateTransit(float deltaTime, const glm::vec3& avatarPosition, const AvatarTransit::TransitConfig& config);
     void setTransitScale(float scale);
 
-    QUuid& getTransitEffectID() { return _transitEffectID; };
     void overrideNextPackagePositionData(const glm::vec3& position);
 
 signals:
@@ -639,7 +617,6 @@ protected:
     static const float OTHERAVATAR_LOADING_PRIORITY;
     static const float ATTACHMENT_LOADING_PRIORITY;
 
-    QUuid _transitEffectID{ QUuid::createUuid() };
     LoadingStatus _loadingStatus { LoadingStatus::NoModel };
 };