diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp
index f82756b995..a6555352dd 100644
--- a/interface/src/Application.cpp
+++ b/interface/src/Application.cpp
@@ -1674,8 +1674,7 @@ void Application::paintGL() {
         renderArgs._boomOffset = boomOffset;
         // Viewport is assigned to the size of the framebuffer
         renderArgs._viewport = ivec4(0, 0, size.width(), size.height());
-     //   if (displayPlugin->isStereo()) {
-        if (true) {
+        if (displayPlugin->isStereo()) {
             // Stereo modes will typically have a larger projection matrix overall,
             // so we ask for the 'mono' projection matrix, which for stereo and HMD
             // plugins will imply the combined projection for both eyes.
diff --git a/libraries/gpu/src/gpu/GLBackend.cpp b/libraries/gpu/src/gpu/GLBackend.cpp
index e16407a449..b44d4e97ef 100644
--- a/libraries/gpu/src/gpu/GLBackend.cpp
+++ b/libraries/gpu/src/gpu/GLBackend.cpp
@@ -251,26 +251,20 @@ void GLBackend::render(Batch& batch) {
         PROFILE_RANGE("Transfer");
         renderPassTransfer(batch);
     }
-  //  _stereo._enable =batch.isStereoEnabled();
     
-    if (_stereo._enable)
+    if (_stereo._enable) {
         glEnable(GL_CLIP_DISTANCE0);
+    }
 
     {
-        PROFILE_RANGE(_stereo._enable ? "LeftRender" : "Render");
+        PROFILE_RANGE(_stereo._enable ? "Render Stereo" : "Render");
         renderPassDraw(batch);
     }
 
-  /*  if (_stereo._enable) {
-        PROFILE_RANGE("RightRender");
-        _stereo._pass = 1;
-        renderPassDraw(batch);
-        _stereo._pass = 0;
-    }*/
-
-    if (_stereo._enable)
+    if (_stereo._enable) {
         glDisable(GL_CLIP_DISTANCE0);
-    
+    }
+
     // Restore the saved stereo state for the next batch
     _stereo._enable = savedStereo;
 }
@@ -335,11 +329,12 @@ void GLBackend::do_draw(Batch& batch, size_t paramOffset) {
     if (isStereo()) {
         glDrawArraysInstanced(mode, startVertex, numVertices, 2);
         _stats._DSNumTriangles += 2 * numVertices / 3;
+        _stats._DSNumDrawcalls += 2;
     } else {
         glDrawArrays(mode, startVertex, numVertices);
         _stats._DSNumTriangles += numVertices / 3;
+        _stats._DSNumDrawcalls++;
     }
-    _stats._DSNumDrawcalls++;
     _stats._DSNumAPIDrawcalls++;
 
     (void) CHECK_GL_ERROR();
@@ -359,11 +354,12 @@ void GLBackend::do_drawIndexed(Batch& batch, size_t paramOffset) {
     if (isStereo()) {
         glDrawElementsInstanced(mode, numIndices, glType, indexBufferByteOffset, 2);
         _stats._DSNumTriangles += 2 * numIndices / 3;
+        _stats._DSNumDrawcalls += 2;
     } else {
         glDrawElements(mode, numIndices, glType, indexBufferByteOffset);
         _stats._DSNumTriangles += numIndices / 3;
+        _stats._DSNumDrawcalls++;
     }
-    _stats._DSNumDrawcalls++;
     _stats._DSNumAPIDrawcalls++;
 
     (void) CHECK_GL_ERROR();
diff --git a/libraries/gpu/src/gpu/GLBackend.h b/libraries/gpu/src/gpu/GLBackend.h
index 2ddd73ac78..7c04add684 100644
--- a/libraries/gpu/src/gpu/GLBackend.h
+++ b/libraries/gpu/src/gpu/GLBackend.h
@@ -396,7 +396,15 @@ protected:
     void resetTransformStage();
 
     struct TransformStageState {
-        using TransformCameras = std::vector<TransformCamera>;
+        struct Cameras {
+            TransformCamera _cams[2];
+
+            Cameras() {};
+            Cameras(const TransformCamera& cam) { memcpy(_cams, &cam, sizeof(TransformCamera)); };
+            Cameras(const TransformCamera& camL, const TransformCamera& camR) { memcpy(_cams, &camL, sizeof(TransformCamera)); memcpy(_cams + 1, &camR, sizeof(TransformCamera)); };
+        };
+
+        using TransformCameras = std::vector<Cameras>;
 
         TransformCamera _camera;
         TransformCameras _cameras;
@@ -407,7 +415,7 @@ protected:
         GLuint _cameraBuffer { 0 };
         GLuint _drawCallInfoBuffer { 0 };
         GLuint _objectBufferTexture { 0 };
-        size_t _cameraUboSize { 0 };
+        size_t _cameraUboSize { 0 }; // 2 sizes, one for mono, one for stereo
         Transform _view;
         Mat4 _projection;
         Vec4i _viewport { 0, 0, 1, 1 };
diff --git a/libraries/gpu/src/gpu/GLBackendTransform.cpp b/libraries/gpu/src/gpu/GLBackendTransform.cpp
index 8188a7b4a6..333fa90480 100755
--- a/libraries/gpu/src/gpu/GLBackendTransform.cpp
+++ b/libraries/gpu/src/gpu/GLBackendTransform.cpp
@@ -66,7 +66,7 @@ void GLBackend::initTransform() {
 #ifndef GPU_SSBO_DRAW_CALL_INFO
     glGenTextures(1, &_transform._objectBufferTexture);
 #endif
-    size_t cameraSize = sizeof(TransformCamera);
+    size_t cameraSize = sizeof(TransformStageState::Cameras);
     while (_transform._cameraUboSize < cameraSize) {
         _transform._cameraUboSize += _uboAlignment;
     }
@@ -112,14 +112,11 @@ void GLBackend::TransformStageState::preUpdate(size_t commandIndex, const Stereo
 
     if (_invalidView || _invalidProj || _invalidViewport) {
         size_t offset = _cameraUboSize * _cameras.size();
+        _cameraOffsets.push_back(TransformStageState::Pair(commandIndex, offset));
         if (stereo._enable) {
-            _cameraOffsets.push_back(TransformStageState::Pair(commandIndex, offset));
-            for (int i = 0; i < 2; ++i) {
-                _cameras.push_back(_camera.getEyeCamera(i, stereo, _view));
-            }
+            _cameras.push_back(Cameras(_camera.getEyeCamera(0, stereo, _view), _camera.getEyeCamera(1, stereo, _view)) );
         } else {
-            _cameraOffsets.push_back(TransformStageState::Pair(commandIndex, offset));
-            _cameras.push_back(_camera.recomputeDerived(_view));
+            _cameras.push_back(Cameras(_camera.recomputeDerived(_view)));
         }
     }
 
@@ -133,7 +130,7 @@ void GLBackend::TransformStageState::transfer(const Batch& batch) const {
     if (!_cameras.empty()) {
         bufferData.resize(_cameraUboSize * _cameras.size());
         for (size_t i = 0; i < _cameras.size(); ++i) {
-            memcpy(bufferData.data() + (_cameraUboSize * i), &_cameras[i], sizeof(TransformCamera));
+            memcpy(bufferData.data() + (_cameraUboSize * i), &_cameras[i], sizeof(Cameras));
         }
         glBindBuffer(GL_UNIFORM_BUFFER, _cameraBuffer);
         glBufferData(GL_UNIFORM_BUFFER, bufferData.size(), bufferData.data(), GL_DYNAMIC_DRAW);
@@ -191,13 +188,8 @@ void GLBackend::TransformStageState::update(size_t commandIndex, const StereoSta
     }
     if (offset != INVALID_OFFSET) {
         // We include both camera offsets for stereo
-        GLuint rangeSize = sizeof(Backend::TransformCamera);
-        if (stereo._enable && stereo._pass) {
-            offset += _cameraUboSize;
-            rangeSize += sizeof(Backend::TransformCamera);
-        }
-        glBindBufferRange(GL_UNIFORM_BUFFER, TRANSFORM_CAMERA_SLOT,
-                          _cameraBuffer, offset, sizeof(Backend::TransformCamera));
+        GLuint rangeSize = sizeof(Cameras);
+        glBindBufferRange(GL_UNIFORM_BUFFER, TRANSFORM_CAMERA_SLOT, _cameraBuffer, offset, rangeSize);
     }
 
     (void)CHECK_GL_ERROR();