diff --git a/domain-server/src/DomainServer.cpp b/domain-server/src/DomainServer.cpp
index d75a2c3245..8b3f09d1f7 100644
--- a/domain-server/src/DomainServer.cpp
+++ b/domain-server/src/DomainServer.cpp
@@ -389,6 +389,8 @@ void DomainServer::setupNodeListAndAssignments() {
     const QVariant* idValueVariant = valueForKeyPath(settingsMap, METAVERSE_DOMAIN_ID_KEY_PATH);
     if (idValueVariant) {
         nodeList->setSessionUUID(idValueVariant->toString());
+    } else {
+        nodeList->setSessionUUID(QUuid::createUuid()); // Use random UUID
     }
 
     connect(nodeList.data(), &LimitedNodeList::nodeAdded, this, &DomainServer::nodeAdded);
diff --git a/interface/resources/controllers/oculus_touch.json b/interface/resources/controllers/oculus_touch.json
index b59bf54e5b..3def439221 100644
--- a/interface/resources/controllers/oculus_touch.json
+++ b/interface/resources/controllers/oculus_touch.json
@@ -1,10 +1,10 @@
 {
     "name": "Oculus Touch to Standard",
     "channels": [
-        { "from": "OculusTouch.A", "to": "Standard.A" },
-        { "from": "OculusTouch.B", "to": "Standard.B" },
-        { "from": "OculusTouch.X", "to": "Standard.X" },
-        { "from": "OculusTouch.Y", "to": "Standard.Y" },
+        { "from": "OculusTouch.A", "to": "Standard.RightPrimaryThumb" },
+        { "from": "OculusTouch.B", "to": "Standard.RightSecondaryThumb" },
+        { "from": "OculusTouch.X", "to": "Standard.LeftPrimaryThumb" },
+        { "from": "OculusTouch.Y", "to": "Standard.LeftSecondaryThumb" },
 
         { "from": "OculusTouch.LY", "filters": "invert", "to": "Standard.LY" },
         { "from": "OculusTouch.LX", "to": "Standard.LX" },
diff --git a/interface/resources/qml/desktop/Desktop.qml b/interface/resources/qml/desktop/Desktop.qml
index 59d5b435ba..e5ff849df8 100644
--- a/interface/resources/qml/desktop/Desktop.qml
+++ b/interface/resources/qml/desktop/Desktop.qml
@@ -25,6 +25,7 @@ FocusScope {
     property rect recommendedRect: Qt.rect(0,0,0,0);
     property var expectedChildren;
     property bool repositionLocked: true
+    property bool hmdHandMouseActive: false
 
     onRepositionLockedChanged: {
         if (!repositionLocked) {
diff --git a/interface/resources/qml/hifi/dialogs/AvatarPreferencesDialog.qml b/interface/resources/qml/hifi/dialogs/AvatarPreferencesDialog.qml
index 86f195612c..45414cfaf8 100644
--- a/interface/resources/qml/hifi/dialogs/AvatarPreferencesDialog.qml
+++ b/interface/resources/qml/hifi/dialogs/AvatarPreferencesDialog.qml
@@ -7,7 +7,7 @@ PreferencesDialog {
     id: root
     objectName: "AvatarPreferencesDialog"
     title: "Avatar Settings"
-    showCategories: [ "Avatar Basics", "Avatar Tuning", "Avatar Camera" ]
+    showCategories: [ "Avatar Basics", "Snapshots", "Avatar Tuning", "Avatar Camera" ]
     property var settings: Settings {
         category: root.objectName
         property alias x: root.x
diff --git a/interface/resources/qml/hifi/dialogs/SnapshotShareDialog.qml b/interface/resources/qml/hifi/dialogs/SnapshotShareDialog.qml
deleted file mode 100644
index f99b770a78..0000000000
--- a/interface/resources/qml/hifi/dialogs/SnapshotShareDialog.qml
+++ /dev/null
@@ -1,117 +0,0 @@
-import QtQuick 2.5
-import QtQuick.Controls 1.4
-import QtQuick.Controls.Styles 1.4
-import QtQuick.XmlListModel 2.0
-
-import "../../windows"
-import "../../js/Utils.js" as Utils
-import "../models"
-
-Window {
-    id: root
-    resizable: true
-    width: 516
-    height: 616
-    minSize: Qt.vector2d(500, 600);
-    maxSize: Qt.vector2d(1000, 800);
-
-    property alias source: image.source
-
-    Rectangle {
-        anchors.fill: parent
-        color: "white"
-
-        Item {
-            anchors { fill: parent; margins: 8 }
-
-            Image {
-                id: image
-                anchors { top: parent.top; left: parent.left; right: parent.right; bottom: notesLabel.top; bottomMargin: 8 }
-                fillMode: Image.PreserveAspectFit
-            }
-
-            Text {
-                id: notesLabel
-                anchors { left: parent.left; bottom: notes.top; bottomMargin: 8; }
-                text: "Notes about this image"
-                font.pointSize: 14
-                font.bold: true
-                color: "#666"
-            }
-
-            TextArea {
-                id: notes
-                anchors { left: parent.left; bottom: parent.bottom;  right: shareButton.left; rightMargin: 8 }
-                height: 60
-            }
-
-            Button {
-                id: shareButton
-                anchors { verticalCenter: notes.verticalCenter; right: parent.right; }
-                width: 120; height: 50
-                text: "Share"
-
-                style: ButtonStyle {
-                    background:  Rectangle {
-                        implicitWidth: 120
-                        implicitHeight: 50
-                        border.width: control.activeFocus ? 2 : 1
-                        color: "#333"
-                        radius: 9
-                    }
-                    label: Text {
-                        color: shareButton.enabled ? "white" : "gray"
-                        font.pixelSize: 18
-                        font.bold: true
-                        verticalAlignment: Text.AlignVCenter
-                        horizontalAlignment: Text.AlignHCenter
-                        anchors.fill: parent
-                        text: shareButton.text
-                    }
-                }
-
-                onClicked: {
-                    enabled = false;
-                    uploadTimer.start();
-                }
-
-                Timer {
-                    id: uploadTimer
-                    running: false
-                    interval: 5
-                    repeat: false
-                    onTriggered: {
-                        var uploaded = SnapshotUploader.uploadSnapshot(root.source.toString())
-                        console.log("Uploaded result " + uploaded)
-                        if (!uploaded) {
-                            console.log("Upload failed ");
-                        }
-                    }
-                }
-            }
-        }
-
-        Action {
-            id: shareAction
-            text: qsTr("OK")
-            enabled: root.result ? true : false
-            shortcut: Qt.Key_Return
-            onTriggered: {
-                root.destroy();
-            }
-        }
-
-        Action {
-            id: cancelAction
-            text: qsTr("Cancel")
-            shortcut: Qt.Key_Escape
-            onTriggered: {
-                root.destroy();
-            }
-        }
-    }
-}
-
-
-
-
diff --git a/interface/resources/qml/hifi/toolbars/Toolbar.qml b/interface/resources/qml/hifi/toolbars/Toolbar.qml
index 75c06e4199..c5c15a6406 100644
--- a/interface/resources/qml/hifi/toolbars/Toolbar.qml
+++ b/interface/resources/qml/hifi/toolbars/Toolbar.qml
@@ -21,7 +21,19 @@ Window {
     height: content.height
     visible: true
     // Disable this window from being able to call 'desktop.raise() and desktop.showDesktop'
-    activator: Item {}
+    activator: MouseArea {
+        width: frame.decoration ? frame.decoration.width : window.width
+        height: frame.decoration ? frame.decoration.height : window.height
+        x: frame.decoration ? frame.decoration.anchors.leftMargin : 0
+        y: frame.decoration ? frame.decoration.anchors.topMargin : 0
+        propagateComposedEvents: true
+        acceptedButtons: Qt.AllButtons
+        enabled: window.visible
+        hoverEnabled: true
+        onPressed: mouse.accepted = false;
+        onEntered: window.mouseEntered();
+        onExited: window.mouseExited();
+    }
     property bool horizontal: true
     property real buttonSize: 50;
     property var buttons: []
diff --git a/interface/resources/qml/windows/Decoration.qml b/interface/resources/qml/windows/Decoration.qml
new file mode 100644
index 0000000000..edfb369c0f
--- /dev/null
+++ b/interface/resources/qml/windows/Decoration.qml
@@ -0,0 +1,71 @@
+//
+//  DefaultFrame.qml
+//
+//  Created by Bradley Austin Davis on 12 Jan 2016
+//  Copyright 2016 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+import QtQuick 2.5
+import QtGraphicalEffects 1.0
+
+import "."
+import "../styles-uit"
+
+Rectangle {
+    HifiConstants { id: hifi }
+
+    signal inflateDecorations();
+    signal deflateDecorations();
+
+    property int frameMargin: 9
+    property int frameMarginLeft: frameMargin
+    property int frameMarginRight: frameMargin
+    property int frameMarginTop: 2 * frameMargin + iconSize
+    property int frameMarginBottom: iconSize + 11
+
+    anchors {
+        topMargin: -frameMarginTop
+        leftMargin: -frameMarginLeft
+        rightMargin: -frameMarginRight
+        bottomMargin: -frameMarginBottom
+    }
+    anchors.fill: parent
+    color: hifi.colors.baseGrayHighlight40
+    border {
+        width: hifi.dimensions.borderWidth
+        color: hifi.colors.faintGray50
+    }
+    radius: hifi.dimensions.borderRadius
+
+    // Enable dragging of the window,
+    // detect mouseover of the window (including decoration)
+    MouseArea {
+        anchors.fill: parent
+        drag.target: window
+    }
+    Connections {
+        target: window
+        onMouseEntered: {
+            if (desktop.hmdHandMouseActive) {
+                root.inflateDecorations()
+           }
+        }
+        onMouseExited: root.deflateDecorations();
+    }
+    Connections {
+        target: desktop
+        onHmdHandMouseActiveChanged: {
+            if (desktop.hmdHandMouseActive) {
+                if (window.activator.containsMouse) {
+                    root.inflateDecorations();
+                }
+            } else {
+                root.deflateDecorations();
+            }
+        }
+    }
+}
+
diff --git a/interface/resources/qml/windows/DefaultFrame.qml b/interface/resources/qml/windows/DefaultFrame.qml
index 242209dbe0..33c2818849 100644
--- a/interface/resources/qml/windows/DefaultFrame.qml
+++ b/interface/resources/qml/windows/DefaultFrame.qml
@@ -16,104 +16,6 @@ import "../styles-uit"
 
 Frame {
     HifiConstants { id: hifi }
-
-    Rectangle {
-        // Dialog frame
-        id: frameContent
-
-        readonly property int iconSize: hifi.dimensions.frameIconSize
-        readonly property int frameMargin: 9
-        readonly property int frameMarginLeft: frameMargin
-        readonly property int frameMarginRight: frameMargin
-        readonly property int frameMarginTop: 2 * frameMargin + iconSize
-        readonly property int frameMarginBottom: iconSize + 11
-
-        anchors {
-            topMargin: -frameMarginTop
-            leftMargin: -frameMarginLeft
-            rightMargin: -frameMarginRight
-            bottomMargin: -frameMarginBottom
-        }
-        anchors.fill: parent
-        color: hifi.colors.baseGrayHighlight40
-        border {
-            width: hifi.dimensions.borderWidth
-            color: hifi.colors.faintGray50
-        }
-        radius: hifi.dimensions.borderRadius
-
-        // Enable dragging of the window
-        MouseArea {
-            anchors.fill: parent
-            drag.target: window
-        }
-
-        Row {
-            id: controlsRow
-            anchors {
-                right: parent.right;
-                top: parent.top;
-                topMargin: frameContent.frameMargin + 1  // Move down a little to visually align with the title
-                rightMargin: frameContent.frameMarginRight;
-            }
-            spacing: frameContent.iconSize / 4
-
-            HiFiGlyphs {
-                // "Pin" button
-                visible: window.pinnable
-                text: window.pinned ? hifi.glyphs.pinInverted : hifi.glyphs.pin
-                color: pinClickArea.pressed ? hifi.colors.redHighlight : hifi.colors.white
-                size: frameContent.iconSize
-                MouseArea {
-                    id: pinClickArea
-                    anchors.fill: parent
-                    hoverEnabled: true
-                    propagateComposedEvents: true
-                    onClicked: window.pinned = !window.pinned;
-                }
-            }
-
-            HiFiGlyphs {
-                // "Close" button
-                visible: window ? window.closable : false
-                text: closeClickArea.containsPress ? hifi.glyphs.closeInverted : hifi.glyphs.close
-                color: closeClickArea.containsMouse ? hifi.colors.redHighlight : hifi.colors.white
-                size: frameContent.iconSize
-                MouseArea {
-                    id: closeClickArea
-                    anchors.fill: parent
-                    hoverEnabled: true
-                    onClicked: window.shown = false;
-                }
-            }
-        }
-
-        RalewayRegular {
-            // Title
-            id: titleText
-            anchors {
-                left: parent.left
-                leftMargin: frameContent.frameMarginLeft + hifi.dimensions.contentMargin.x
-                right: controlsRow.left
-                rightMargin: frameContent.iconSize
-                top: parent.top
-                topMargin: frameContent.frameMargin
-            }
-            text: window ? window.title : ""
-            color: hifi.colors.white
-            size: hifi.fontSizes.overlayTitle
-        }
-
-        DropShadow {
-            source: titleText
-            anchors.fill: titleText
-            horizontalOffset: 2
-            verticalOffset: 2
-            samples: 2
-            color: hifi.colors.baseGrayShadow60
-            visible: (window && window.focus)
-            cached: true
-        }
-    }
+    DefaultFrameDecoration {}
 }
 
diff --git a/interface/resources/qml/windows/DefaultFrameDecoration.qml b/interface/resources/qml/windows/DefaultFrameDecoration.qml
new file mode 100644
index 0000000000..ce47b818b1
--- /dev/null
+++ b/interface/resources/qml/windows/DefaultFrameDecoration.qml
@@ -0,0 +1,113 @@
+//
+//  DefaultFrame.qml
+//
+//  Created by Bradley Austin Davis on 12 Jan 2016
+//  Copyright 2016 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+import QtQuick 2.5
+import QtGraphicalEffects 1.0
+
+import "."
+import "../styles-uit"
+
+Decoration {
+    HifiConstants { id: hifi }
+
+    // Dialog frame
+    id: root
+
+    property int iconSize: hifi.dimensions.frameIconSize
+    frameMargin: 9
+    frameMarginLeft: frameMargin
+    frameMarginRight: frameMargin
+    frameMarginTop: 2 * frameMargin + iconSize
+    frameMarginBottom: iconSize + 11
+
+    onInflateDecorations: {
+        if (!HMD.active) {
+            return;
+        }
+        root.frameMargin = 18
+        titleText.size = hifi.fontSizes.overlayTitle * 2
+        root.iconSize = hifi.dimensions.frameIconSize * 2
+    }
+
+    onDeflateDecorations: {
+        root.frameMargin = 9
+        titleText.size = hifi.fontSizes.overlayTitle
+        root.iconSize = hifi.dimensions.frameIconSize
+    }
+
+
+    Row {
+        id: controlsRow
+        anchors {
+            right: parent.right;
+            top: parent.top;
+            topMargin: root.frameMargin + 1  // Move down a little to visually align with the title
+            rightMargin: root.frameMarginRight;
+        }
+        spacing: root.iconSize / 4
+
+        HiFiGlyphs {
+            // "Pin" button
+            visible: window.pinnable
+            text: window.pinned ? hifi.glyphs.pinInverted : hifi.glyphs.pin
+            color: pinClickArea.pressed ? hifi.colors.redHighlight : hifi.colors.white
+            size: root.iconSize
+            MouseArea {
+                id: pinClickArea
+                anchors.fill: parent
+                hoverEnabled: true
+                propagateComposedEvents: true
+                onClicked: window.pinned = !window.pinned;
+            }
+        }
+
+        HiFiGlyphs {
+            // "Close" button
+            visible: window ? window.closable : false
+            text: closeClickArea.containsPress ? hifi.glyphs.closeInverted : hifi.glyphs.close
+            color: closeClickArea.containsMouse ? hifi.colors.redHighlight : hifi.colors.white
+            size: root.iconSize
+            MouseArea {
+                id: closeClickArea
+                anchors.fill: parent
+                hoverEnabled: true
+                onClicked: window.shown = false;
+            }
+        }
+    }
+
+    RalewayRegular {
+        // Title
+        id: titleText
+        anchors {
+            left: parent.left
+            leftMargin: root.frameMarginLeft + hifi.dimensions.contentMargin.x
+            right: controlsRow.left
+            rightMargin: root.iconSize
+            top: parent.top
+            topMargin: root.frameMargin
+        }
+        text: window ? window.title : ""
+        color: hifi.colors.white
+        size: hifi.fontSizes.overlayTitle
+    }
+
+    DropShadow {
+        source: titleText
+        anchors.fill: titleText
+        horizontalOffset: 2
+        verticalOffset: 2
+        samples: 2
+        color: hifi.colors.baseGrayShadow60
+        visible: (window && window.focus)
+        cached: true
+    }
+}
+
diff --git a/interface/resources/qml/windows/Frame.qml b/interface/resources/qml/windows/Frame.qml
index 88d8c3ad41..030af974f6 100644
--- a/interface/resources/qml/windows/Frame.qml
+++ b/interface/resources/qml/windows/Frame.qml
@@ -22,10 +22,10 @@ Item {
 
     property bool gradientsSupported: desktop.gradientsSupported
 
-    readonly property int frameMarginLeft: frameContent.frameMarginLeft
-    readonly property int frameMarginRight: frameContent.frameMarginRight
-    readonly property int frameMarginTop: frameContent.frameMarginTop
-    readonly property int frameMarginBottom: frameContent.frameMarginBottom
+    readonly property int frameMarginLeft: frame.decoration ? frame.decoration.frameMarginLeft : 0
+    readonly property int frameMarginRight: frame.decoration ? frame.decoration.frameMarginRight : 0
+    readonly property int frameMarginTop: frame.decoration ? frame.decoration.frameMarginTop : 0
+    readonly property int frameMarginBottom: frame.decoration ? frame.decoration.frameMarginBottom : 0
 
     // Frames always fill their parents, but their decorations may extend
     // beyond the window via negative margin sizes
@@ -103,16 +103,14 @@ Item {
         }
         onReleased: {
             if (hid) {
-                pane.visible = true
-                frameContent.visible = true
+                window.content.visible = true
                 hid = false;
             }
         }
         onPositionChanged: {
             if (pressed) {
-                if (pane.visible) {
-                    pane.visible = false;
-                    frameContent.visible = false
+                if (window.content.visible) {
+                    window.content.visible = false;
                     hid = true;
                 }
                 var delta = Qt.vector2d(mouseX, mouseY).minus(pressOrigin);
diff --git a/interface/resources/qml/windows/ToolFrame.qml b/interface/resources/qml/windows/ToolFrame.qml
index eff5fc0377..20c86afb5e 100644
--- a/interface/resources/qml/windows/ToolFrame.qml
+++ b/interface/resources/qml/windows/ToolFrame.qml
@@ -16,81 +16,11 @@ import "../styles-uit"
 
 Frame {
     HifiConstants { id: hifi }
-    property bool horizontalSpacers: false
-    property bool verticalSpacers: false
+    property alias horizontalSpacers: decoration.horizontalSpacers
+    property alias verticalSpacers: decoration.verticalSpacers
 
-    Rectangle {
-        // Dialog frame
-        id: frameContent
-        readonly property int frameMargin: 6
-        readonly property int frameMarginLeft: frameMargin + (horizontalSpacers ? 12 : 0)
-        readonly property int frameMarginRight: frameMargin + (horizontalSpacers ? 12 : 0)
-        readonly property int frameMarginTop: frameMargin + (verticalSpacers ? 12 : 0)
-        readonly property int frameMarginBottom: frameMargin + (verticalSpacers ? 12 : 0)
-
-        Rectangle {
-            visible: horizontalSpacers
-            anchors.left: parent.left
-            anchors.leftMargin: 6
-            anchors.verticalCenter: parent.verticalCenter
-            width: 8
-            height: window.height
-            color: "gray";
-            radius: 4
-        }
-
-        Rectangle {
-            visible: horizontalSpacers
-            anchors.right: parent.right
-            anchors.rightMargin: 6
-            anchors.verticalCenter: parent.verticalCenter
-            width: 8
-            height: window.height
-            color: "gray";
-            radius: 4
-        }
-
-        Rectangle {
-            visible: verticalSpacers
-            anchors.top: parent.top
-            anchors.topMargin: 6
-            anchors.horizontalCenter: parent.horizontalCenter
-            height: 8
-            width: window.width
-            color: "gray";
-            radius: 4
-        }
-
-        Rectangle {
-            visible: verticalSpacers
-            anchors.bottom: parent.bottom
-            anchors.bottomMargin: 6
-            anchors.horizontalCenter: parent.horizontalCenter
-            height: 8
-            width: window.width
-            color: "gray";
-            radius: 4
-        }
-
-        anchors {
-            leftMargin: -frameMarginLeft
-            rightMargin: -frameMarginRight
-            topMargin: -frameMarginTop
-            bottomMargin: -frameMarginBottom
-        }
-        anchors.fill: parent
-        color: hifi.colors.baseGrayHighlight40
-        border {
-            width: hifi.dimensions.borderWidth
-            color: hifi.colors.faintGray50
-        }
-        radius: hifi.dimensions.borderRadius / 2
-
-        // Enable dragging of the window
-        MouseArea {
-            anchors.fill: parent
-            drag.target: window
-        }
+    ToolFrameDecoration {
+        id: decoration
     }
 }
 
diff --git a/interface/resources/qml/windows/ToolFrameDecoration.qml b/interface/resources/qml/windows/ToolFrameDecoration.qml
new file mode 100644
index 0000000000..ba36a2a38c
--- /dev/null
+++ b/interface/resources/qml/windows/ToolFrameDecoration.qml
@@ -0,0 +1,96 @@
+//
+//  DefaultFrame.qml
+//
+//  Created by Bradley Austin Davis on 12 Jan 2016
+//  Copyright 2016 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+import QtQuick 2.5
+import QtGraphicalEffects 1.0
+
+import "."
+import "../styles-uit"
+
+Decoration {
+    id: root
+    HifiConstants { id: hifi }
+
+    property bool horizontalSpacers: false
+    property bool verticalSpacers: false
+
+    // Dialog frame
+    property int spacerWidth: 8
+    property int spacerRadius: 4
+    property int spacerMargin: 12
+    frameMargin: 6
+    frameMarginLeft: frameMargin + (horizontalSpacers ? spacerMargin : 0)
+    frameMarginRight: frameMargin + (horizontalSpacers ? spacerMargin : 0)
+    frameMarginTop: frameMargin + (verticalSpacers ? spacerMargin : 0)
+    frameMarginBottom: frameMargin + (verticalSpacers ? spacerMargin : 0)
+    radius: hifi.dimensions.borderRadius / 2
+
+    onInflateDecorations: {
+        if (!HMD.active) {
+            return;
+        }
+        root.frameMargin = 18
+        root.spacerWidth = 16
+        root.spacerRadius = 8
+        root.spacerMargin = 8
+    }
+
+    onDeflateDecorations: {
+        root.frameMargin = 6
+        root.spacerWidth = 8
+        root.spacerRadius = 4
+        root.spacerMargin = 12
+    }
+
+    Rectangle {
+        visible: horizontalSpacers
+        anchors.left: parent.left
+        anchors.leftMargin: 6
+        anchors.verticalCenter: parent.verticalCenter
+        width: root.spacerWidth
+        height: decoration.height - 12
+        color: "gray";
+        radius: root.spacerRadius
+    }
+
+    Rectangle {
+        visible: horizontalSpacers
+        anchors.right: parent.right
+        anchors.rightMargin: 6
+        anchors.verticalCenter: parent.verticalCenter
+        width: root.spacerWidth
+        height: decoration.height - 12
+        color: "gray";
+        radius: root.spacerRadius
+    }
+
+    Rectangle {
+        visible: verticalSpacers
+        anchors.top: parent.top
+        anchors.topMargin: 6
+        anchors.horizontalCenter: parent.horizontalCenter
+        height: root.spacerWidth
+        width: decoration.width - 12
+        color: "gray";
+        radius: root.spacerRadius
+    }
+
+    Rectangle {
+        visible: verticalSpacers
+        anchors.bottom: parent.bottom
+        anchors.bottomMargin: 6
+        anchors.horizontalCenter: parent.horizontalCenter
+        height: root.spacerWidth
+        width: decoration.width - 12
+        color: "gray";
+        radius: root.spacerRadius
+    }
+}
+
diff --git a/interface/resources/qml/windows/Window.qml b/interface/resources/qml/windows/Window.qml
index 82bcf011e9..ca37c55f4d 100644
--- a/interface/resources/qml/windows/Window.qml
+++ b/interface/resources/qml/windows/Window.qml
@@ -31,6 +31,8 @@ Fadable {
     // Signals
     //
     signal windowDestroyed();
+    signal mouseEntered();
+    signal mouseExited();
 
     //
     // Native properties
@@ -113,11 +115,14 @@ Fadable {
         propagateComposedEvents: true
         acceptedButtons: Qt.AllButtons
         enabled: window.visible
+        hoverEnabled: true
         onPressed: {
             //console.log("Pressed on activator area");
             window.raise();
             mouse.accepted = false;
         }
+        onEntered:  window.mouseEntered();
+        onExited: window.mouseExited();
     }
 
     // This mouse area serves to swallow mouse events while the mouse is over the window
@@ -287,4 +292,7 @@ Fadable {
                 break;
         }
     }
+
+    onMouseEntered: console.log("Mouse entered " + window)
+    onMouseExited: console.log("Mouse exited " + window)
 }
diff --git a/interface/resources/shaders/hmd_hand_lasers.frag b/interface/resources/shaders/hmd_hand_lasers.frag
new file mode 100644
index 0000000000..6fffb1c521
--- /dev/null
+++ b/interface/resources/shaders/hmd_hand_lasers.frag
@@ -0,0 +1,35 @@
+//
+//  Created by Bradley Austin Davis on 2016/07/11
+//  Copyright 2013-2016 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#version 410 core
+
+uniform vec4 color = vec4(1.0, 1.0, 1.0, 1.0);
+
+layout(location = 0) in vec3 inLineDistance;
+
+out vec4 FragColor;
+
+void main() {
+    vec2 d = inLineDistance.xy;
+    d.y = abs(d.y);
+    d.x = abs(d.x);
+    if (d.x > 1.0) {
+        d.x = (d.x - 1.0) / 0.02;
+    } else { 
+        d.x = 0.0; 
+    }
+    float alpha = 1.0 - length(d);
+    if (alpha <= 0.0) {
+        discard;
+    }
+    alpha = pow(alpha, 10.0);
+    if (alpha < 0.05) {
+        discard;
+    }
+    FragColor = vec4(color.rgb, alpha);
+}
diff --git a/interface/resources/shaders/hmd_hand_lasers.geom b/interface/resources/shaders/hmd_hand_lasers.geom
new file mode 100644
index 0000000000..16b5dafadd
--- /dev/null
+++ b/interface/resources/shaders/hmd_hand_lasers.geom
@@ -0,0 +1,70 @@
+//
+//  Created by Bradley Austin Davis on 2016/07/11
+//  Copyright 2013-2016 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+#version 410 core
+#extension GL_EXT_geometry_shader4 : enable
+
+layout(location = 0) out vec3 outLineDistance;
+
+layout(lines) in;
+layout(triangle_strip, max_vertices = 24) out;
+
+vec3[2] getOrthogonals(in vec3 n, float scale) {
+    float yDot = abs(dot(n, vec3(0, 1, 0)));
+
+    vec3 result[2];
+    if (yDot < 0.9) {
+        result[0] = normalize(cross(n, vec3(0, 1, 0)));
+    } else {
+        result[0] = normalize(cross(n, vec3(1, 0, 0)));
+    }
+    // The cross of result[0] and n is orthogonal to both, which are orthogonal to each other
+    result[1] = cross(result[0], n);
+    result[0] *= scale;
+    result[1] *= scale;
+    return result;
+}
+
+
+vec2 orthogonal(vec2 v) {
+    vec2 result = v.yx;
+    result.y *= -1.0;
+    return result;
+}
+
+void main() {
+    vec2 endpoints[2];
+    for (int i = 0; i < 2; ++i) {
+        endpoints[i] = gl_PositionIn[i].xy / gl_PositionIn[i].w;
+    }
+    vec2 lineNormal = normalize(endpoints[1] - endpoints[0]);
+    vec2 lineOrthogonal = orthogonal(lineNormal);
+    lineNormal *= 0.02;
+    lineOrthogonal *= 0.02;
+
+    gl_Position = gl_PositionIn[0];
+    gl_Position.xy -= lineOrthogonal;
+    outLineDistance = vec3(-1.02, -1, gl_Position.z);
+    EmitVertex();
+
+    gl_Position = gl_PositionIn[0];
+    gl_Position.xy += lineOrthogonal;
+    outLineDistance = vec3(-1.02, 1, gl_Position.z);
+    EmitVertex();
+
+    gl_Position = gl_PositionIn[1];
+    gl_Position.xy -= lineOrthogonal;
+    outLineDistance = vec3(1.02, -1, gl_Position.z);
+    EmitVertex();
+
+    gl_Position = gl_PositionIn[1];
+    gl_Position.xy += lineOrthogonal;
+    outLineDistance = vec3(1.02, 1, gl_Position.z);
+    EmitVertex();
+
+    EndPrimitive();
+}
diff --git a/interface/resources/shaders/hmd_hand_lasers.vert b/interface/resources/shaders/hmd_hand_lasers.vert
new file mode 100644
index 0000000000..db5c7c1ecd
--- /dev/null
+++ b/interface/resources/shaders/hmd_hand_lasers.vert
@@ -0,0 +1,15 @@
+//
+//  Created by Bradley Austin Davis on 2016/07/11
+//  Copyright 2013-2016 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+#version 410 core
+uniform mat4 mvp = mat4(1);
+
+in vec3 Position;
+
+void main() {
+  gl_Position = mvp * vec4(Position, 1);
+}
diff --git a/interface/resources/shaders/hmd_reproject.frag b/interface/resources/shaders/hmd_reproject.frag
new file mode 100644
index 0000000000..adda0315a3
--- /dev/null
+++ b/interface/resources/shaders/hmd_reproject.frag
@@ -0,0 +1,78 @@
+//
+//  Created by Bradley Austin Davis on 2016/07/11
+//  Copyright 2013-2016 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#version 410 core
+
+uniform sampler2D sampler;
+uniform mat3 reprojection = mat3(1);
+uniform mat4 inverseProjections[2];
+uniform mat4 projections[2];
+
+in vec2 vTexCoord;
+in vec3 vPosition;
+
+out vec4 FragColor;
+
+void main() {
+    vec2 uv = vTexCoord;
+
+    mat4 eyeInverseProjection;
+    mat4 eyeProjection;
+    
+    float xoffset = 1.0;
+    vec2 uvmin = vec2(0.0);
+    vec2 uvmax = vec2(1.0);
+    // determine the correct projection and inverse projection to use.
+    if (vTexCoord.x < 0.5) {
+        uvmax.x = 0.5;
+        eyeInverseProjection = inverseProjections[0];
+        eyeProjection = projections[0];
+    } else {
+        xoffset = -1.0;
+        uvmin.x = 0.5;
+        uvmax.x = 1.0;
+        eyeInverseProjection = inverseProjections[1];
+        eyeProjection = projections[1];
+    }
+
+    // Account for stereo in calculating the per-eye NDC coordinates
+    vec4 ndcSpace = vec4(vPosition, 1.0);
+    ndcSpace.x *= 2.0;
+    ndcSpace.x += xoffset;
+    
+    // Convert from NDC to eyespace
+    vec4 eyeSpace = eyeInverseProjection * ndcSpace;
+    eyeSpace /= eyeSpace.w;
+
+    // Convert to a noramlized ray 
+    vec3 ray = eyeSpace.xyz;
+    ray = normalize(ray);
+
+    // Adjust the ray by the rotation
+    ray = reprojection * ray;
+
+    // Project back on to the texture plane
+    ray *= eyeSpace.z / ray.z;
+
+    // Update the eyespace vector
+    eyeSpace.xyz = ray;
+
+    // Reproject back into NDC
+    ndcSpace = eyeProjection * eyeSpace;
+    ndcSpace /= ndcSpace.w;
+    ndcSpace.x -= xoffset;
+    ndcSpace.x /= 2.0;
+    
+    // Calculate the new UV coordinates
+    uv = (ndcSpace.xy / 2.0) + 0.5;
+    if (any(greaterThan(uv, uvmax)) || any(lessThan(uv, uvmin))) {
+        FragColor = vec4(0.0, 0.0, 0.0, 1.0);
+    } else {
+        FragColor = texture(sampler, uv);
+    }
+}
\ No newline at end of file
diff --git a/interface/resources/shaders/hmd_reproject.vert b/interface/resources/shaders/hmd_reproject.vert
new file mode 100644
index 0000000000..923375613a
--- /dev/null
+++ b/interface/resources/shaders/hmd_reproject.vert
@@ -0,0 +1,20 @@
+//
+//  Created by Bradley Austin Davis on 2016/07/11
+//  Copyright 2013-2016 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#version 410 core
+in vec3 Position;
+in vec2 TexCoord;
+
+out vec3 vPosition;
+out vec2 vTexCoord;
+
+void main() {
+  gl_Position = vec4(Position, 1);
+  vTexCoord = TexCoord;
+  vPosition = Position;
+}
diff --git a/interface/resources/shaders/hmd_ui_glow.frag b/interface/resources/shaders/hmd_ui_glow.frag
new file mode 100644
index 0000000000..733f32d718
--- /dev/null
+++ b/interface/resources/shaders/hmd_ui_glow.frag
@@ -0,0 +1,65 @@
+//
+//  Created by Bradley Austin Davis on 2016/07/11
+//  Copyright 2013-2016 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#version 410 core
+
+uniform sampler2D sampler;
+uniform float alpha = 1.0;
+uniform vec4 glowPoints = vec4(-1);
+uniform vec4 glowColors[2];
+uniform vec2 resolution = vec2(3960.0, 1188.0);
+uniform float radius = 0.005;
+
+in vec3 vPosition;
+in vec2 vTexCoord;
+in vec4 vGlowPoints;
+
+out vec4 FragColor;
+
+float easeInOutCubic(float f) {
+    const float d = 1.0;
+    const float b = 0.0;
+    const float c = 1.0;
+    float t = f;
+    if ((t /= d / 2.0) < 1.0) return c / 2.0 * t * t * t + b;
+    return c / 2.0 * ((t -= 2.0) * t * t + 2.0) + b;
+}
+
+void main() {
+    vec2 aspect = resolution;
+    aspect /= resolution.x;
+    FragColor = texture(sampler, vTexCoord);
+
+    float glowIntensity = 0.0;
+    float dist1 = distance(vTexCoord * aspect, glowPoints.xy * aspect);
+    float dist2 = distance(vTexCoord * aspect, glowPoints.zw * aspect);
+    float dist = min(dist1, dist2);
+    vec3 glowColor = glowColors[0].rgb;
+    if (dist2 < dist1) {
+        glowColor = glowColors[1].rgb;
+    }
+
+    if (dist <= radius) {
+       glowIntensity = 1.0 - (dist / radius);
+       glowColor.rgb = pow(glowColor, vec3(1.0 - glowIntensity));
+       glowIntensity = easeInOutCubic(glowIntensity);
+       glowIntensity = pow(glowIntensity, 0.5);
+    }
+
+    if (alpha <= 0.0) {
+        if (glowIntensity <= 0.0) {
+            discard;
+        }
+
+        FragColor = vec4(glowColor, glowIntensity);
+        return;
+    }
+
+    FragColor.rgb = mix(FragColor.rgb, glowColor.rgb, glowIntensity);
+    FragColor.a *= alpha;
+}
\ No newline at end of file
diff --git a/interface/resources/shaders/hmd_ui_glow.vert b/interface/resources/shaders/hmd_ui_glow.vert
new file mode 100644
index 0000000000..5defec085f
--- /dev/null
+++ b/interface/resources/shaders/hmd_ui_glow.vert
@@ -0,0 +1,23 @@
+//
+//  Created by Bradley Austin Davis on 2016/07/11
+//  Copyright 2013-2016 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#version 410 core
+
+uniform mat4 mvp = mat4(1);
+
+in vec3 Position;
+in vec2 TexCoord;
+
+out vec3 vPosition;
+out vec2 vTexCoord;
+
+void main() {
+  gl_Position = mvp * vec4(Position, 1);
+  vTexCoord = TexCoord;
+  vPosition = Position;
+}
diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp
index d4020ad98a..9af09dc21d 100644
--- a/interface/src/Application.cpp
+++ b/interface/src/Application.cpp
@@ -1525,7 +1525,6 @@ void Application::initializeUi() {
 
     // For some reason there is already an "Application" object in the QML context,
     // though I can't find it. Hence, "ApplicationInterface"
-    rootContext->setContextProperty("SnapshotUploader", new SnapshotUploader());
     rootContext->setContextProperty("ApplicationInterface", this);
     rootContext->setContextProperty("Audio", &AudioScriptingInterface::getInstance());
     rootContext->setContextProperty("Controller", DependencyManager::get<controller::ScriptingInterface>().data());
@@ -5046,16 +5045,9 @@ void Application::takeSnapshot() {
     player->setMedia(QUrl::fromLocalFile(inf.absoluteFilePath()));
     player->play();
 
-    QString fileName = Snapshot::saveSnapshot(getActiveDisplayPlugin()->getScreenshot());
+    QString path = Snapshot::saveSnapshot(getActiveDisplayPlugin()->getScreenshot());
 
-    auto accountManager = DependencyManager::get<AccountManager>();
-    if (!accountManager->isLoggedIn()) {
-        return;
-    }
-
-    DependencyManager::get<OffscreenUi>()->load("hifi/dialogs/SnapshotShareDialog.qml", [=](QQmlContext*, QObject* dialog) {
-        dialog->setProperty("source", QUrl::fromLocalFile(fileName));
-    });
+    emit DependencyManager::get<WindowScriptingInterface>()->snapshotTaken(path);
 }
 
 float Application::getRenderResolutionScale() const {
diff --git a/interface/src/avatar/Avatar.cpp b/interface/src/avatar/Avatar.cpp
index 39bb7eac17..4d9481f002 100644
--- a/interface/src/avatar/Avatar.cpp
+++ b/interface/src/avatar/Avatar.cpp
@@ -1085,6 +1085,15 @@ void Avatar::computeShapeInfo(ShapeInfo& shapeInfo) {
     shapeInfo.setOffset(uniformScale * _skeletonModel->getBoundingCapsuleOffset());
 }
 
+void Avatar::getCapsule(glm::vec3& start, glm::vec3& end, float& radius) {
+    ShapeInfo shapeInfo;
+    computeShapeInfo(shapeInfo);
+    glm::vec3 halfExtents = shapeInfo.getHalfExtents(); // x = radius, y = halfHeight
+    start = getPosition() - glm::vec3(0, halfExtents.y, 0) + shapeInfo.getOffset();
+    end = getPosition() + glm::vec3(0, halfExtents.y, 0) + shapeInfo.getOffset();
+    radius = halfExtents.x;
+}
+
 void Avatar::setMotionState(AvatarMotionState* motionState) {
     _motionState = motionState;
 }
diff --git a/interface/src/avatar/Avatar.h b/interface/src/avatar/Avatar.h
index 064f0a9533..b9f44613c7 100644
--- a/interface/src/avatar/Avatar.h
+++ b/interface/src/avatar/Avatar.h
@@ -154,6 +154,7 @@ public:
     virtual void rebuildCollisionShape();
 
     virtual void computeShapeInfo(ShapeInfo& shapeInfo);
+    void getCapsule(glm::vec3& start, glm::vec3& end, float& radius);
 
     AvatarMotionState* getMotionState() { return _motionState; }
 
diff --git a/interface/src/avatar/AvatarManager.cpp b/interface/src/avatar/AvatarManager.cpp
index 68d2eca2c0..31a77df0cf 100644
--- a/interface/src/avatar/AvatarManager.cpp
+++ b/interface/src/avatar/AvatarManager.cpp
@@ -398,3 +398,76 @@ AvatarSharedPointer AvatarManager::getAvatarBySessionID(const QUuid& sessionID)
 
     return findAvatar(sessionID);
 }
+
+RayToAvatarIntersectionResult AvatarManager::findRayIntersection(const PickRay& ray,
+                                                                 const QScriptValue& avatarIdsToInclude,
+                                                                 const QScriptValue& avatarIdsToDiscard) {
+    RayToAvatarIntersectionResult result;
+    if (QThread::currentThread() != thread()) {
+        QMetaObject::invokeMethod(const_cast<AvatarManager*>(this), "findRayIntersection", Qt::BlockingQueuedConnection,
+                                  Q_RETURN_ARG(RayToAvatarIntersectionResult, result),
+                                  Q_ARG(const PickRay&, ray),
+                                  Q_ARG(const QScriptValue&, avatarIdsToInclude),
+                                  Q_ARG(const QScriptValue&, avatarIdsToDiscard));
+        return result;
+    }
+
+    QVector<EntityItemID> avatarsToInclude = qVectorEntityItemIDFromScriptValue(avatarIdsToInclude);
+    QVector<EntityItemID> avatarsToDiscard = qVectorEntityItemIDFromScriptValue(avatarIdsToDiscard);
+
+    glm::vec3 normDirection = glm::normalize(ray.direction);
+
+    for (auto avatarData : _avatarHash) {
+        auto avatar = std::static_pointer_cast<Avatar>(avatarData);
+        if ((avatarsToInclude.size() > 0 && !avatarsToInclude.contains(avatar->getID())) ||
+            (avatarsToDiscard.size() > 0 && avatarsToDiscard.contains(avatar->getID()))) {
+            continue;
+        }
+
+        float distance;
+        BoxFace face;
+        glm::vec3 surfaceNormal;
+
+        SkeletonModelPointer avatarModel = avatar->getSkeletonModel();
+
+        // It's better to intersect the ray against the avatar's actual mesh, but this is currently difficult to
+        // do, because the transformed mesh data only exists over in GPU-land.  As a compromise, this code
+        // intersects against the avatars capsule and then against the (T-pose) mesh.  The end effect is that picking
+        // against the avatar is sort-of right, but you likely wont be able to pick against the arms.
+
+        // TODO -- find a way to extract transformed avatar mesh data from the rendering engine.
+
+        // if we weren't picking against the capsule, we would want to pick against the avatarBounds...
+        // AABox avatarBounds = avatarModel->getRenderableMeshBound();
+        // if (!avatarBounds.findRayIntersection(ray.origin, normDirection, distance, face, surfaceNormal)) {
+        //     // ray doesn't intersect avatar's bounding-box
+        //     continue;
+        // }
+
+        glm::vec3 start;
+        glm::vec3 end;
+        float radius;
+        avatar->getCapsule(start, end, radius);
+        bool intersects = findRayCapsuleIntersection(ray.origin, normDirection, start, end, radius, distance);
+        if (!intersects) {
+            // ray doesn't intersect avatar's capsule
+            continue;
+        }
+
+        QString extraInfo;
+        intersects = avatarModel->findRayIntersectionAgainstSubMeshes(ray.origin, normDirection,
+                                                                      distance, face, surfaceNormal, extraInfo, true);
+
+        if (intersects && (!result.intersects || distance < result.distance)) {
+            result.intersects = true;
+            result.avatarID = avatar->getID();
+            result.distance = distance;
+        }
+    }
+
+    if (result.intersects) {
+        result.intersection = ray.origin + normDirection * result.distance;
+    }
+
+    return result;
+}
diff --git a/interface/src/avatar/AvatarManager.h b/interface/src/avatar/AvatarManager.h
index 9be186301d..c49d566aa8 100644
--- a/interface/src/avatar/AvatarManager.h
+++ b/interface/src/avatar/AvatarManager.h
@@ -70,6 +70,10 @@ public:
 
     void addAvatarToSimulation(Avatar* avatar);
 
+    Q_INVOKABLE RayToAvatarIntersectionResult findRayIntersection(const PickRay& ray,
+                                                                  const QScriptValue& avatarIdsToInclude = QScriptValue(),
+                                                                  const QScriptValue& avatarIdsToDiscard = QScriptValue());
+
 public slots:
     void setShouldShowReceiveStats(bool shouldShowReceiveStats) { _shouldShowReceiveStats = shouldShowReceiveStats; }
     void updateAvatarRenderStatus(bool shouldRenderAvatars);
diff --git a/interface/src/avatar/MyAvatar.h b/interface/src/avatar/MyAvatar.h
index 96fa999de5..a21922f1b1 100644
--- a/interface/src/avatar/MyAvatar.h
+++ b/interface/src/avatar/MyAvatar.h
@@ -212,8 +212,8 @@ public:
     virtual void clearJointsData() override;
 
     Q_INVOKABLE void useFullAvatarURL(const QUrl& fullAvatarURL, const QString& modelName = QString());
-    Q_INVOKABLE const QUrl& getFullAvatarURLFromPreferences() const { return _fullAvatarURLFromPreferences; }
-    Q_INVOKABLE const QString& getFullAvatarModelName() const { return _fullAvatarModelName; }
+    Q_INVOKABLE QUrl getFullAvatarURLFromPreferences() const { return _fullAvatarURLFromPreferences; }
+    Q_INVOKABLE QString getFullAvatarModelName() const { return _fullAvatarModelName; }
     void resetFullAvatarURL();
 
 
diff --git a/interface/src/scripting/HMDScriptingInterface.cpp b/interface/src/scripting/HMDScriptingInterface.cpp
index e9677cc3c8..36cde378f8 100644
--- a/interface/src/scripting/HMDScriptingInterface.cpp
+++ b/interface/src/scripting/HMDScriptingInterface.cpp
@@ -15,6 +15,7 @@
 
 #include <display-plugins/DisplayPlugin.h>
 #include <display-plugins/CompositorHelper.h>
+#include <OffscreenUi.h>
 #include <avatar/AvatarManager.h>
 #include "Application.h"
 
@@ -110,13 +111,17 @@ QString HMDScriptingInterface::preferredAudioOutput() const {
 }
 
 bool HMDScriptingInterface::setHandLasers(int hands, bool enabled, const glm::vec4& color, const glm::vec3& direction) const {
+    auto offscreenUi = DependencyManager::get<OffscreenUi>();
+    offscreenUi->executeOnUiThread([offscreenUi, enabled] {
+        offscreenUi->getDesktop()->setProperty("hmdHandMouseActive", enabled);
+    });
     return qApp->getActiveDisplayPlugin()->setHandLaser(hands,
         enabled ? DisplayPlugin::HandLaserMode::Overlay : DisplayPlugin::HandLaserMode::None,
         color, direction);
 }
 
 void HMDScriptingInterface::disableHandLasers(int hands) const {
-    qApp->getActiveDisplayPlugin()->setHandLaser(hands, DisplayPlugin::HandLaserMode::None);
+    setHandLasers(hands, false, vec4(0), vec3(0));
 }
 
 bool HMDScriptingInterface::suppressKeyboard() {
diff --git a/interface/src/scripting/WindowScriptingInterface.h b/interface/src/scripting/WindowScriptingInterface.h
index b92114c1bf..4f26ccd057 100644
--- a/interface/src/scripting/WindowScriptingInterface.h
+++ b/interface/src/scripting/WindowScriptingInterface.h
@@ -46,6 +46,7 @@ signals:
     void domainChanged(const QString& domainHostname);
     void svoImportRequested(const QString& url);
     void domainConnectionRefused(const QString& reasonMessage, int reasonCode);
+    void snapshotTaken(const QString& path);
 
 private slots:
     WebWindowClass* doCreateWebWindow(const QString& title, const QString& url, int width, int height);
diff --git a/interface/src/ui/PreferencesDialog.cpp b/interface/src/ui/PreferencesDialog.cpp
index c1705da206..4007c940c3 100644
--- a/interface/src/ui/PreferencesDialog.cpp
+++ b/interface/src/ui/PreferencesDialog.cpp
@@ -35,7 +35,7 @@ void setupPreferences() {
     MyAvatar* myAvatar = DependencyManager::get<AvatarManager>()->getMyAvatar();
     static const QString AVATAR_BASICS { "Avatar Basics" };
     {
-        auto getter = [=]()->QString {return myAvatar->getDisplayName(); };
+        auto getter = [=]()->QString { return myAvatar->getDisplayName(); };
         auto setter = [=](const QString& value) { myAvatar->setDisplayName(value); };
         auto preference = new EditPreference(AVATAR_BASICS, "Avatar display name (optional)", getter, setter);
         preference->setPlaceholderText("Not showing a name");
@@ -43,7 +43,7 @@ void setupPreferences() {
     }
 
     {
-        auto getter = [=]()->QString {return myAvatar->getCollisionSoundURL(); };
+        auto getter = [=]()->QString { return myAvatar->getCollisionSoundURL(); };
         auto setter = [=](const QString& value) { myAvatar->setCollisionSoundURL(value); };
         auto preference = new EditPreference(AVATAR_BASICS, "Avatar collision sound URL (optional)", getter, setter);
         preference->setPlaceholderText("Enter the URL of a sound to play when you bump into something");
@@ -56,20 +56,24 @@ void setupPreferences() {
         auto preference = new AvatarPreference(AVATAR_BASICS, "Appearance", getter, setter);
         preferences->addPreference(preference);
     }
+
     {
-        auto getter = [=]()->bool {return myAvatar->getSnapTurn(); };
+        auto getter = [=]()->bool { return myAvatar->getSnapTurn(); };
         auto setter = [=](bool value) { myAvatar->setSnapTurn(value); };
         preferences->addPreference(new CheckPreference(AVATAR_BASICS, "Snap turn when in HMD", getter, setter));
     }
     {
-        auto getter = [=]()->bool {return myAvatar->getClearOverlayWhenMoving(); };
+        auto getter = [=]()->bool { return myAvatar->getClearOverlayWhenMoving(); };
         auto setter = [=](bool value) { myAvatar->setClearOverlayWhenMoving(value); };
         preferences->addPreference(new CheckPreference(AVATAR_BASICS, "Clear overlays when moving", getter, setter));
     }
+
+    // Snapshots
+    static const QString SNAPSHOTS { "Snapshots" };
     {
         auto getter = []()->QString { return Snapshot::snapshotsLocation.get(); };
         auto setter = [](const QString& value) { Snapshot::snapshotsLocation.set(value); };
-        auto preference = new BrowsePreference("Snapshots", "Put my snapshots here", getter, setter);
+        auto preference = new BrowsePreference(SNAPSHOTS, "Put my snapshots here", getter, setter);
         preferences->addPreference(preference);
     }
 
@@ -85,7 +89,7 @@ void setupPreferences() {
     }));
 
     {
-        auto getter = []()->bool {return !Menu::getInstance()->isOptionChecked(MenuOption::DisableActivityLogger); };
+        auto getter = []()->bool { return !Menu::getInstance()->isOptionChecked(MenuOption::DisableActivityLogger); };
         auto setter = [](bool value) { Menu::getInstance()->setIsOptionChecked(MenuOption::DisableActivityLogger, !value); };
         preferences->addPreference(new CheckPreference("Privacy", "Send data", getter, setter));
     }
@@ -184,7 +188,7 @@ void setupPreferences() {
 
     static const QString AUDIO("Audio");
     {
-        auto getter = []()->bool {return DependencyManager::get<AudioClient>()->getReceivedAudioStream().getDynamicJitterBuffers(); };
+        auto getter = []()->bool { return DependencyManager::get<AudioClient>()->getReceivedAudioStream().getDynamicJitterBuffers(); };
         auto setter = [](bool value) { DependencyManager::get<AudioClient>()->getReceivedAudioStream().setDynamicJitterBuffers(value); };
         preferences->addPreference(new CheckPreference(AUDIO, "Enable dynamic jitter buffers", getter, setter));
     }
@@ -207,7 +211,7 @@ void setupPreferences() {
         preferences->addPreference(preference);
     }
     {
-        auto getter = []()->bool {return DependencyManager::get<AudioClient>()->getReceivedAudioStream().getUseStDevForJitterCalc(); };
+        auto getter = []()->bool { return DependencyManager::get<AudioClient>()->getReceivedAudioStream().getUseStDevForJitterCalc(); };
         auto setter = [](bool value) { DependencyManager::get<AudioClient>()->getReceivedAudioStream().setUseStDevForJitterCalc(value); };
         preferences->addPreference(new CheckPreference(AUDIO, "Use standard deviation for dynamic jitter calc", getter, setter));
     }
@@ -236,7 +240,7 @@ void setupPreferences() {
         preferences->addPreference(preference);
     }
     {
-        auto getter = []()->bool {return DependencyManager::get<AudioClient>()->getReceivedAudioStream().getRepetitionWithFade(); };
+        auto getter = []()->bool { return DependencyManager::get<AudioClient>()->getReceivedAudioStream().getRepetitionWithFade(); };
         auto setter = [](bool value) { DependencyManager::get<AudioClient>()->getReceivedAudioStream().setRepetitionWithFade(value); };
         preferences->addPreference(new CheckPreference(AUDIO, "Repetition with fade", getter, setter));
     }
@@ -250,7 +254,7 @@ void setupPreferences() {
         preferences->addPreference(preference);
     }
     {
-        auto getter = []()->bool {return DependencyManager::get<AudioClient>()->getOutputStarveDetectionEnabled(); };
+        auto getter = []()->bool { return DependencyManager::get<AudioClient>()->getOutputStarveDetectionEnabled(); };
         auto setter = [](bool value) { DependencyManager::get<AudioClient>()->setOutputStarveDetectionEnabled(value); };
         auto preference = new CheckPreference(AUDIO, "Output starve detection (automatic buffer size increase)", getter, setter);
         preferences->addPreference(preference);
diff --git a/interface/src/ui/Snapshot.cpp b/interface/src/ui/Snapshot.cpp
index b8be2bb8c4..aaf11d14a4 100644
--- a/interface/src/ui/Snapshot.cpp
+++ b/interface/src/ui/Snapshot.cpp
@@ -44,6 +44,7 @@ const QString URL = "highfidelity_url";
 
 Setting::Handle<QString> Snapshot::snapshotsLocation("snapshotsLocation",
     QStandardPaths::writableLocation(QStandardPaths::DesktopLocation));
+Setting::Handle<bool> Snapshot::hasSetSnapshotsLocation("hasSetSnapshotsLocation", false);
 
 SnapshotMetaData* Snapshot::parseSnapshotData(QString snapshotPath) {
 
@@ -103,7 +104,14 @@ QFile* Snapshot::savedFileForSnapshot(QImage & shot, bool isTemporary) {
     const int IMAGE_QUALITY = 100;
 
     if (!isTemporary) {
-        QString snapshotFullPath = snapshotsLocation.get();
+        QString snapshotFullPath;
+        if (!hasSetSnapshotsLocation.get()) {
+            snapshotFullPath = QFileDialog::getExistingDirectory(nullptr, "Choose Snapshots Directory", snapshotsLocation.get());
+            hasSetSnapshotsLocation.set(true);
+            snapshotsLocation.set(snapshotFullPath);
+        } else {
+            snapshotFullPath = snapshotsLocation.get();
+        }
 
         if (!snapshotFullPath.endsWith(QDir::separator())) {
             snapshotFullPath.append(QDir::separator());
@@ -133,118 +141,3 @@ QFile* Snapshot::savedFileForSnapshot(QImage & shot, bool isTemporary) {
         return imageTempFile;
     }
 }
-
-const QString FORUM_URL = "https://alphas.highfidelity.io";
-const QString FORUM_UPLOADS_URL = FORUM_URL + "/uploads";
-const QString FORUM_POST_URL = FORUM_URL + "/posts";
-const QString FORUM_REPLY_TO_TOPIC = "244";
-const QString FORUM_POST_TEMPLATE = "<img src='%1'/><p>%2</p>";
-const QString SHARE_DEFAULT_ERROR = "The server isn't responding. Please try again in a few minutes.";
-const QString SUCCESS_LABEL_TEMPLATE = "Success!!! Go check out your image ...<br/><a style='color:#333;text-decoration:none' href='%1'>%1</a>";
-
-
-QString SnapshotUploader::uploadSnapshot(const QUrl& fileUrl) {
-    auto accountManager = DependencyManager::get<AccountManager>();
-    if (accountManager->getAccountInfo().getDiscourseApiKey().isEmpty()) {
-        OffscreenUi::warning(nullptr, "", "Your Discourse API key is missing, you cannot share snapshots. Please try to relog.");
-        return QString();
-    }
-
-    QHttpPart apiKeyPart;
-    apiKeyPart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"api_key\""));
-    apiKeyPart.setBody(accountManager->getAccountInfo().getDiscourseApiKey().toLatin1());
-
-    QString filename = fileUrl.toLocalFile();
-    qDebug() << filename;
-    QFile* file = new QFile(filename);
-    Q_ASSERT(file->exists());
-    file->open(QIODevice::ReadOnly);
-
-    QHttpPart imagePart;
-    imagePart.setHeader(QNetworkRequest::ContentTypeHeader, QVariant("image/jpeg"));
-    imagePart.setHeader(QNetworkRequest::ContentDispositionHeader,
-        QVariant("form-data; name=\"file\"; filename=\"" + file->fileName() + "\""));
-    imagePart.setBodyDevice(file);
-
-    QHttpMultiPart* multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
-    file->setParent(multiPart); // we cannot delete the file now, so delete it with the multiPart
-    multiPart->append(apiKeyPart);
-    multiPart->append(imagePart);
-
-    QUrl url(FORUM_UPLOADS_URL);
-    QNetworkRequest request(url);
-    request.setHeader(QNetworkRequest::UserAgentHeader, HIGH_FIDELITY_USER_AGENT);
-
-    QString result;
-    QEventLoop loop;
-
-    QSharedPointer<QNetworkReply> reply(NetworkAccessManager::getInstance().post(request, multiPart));
-    QObject::connect(reply.data(), &QNetworkReply::finished, [&] {
-        loop.quit();
-
-        qDebug() << reply->errorString();
-        for (const auto& header : reply->rawHeaderList()) {
-            qDebug() << "Header " << QString(header);
-        }
-        auto replyResult = reply->readAll();
-        qDebug() << QString(replyResult);
-        QJsonDocument jsonResponse = QJsonDocument::fromJson(replyResult);
-        const QJsonObject& responseObject = jsonResponse.object();
-        if (!responseObject.contains("url")) {
-            OffscreenUi::warning(this, "", SHARE_DEFAULT_ERROR);
-            return;
-        }
-        result = responseObject["url"].toString();
-    });
-    loop.exec();
-    return result;
-}
-
-QString SnapshotUploader::sendForumPost(const QString& snapshotPath, const QString& notes) {
-    // post to Discourse forum
-    QNetworkRequest request;
-    request.setHeader(QNetworkRequest::UserAgentHeader, HIGH_FIDELITY_USER_AGENT);
-    QUrl forumUrl(FORUM_POST_URL);
-
-    QUrlQuery query;
-    query.addQueryItem("api_key", DependencyManager::get<AccountManager>()->getAccountInfo().getDiscourseApiKey());
-    query.addQueryItem("topic_id", FORUM_REPLY_TO_TOPIC);
-    query.addQueryItem("raw", FORUM_POST_TEMPLATE.arg(snapshotPath, notes));
-    forumUrl.setQuery(query);
-
-    QByteArray postData = forumUrl.toEncoded(QUrl::RemoveFragment);
-    request.setUrl(forumUrl);
-    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
-
-    QNetworkReply* requestReply = NetworkAccessManager::getInstance().post(request, postData);
-
-    QEventLoop loop;
-    QString result;
-    connect(requestReply, &QNetworkReply::finished, [&] {
-        loop.quit();
-        QJsonDocument jsonResponse = QJsonDocument::fromJson(requestReply->readAll());
-        requestReply->deleteLater();
-        const QJsonObject& responseObject = jsonResponse.object();
-
-        if (!responseObject.contains("id")) {
-            QString errorMessage(SHARE_DEFAULT_ERROR);
-            if (responseObject.contains("errors")) {
-                QJsonArray errorArray = responseObject["errors"].toArray();
-                if (!errorArray.first().toString().isEmpty()) {
-                    errorMessage = errorArray.first().toString();
-                }
-            }
-            OffscreenUi::warning(this, "", errorMessage);
-            return;
-        }
-
-        const QString urlTemplate = "%1/t/%2/%3/%4";
-        result = urlTemplate.arg(FORUM_URL,
-            responseObject["topic_slug"].toString(),
-            QString::number(responseObject["topic_id"].toDouble()),
-            QString::number(responseObject["post_number"].toDouble()));
-    });
-    loop.exec();
-    return result;
-}
-
diff --git a/interface/src/ui/Snapshot.h b/interface/src/ui/Snapshot.h
index d87a70255f..2e7986a5c0 100644
--- a/interface/src/ui/Snapshot.h
+++ b/interface/src/ui/Snapshot.h
@@ -39,16 +39,9 @@ public:
     static SnapshotMetaData* parseSnapshotData(QString snapshotPath);
 
     static Setting::Handle<QString> snapshotsLocation;
+    static Setting::Handle<bool> hasSetSnapshotsLocation;
 private:
     static QFile* savedFileForSnapshot(QImage & image, bool isTemporary);
 };
 
-class SnapshotUploader : public QObject{
-    Q_OBJECT
-public:
-    SnapshotUploader(QObject* parent = nullptr) : QObject(parent) {}
-    Q_INVOKABLE QString uploadSnapshot(const QUrl& fileUrl);
-    Q_INVOKABLE QString sendForumPost(const QString& snapshotPath, const QString& notes);
-};
-
 #endif // hifi_Snapshot_h
diff --git a/interface/src/ui/SnapshotShareDialog.cpp b/interface/src/ui/SnapshotShareDialog.cpp
deleted file mode 100644
index 94f89641e2..0000000000
--- a/interface/src/ui/SnapshotShareDialog.cpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//
-//  SnapshotShareDialog.cpp
-//  interface/src/ui
-//
-//  Created by Stojce Slavkovski on 2/16/14.
-//  Copyright 2014 High Fidelity, Inc.
-//
-//  Distributed under the Apache License, Version 2.0.
-//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
-//
-
-#if 0
-
-
-#include <OffscreenUi.h>
-
-const int NARROW_SNAPSHOT_DIALOG_SIZE = 500;
-const int WIDE_SNAPSHOT_DIALOG_WIDTH = 650;
-const int SUCCESS_LABEL_HEIGHT = 140;
-
-const QString SHARE_BUTTON_STYLE = "border-width:0;border-radius:9px;border-radius:9px;font-family:Arial;font-size:18px;"
-    "font-weight:100;color:#FFFFFF;width: 120px;height: 50px;";
-const QString SHARE_BUTTON_ENABLED_STYLE = "background-color: #333;";
-const QString SHARE_BUTTON_DISABLED_STYLE = "background-color: #999;";
-
-Q_DECLARE_METATYPE(QNetworkAccessManager::Operation)
-
-SnapshotShareDialog::SnapshotShareDialog(QString fileName, QWidget* parent) :
-    QDialog(parent),
-    _fileName(fileName)
-{
-
-
-    _ui.snapshotWidget->setPixmap(snaphsotPixmap);
-    _ui.snapshotWidget->adjustSize();
-}
-
-void SnapshotShareDialog::accept() {
-    // prevent multiple clicks on share button
-    _ui.shareButton->setEnabled(false);
-    // gray out share button
-    _ui.shareButton->setStyleSheet(SHARE_BUTTON_STYLE + SHARE_BUTTON_DISABLED_STYLE);
-    uploadSnapshot();
-}
-
-
-#endif
diff --git a/interface/src/ui/overlays/Circle3DOverlay.cpp b/interface/src/ui/overlays/Circle3DOverlay.cpp
index 2896ce711e..6ebfd5c71c 100644
--- a/interface/src/ui/overlays/Circle3DOverlay.cpp
+++ b/interface/src/ui/overlays/Circle3DOverlay.cpp
@@ -14,30 +14,11 @@
 #include <GeometryCache.h>
 #include <RegisteredMetaTypes.h>
 
-
 QString const Circle3DOverlay::TYPE = "circle3d";
 
-Circle3DOverlay::Circle3DOverlay() :
-    _startAt(0.0f),
-    _endAt(360.0f),
-    _outerRadius(1.0f),
-    _innerRadius(0.0f),
-    _hasTickMarks(false),
-    _majorTickMarksAngle(0.0f),
-    _minorTickMarksAngle(0.0f),
-    _majorTickMarksLength(0.0f),
-    _minorTickMarksLength(0.0f),
-    _quadVerticesID(GeometryCache::UNKNOWN_ID),
-    _lineVerticesID(GeometryCache::UNKNOWN_ID),
-    _majorTicksVerticesID(GeometryCache::UNKNOWN_ID),
-    _minorTicksVerticesID(GeometryCache::UNKNOWN_ID),
-    _lastStartAt(-1.0f),
-    _lastEndAt(-1.0f),
-    _lastOuterRadius(-1.0f),
-    _lastInnerRadius(-1.0f)
-{
-    _majorTickMarksColor.red = _majorTickMarksColor.green = _majorTickMarksColor.blue = (unsigned char)0;
-    _minorTickMarksColor.red = _minorTickMarksColor.green = _minorTickMarksColor.blue = (unsigned char)0;
+Circle3DOverlay::Circle3DOverlay() {
+    memset(&_minorTickMarksColor, 0, sizeof(_minorTickMarksColor));
+    memset(&_majorTickMarksColor, 0, sizeof(_majorTickMarksColor));
 }
 
 Circle3DOverlay::Circle3DOverlay(const Circle3DOverlay* circle3DOverlay) :
@@ -56,11 +37,7 @@ Circle3DOverlay::Circle3DOverlay(const Circle3DOverlay* circle3DOverlay) :
     _quadVerticesID(GeometryCache::UNKNOWN_ID),
     _lineVerticesID(GeometryCache::UNKNOWN_ID),
     _majorTicksVerticesID(GeometryCache::UNKNOWN_ID),
-    _minorTicksVerticesID(GeometryCache::UNKNOWN_ID),
-    _lastStartAt(-1.0f),
-    _lastEndAt(-1.0f),
-    _lastOuterRadius(-1.0f),
-    _lastInnerRadius(-1.0f)
+    _minorTicksVerticesID(GeometryCache::UNKNOWN_ID)
 {
 }
 
@@ -70,36 +47,25 @@ void Circle3DOverlay::render(RenderArgs* args) {
     }
 
     float alpha = getAlpha();
-
     if (alpha == 0.0f) {
         return; // do nothing if our alpha is 0, we're not visible
     }
 
-    // Create the circle in the coordinates origin
-    float outerRadius = getOuterRadius();
-    float innerRadius = getInnerRadius(); // only used in solid case
-    float startAt = getStartAt();
-    float endAt = getEndAt();
-
-    bool geometryChanged = (startAt != _lastStartAt || endAt != _lastEndAt ||
-                                innerRadius != _lastInnerRadius || outerRadius != _lastOuterRadius);
-
+    bool geometryChanged = _dirty;
+    _dirty = false;
 
     const float FULL_CIRCLE = 360.0f;
     const float SLICES = 180.0f;  // The amount of segment to create the circle
     const float SLICE_ANGLE = FULL_CIRCLE / SLICES;
-
-    xColor colorX = getColor();
     const float MAX_COLOR = 255.0f;
-    glm::vec4 color(colorX.red / MAX_COLOR, colorX.green / MAX_COLOR, colorX.blue / MAX_COLOR, alpha);
-
-    bool colorChanged = colorX.red != _lastColor.red || colorX.green != _lastColor.green || colorX.blue != _lastColor.blue;
-    _lastColor = colorX;
 
     auto geometryCache = DependencyManager::get<GeometryCache>();
 
     Q_ASSERT(args->_batch);
     auto& batch = *args->_batch;
+    if (args->_pipeline) {
+        batch.setPipeline(args->_pipeline->pipeline);
+    }
 
     // FIXME: THe line width of _lineWidth is not supported anymore, we ll need a workaround
 
@@ -110,81 +76,89 @@ void Circle3DOverlay::render(RenderArgs* args) {
     // for our overlay, is solid means we draw a ring between the inner and outer radius of the circle, otherwise
     // we just draw a line...
     if (getIsSolid()) {
-        if (_quadVerticesID == GeometryCache::UNKNOWN_ID) {
+        if (!_quadVerticesID) {
             _quadVerticesID = geometryCache->allocateID();
         }
         
-        if (geometryChanged || colorChanged) {
-            
+        if (geometryChanged) {
             QVector<glm::vec2> points;
-            
-            float angle = startAt;
-            float angleInRadians = glm::radians(angle);
-            glm::vec2 mostRecentInnerPoint(cosf(angleInRadians) * innerRadius, sinf(angleInRadians) * innerRadius);
-            glm::vec2 mostRecentOuterPoint(cosf(angleInRadians) * outerRadius, sinf(angleInRadians) * outerRadius);
-            
-            while (angle < endAt) {
-                angleInRadians = glm::radians(angle);
-                glm::vec2 thisInnerPoint(cosf(angleInRadians) * innerRadius, sinf(angleInRadians) * innerRadius);
-                glm::vec2 thisOuterPoint(cosf(angleInRadians) * outerRadius, sinf(angleInRadians) * outerRadius);
-                
-                points << mostRecentInnerPoint << mostRecentOuterPoint << thisOuterPoint; // first triangle
-                points << mostRecentInnerPoint << thisInnerPoint << thisOuterPoint; // second triangle
-                
-                angle += SLICE_ANGLE;
+            QVector<glm::vec4> colors;
 
-                mostRecentInnerPoint = thisInnerPoint;
-                mostRecentOuterPoint = thisOuterPoint;
+            float pulseLevel = updatePulse();
+            vec4 pulseModifier = vec4(1);
+            if (_alphaPulse != 0.0f) {
+                pulseModifier.a = (_alphaPulse >= 0.0f) ? pulseLevel : (1.0f - pulseLevel);
             }
-            
-            // get the last slice portion....
-            angle = endAt;
-            angleInRadians = glm::radians(angle);
-            glm::vec2 lastInnerPoint(cosf(angleInRadians) * innerRadius, sinf(angleInRadians) * innerRadius);
-            glm::vec2 lastOuterPoint(cosf(angleInRadians) * outerRadius, sinf(angleInRadians) * outerRadius);
+            if (_colorPulse != 0.0f) {
+                float pulseValue = (_colorPulse >= 0.0f) ? pulseLevel : (1.0f - pulseLevel);
+                pulseModifier = vec4(vec3(pulseValue), pulseModifier.a);
+            }
+            vec4 innerStartColor = vec4(toGlm(_innerStartColor), _innerStartAlpha) * pulseModifier;
+            vec4 outerStartColor = vec4(toGlm(_outerStartColor), _outerStartAlpha) * pulseModifier;
+            vec4 innerEndColor = vec4(toGlm(_innerEndColor), _innerEndAlpha) * pulseModifier;
+            vec4 outerEndColor = vec4(toGlm(_outerEndColor), _outerEndAlpha) * pulseModifier;
 
-            points << mostRecentInnerPoint << mostRecentOuterPoint << lastOuterPoint; // first triangle
-            points << mostRecentInnerPoint << lastInnerPoint << lastOuterPoint; // second triangle
-            
-            geometryCache->updateVertices(_quadVerticesID, points, color);
+            if (_innerRadius <= 0) {
+                _solidPrimitive = gpu::TRIANGLE_FAN;
+                points << vec2();
+                colors << innerStartColor;
+                for (float angle = _startAt; angle <= _endAt; angle += SLICE_ANGLE) {
+                    float range = (angle - _startAt) / (_endAt - _startAt);
+                    float angleRadians = glm::radians(angle);
+                    points << glm::vec2(cosf(angleRadians) * _outerRadius, sinf(angleRadians) * _outerRadius);
+                    colors << glm::mix(outerStartColor, outerEndColor, range);
+                }
+            } else {
+                _solidPrimitive = gpu::TRIANGLE_STRIP;
+                for (float angle = _startAt; angle <= _endAt; angle += SLICE_ANGLE) {
+                    float range = (angle - _startAt) / (_endAt - _startAt);
+
+                    float angleRadians = glm::radians(angle);
+                    points << glm::vec2(cosf(angleRadians) * _innerRadius, sinf(angleRadians) * _innerRadius);
+                    colors << glm::mix(innerStartColor, innerEndColor, range);
+
+                    points << glm::vec2(cosf(angleRadians) * _outerRadius, sinf(angleRadians) * _outerRadius);
+                    colors << glm::mix(outerStartColor, outerEndColor, range);
+                }
+            }
+            geometryCache->updateVertices(_quadVerticesID, points, colors);
         }
         
-        geometryCache->renderVertices(batch, gpu::TRIANGLES, _quadVerticesID);
+        geometryCache->renderVertices(batch, _solidPrimitive, _quadVerticesID);
         
     } else {
-        if (_lineVerticesID == GeometryCache::UNKNOWN_ID) {
+        if (!_lineVerticesID) {
             _lineVerticesID = geometryCache->allocateID();
         }
         
-        if (geometryChanged || colorChanged) {
+        if (geometryChanged) {
             QVector<glm::vec2> points;
             
-            float angle = startAt;
+            float angle = _startAt;
             float angleInRadians = glm::radians(angle);
-            glm::vec2 firstPoint(cosf(angleInRadians) * outerRadius, sinf(angleInRadians) * outerRadius);
+            glm::vec2 firstPoint(cosf(angleInRadians) * _outerRadius, sinf(angleInRadians) * _outerRadius);
             points << firstPoint;
             
-            while (angle < endAt) {
+            while (angle < _endAt) {
                 angle += SLICE_ANGLE;
                 angleInRadians = glm::radians(angle);
-                glm::vec2 thisPoint(cosf(angleInRadians) * outerRadius, sinf(angleInRadians) * outerRadius);
+                glm::vec2 thisPoint(cosf(angleInRadians) * _outerRadius, sinf(angleInRadians) * _outerRadius);
                 points << thisPoint;
                 
                 if (getIsDashedLine()) {
                     angle += SLICE_ANGLE / 2.0f; // short gap
                     angleInRadians = glm::radians(angle);
-                    glm::vec2 dashStartPoint(cosf(angleInRadians) * outerRadius, sinf(angleInRadians) * outerRadius);
+                    glm::vec2 dashStartPoint(cosf(angleInRadians) * _outerRadius, sinf(angleInRadians) * _outerRadius);
                     points << dashStartPoint;
                 }
             }
             
             // get the last slice portion....
-            angle = endAt;
+            angle = _endAt;
             angleInRadians = glm::radians(angle);
-            glm::vec2 lastPoint(cosf(angleInRadians) * outerRadius, sinf(angleInRadians) * outerRadius);
+            glm::vec2 lastPoint(cosf(angleInRadians) * _outerRadius, sinf(angleInRadians) * _outerRadius);
             points << lastPoint;
-            
-            geometryCache->updateVertices(_lineVerticesID, points, color);
+            geometryCache->updateVertices(_lineVerticesID, points, vec4(toGlm(getColor()), getAlpha()));
         }
         
         if (getIsDashedLine()) {
@@ -214,13 +188,13 @@ void Circle3DOverlay::render(RenderArgs* args) {
             if (getMajorTickMarksAngle() > 0.0f && getMajorTickMarksLength() != 0.0f) {
                 
                 float tickMarkAngle = getMajorTickMarksAngle();
-                float angle = startAt - fmodf(startAt, tickMarkAngle) + tickMarkAngle;
+                float angle = _startAt - fmodf(_startAt, tickMarkAngle) + tickMarkAngle;
                 float angleInRadians = glm::radians(angle);
                 float tickMarkLength = getMajorTickMarksLength();
-                float startRadius = (tickMarkLength > 0.0f) ? innerRadius : outerRadius;
+                float startRadius = (tickMarkLength > 0.0f) ? _innerRadius : _outerRadius;
                 float endRadius = startRadius + tickMarkLength;
                 
-                while (angle <= endAt) {
+                while (angle <= _endAt) {
                     angleInRadians = glm::radians(angle);
                     
                     glm::vec2 thisPointA(cosf(angleInRadians) * startRadius, sinf(angleInRadians) * startRadius);
@@ -236,13 +210,13 @@ void Circle3DOverlay::render(RenderArgs* args) {
             if (getMinorTickMarksAngle() > 0.0f && getMinorTickMarksLength() != 0.0f) {
                 
                 float tickMarkAngle = getMinorTickMarksAngle();
-                float angle = startAt - fmodf(startAt, tickMarkAngle) + tickMarkAngle;
+                float angle = _startAt - fmodf(_startAt, tickMarkAngle) + tickMarkAngle;
                 float angleInRadians = glm::radians(angle);
                 float tickMarkLength = getMinorTickMarksLength();
-                float startRadius = (tickMarkLength > 0.0f) ? innerRadius : outerRadius;
+                float startRadius = (tickMarkLength > 0.0f) ? _innerRadius : _outerRadius;
                 float endRadius = startRadius + tickMarkLength;
                 
-                while (angle <= endAt) {
+                while (angle <= _endAt) {
                     angleInRadians = glm::radians(angle);
                     
                     glm::vec2 thisPointA(cosf(angleInRadians) * startRadius, sinf(angleInRadians) * startRadius);
@@ -269,17 +243,10 @@ void Circle3DOverlay::render(RenderArgs* args) {
         
         geometryCache->renderVertices(batch, gpu::LINES, _minorTicksVerticesID);
     }
-    
-    if (geometryChanged) {
-        _lastStartAt = startAt;
-        _lastEndAt = endAt;
-        _lastInnerRadius = innerRadius;
-        _lastOuterRadius = outerRadius;
-    }
 }
 
 const render::ShapeKey Circle3DOverlay::getShapeKey() {
-    auto builder = render::ShapeKey::Builder().withoutCullFace();
+    auto builder = render::ShapeKey::Builder().withoutCullFace().withUnlit();
     if (getAlpha() != 1.0f) {
         builder.withTranslucent();
     }
@@ -289,72 +256,102 @@ const render::ShapeKey Circle3DOverlay::getShapeKey() {
     return builder.build();
 }
 
+template<typename T> T fromVariant(const QVariant& v, bool& valid) {
+    valid = v.isValid();
+    return qvariant_cast<T>(v);
+}
+
+template<> xColor fromVariant(const QVariant& v, bool& valid) {
+    return xColorFromVariant(v, valid);
+}
+
+template<typename T>
+bool updateIfValid(const QVariantMap& properties, const char* key, T& output) {
+    bool valid;
+    T result = fromVariant<T>(properties[key], valid);
+    if (!valid) {
+        return false;
+    }
+
+    // Don't signal updates if the value was already set
+    if (result == output) {
+        return false;
+    }
+
+    output = result;
+    return true;
+}
+
+// Multicast, many outputs
+template<typename T>
+bool updateIfValid(const QVariantMap& properties, const char* key, std::initializer_list<std::reference_wrapper<T>> outputs) {
+    bool valid;
+    T value = fromVariant<T>(properties[key], valid);
+    if (!valid) {
+        return false;
+    }
+    bool updated = false;
+    for (T& output : outputs) {
+        if (output != value) {
+            output = value;
+            updated = true;
+        }
+    }
+    return updated;
+}
+
+// Multicast, multiple possible inputs, in order of preference
+template<typename T>
+bool updateIfValid(const QVariantMap& properties, const std::initializer_list<const char*> keys, T& output) {
+    for (const char* key : keys) {
+        if (updateIfValid<T>(properties, key, output)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+
 void Circle3DOverlay::setProperties(const QVariantMap& properties) {
     Planar3DOverlay::setProperties(properties);
+    _dirty |= updateIfValid<float>(properties, "alpha", { _innerStartAlpha, _innerEndAlpha, _outerStartAlpha, _outerEndAlpha });
+    _dirty |= updateIfValid<float>(properties, "Alpha", { _innerStartAlpha, _innerEndAlpha, _outerStartAlpha, _outerEndAlpha });
+    _dirty |= updateIfValid<float>(properties, "startAlpha", { _innerStartAlpha, _outerStartAlpha });
+    _dirty |= updateIfValid<float>(properties, "endAlpha", { _innerEndAlpha, _outerEndAlpha });
+    _dirty |= updateIfValid<float>(properties, "innerAlpha", { _innerStartAlpha, _innerEndAlpha });
+    _dirty |= updateIfValid<float>(properties, "outerAlpha", { _outerStartAlpha, _outerEndAlpha });
+    _dirty |= updateIfValid(properties, "innerStartAlpha", _innerStartAlpha);
+    _dirty |= updateIfValid(properties, "innerEndAlpha", _innerEndAlpha);
+    _dirty |= updateIfValid(properties, "outerStartAlpha", _outerStartAlpha);
+    _dirty |= updateIfValid(properties, "outerEndAlpha", _outerEndAlpha);
 
-    QVariant startAt = properties["startAt"];
-    if (startAt.isValid()) {
-        setStartAt(startAt.toFloat());
-    }
+    _dirty |= updateIfValid<xColor>(properties, "color", { _innerStartColor, _innerEndColor, _outerStartColor, _outerEndColor });
+    _dirty |= updateIfValid<xColor>(properties, "startColor", { _innerStartColor, _outerStartColor } );
+    _dirty |= updateIfValid<xColor>(properties, "endColor", { _innerEndColor, _outerEndColor } );
+    _dirty |= updateIfValid<xColor>(properties, "innerColor", { _innerStartColor, _innerEndColor } );
+    _dirty |= updateIfValid<xColor>(properties, "outerColor", { _outerStartColor, _outerEndColor } );
+    _dirty |= updateIfValid(properties, "innerStartColor", _innerStartColor);
+    _dirty |= updateIfValid(properties, "innerEndColor", _innerEndColor);
+    _dirty |= updateIfValid(properties, "outerStartColor", _outerStartColor);
+    _dirty |= updateIfValid(properties, "outerEndColor", _outerEndColor);
 
-    QVariant endAt = properties["endAt"];
-    if (endAt.isValid()) {
-        setEndAt(endAt.toFloat());
-    }
+    _dirty |= updateIfValid(properties, "startAt", _startAt);
+    _dirty |= updateIfValid(properties, "endAt", _endAt);
 
-    QVariant outerRadius = properties["radius"];
-    if (!outerRadius.isValid()) {
-        outerRadius = properties["outerRadius"];
-    }
-    if (outerRadius.isValid()) {
-        setOuterRadius(outerRadius.toFloat());
-    }
+    _dirty |= updateIfValid(properties, { "radius", "outerRadius" }, _outerRadius);
+    _dirty |= updateIfValid(properties, "innerRadius", _innerRadius);
+    _dirty |= updateIfValid(properties, "hasTickMarks", _hasTickMarks);
+    _dirty |= updateIfValid(properties, "majorTickMarksAngle", _majorTickMarksAngle);
+    _dirty |= updateIfValid(properties, "minorTickMarksAngle", _minorTickMarksAngle);
+    _dirty |= updateIfValid(properties, "majorTickMarksLength", _majorTickMarksLength);
+    _dirty |= updateIfValid(properties, "minorTickMarksLength", _minorTickMarksLength);
+    _dirty |= updateIfValid(properties, "majorTickMarksColor", _majorTickMarksColor);
+    _dirty |= updateIfValid(properties, "minorTickMarksColor", _minorTickMarksColor);
 
-    QVariant innerRadius = properties["innerRadius"];
-    if (innerRadius.isValid()) {
-        setInnerRadius(innerRadius.toFloat());
-    }
-
-    QVariant hasTickMarks = properties["hasTickMarks"];
-    if (hasTickMarks.isValid()) {
-        setHasTickMarks(hasTickMarks.toBool());
-    }
-
-    QVariant majorTickMarksAngle = properties["majorTickMarksAngle"];
-    if (majorTickMarksAngle.isValid()) {
-        setMajorTickMarksAngle(majorTickMarksAngle.toFloat());
-    }
-
-    QVariant minorTickMarksAngle = properties["minorTickMarksAngle"];
-    if (minorTickMarksAngle.isValid()) {
-        setMinorTickMarksAngle(minorTickMarksAngle.toFloat());
-    }
-
-    QVariant majorTickMarksLength = properties["majorTickMarksLength"];
-    if (majorTickMarksLength.isValid()) {
-        setMajorTickMarksLength(majorTickMarksLength.toFloat());
-    }
-
-    QVariant minorTickMarksLength = properties["minorTickMarksLength"];
-    if (minorTickMarksLength.isValid()) {
-        setMinorTickMarksLength(minorTickMarksLength.toFloat());
-    }
-
-    bool valid;
-    auto majorTickMarksColor = properties["majorTickMarksColor"];
-    if (majorTickMarksColor.isValid()) {
-        auto color = xColorFromVariant(majorTickMarksColor, valid);
-        if (valid) {
-            _majorTickMarksColor = color;
-        }
-    }
-
-    auto minorTickMarksColor = properties["minorTickMarksColor"];
-    if (minorTickMarksColor.isValid()) {
-        auto color = xColorFromVariant(majorTickMarksColor, valid);
-        if (valid) {
-            _minorTickMarksColor = color;
-        }
+    if (_innerStartAlpha < 1.0f || _innerEndAlpha < 1.0f || _outerStartAlpha < 1.0f || _outerEndAlpha < 1.0f) {
+        // Force the alpha to 0.5, since we'll ignore it in the presence of these other values, but we need
+        // it to be non-1 in order to get the right pipeline and non-0 in order to render at all.
+        _alpha = 0.5f;
     }
 }
 
diff --git a/interface/src/ui/overlays/Circle3DOverlay.h b/interface/src/ui/overlays/Circle3DOverlay.h
index c0e84ef1c6..82c7c47dc7 100644
--- a/interface/src/ui/overlays/Circle3DOverlay.h
+++ b/interface/src/ui/overlays/Circle3DOverlay.h
@@ -59,28 +59,34 @@ public:
     virtual Circle3DOverlay* createClone() const override;
     
 protected:
-    float _startAt;
-    float _endAt;
-    float _outerRadius;
-    float _innerRadius;
-    bool _hasTickMarks;
-    float _majorTickMarksAngle;
-    float _minorTickMarksAngle;
-    float _majorTickMarksLength;
-    float _minorTickMarksLength;
+    float _startAt { 0 };
+    float _endAt { 360 };
+    float _outerRadius { 1 };
+    float _innerRadius { 0 };
+
+    xColor _innerStartColor;
+    xColor _innerEndColor;
+    xColor _outerStartColor;
+    xColor _outerEndColor;
+    float _innerStartAlpha;
+    float _innerEndAlpha;
+    float _outerStartAlpha;
+    float _outerEndAlpha;
+
+    bool _hasTickMarks { false };
+    float _majorTickMarksAngle { 0 };
+    float _minorTickMarksAngle { 0 };
+    float _majorTickMarksLength { 0 };
+    float _minorTickMarksLength { 0 };
     xColor _majorTickMarksColor;
     xColor _minorTickMarksColor;
-    
-    int _quadVerticesID;
-    int _lineVerticesID;
-    int _majorTicksVerticesID;
-    int _minorTicksVerticesID;
+    gpu::Primitive _solidPrimitive { gpu::TRIANGLE_FAN };
+    int _quadVerticesID { 0 };
+    int _lineVerticesID { 0 };
+    int _majorTicksVerticesID { 0 };
+    int _minorTicksVerticesID { 0 };
 
-    xColor _lastColor;
-    float _lastStartAt;
-    float _lastEndAt;
-    float _lastOuterRadius;
-    float _lastInnerRadius;
+    bool _dirty { true };
 };
 
  
diff --git a/libraries/avatars/src/AvatarData.cpp b/libraries/avatars/src/AvatarData.cpp
index 709cc76d01..e73702cd95 100644
--- a/libraries/avatars/src/AvatarData.cpp
+++ b/libraries/avatars/src/AvatarData.cpp
@@ -34,6 +34,7 @@
 #include <StreamUtils.h>
 #include <UUID.h>
 #include <shared/JSONHelpers.h>
+#include <ShapeInfo.h>
 
 #include "AvatarLogging.h"
 
@@ -1681,3 +1682,25 @@ AvatarEntityIDs AvatarData::getAndClearRecentlyDetachedIDs() {
     });
     return result;
 }
+
+QScriptValue RayToAvatarIntersectionResultToScriptValue(QScriptEngine* engine, const RayToAvatarIntersectionResult& value) {
+    QScriptValue obj = engine->newObject();
+    obj.setProperty("intersects", value.intersects);
+    QScriptValue avatarIDValue = quuidToScriptValue(engine, value.avatarID);
+    obj.setProperty("avatarID", avatarIDValue);
+    obj.setProperty("distance", value.distance);
+    QScriptValue intersection = vec3toScriptValue(engine, value.intersection);
+    obj.setProperty("intersection", intersection);
+    return obj;
+}
+
+void RayToAvatarIntersectionResultFromScriptValue(const QScriptValue& object, RayToAvatarIntersectionResult& value) {
+    value.intersects = object.property("intersects").toVariant().toBool();
+    QScriptValue avatarIDValue = object.property("avatarID");
+    quuidFromScriptValue(avatarIDValue, value.avatarID);
+    value.distance = object.property("distance").toVariant().toFloat();
+    QScriptValue intersection = object.property("intersection");
+    if (intersection.isValid()) {
+        vec3FromScriptValue(intersection, value.intersection);
+    }
+}
diff --git a/libraries/avatars/src/AvatarData.h b/libraries/avatars/src/AvatarData.h
index 2dd1079b49..14b4f07471 100644
--- a/libraries/avatars/src/AvatarData.h
+++ b/libraries/avatars/src/AvatarData.h
@@ -495,4 +495,19 @@ public:
 
 void registerAvatarTypes(QScriptEngine* engine);
 
+class RayToAvatarIntersectionResult {
+public:
+RayToAvatarIntersectionResult() : intersects(false), avatarID(), distance(0) {}
+    bool intersects;
+    QUuid avatarID;
+    float distance;
+    glm::vec3 intersection;
+};
+
+Q_DECLARE_METATYPE(RayToAvatarIntersectionResult)
+
+QScriptValue RayToAvatarIntersectionResultToScriptValue(QScriptEngine* engine, const RayToAvatarIntersectionResult& results);
+void RayToAvatarIntersectionResultFromScriptValue(const QScriptValue& object, RayToAvatarIntersectionResult& results);
+
+
 #endif // hifi_AvatarData_h
diff --git a/libraries/display-plugins/src/display-plugins/hmd/HmdDisplayPlugin.cpp b/libraries/display-plugins/src/display-plugins/hmd/HmdDisplayPlugin.cpp
index c2497e5740..1bfa6c7921 100644
--- a/libraries/display-plugins/src/display-plugins/hmd/HmdDisplayPlugin.cpp
+++ b/libraries/display-plugins/src/display-plugins/hmd/HmdDisplayPlugin.cpp
@@ -12,6 +12,8 @@
 #include <glm/gtx/intersect.hpp>
 
 #include <QtCore/QLoggingCategory>
+#include <QtCore/QFileInfo>
+#include <QtCore/QDateTime>
 #include <QtWidgets/QApplication>
 #include <QtWidgets/QWidget>
 
@@ -34,6 +36,9 @@ static const QString REPROJECTION = "Allow Reprojection";
 static const QString FRAMERATE = DisplayPlugin::MENU_PATH() + ">Framerate";
 static const QString DEVELOPER_MENU_PATH = "Developer>" + DisplayPlugin::MENU_PATH();
 static const bool DEFAULT_MONO_VIEW = true;
+static const int NUMBER_OF_HANDS = 2;
+static const glm::mat4 IDENTITY_MATRIX;
+
 
 glm::uvec2 HmdDisplayPlugin::getRecommendedUiSize() const {
     return CompositorHelper::VIRTUAL_SCREEN_SIZE;
@@ -90,170 +95,6 @@ void HmdDisplayPlugin::internalDeactivate() {
     Parent::internalDeactivate();
 }
 
-
-static const char * REPROJECTION_VS = R"VS(#version 410 core
-in vec3 Position;
-in vec2 TexCoord;
-
-out vec3 vPosition;
-out vec2 vTexCoord;
-
-void main() {
-  gl_Position = vec4(Position, 1);
-  vTexCoord = TexCoord;
-  vPosition = Position;
-}
-
-)VS";
-
-static GLint REPROJECTION_MATRIX_LOCATION = -1;
-static GLint INVERSE_PROJECTION_MATRIX_LOCATION = -1;
-static GLint PROJECTION_MATRIX_LOCATION = -1;
-static const char * REPROJECTION_FS = R"FS(#version 410 core
-
-uniform sampler2D sampler;
-uniform mat3 reprojection = mat3(1);
-uniform mat4 inverseProjections[2];
-uniform mat4 projections[2];
-
-in vec2 vTexCoord;
-in vec3 vPosition;
-
-out vec4 FragColor;
-
-void main() {
-    vec2 uv = vTexCoord;
-
-    mat4 eyeInverseProjection;
-    mat4 eyeProjection;
-    
-    float xoffset = 1.0;
-    vec2 uvmin = vec2(0.0);
-    vec2 uvmax = vec2(1.0);
-    // determine the correct projection and inverse projection to use.
-    if (vTexCoord.x < 0.5) {
-        uvmax.x = 0.5;
-        eyeInverseProjection = inverseProjections[0];
-        eyeProjection = projections[0];
-    } else {
-        xoffset = -1.0;
-        uvmin.x = 0.5;
-        uvmax.x = 1.0;
-        eyeInverseProjection = inverseProjections[1];
-        eyeProjection = projections[1];
-    }
-
-    // Account for stereo in calculating the per-eye NDC coordinates
-    vec4 ndcSpace = vec4(vPosition, 1.0);
-    ndcSpace.x *= 2.0;
-    ndcSpace.x += xoffset;
-    
-    // Convert from NDC to eyespace
-    vec4 eyeSpace = eyeInverseProjection * ndcSpace;
-    eyeSpace /= eyeSpace.w;
-
-    // Convert to a noramlized ray 
-    vec3 ray = eyeSpace.xyz;
-    ray = normalize(ray);
-
-    // Adjust the ray by the rotation
-    ray = reprojection * ray;
-
-    // Project back on to the texture plane
-    ray *= eyeSpace.z / ray.z;
-
-    // Update the eyespace vector
-    eyeSpace.xyz = ray;
-
-    // Reproject back into NDC
-    ndcSpace = eyeProjection * eyeSpace;
-    ndcSpace /= ndcSpace.w;
-    ndcSpace.x -= xoffset;
-    ndcSpace.x /= 2.0;
-    
-    // Calculate the new UV coordinates
-    uv = (ndcSpace.xy / 2.0) + 0.5;
-    if (any(greaterThan(uv, uvmax)) || any(lessThan(uv, uvmin))) {
-        FragColor = vec4(0.0, 0.0, 0.0, 1.0);
-    } else {
-        FragColor = texture(sampler, uv);
-    }
-}
-)FS";
-
-#ifdef DEBUG_REPROJECTION_SHADER
-#include <QtCore/QFile>
-#include <QtCore/QFileInfo>
-#include <QtCore/QDateTime>
-#include <PathUtils.h>
-
-static const QString REPROJECTION_FS_FILE =  "c:/Users/bdavis/Git/hifi/interface/resources/shaders/reproject.frag";
-
-static ProgramPtr getReprojectionProgram() {
-    static ProgramPtr _currentProgram;
-    uint64_t now = usecTimestampNow();
-    static uint64_t _lastFileCheck = now;
-
-    bool modified = false;
-    if ((now - _lastFileCheck) > USECS_PER_MSEC * 100) {
-        QFileInfo info(REPROJECTION_FS_FILE);
-        QDateTime lastModified = info.lastModified();
-        static QDateTime _lastModified = lastModified;
-        qDebug() << lastModified.toTime_t();
-        qDebug() << _lastModified.toTime_t();
-        if (lastModified > _lastModified) {
-            _lastModified = lastModified;
-            modified = true;
-        }
-    }
-
-    if (!_currentProgram || modified) {
-        _currentProgram.reset();
-        try {
-            QFile shaderFile(REPROJECTION_FS_FILE);
-            shaderFile.open(QIODevice::ReadOnly);
-            QString fragment = shaderFile.readAll();
-            compileProgram(_currentProgram, REPROJECTION_VS, fragment.toLocal8Bit().data());
-        } catch (const std::runtime_error& error) {
-            qDebug() << "Failed to build: " << error.what();
-        }
-        if (!_currentProgram) {
-            _currentProgram = loadDefaultShader();
-        }
-    }
-    return _currentProgram;
-}
-#endif
-
-static GLint PREVIEW_TEXTURE_LOCATION = -1;
-
-static const char * LASER_VS = R"VS(#version 410 core
-uniform mat4 mvp = mat4(1);
-
-in vec3 Position;
-
-out vec3 vPosition;
-
-void main() {
-  gl_Position = mvp * vec4(Position, 1);
-  vPosition = Position;
-}
-
-)VS";
-
-static const char * LASER_FS = R"FS(#version 410 core
-
-uniform vec4 color = vec4(1.0, 1.0, 1.0, 1.0);
-in vec3 vPosition;
-
-out vec4 FragColor;
-
-void main() {
-    FragColor = color;
-}
-
-)FS";
-
 void HmdDisplayPlugin::customizeContext() {
     Parent::customizeContext();
     // Only enable mirroring if we know vsync is disabled
@@ -263,24 +104,147 @@ void HmdDisplayPlugin::customizeContext() {
 #endif
     _enablePreview = !isVsyncEnabled();
     _sphereSection = loadSphereSection(_program, CompositorHelper::VIRTUAL_UI_TARGET_FOV.y, CompositorHelper::VIRTUAL_UI_ASPECT_RATIO);
-
     using namespace oglplus;
     if (!_enablePreview) {
         const std::string version("#version 410 core\n");
         compileProgram(_previewProgram, version + DrawUnitQuadTexcoord_vert, version + DrawTexture_frag);
-        PREVIEW_TEXTURE_LOCATION = Uniform<int>(*_previewProgram, "colorMap").Location();
+        _previewUniforms.previewTexture = Uniform<int>(*_previewProgram, "colorMap").Location();
     }
 
-    compileProgram(_laserProgram, LASER_VS, LASER_FS);
-    _laserGeometry = loadLaser(_laserProgram);
+    updateReprojectionProgram();
+    updateOverlayProgram();
+    updateLaserProgram();
 
-    compileProgram(_reprojectionProgram, REPROJECTION_VS, REPROJECTION_FS);
-    REPROJECTION_MATRIX_LOCATION = Uniform<glm::mat3>(*_reprojectionProgram, "reprojection").Location();
-    INVERSE_PROJECTION_MATRIX_LOCATION = Uniform<glm::mat4>(*_reprojectionProgram, "inverseProjections").Location();
-    PROJECTION_MATRIX_LOCATION = Uniform<glm::mat4>(*_reprojectionProgram, "projections").Location();
+    _laserGeometry = loadLaser(_laserProgram);
+}
+//#define LIVE_SHADER_RELOAD 1
+
+static QString readFile(const QString& filename) {
+    QFile file(filename);
+    file.open(QFile::Text | QFile::ReadOnly);
+    QString result;
+    result.append(QTextStream(&file).readAll());
+    return result;
+}
+
+void HmdDisplayPlugin::updateReprojectionProgram() {
+    static const QString vsFile = PathUtils::resourcesPath() + "/shaders/hmd_reproject.vert";
+    static const QString fsFile = PathUtils::resourcesPath() + "/shaders/hmd_reproject.frag";
+#if LIVE_SHADER_RELOAD
+    static qint64 vsBuiltAge = 0;
+    static qint64 fsBuiltAge = 0;
+    QFileInfo vsInfo(vsFile);
+    QFileInfo fsInfo(fsFile);
+    auto vsAge = vsInfo.lastModified().toMSecsSinceEpoch();
+    auto fsAge = fsInfo.lastModified().toMSecsSinceEpoch();
+    if (!_reprojectionProgram || vsAge > vsBuiltAge || fsAge > fsBuiltAge) {
+        vsBuiltAge = vsAge;
+        fsBuiltAge = fsAge;
+#else
+    if (!_reprojectionProgram) {
+#endif
+        QString vsSource = readFile(vsFile);
+        QString fsSource = readFile(fsFile);
+        ProgramPtr program;
+        try {
+            compileProgram(program, vsSource.toLocal8Bit().toStdString(), fsSource.toLocal8Bit().toStdString());
+            if (program) {
+                using namespace oglplus;
+                _reprojectionUniforms.reprojectionMatrix = Uniform<glm::mat3>(*program, "reprojection").Location();
+                _reprojectionUniforms.inverseProjectionMatrix = Uniform<glm::mat4>(*program, "inverseProjections").Location();
+                _reprojectionUniforms.projectionMatrix = Uniform<glm::mat4>(*program, "projections").Location();
+                _reprojectionProgram = program;
+            }
+        } catch (std::runtime_error& error) {
+            qWarning() << "Error building reprojection shader " << error.what();
+        }
+    }
+
+}
+
+void HmdDisplayPlugin::updateLaserProgram() {
+    static const QString vsFile = PathUtils::resourcesPath() + "/shaders/hmd_hand_lasers.vert";
+    static const QString gsFile = PathUtils::resourcesPath() + "/shaders/hmd_hand_lasers.geom";
+    static const QString fsFile = PathUtils::resourcesPath() + "/shaders/hmd_hand_lasers.frag";
+
+#if LIVE_SHADER_RELOAD
+    static qint64 vsBuiltAge = 0;
+    static qint64 gsBuiltAge = 0;
+    static qint64 fsBuiltAge = 0;
+    QFileInfo vsInfo(vsFile);
+    QFileInfo fsInfo(fsFile);
+    QFileInfo gsInfo(fsFile);
+    auto vsAge = vsInfo.lastModified().toMSecsSinceEpoch();
+    auto fsAge = fsInfo.lastModified().toMSecsSinceEpoch();
+    auto gsAge = gsInfo.lastModified().toMSecsSinceEpoch();
+    if (!_laserProgram || vsAge > vsBuiltAge || fsAge > fsBuiltAge || gsAge > gsBuiltAge) {
+        vsBuiltAge = vsAge;
+        gsBuiltAge = gsAge;
+        fsBuiltAge = fsAge;
+#else
+    if (!_laserProgram) {
+#endif
+
+        QString vsSource = readFile(vsFile);
+        QString fsSource = readFile(fsFile);
+        QString gsSource = readFile(gsFile);
+        ProgramPtr program;
+        try {
+            compileProgram(program, vsSource.toLocal8Bit().toStdString(), gsSource.toLocal8Bit().toStdString(), fsSource.toLocal8Bit().toStdString());
+            if (program) {
+                using namespace oglplus;
+                _laserUniforms.color = Uniform<glm::vec4>(*program, "color").Location();
+                _laserUniforms.mvp = Uniform<glm::mat4>(*program, "mvp").Location();
+                _laserProgram = program;
+            }
+        } catch (std::runtime_error& error) {
+            qWarning() << "Error building hand laser composite shader " << error.what();
+        }
+    }
+}
+
+void HmdDisplayPlugin::updateOverlayProgram() {
+    static const QString vsFile = PathUtils::resourcesPath() + "/shaders/hmd_ui_glow.vert";
+    static const QString fsFile = PathUtils::resourcesPath() + "/shaders/hmd_ui_glow.frag";
+
+#if LIVE_SHADER_RELOAD
+    static qint64 vsBuiltAge = 0;
+    static qint64 fsBuiltAge = 0;
+    QFileInfo vsInfo(vsFile);
+    QFileInfo fsInfo(fsFile);
+    auto vsAge = vsInfo.lastModified().toMSecsSinceEpoch();
+    auto fsAge = fsInfo.lastModified().toMSecsSinceEpoch();
+    if (!_overlayProgram || vsAge > vsBuiltAge || fsAge > fsBuiltAge) {
+        vsBuiltAge = vsAge;
+        fsBuiltAge = fsAge;
+#else
+    if (!_overlayProgram) {
+#endif
+        QString vsSource = readFile(vsFile);
+        QString fsSource = readFile(fsFile);
+        ProgramPtr program;
+        try {
+            compileProgram(program, vsSource.toLocal8Bit().toStdString(), fsSource.toLocal8Bit().toStdString());
+            if (program) {
+                using namespace oglplus;
+                _overlayUniforms.mvp = Uniform<glm::mat4>(*program, "mvp").Location();
+                _overlayUniforms.alpha = Uniform<float>(*program, "alpha").Location();
+                _overlayUniforms.glowColors = Uniform<glm::vec4>(*program, "glowColors").Location();
+                _overlayUniforms.glowPoints = Uniform<glm::vec4>(*program, "glowPoints").Location();
+                _overlayUniforms.resolution = Uniform<glm::vec2>(*program, "resolution").Location();
+                _overlayUniforms.radius = Uniform<float>(*program, "radius").Location();
+                _overlayProgram = program;
+                useProgram(_overlayProgram);
+                Uniform<glm::vec2>(*_overlayProgram, _overlayUniforms.resolution).Set(CompositorHelper::VIRTUAL_SCREEN_SIZE);
+            }
+        } catch (std::runtime_error& error) {
+            qWarning() << "Error building overlay composite shader " << error.what();
+        }
+    }
 }
 
 void HmdDisplayPlugin::uncustomizeContext() {
+    _overlayProgram.reset();
     _sphereSection.reset();
     _compositeFramebuffer.reset();
     _previewProgram.reset();
@@ -312,12 +276,12 @@ void HmdDisplayPlugin::compositeScene() {
     using namespace oglplus;
     Texture::MinFilter(TextureTarget::_2D, TextureMinFilter::Linear);
     Texture::MagFilter(TextureTarget::_2D, TextureMagFilter::Linear);
-    Uniform<glm::mat3>(*_reprojectionProgram, REPROJECTION_MATRIX_LOCATION).Set(_currentPresentFrameInfo.presentReprojection);
+    Uniform<glm::mat3>(*_reprojectionProgram, _reprojectionUniforms.reprojectionMatrix).Set(_currentPresentFrameInfo.presentReprojection);
     //Uniform<glm::mat4>(*_reprojectionProgram, PROJECTION_MATRIX_LOCATION).Set(_eyeProjections);
     //Uniform<glm::mat4>(*_reprojectionProgram, INVERSE_PROJECTION_MATRIX_LOCATION).Set(_eyeInverseProjections);
     // FIXME what's the right oglplus mechanism to do this?  It's not that ^^^ ... better yet, switch to a uniform buffer
-    glUniformMatrix4fv(INVERSE_PROJECTION_MATRIX_LOCATION, 2, GL_FALSE, &(_eyeInverseProjections[0][0][0]));
-    glUniformMatrix4fv(PROJECTION_MATRIX_LOCATION, 2, GL_FALSE, &(_eyeProjections[0][0][0]));
+    glUniformMatrix4fv(_reprojectionUniforms.inverseProjectionMatrix, 2, GL_FALSE, &(_eyeInverseProjections[0][0][0]));
+    glUniformMatrix4fv(_reprojectionUniforms.projectionMatrix, 2, GL_FALSE, &(_eyeProjections[0][0][0]));
     _plane->UseInProgram(*_reprojectionProgram);
     _plane->Draw();
 }
@@ -327,19 +291,93 @@ void HmdDisplayPlugin::compositeOverlay() {
     auto compositorHelper = DependencyManager::get<CompositorHelper>();
     glm::mat4 modelMat = compositorHelper->getModelTransform().getMatrix();
 
-    useProgram(_program);
-    // set the alpha
-    Uniform<float>(*_program, _alphaUniform).Set(_compositeOverlayAlpha);
+    withPresentThreadLock([&] {
+        _presentHandLasers = _handLasers;
+        _presentHandPoses = _handPoses;
+        _presentUiModelTransform = _uiModelTransform;
+    });
+    std::array<vec2, NUMBER_OF_HANDS> handGlowPoints { { vec2(-1), vec2(-1) } };
+
+    // compute the glow point interesections
+    for (int i = 0; i < NUMBER_OF_HANDS; ++i) {
+        if (_presentHandPoses[i] == IDENTITY_MATRIX) {
+            continue;
+        }
+        const auto& handLaser = _presentHandLasers[i];
+        if (!handLaser.valid()) {
+            continue;
+        }
+
+        const auto& laserDirection = handLaser.direction;
+        auto model = _presentHandPoses[i];
+        auto castDirection = glm::quat_cast(model) * laserDirection;
+        if (glm::abs(glm::length2(castDirection) - 1.0f) > EPSILON) {
+            castDirection = glm::normalize(castDirection);
+            castDirection = glm::inverse(_presentUiModelTransform.getRotation()) * castDirection;
+        }
+
+        // FIXME fetch the actual UI radius from... somewhere?
+        float uiRadius = 1.0f;
+
+        // Find the intersection of the laser with he UI and use it to scale the model matrix
+        float distance;
+        if (!glm::intersectRaySphere(vec3(_presentHandPoses[i][3]), castDirection, _presentUiModelTransform.getTranslation(), uiRadius * uiRadius, distance)) {
+            continue;
+        }
+
+        vec3 intersectionPosition = vec3(_presentHandPoses[i][3]) + (castDirection * distance) - _presentUiModelTransform.getTranslation();
+        intersectionPosition = glm::inverse(_presentUiModelTransform.getRotation()) * intersectionPosition;
+
+        // Take the interesection normal and convert it to a texture coordinate
+        vec2 yawPitch;
+        {
+            vec2 xdir = glm::normalize(vec2(intersectionPosition.x, -intersectionPosition.z));
+            yawPitch.x = glm::atan(xdir.x, xdir.y);
+            yawPitch.y = (acosf(intersectionPosition.y) * -1.0f) + M_PI_2;
+        }
+        vec2 halfFov = CompositorHelper::VIRTUAL_UI_TARGET_FOV / 2.0f;
+
+        // Are we out of range
+        if (glm::any(glm::greaterThan(glm::abs(yawPitch), halfFov))) {
+            continue;
+        }
+
+        yawPitch /= CompositorHelper::VIRTUAL_UI_TARGET_FOV;
+        yawPitch += 0.5f;
+        handGlowPoints[i] = yawPitch;
+    }
+
+    updateOverlayProgram();
+    if (!_overlayProgram) {
+        return;
+    }
+
+    useProgram(_overlayProgram);
+    // Setup the uniforms
+    {
+        if (_overlayUniforms.alpha >= 0) {
+            Uniform<float>(*_overlayProgram, _overlayUniforms.alpha).Set(_compositeOverlayAlpha);
+        }
+        if (_overlayUniforms.glowPoints >= 0) {
+            vec4 glowPoints(handGlowPoints[0], handGlowPoints[1]);
+            Uniform<glm::vec4>(*_overlayProgram, _overlayUniforms.glowPoints).Set(glowPoints);
+        }
+        if (_overlayUniforms.glowColors >= 0) {
+            std::array<glm::vec4, NUMBER_OF_HANDS> glowColors;
+            glowColors[0] = _presentHandLasers[0].color;
+            glowColors[1] = _presentHandLasers[1].color;
+            glProgramUniform4fv(GetName(*_overlayProgram), _overlayUniforms.glowColors, 2, &glowColors[0].r);
+        }
+    }
+
     _sphereSection->Use();
     for_each_eye([&](Eye eye) {
         eyeViewport(eye);
         auto modelView = glm::inverse(_currentPresentFrameInfo.presentPose * getEyeToHeadTransform(eye)) * modelMat;
         auto mvp = _eyeProjections[eye] * modelView;
-        Uniform<glm::mat4>(*_program, _mvpUniform).Set(mvp);
+        Uniform<glm::mat4>(*_overlayProgram, _overlayUniforms.mvp).Set(mvp);
         _sphereSection->Draw();
     });
-    // restore the alpha
-    Uniform<float>(*_program, _alphaUniform).Set(1.0);
 }
 
 void HmdDisplayPlugin::compositePointer() {
@@ -423,7 +461,7 @@ void HmdDisplayPlugin::internalPresent() {
         glClearColor(0, 0, 0, 1);
         glClear(GL_COLOR_BUFFER_BIT);
         glViewport(targetViewportPosition.x, targetViewportPosition.y, targetViewportSize.x, targetViewportSize.y);
-        glUniform1i(PREVIEW_TEXTURE_LOCATION, 0);
+        glUniform1i(_previewUniforms.previewTexture, 0);
         glActiveTexture(GL_TEXTURE0);
         glBindTexture(GL_TEXTURE_2D, _previewTextureID);
         glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
@@ -478,26 +516,17 @@ bool HmdDisplayPlugin::setHandLaser(uint32_t hands, HandLaserMode mode, const ve
 }
 
 void HmdDisplayPlugin::compositeExtra() {
-    const int NUMBER_OF_HANDS = 2;
-    std::array<HandLaserInfo, NUMBER_OF_HANDS> handLasers;
-    std::array<mat4, NUMBER_OF_HANDS> renderHandPoses;
-    Transform uiModelTransform;
-    withPresentThreadLock([&] {
-        handLasers = _handLasers;
-        renderHandPoses = _handPoses;
-        uiModelTransform = _uiModelTransform;
-    });
-
     // If neither hand laser is activated, exit
-    if (!handLasers[0].valid() && !handLasers[1].valid()) {
+    if (!_presentHandLasers[0].valid() && !_presentHandLasers[1].valid()) {
         return;
     }
 
-    static const glm::mat4 identity;
-    if (renderHandPoses[0] == identity && renderHandPoses[1] == identity) {
+    if (_presentHandPoses[0] == IDENTITY_MATRIX && _presentHandPoses[1] == IDENTITY_MATRIX) {
         return;
     }
 
+    updateLaserProgram();
+
     // Render hand lasers
     using namespace oglplus;
     useProgram(_laserProgram);
@@ -505,16 +534,16 @@ void HmdDisplayPlugin::compositeExtra() {
     std::array<mat4, NUMBER_OF_HANDS> handLaserModelMatrices;
 
     for (int i = 0; i < NUMBER_OF_HANDS; ++i) {
-        if (renderHandPoses[i] == identity) {
+        if (_presentHandPoses[i] == IDENTITY_MATRIX) {
             continue;
         }
-        const auto& handLaser = handLasers[i];
+        const auto& handLaser = _presentHandLasers[i];
         if (!handLaser.valid()) {
             continue;
         }
 
         const auto& laserDirection = handLaser.direction;
-        auto model = renderHandPoses[i];
+        auto model = _presentHandPoses[i];
         auto castDirection = glm::quat_cast(model) * laserDirection;
         if (glm::abs(glm::length2(castDirection) - 1.0f) > EPSILON) {
             castDirection = glm::normalize(castDirection);
@@ -525,7 +554,7 @@ void HmdDisplayPlugin::compositeExtra() {
 
         // Find the intersection of the laser with he UI and use it to scale the model matrix
         float distance; 
-        if (!glm::intersectRaySphere(vec3(renderHandPoses[i][3]), castDirection, uiModelTransform.getTranslation(), uiRadius * uiRadius, distance)) {
+        if (!glm::intersectRaySphere(vec3(_presentHandPoses[i][3]), castDirection, _presentUiModelTransform.getTranslation(), uiRadius * uiRadius, distance)) {
             continue;
         }
 
@@ -539,19 +568,20 @@ void HmdDisplayPlugin::compositeExtra() {
         handLaserModelMatrices[i] = model;
     }
 
+    glEnable(GL_BLEND);
     for_each_eye([&](Eye eye) {
         eyeViewport(eye);
         auto eyePose = _currentPresentFrameInfo.presentPose * getEyeToHeadTransform(eye);
         auto view = glm::inverse(eyePose);
         const auto& projection = _eyeProjections[eye];
         for (int i = 0; i < NUMBER_OF_HANDS; ++i) {
-            if (handLaserModelMatrices[i] == identity) {
+            if (handLaserModelMatrices[i] == IDENTITY_MATRIX) {
                 continue;
             }
             Uniform<glm::mat4>(*_laserProgram, "mvp").Set(projection * view * handLaserModelMatrices[i]);
-            Uniform<glm::vec4>(*_laserProgram, "color").Set(handLasers[i].color);
+            Uniform<glm::vec4>(*_laserProgram, "color").Set(_presentHandLasers[i].color);
             _laserGeometry->Draw();
-            // TODO render some kind of visual indicator at the intersection point with the UI.
         }
     });
+    glDisable(GL_BLEND);
 }
diff --git a/libraries/display-plugins/src/display-plugins/hmd/HmdDisplayPlugin.h b/libraries/display-plugins/src/display-plugins/hmd/HmdDisplayPlugin.h
index 8e48690fd1..f168ec9607 100644
--- a/libraries/display-plugins/src/display-plugins/hmd/HmdDisplayPlugin.h
+++ b/libraries/display-plugins/src/display-plugins/hmd/HmdDisplayPlugin.h
@@ -64,6 +64,11 @@ protected:
     Transform _uiModelTransform;
     std::array<HandLaserInfo, 2> _handLasers;
     std::array<glm::mat4, 2> _handPoses;
+
+    Transform _presentUiModelTransform;
+    std::array<HandLaserInfo, 2> _presentHandLasers;
+    std::array<mat4, 2> _presentHandPoses;
+
     std::array<glm::mat4, 2> _eyeOffsets;
     std::array<glm::mat4, 2> _eyeProjections;
     std::array<glm::mat4, 2> _eyeInverseProjections;
@@ -87,21 +92,49 @@ protected:
     FrameInfo _currentRenderFrameInfo;
 
 private:
+    void updateOverlayProgram();
+    void updateLaserProgram();
+    void updateReprojectionProgram();
+
     bool _enablePreview { false };
     bool _monoPreview { true };
     bool _enableReprojection { true };
     bool _firstPreview { true };
 
+    ProgramPtr _overlayProgram;
+    struct OverlayUniforms {
+        int32_t mvp { -1 };
+        int32_t alpha { -1 };
+        int32_t glowColors { -1 };
+        int32_t glowPoints { -1 };
+        int32_t resolution { -1 };
+        int32_t radius { -1 };
+    } _overlayUniforms;
+
     ProgramPtr _previewProgram;
+    struct PreviewUniforms {
+        int32_t previewTexture { -1 };
+    } _previewUniforms;
+
     float _previewAspect { 0 };
     GLuint _previewTextureID { 0 };
     glm::uvec2 _prevWindowSize { 0, 0 };
     qreal _prevDevicePixelRatio { 0 };
 
     ProgramPtr _reprojectionProgram;
+    struct ReprojectionUniforms {
+        int32_t reprojectionMatrix { -1 };
+        int32_t inverseProjectionMatrix { -1 };
+        int32_t projectionMatrix { -1 };
+    } _reprojectionUniforms;
+
     ShapeWrapperPtr _sphereSection;
 
     ProgramPtr _laserProgram;
+    struct LaserUniforms {
+        int32_t mvp { -1 };
+        int32_t color { -1 };
+    } _laserUniforms;
     ShapeWrapperPtr _laserGeometry;
 };
 
diff --git a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
index 416a38d27c..d63361538a 100644
--- a/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableModelEntityItem.cpp
@@ -10,6 +10,7 @@
 //
 
 #include <glm/gtx/quaternion.hpp>
+#include <set>
 
 #include <QJsonDocument>
 #include <QtCore/QThread>
@@ -690,8 +691,8 @@ void RenderableModelEntityItem::computeShapeInfo(ShapeInfo& info) {
         glm::vec3 scaleToFit = dimensions / _model->getFBXGeometry().getUnscaledMeshExtents().size();
         // multiply each point by scale before handing the point-set off to the physics engine.
         // also determine the extents of the collision model.
-        for (int i = 0; i < pointCollection.size(); i++) {
-            for (int j = 0; j < pointCollection[i].size(); j++) {
+        for (int32_t i = 0; i < pointCollection.size(); i++) {
+            for (int32_t j = 0; j < pointCollection[i].size(); j++) {
                 // compensate for registration
                 pointCollection[i][j] += _model->getOffset();
                 // scale so the collision points match the model points
@@ -708,9 +709,9 @@ void RenderableModelEntityItem::computeShapeInfo(ShapeInfo& info) {
         // compute meshPart local transforms
         QVector<glm::mat4> localTransforms;
         const FBXGeometry& fbxGeometry = _model->getFBXGeometry();
-        int numberOfMeshes = fbxGeometry.meshes.size();
-        int totalNumVertices = 0;
-        for (int i = 0; i < numberOfMeshes; i++) {
+        int32_t numMeshes = (int32_t)fbxGeometry.meshes.size();
+        int32_t totalNumVertices = 0;
+        for (int32_t i = 0; i < numMeshes; i++) {
             const FBXMesh& mesh = fbxGeometry.meshes.at(i);
             if (mesh.clusters.size() > 0) {
                 const FBXCluster& cluster = mesh.clusters.at(0);
@@ -722,7 +723,7 @@ void RenderableModelEntityItem::computeShapeInfo(ShapeInfo& info) {
             }
             totalNumVertices += mesh.vertices.size();
         }
-        const int MAX_VERTICES_PER_STATIC_MESH = 1e6;
+        const int32_t MAX_VERTICES_PER_STATIC_MESH = 1e6;
         if (totalNumVertices > MAX_VERTICES_PER_STATIC_MESH) {
             qWarning() << "model" << getModelURL() << "has too many vertices" << totalNumVertices << "and will collide as a box.";
             info.setParams(SHAPE_TYPE_BOX, 0.5f * dimensions);
@@ -730,7 +731,9 @@ void RenderableModelEntityItem::computeShapeInfo(ShapeInfo& info) {
         }
 
         auto& meshes = _model->getGeometry()->getGeometry()->getMeshes();
-        int32_t numMeshes = (int32_t)(meshes.size());
+
+        // the render geometry's mesh count should match that of the FBXGeometry
+        assert(numMeshes == (int32_t)(meshes.size()));
 
         ShapeInfo::PointCollection& pointCollection = info.getPointCollection();
         pointCollection.clear();
@@ -741,8 +744,8 @@ void RenderableModelEntityItem::computeShapeInfo(ShapeInfo& info) {
         }
 
         Extents extents;
-        int meshCount = 0;
-        int pointListIndex = 0;
+        int32_t meshCount = 0;
+        int32_t pointListIndex = 0;
         for (auto& mesh : meshes) {
             const gpu::BufferView& vertices = mesh->getVertexBuffer();
             const gpu::BufferView& indices = mesh->getIndexBuffer();
@@ -775,6 +778,7 @@ void RenderableModelEntityItem::computeShapeInfo(ShapeInfo& info) {
             if (type == SHAPE_TYPE_STATIC_MESH) {
                 // copy into triangleIndices
                 ShapeInfo::TriangleIndices& triangleIndices = info.getTriangleIndices();
+                triangleIndices.clear();
                 triangleIndices.reserve((int32_t)((gpu::Size)(triangleIndices.size()) + indices.getNumElements()));
                 gpu::BufferView::Iterator<const model::Mesh::Part> partItr = parts.cbegin<const model::Mesh::Part>();
                 while (partItr != parts.cend<const model::Mesh::Part>()) {
@@ -823,6 +827,64 @@ void RenderableModelEntityItem::computeShapeInfo(ShapeInfo& info) {
                     }
                     ++partItr;
                 }
+            } else if (type == SHAPE_TYPE_SIMPLE_COMPOUND) {
+                // for each mesh copy unique part indices, separated by special bogus (flag) index values
+                ShapeInfo::TriangleIndices& triangleIndices = info.getTriangleIndices();
+                triangleIndices.clear();
+                gpu::BufferView::Iterator<const model::Mesh::Part> partItr = parts.cbegin<const model::Mesh::Part>();
+                while (partItr != parts.cend<const model::Mesh::Part>()) {
+                    // collect unique list of indices for this part
+                    std::set<int32_t> uniqueIndices;
+                    if (partItr->_topology == model::Mesh::TRIANGLES) {
+                        assert(partItr->_numIndices % 3 == 0);
+                        auto indexItr = indices.cbegin<const gpu::BufferView::Index>() + partItr->_startIndex;
+                        auto indexEnd = indexItr + partItr->_numIndices;
+                        while (indexItr != indexEnd) {
+                            uniqueIndices.insert(*indexItr);
+                            ++indexItr;
+                        }
+                    } else if (partItr->_topology == model::Mesh::TRIANGLE_STRIP) {
+                        assert(partItr->_numIndices > 2);
+                        auto indexItr = indices.cbegin<const gpu::BufferView::Index>() + partItr->_startIndex;
+                        auto indexEnd = indexItr + (partItr->_numIndices - 2);
+
+                        // first triangle uses the first three indices
+                        uniqueIndices.insert(*(indexItr++));
+                        uniqueIndices.insert(*(indexItr++));
+                        uniqueIndices.insert(*(indexItr++));
+
+                        // the rest use previous and next index
+                        uint32_t triangleCount = 1;
+                        while (indexItr != indexEnd) {
+                            if ((*indexItr) != model::Mesh::PRIMITIVE_RESTART_INDEX) {
+                                if (triangleCount % 2 == 0) {
+                                    // even triangles use first two indices in order
+                                    uniqueIndices.insert(*(indexItr - 2));
+                                    uniqueIndices.insert(*(indexItr - 1));
+                                } else {
+                                    // odd triangles swap order of first two indices
+                                    uniqueIndices.insert(*(indexItr - 1));
+                                    uniqueIndices.insert(*(indexItr - 2));
+                                }
+                                uniqueIndices.insert(*indexItr);
+                                ++triangleCount;
+                            }
+                            ++indexItr;
+                        }
+                    }
+
+                    // store uniqueIndices in triangleIndices
+                    triangleIndices.reserve(triangleIndices.size() + (int32_t)uniqueIndices.size());
+                    for (auto index : uniqueIndices) {
+                        triangleIndices.push_back(index);
+                    }
+                    // flag end of part
+                    triangleIndices.push_back(END_OF_MESH_PART);
+
+                    ++partItr;
+                }
+                // flag end of mesh
+                triangleIndices.push_back(END_OF_MESH);
             }
             ++meshCount;
         }
@@ -830,13 +892,13 @@ void RenderableModelEntityItem::computeShapeInfo(ShapeInfo& info) {
         // scale and shift
         glm::vec3 extentsSize = extents.size();
         glm::vec3 scaleToFit = dimensions / extentsSize;
-        for (int i = 0; i < 3; ++i) {
+        for (int32_t i = 0; i < 3; ++i) {
             if (extentsSize[i] < 1.0e-6f) {
                 scaleToFit[i] = 1.0f;
             }
         }
         for (auto points : pointCollection) {
-            for (int i = 0; i < points.size(); ++i) {
+            for (int32_t i = 0; i < points.size(); ++i) {
                 points[i] = (points[i] * scaleToFit);
             }
         }
diff --git a/libraries/gl/src/gl/OglplusHelpers.cpp b/libraries/gl/src/gl/OglplusHelpers.cpp
index 7a535a806d..1154042b4a 100644
--- a/libraries/gl/src/gl/OglplusHelpers.cpp
+++ b/libraries/gl/src/gl/OglplusHelpers.cpp
@@ -87,6 +87,36 @@ ProgramPtr loadCubemapShader() {
     return result;
 }
 
+void compileProgram(ProgramPtr & result, const std::string& vs, const std::string& gs, const std::string& fs) {
+    using namespace oglplus;
+    try {
+        result = std::make_shared<Program>();
+        // attach the shaders to the program
+        result->AttachShader(
+            VertexShader()
+            .Source(GLSLSource(vs))
+            .Compile()
+            );
+        result->AttachShader(
+            GeometryShader()
+            .Source(GLSLSource(gs))
+            .Compile()
+            );
+        result->AttachShader(
+            FragmentShader()
+            .Source(GLSLSource(fs))
+            .Compile()
+            );
+        result->Link();
+    } catch (ProgramBuildError& err) {
+        Q_UNUSED(err);
+        qWarning() << err.Log().c_str();
+        Q_ASSERT_X(false, "compileProgram", "Failed to build shader program");
+        qFatal("%s", (const char*)err.Message);
+        result.reset();
+    }
+}
+
 void compileProgram(ProgramPtr & result, const std::string& vs, const std::string& fs) {
     using namespace oglplus;
     try {
diff --git a/libraries/gl/src/gl/OglplusHelpers.h b/libraries/gl/src/gl/OglplusHelpers.h
index 8940205b21..c453fbad28 100644
--- a/libraries/gl/src/gl/OglplusHelpers.h
+++ b/libraries/gl/src/gl/OglplusHelpers.h
@@ -62,6 +62,8 @@ using Mat4Uniform = oglplus::Uniform<mat4>;
 ProgramPtr loadDefaultShader();
 ProgramPtr loadCubemapShader();
 void compileProgram(ProgramPtr & result, const std::string& vs, const std::string& fs);
+void compileProgram(ProgramPtr & result, const std::string& vs, const std::string& gs, const std::string& fs);
+
 ShapeWrapperPtr loadSkybox(ProgramPtr program);
 ShapeWrapperPtr loadPlane(ProgramPtr program, float aspect = 1.0f);
 ShapeWrapperPtr loadSphereSection(ProgramPtr program, float fov = PI / 3.0f * 2.0f, float aspect = 16.0f / 9.0f, int slices = 128, int stacks = 128);
diff --git a/libraries/input-plugins/src/input-plugins/KeyboardMouseDevice.cpp b/libraries/input-plugins/src/input-plugins/KeyboardMouseDevice.cpp
index 56894efc4c..c1f764f5fa 100755
--- a/libraries/input-plugins/src/input-plugins/KeyboardMouseDevice.cpp
+++ b/libraries/input-plugins/src/input-plugins/KeyboardMouseDevice.cpp
@@ -50,9 +50,11 @@ void KeyboardMouseDevice::InputDevice::focusOutEvent() {
 
 void KeyboardMouseDevice::keyPressEvent(QKeyEvent* event) {
     auto input = _inputDevice->makeInput((Qt::Key) event->key());
-    auto result = _inputDevice->_buttonPressedMap.insert(input.getChannel());
-    if (!result.second) {
-        // key pressed again ? without catching the release event ?
+    if (!(event->modifiers() & Qt::KeyboardModifier::ControlModifier)) {
+        auto result = _inputDevice->_buttonPressedMap.insert(input.getChannel());
+        if (result.second) {
+            // key pressed again ? without catching the release event ?
+        }
     }
 }
 
diff --git a/libraries/networking/src/AddressManager.cpp b/libraries/networking/src/AddressManager.cpp
index df9b4094b0..7ed3888be0 100644
--- a/libraries/networking/src/AddressManager.cpp
+++ b/libraries/networking/src/AddressManager.cpp
@@ -564,10 +564,10 @@ bool AddressManager::handleViewpoint(const QString& viewpointString, bool should
             if (viewpointString[positionRegex.matchedLength() - 1] == QChar('/')
                 && orientationRegex.indexIn(viewpointString, positionRegex.matchedLength() - 1) != -1) {
 
-                glm::quat newOrientation = glm::normalize(glm::quat(orientationRegex.cap(4).toFloat(),
-                                                                    orientationRegex.cap(1).toFloat(),
-                                                                    orientationRegex.cap(2).toFloat(),
-                                                                    orientationRegex.cap(3).toFloat()));
+                newOrientation = glm::normalize(glm::quat(orientationRegex.cap(4).toFloat(),
+                                                          orientationRegex.cap(1).toFloat(),
+                                                          orientationRegex.cap(2).toFloat(),
+                                                          orientationRegex.cap(3).toFloat()));
 
                 if (!isNaN(newOrientation.x) && !isNaN(newOrientation.y) && !isNaN(newOrientation.z)
                     && !isNaN(newOrientation.w)) {
diff --git a/libraries/networking/src/LimitedNodeList.cpp b/libraries/networking/src/LimitedNodeList.cpp
index d7a2d47fab..a03fa43093 100644
--- a/libraries/networking/src/LimitedNodeList.cpp
+++ b/libraries/networking/src/LimitedNodeList.cpp
@@ -522,6 +522,7 @@ SharedNodePointer LimitedNodeList::addOrUpdateNode(const QUuid& uuid, NodeType_t
                                                    const HifiSockAddr& publicSocket, const HifiSockAddr& localSocket,
                                                    const NodePermissions& permissions,
                                                    const QUuid& connectionSecret) {
+    QReadLocker readLocker(&_nodeMutex);
     NodeHash::const_iterator it = _nodeHash.find(uuid);
 
     if (it != _nodeHash.end()) {
diff --git a/libraries/networking/src/LimitedNodeList.h b/libraries/networking/src/LimitedNodeList.h
index 483aa0734c..c9054ac6d7 100644
--- a/libraries/networking/src/LimitedNodeList.h
+++ b/libraries/networking/src/LimitedNodeList.h
@@ -131,7 +131,7 @@ public:
 
     std::function<void(Node*)> linkedDataCreateCallback;
 
-    size_t size() const { return _nodeHash.size(); }
+    size_t size() const { QReadLocker readLock(&_nodeMutex); return _nodeHash.size(); }
 
     SharedNodePointer nodeWithUUID(const QUuid& nodeUUID);
 
@@ -287,7 +287,7 @@ protected:
 
     QUuid _sessionUUID;
     NodeHash _nodeHash;
-    QReadWriteLock _nodeMutex;
+    mutable QReadWriteLock _nodeMutex;
     udt::Socket _nodeSocket;
     QUdpSocket* _dtlsSocket;
     HifiSockAddr _localSockAddr;
diff --git a/libraries/networking/src/NodeList.cpp b/libraries/networking/src/NodeList.cpp
index fd1442d639..d3fc93b991 100644
--- a/libraries/networking/src/NodeList.cpp
+++ b/libraries/networking/src/NodeList.cpp
@@ -513,6 +513,7 @@ void NodeList::processDomainServerConnectionTokenPacket(QSharedPointer<ReceivedM
 
 void NodeList::processDomainServerList(QSharedPointer<ReceivedMessage> message) {
     if (_domainHandler.getSockAddr().isNull()) {
+        qWarning() << "IGNORING DomainList packet while not connected to a Domain Server";
         // refuse to process this packet if we aren't currently connected to the DS
         return;
     }
@@ -535,6 +536,10 @@ void NodeList::processDomainServerList(QSharedPointer<ReceivedMessage> message)
     if (!_domainHandler.isConnected()) {
         _domainHandler.setUUID(domainUUID);
         _domainHandler.setIsConnected(true);
+    } else if (_domainHandler.getUUID() != domainUUID) {
+        // Recieved packet from different domain.
+        qWarning() << "IGNORING DomainList packet from" << domainUUID << "while connected to" << _domainHandler.getUUID();
+        return;
     }
 
     // pull our owner UUID from the packet, it's always the first thing
diff --git a/libraries/physics/src/ShapeFactory.cpp b/libraries/physics/src/ShapeFactory.cpp
index f71711eccd..944e05e571 100644
--- a/libraries/physics/src/ShapeFactory.cpp
+++ b/libraries/physics/src/ShapeFactory.cpp
@@ -69,6 +69,7 @@ static const btVector3 _unitSphereDirections[NUM_UNIT_SPHERE_DIRECTIONS] = {
 
 // util method
 btConvexHullShape* createConvexHull(const ShapeInfo::PointList& points) {
+    //std::cout << "adebug createConvexHull() points.size() = " << points.size() << std::endl;  // adebug
     assert(points.size() > 0);
 
     btConvexHullShape* hull = new btConvexHullShape();
@@ -240,6 +241,7 @@ void deleteStaticMeshArray(btTriangleIndexVertexArray* dataArray) {
 btCollisionShape* ShapeFactory::createShapeFromInfo(const ShapeInfo& info) {
     btCollisionShape* shape = NULL;
     int type = info.getType();
+    //std::cout << "adebug createShapeFromInfo() type = " << type << std::endl;  // adebug
     switch(type) {
         case SHAPE_TYPE_BOX: {
             shape = new btBoxShape(glmToBullet(info.getHalfExtents()));
@@ -258,8 +260,7 @@ btCollisionShape* ShapeFactory::createShapeFromInfo(const ShapeInfo& info) {
         }
         break;
         case SHAPE_TYPE_COMPOUND:
-        case SHAPE_TYPE_SIMPLE_HULL:
-        case SHAPE_TYPE_SIMPLE_COMPOUND: {
+        case SHAPE_TYPE_SIMPLE_HULL: {
             const ShapeInfo::PointCollection& pointCollection = info.getPointCollection();
             uint32_t numSubShapes = info.getNumSubShapes();
             if (numSubShapes == 1) {
@@ -270,12 +271,63 @@ btCollisionShape* ShapeFactory::createShapeFromInfo(const ShapeInfo& info) {
                 trans.setIdentity();
                 foreach (const ShapeInfo::PointList& hullPoints, pointCollection) {
                     btConvexHullShape* hull = createConvexHull(hullPoints);
-                    compound->addChildShape (trans, hull);
+                    compound->addChildShape(trans, hull);
                 }
                 shape = compound;
             }
         }
         break;
+        case SHAPE_TYPE_SIMPLE_COMPOUND: {
+            const ShapeInfo::PointCollection& pointCollection = info.getPointCollection();
+            const ShapeInfo::TriangleIndices& triangleIndices = info.getTriangleIndices();
+            uint32_t numIndices = triangleIndices.size();
+            uint32_t numMeshes = info.getNumSubShapes();
+            const uint32_t MIN_NUM_SIMPLE_COMPOUND_INDICES = 2; // END_OF_MESH_PART + END_OF_MESH
+            if (numMeshes > 0 && numIndices > MIN_NUM_SIMPLE_COMPOUND_INDICES) {
+                uint32_t i = 0;
+                std::vector<btConvexHullShape*> hulls;
+                for (auto& points : pointCollection) {
+                    // build a hull around each part
+                    while (i < numIndices) {
+                        ShapeInfo::PointList hullPoints;
+                        hullPoints.reserve(points.size());
+                        while (i < numIndices) {
+                            int32_t j = triangleIndices[i];
+                            ++i;
+                            if (j == END_OF_MESH_PART) {
+                                // end of part
+                                break;
+                            }
+                            hullPoints.push_back(points[j]);
+                        }
+                        if (hullPoints.size() > 0) {
+                            btConvexHullShape* hull = createConvexHull(hullPoints);
+                            hulls.push_back(hull);
+                        }
+
+                        assert(i < numIndices);
+                        if (triangleIndices[i] == END_OF_MESH) {
+                            // end of mesh
+                            ++i;
+                            break;
+                        }
+                    }
+                }
+                uint32_t numHulls = (uint32_t)hulls.size();
+                if (numHulls == 1) {
+                    shape = hulls[0];
+                } else {
+                    auto compound = new btCompoundShape();
+                    btTransform trans;
+                    trans.setIdentity();
+                    for (auto hull : hulls) {
+                        compound->addChildShape(trans, hull);
+                    }
+                    shape = compound;
+                }
+            }
+        }
+        break;
         case SHAPE_TYPE_STATIC_MESH: {
             btTriangleIndexVertexArray* dataArray = createStaticMeshArray(info);
             shape = new StaticMeshShape(dataArray);
diff --git a/libraries/render-utils/src/GeometryCache.cpp b/libraries/render-utils/src/GeometryCache.cpp
index fd06272fa9..4558b68af9 100644
--- a/libraries/render-utils/src/GeometryCache.cpp
+++ b/libraries/render-utils/src/GeometryCache.cpp
@@ -432,7 +432,7 @@ void GeometryCache::renderGrid(gpu::Batch& batch, const glm::vec2& minCorner, co
     renderQuad(batch, minCorner, maxCorner, MIN_TEX_COORD, MAX_TEX_COORD, color, id);
 }
 
-void GeometryCache::updateVertices(int id, const QVector<glm::vec2>& points, const glm::vec4& color) {
+void GeometryCache::updateVertices(int id, const QVector<glm::vec2>& points, const QVector<glm::vec4>& colors) {
     BatchItemDetails& details = _registeredVertices[id];
 
     if (details.isCreated) {
@@ -469,11 +469,6 @@ void GeometryCache::updateVertices(int id, const QVector<glm::vec2>& points, con
     details.vertices = points.size();
     details.vertexSize = FLOATS_PER_VERTEX;
 
-    int compactColor = ((int(color.x * 255.0f) & 0xFF)) |
-        ((int(color.y * 255.0f) & 0xFF) << 8) |
-        ((int(color.z * 255.0f) & 0xFF) << 16) |
-        ((int(color.w * 255.0f) & 0xFF) << 24);
-
     float* vertexData = new float[details.vertices * FLOATS_PER_VERTEX];
     float* vertex = vertexData;
 
@@ -481,16 +476,25 @@ void GeometryCache::updateVertices(int id, const QVector<glm::vec2>& points, con
     int* colorDataAt = colorData;
 
     const glm::vec3 NORMAL(0.0f, 0.0f, 1.0f);
-    foreach(const glm::vec2& point, points) {
+    auto pointCount = points.size();
+    auto colorCount = colors.size();
+    int compactColor = 0;
+    for (auto i = 0; i < pointCount; ++i) {
+        const auto& point = points[i];
         *(vertex++) = point.x;
         *(vertex++) = point.y;
         *(vertex++) = NORMAL.x;
         *(vertex++) = NORMAL.y;
         *(vertex++) = NORMAL.z;
-
+        if (i < colorCount) {
+            const auto& color = colors[i];
+            compactColor = ((int(color.x * 255.0f) & 0xFF)) |
+                ((int(color.y * 255.0f) & 0xFF) << 8) |
+                ((int(color.z * 255.0f) & 0xFF) << 16) |
+                ((int(color.w * 255.0f) & 0xFF) << 24);
+        }
         *(colorDataAt++) = compactColor;
     }
-
     details.verticesBuffer->append(sizeof(float) * FLOATS_PER_VERTEX * details.vertices, (gpu::Byte*) vertexData);
     details.colorBuffer->append(sizeof(int) * details.vertices, (gpu::Byte*) colorData);
     delete[] vertexData;
@@ -501,7 +505,11 @@ void GeometryCache::updateVertices(int id, const QVector<glm::vec2>& points, con
 #endif
 }
 
-void GeometryCache::updateVertices(int id, const QVector<glm::vec3>& points, const glm::vec4& color) {
+void GeometryCache::updateVertices(int id, const QVector<glm::vec2>& points, const glm::vec4& color) {
+    updateVertices(id, points, QVector<glm::vec4>({ color }));
+}
+
+void GeometryCache::updateVertices(int id, const QVector<glm::vec3>& points, const QVector<glm::vec4>& colors) {
     BatchItemDetails& details = _registeredVertices[id];
     if (details.isCreated) {
         details.clear();
@@ -537,11 +545,8 @@ void GeometryCache::updateVertices(int id, const QVector<glm::vec3>& points, con
     details.vertices = points.size();
     details.vertexSize = FLOATS_PER_VERTEX;
 
-    int compactColor = ((int(color.x * 255.0f) & 0xFF)) |
-        ((int(color.y * 255.0f) & 0xFF) << 8) |
-        ((int(color.z * 255.0f) & 0xFF) << 16) |
-        ((int(color.w * 255.0f) & 0xFF) << 24);
-
+    // Default to white
+    int compactColor = 0xFFFFFFFF;
     float* vertexData = new float[details.vertices * FLOATS_PER_VERTEX];
     float* vertex = vertexData;
 
@@ -549,14 +554,23 @@ void GeometryCache::updateVertices(int id, const QVector<glm::vec3>& points, con
     int* colorDataAt = colorData;
 
     const glm::vec3 NORMAL(0.0f, 0.0f, 1.0f);
-    foreach(const glm::vec3& point, points) {
+    auto pointCount = points.size();
+    auto colorCount = colors.size();
+    for (auto i = 0; i < pointCount; ++i) {
+        const glm::vec3& point = points[i];
+        if (i < colorCount) {
+            const glm::vec4& color = colors[i];
+            compactColor = ((int(color.x * 255.0f) & 0xFF)) |
+                ((int(color.y * 255.0f) & 0xFF) << 8) |
+                ((int(color.z * 255.0f) & 0xFF) << 16) |
+                ((int(color.w * 255.0f) & 0xFF) << 24);
+        }
         *(vertex++) = point.x;
         *(vertex++) = point.y;
         *(vertex++) = point.z;
         *(vertex++) = NORMAL.x;
         *(vertex++) = NORMAL.y;
         *(vertex++) = NORMAL.z;
-
         *(colorDataAt++) = compactColor;
     }
 
@@ -570,6 +584,10 @@ void GeometryCache::updateVertices(int id, const QVector<glm::vec3>& points, con
 #endif
 }
 
+void GeometryCache::updateVertices(int id, const QVector<glm::vec3>& points, const glm::vec4& color) {
+    updateVertices(id, points, QVector<glm::vec4>({ color }));
+}
+
 void GeometryCache::updateVertices(int id, const QVector<glm::vec3>& points, const QVector<glm::vec2>& texCoords, const glm::vec4& color) {
     BatchItemDetails& details = _registeredVertices[id];
 
diff --git a/libraries/render-utils/src/GeometryCache.h b/libraries/render-utils/src/GeometryCache.h
index 647fa9889c..1bfdc1798e 100644
--- a/libraries/render-utils/src/GeometryCache.h
+++ b/libraries/render-utils/src/GeometryCache.h
@@ -283,7 +283,9 @@ public:
                                     const glm::vec4& color1, const glm::vec4& color2, int id = UNKNOWN_ID);
 
     void updateVertices(int id, const QVector<glm::vec2>& points, const glm::vec4& color);
+    void updateVertices(int id, const QVector<glm::vec2>& points, const QVector<glm::vec4>& colors);
     void updateVertices(int id, const QVector<glm::vec3>& points, const glm::vec4& color);
+    void updateVertices(int id, const QVector<glm::vec3>& points, const QVector<glm::vec4>& colors);
     void updateVertices(int id, const QVector<glm::vec3>& points, const QVector<glm::vec2>& texCoords, const glm::vec4& color);
     void renderVertices(gpu::Batch& batch, gpu::Primitive primitiveType, int id);
 
@@ -360,7 +362,7 @@ private:
 
     QHash<IntPair, VerticesIndices> _coneVBOs;
 
-    int _nextID{ 0 };
+    int _nextID{ 1 };
 
     QHash<int, Vec3PairVec4Pair> _lastRegisteredQuad3DTexture;
     QHash<Vec3PairVec4Pair, BatchItemDetails> _quad3DTextures;
diff --git a/libraries/render-utils/src/Model.cpp b/libraries/render-utils/src/Model.cpp
index 0470a238fc..43eced3107 100644
--- a/libraries/render-utils/src/Model.cpp
+++ b/libraries/render-utils/src/Model.cpp
@@ -20,6 +20,7 @@
 #include <PathUtils.h>
 #include <PerfStat.h>
 #include <ViewFrustum.h>
+#include <GLMHelpers.h>
 
 #include "AbstractViewStateInterface.h"
 #include "MeshPartPayload.h"
diff --git a/libraries/script-engine/src/ScriptEngine.cpp b/libraries/script-engine/src/ScriptEngine.cpp
index a5e3be8a43..9642aaf588 100644
--- a/libraries/script-engine/src/ScriptEngine.cpp
+++ b/libraries/script-engine/src/ScriptEngine.cpp
@@ -465,6 +465,7 @@ void ScriptEngine::init() {
     qScriptRegisterMetaType(this, EntityItemPropertiesToScriptValue, EntityItemPropertiesFromScriptValueHonorReadOnly);
     qScriptRegisterMetaType(this, EntityItemIDtoScriptValue, EntityItemIDfromScriptValue);
     qScriptRegisterMetaType(this, RayToEntityIntersectionResultToScriptValue, RayToEntityIntersectionResultFromScriptValue);
+    qScriptRegisterMetaType(this, RayToAvatarIntersectionResultToScriptValue, RayToAvatarIntersectionResultFromScriptValue);
     qScriptRegisterSequenceMetaType<QVector<QUuid>>(this);
     qScriptRegisterSequenceMetaType<QVector<EntityItemID>>(this);
 
diff --git a/libraries/shared/src/ShapeInfo.h b/libraries/shared/src/ShapeInfo.h
index 7bf145412a..a6ff8d6d4a 100644
--- a/libraries/shared/src/ShapeInfo.h
+++ b/libraries/shared/src/ShapeInfo.h
@@ -26,6 +26,10 @@ const float MIN_SHAPE_OFFSET = 0.001f; // offsets less than 1mm will be ignored
 // trim convex hulls with many points down to only 42 points.
 const int MAX_HULL_POINTS = 42;
 
+
+const int32_t END_OF_MESH_PART = -1; // bogus vertex index at end of mesh part
+const int32_t END_OF_MESH = -2; // bogus vertex index at end of mesh
+
 enum ShapeType {
     SHAPE_TYPE_NONE,
     SHAPE_TYPE_BOX,
@@ -50,7 +54,7 @@ public:
 
     using PointList = QVector<glm::vec3>;
     using PointCollection = QVector<PointList>;
-    using TriangleIndices = QVector<uint32_t>;
+    using TriangleIndices = QVector<int32_t>;
 
     void clear();
 
diff --git a/scripts/defaultScripts.js b/scripts/defaultScripts.js
index 2bf908ab57..711e64f938 100644
--- a/scripts/defaultScripts.js
+++ b/scripts/defaultScripts.js
@@ -23,5 +23,6 @@ Script.load("system/controllers/handControllerGrab.js");
 Script.load("system/controllers/handControllerPointer.js");
 Script.load("system/controllers/squeezeHands.js");
 Script.load("system/controllers/grab.js");
+Script.load("system/controllers/teleport.js");
 Script.load("system/dialTone.js");
 Script.load("system/firstPersonHMD.js");
diff --git a/scripts/developer/utilities/tools/overlayFinder.js b/scripts/developer/utilities/tools/overlayFinder.js
new file mode 100644
index 0000000000..75b8aeacfa
--- /dev/null
+++ b/scripts/developer/utilities/tools/overlayFinder.js
@@ -0,0 +1,17 @@
+function mousePressEvent(event) {
+    var overlay = Overlays.getOverlayAtPoint({
+        x: event.x,
+        y: event.y
+    });
+    // var pickRay = Camera.computePickRay(event.x, event.y);
+    // var intersection =  Overlays.findRayIntersection(pickRay);
+    // print('intersection is: ' + intersection)
+};
+
+Controller.mousePressEvent.connect(function(event) {
+    mousePressEvent(event)
+});
+
+Script.scriptEnding.connect(function() {
+    Controller.mousePressEvent.disconnect(mousePressEvent);
+})
\ No newline at end of file
diff --git a/scripts/system/assets/models/teleport.fbx b/scripts/system/assets/models/teleport.fbx
new file mode 100644
index 0000000000..831f152add
Binary files /dev/null and b/scripts/system/assets/models/teleport.fbx differ
diff --git a/scripts/system/controllers/handControllerGrab.js b/scripts/system/controllers/handControllerGrab.js
index 416e6b10d8..94a10798fe 100644
--- a/scripts/system/controllers/handControllerGrab.js
+++ b/scripts/system/controllers/handControllerGrab.js
@@ -1984,10 +1984,24 @@ function MyController(hand) {
 
         var noVelocity = false;
         if (this.grabbedEntity !== null) {
+
+            // If this looks like the release after adjusting something still held in the other hand, print the position
+            // and rotation of the held thing to help content creators set the userData.
+            var grabData = getEntityCustomData(GRAB_USER_DATA_KEY, this.grabbedEntity, {});
+            if (grabData.refCount > 1) {
+                grabbedProperties = Entities.getEntityProperties(this.grabbedEntity, ["localPosition", "localRotation"]);
+                if (grabbedProperties && grabbedProperties.localPosition && grabbedProperties.localRotation) {
+                    print((this.hand === RIGHT_HAND ? '"LeftHand"' : '"RightHand"') + ":" +
+                          '[{"x":' + grabbedProperties.localPosition.x + ', "y":' + grabbedProperties.localPosition.y +
+                          ', "z":' + grabbedProperties.localPosition.z + '}, {"x":' + grabbedProperties.localRotation.x +
+                          ', "y":' + grabbedProperties.localRotation.y + ', "z":' + grabbedProperties.localRotation.z +
+                          ', "w":' + grabbedProperties.localRotation.w + '}]');
+                }
+            }
+
             if (this.actionID !== null) {
                 Entities.deleteAction(this.grabbedEntity, this.actionID);
                 // sometimes we want things to stay right where they are when we let go.
-                var grabData = getEntityCustomData(GRAB_USER_DATA_KEY, this.grabbedEntity, {});
                 var releaseVelocityData = getEntityCustomData(GRABBABLE_DATA_KEY, this.grabbedEntity, DEFAULT_GRABBABLE_DATA);
                 if (releaseVelocityData.disableReleaseVelocity === true ||
                     // this next line allowed both:
@@ -2247,11 +2261,18 @@ var handleHandMessages = function (channel, message, sender) {
         if (channel === 'Hifi-Hand-Disabler') {
             if (message === 'left') {
                 handToDisable = LEFT_HAND;
+                leftController.turnOffVisualizations();
             }
             if (message === 'right') {
                 handToDisable = RIGHT_HAND;
+                rightController.turnOffVisualizations();
             }
             if (message === 'both' || message === 'none') {
+                if (message === 'both') {
+                    rightController.turnOffVisualizations();
+                    leftController.turnOffVisualizations();
+
+                }
                 handToDisable = message;
             }
         } else if (channel === 'Hifi-Hand-Grab') {
@@ -2331,4 +2352,3 @@ function handleMenuItemEvent(menuItem) {
 }
 
 Menu.menuItemEvent.connect(handleMenuItemEvent);
-
diff --git a/scripts/system/controllers/teleport.js b/scripts/system/controllers/teleport.js
new file mode 100644
index 0000000000..da0b4cb576
--- /dev/null
+++ b/scripts/system/controllers/teleport.js
@@ -0,0 +1,619 @@
+// Created by james b. pollack @imgntn on 7/2/2016
+// Copyright 2016 High Fidelity, Inc.
+//
+//  Creates a beam and target and then teleports you there when you let go of either activation button.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+
+var inTeleportMode = false;
+
+var currentFadeSphereOpacity = 1;
+var fadeSphereInterval = null;
+var fadeSphereUpdateInterval = null;
+//milliseconds between fading one-tenth -- so this is a half second fade total
+var USE_FADE_MODE = false;
+var USE_FADE_OUT = true;
+var FADE_OUT_INTERVAL = 25;
+
+// instant
+// var NUMBER_OF_STEPS = 0;
+// var SMOOTH_ARRIVAL_SPACING = 0;
+
+// // slow
+// var SMOOTH_ARRIVAL_SPACING = 150;
+// var NUMBER_OF_STEPS = 2;
+
+// medium-slow
+// var SMOOTH_ARRIVAL_SPACING = 100;
+// var NUMBER_OF_STEPS = 4;
+
+// medium-fast
+var SMOOTH_ARRIVAL_SPACING = 33;
+var NUMBER_OF_STEPS = 6;
+
+//fast
+// var SMOOTH_ARRIVAL_SPACING = 10;
+// var NUMBER_OF_STEPS = 20;
+
+
+var TARGET_MODEL_URL = Script.resolvePath("../assets/models/teleport.fbx");
+var TARGET_MODEL_DIMENSIONS = {
+    x: 1.15,
+    y: 0.5,
+    z: 1.15
+
+};
+
+function ThumbPad(hand) {
+    this.hand = hand;
+    var _thisPad = this;
+
+    this.buttonPress = function(value) {
+        _thisPad.buttonValue = value;
+    };
+
+}
+
+function Trigger(hand) {
+    this.hand = hand;
+    var _this = this;
+
+    this.buttonPress = function(value) {
+        _this.buttonValue = value;
+
+    };
+
+    this.down = function() {
+        var down = _this.buttonValue === 1 ? 1.0 : 0.0;
+        return down
+    };
+}
+
+function Teleporter() {
+    var _this = this;
+    this.intersection = null;
+    this.rightOverlayLine = null;
+    this.leftOverlayLine = null;
+    this.targetOverlay = null;
+    this.updateConnected = null;
+    this.smoothArrivalInterval = null;
+    this.fadeSphere = null;
+    this.teleportHand = null;
+
+    this.initialize = function() {
+        this.createMappings();
+        this.disableGrab();
+    };
+
+    this.createTargetOverlay = function() {
+
+        var targetOverlayProps = {
+            url: TARGET_MODEL_URL,
+            dimensions: TARGET_MODEL_DIMENSIONS,
+            visible: true,
+        };
+
+        _this.targetOverlay = Overlays.addOverlay("model", targetOverlayProps);
+    };
+
+    this.createMappings = function() {
+        teleporter.telporterMappingInternalName = 'Hifi-Teleporter-Internal-Dev-' + Math.random();
+        teleporter.teleportMappingInternal = Controller.newMapping(teleporter.telporterMappingInternalName);
+
+        Controller.enableMapping(teleporter.telporterMappingInternalName);
+    };
+
+    this.disableMappings = function() {
+        Controller.disableMapping(teleporter.telporterMappingInternalName);
+    };
+
+    this.enterTeleportMode = function(hand) {
+        if (inTeleportMode === true) {
+            return;
+        }
+        inTeleportMode = true;
+        if (this.smoothArrivalInterval !== null) {
+            Script.clearInterval(this.smoothArrivalInterval);
+        }
+        if (fadeSphereInterval !== null) {
+            Script.clearInterval(fadeSphereInterval);
+        }
+        this.teleportHand = hand;
+        this.initialize();
+        Script.update.connect(this.update);
+        this.updateConnected = true;
+    };
+
+    this.createFadeSphere = function(avatarHead) {
+        var sphereProps = {
+            position: avatarHead,
+            size: -1,
+            color: {
+                red: 0,
+                green: 0,
+                blue: 0,
+            },
+            alpha: 1,
+            solid: true,
+            visible: true,
+            ignoreRayIntersection: true,
+            drawInFront: false
+        };
+
+        currentFadeSphereOpacity = 10;
+
+        _this.fadeSphere = Overlays.addOverlay("sphere", sphereProps);
+        Script.clearInterval(fadeSphereInterval)
+        Script.update.connect(_this.updateFadeSphere);
+        if (USE_FADE_OUT === true) {
+            this.fadeSphereOut();
+        }
+
+
+    };
+
+    this.fadeSphereOut = function() {
+
+        fadeSphereInterval = Script.setInterval(function() {
+            if (currentFadeSphereOpacity <= 0) {
+                Script.clearInterval(fadeSphereInterval);
+                _this.deleteFadeSphere();
+                fadeSphereInterval = null;
+                return;
+            }
+            if (currentFadeSphereOpacity > 0) {
+                currentFadeSphereOpacity = currentFadeSphereOpacity - 1;
+            }
+
+            Overlays.editOverlay(_this.fadeSphere, {
+                alpha: currentFadeSphereOpacity / 10
+            })
+
+        }, FADE_OUT_INTERVAL);
+    };
+
+
+    this.updateFadeSphere = function() {
+        var headPosition = MyAvatar.getHeadPosition();
+        Overlays.editOverlay(_this.fadeSphere, {
+            position: headPosition
+        })
+    };
+
+    this.deleteFadeSphere = function() {
+        if (_this.fadeSphere !== null) {
+            Script.update.disconnect(_this.updateFadeSphere);
+            Overlays.deleteOverlay(_this.fadeSphere);
+            _this.fadeSphere = null;
+        }
+
+    };
+
+    this.deleteTargetOverlay = function() {
+        Overlays.deleteOverlay(this.targetOverlay);
+        this.intersection = null;
+        this.targetOverlay = null;
+    }
+
+    this.turnOffOverlayBeams = function() {
+        this.rightOverlayOff();
+        this.leftOverlayOff();
+    }
+
+    this.exitTeleportMode = function(value) {
+        if (this.updateConnected === true) {
+            Script.update.disconnect(this.update);
+        }
+        this.disableMappings();
+        this.turnOffOverlayBeams();
+
+
+        this.updateConnected = null;
+
+        Script.setTimeout(function() {
+            inTeleportMode = false;
+            _this.enableGrab();
+        }, 100);
+    };
+
+
+
+    this.update = function() {
+
+        if (teleporter.teleportHand === 'left') {
+            teleporter.leftRay();
+
+            if ((leftPad.buttonValue === 0 || leftTrigger.buttonValue === 0) && inTeleportMode === true) {
+                _this.teleport();
+                return;
+            }
+
+        } else {
+            teleporter.rightRay();
+
+            if ((rightPad.buttonValue === 0 || rightTrigger.buttonValue === 0) && inTeleportMode === true) {
+                _this.teleport();
+                return;
+            }
+        }
+
+    };
+
+    this.rightRay = function() {
+
+
+        var rightPosition = Vec3.sum(Vec3.multiplyQbyV(MyAvatar.orientation, Controller.getPoseValue(Controller.Standard.RightHand).translation), MyAvatar.position);
+
+        var rightControllerRotation = Controller.getPoseValue(Controller.Standard.RightHand).rotation;
+
+        var rightRotation = Quat.multiply(MyAvatar.orientation, rightControllerRotation)
+
+
+        var rightFinal = Quat.multiply(rightRotation, Quat.angleAxis(90, {
+            x: 1,
+            y: 0,
+            z: 0
+        }));
+
+        var rightPickRay = {
+            origin: rightPosition,
+            direction: Quat.getUp(rightRotation),
+        };
+
+        this.rightPickRay = rightPickRay;
+
+        var location = Vec3.sum(rightPickRay.origin, Vec3.multiply(rightPickRay.direction, 500));
+
+
+        var rightIntersection = Entities.findRayIntersection(teleporter.rightPickRay, true, [], [this.targetEntity]);
+
+        if (rightIntersection.intersects) {
+            this.rightLineOn(rightPickRay.origin, rightIntersection.intersection, {
+                red: 7,
+                green: 36,
+                blue: 44
+            });
+            if (this.targetOverlay !== null) {
+                this.updateTargetOverlay(rightIntersection);
+            } else {
+                this.createTargetOverlay();
+            }
+
+        } else {
+
+            this.deleteTargetOverlay();
+            this.rightLineOn(rightPickRay.origin, location, {
+                red: 7,
+                green: 36,
+                blue: 44
+            });
+        }
+    }
+
+
+    this.leftRay = function() {
+        var leftPosition = Vec3.sum(Vec3.multiplyQbyV(MyAvatar.orientation, Controller.getPoseValue(Controller.Standard.LeftHand).translation), MyAvatar.position);
+
+        var leftRotation = Quat.multiply(MyAvatar.orientation, Controller.getPoseValue(Controller.Standard.LeftHand).rotation)
+
+
+        var leftFinal = Quat.multiply(leftRotation, Quat.angleAxis(90, {
+            x: 1,
+            y: 0,
+            z: 0
+        }));
+
+
+        var leftPickRay = {
+            origin: leftPosition,
+            direction: Quat.getUp(leftRotation),
+        };
+
+        this.leftPickRay = leftPickRay;
+
+        var location = Vec3.sum(MyAvatar.position, Vec3.multiply(leftPickRay.direction, 500));
+
+
+        var leftIntersection = Entities.findRayIntersection(teleporter.leftPickRay, true, [], [this.targetEntity]);
+
+        if (leftIntersection.intersects) {
+
+            this.leftLineOn(leftPickRay.origin, leftIntersection.intersection, {
+                red: 7,
+                green: 36,
+                blue: 44
+            });
+            if (this.targetOverlay !== null) {
+                this.updateTargetOverlay(leftIntersection);
+            } else {
+                this.createTargetOverlay();
+            }
+
+
+        } else {
+
+
+            this.deleteTargetOverlay();
+            this.leftLineOn(leftPickRay.origin, location, {
+                red: 7,
+                green: 36,
+                blue: 44
+            });
+        }
+    };
+
+    this.rightLineOn = function(closePoint, farPoint, color) {
+        if (this.rightOverlayLine === null) {
+            var lineProperties = {
+                start: closePoint,
+                end: farPoint,
+                color: color,
+                ignoreRayIntersection: true, // always ignore this
+                visible: true,
+                alpha: 1,
+                solid: true,
+                drawInFront: true,
+                glow: 1.0
+            };
+
+            this.rightOverlayLine = Overlays.addOverlay("line3d", lineProperties);
+
+        } else {
+            var success = Overlays.editOverlay(this.rightOverlayLine, {
+                lineWidth: 50,
+                start: closePoint,
+                end: farPoint,
+                color: color,
+                visible: true,
+                ignoreRayIntersection: true, // always ignore this
+                alpha: 1,
+                glow: 1.0
+            });
+        }
+    };
+
+    this.leftLineOn = function(closePoint, farPoint, color) {
+        if (this.leftOverlayLine === null) {
+            var lineProperties = {
+                ignoreRayIntersection: true, // always ignore this
+                start: closePoint,
+                end: farPoint,
+                color: color,
+                visible: true,
+                alpha: 1,
+                solid: true,
+                glow: 1.0,
+                drawInFront: true
+            };
+
+            this.leftOverlayLine = Overlays.addOverlay("line3d", lineProperties);
+
+        } else {
+            var success = Overlays.editOverlay(this.leftOverlayLine, {
+                start: closePoint,
+                end: farPoint,
+                color: color,
+                visible: true,
+                alpha: 1,
+                solid: true,
+                glow: 1.0
+            });
+        }
+    };
+    this.rightOverlayOff = function() {
+        if (this.rightOverlayLine !== null) {
+            Overlays.deleteOverlay(this.rightOverlayLine);
+            this.rightOverlayLine = null;
+        }
+    };
+
+    this.leftOverlayOff = function() {
+        if (this.leftOverlayLine !== null) {
+            Overlays.deleteOverlay(this.leftOverlayLine);
+            this.leftOverlayLine = null;
+        }
+    };
+
+    this.updateTargetOverlay = function(intersection) {
+        _this.intersection = intersection;
+
+        var rotation = Quat.lookAt(intersection.intersection, MyAvatar.position, Vec3.UP)
+        var euler = Quat.safeEulerAngles(rotation)
+        var position = {
+            x: intersection.intersection.x,
+            y: intersection.intersection.y + TARGET_MODEL_DIMENSIONS.y / 2,
+            z: intersection.intersection.z
+        }
+        Overlays.editOverlay(this.targetOverlay, {
+            position: position,
+            rotation: Quat.fromPitchYawRollDegrees(0, euler.y, 0),
+        });
+
+    };
+
+    this.disableGrab = function() {
+        Messages.sendLocalMessage('Hifi-Hand-Disabler', this.teleportHand);
+    };
+
+    this.enableGrab = function() {
+        Messages.sendLocalMessage('Hifi-Hand-Disabler', 'none');
+    };
+
+    this.triggerHaptics = function() {
+        var hand = this.teleportHand === 'left' ? 0 : 1;
+        var haptic = Controller.triggerShortHapticPulse(0.2, hand);
+    };
+
+    this.teleport = function(value) {
+        if (value === undefined) {
+            this.exitTeleportMode();
+        }
+        if (this.intersection !== null) {
+            if (USE_FADE_MODE === true) {
+                this.createFadeSphere();
+            }
+            var offset = getAvatarFootOffset();
+            this.intersection.intersection.y += offset;
+            this.exitTeleportMode();
+            this.smoothArrival();
+
+        }
+
+    };
+
+
+    this.findMidpoint = function(start, end) {
+        var xy = Vec3.sum(start, end);
+        var midpoint = Vec3.multiply(0.5, xy);
+        return midpoint
+    };
+
+
+
+    this.getArrivalPoints = function(startPoint, endPoint) {
+        var arrivalPoints = [];
+
+
+        var i;
+        var lastPoint;
+
+        for (i = 0; i < NUMBER_OF_STEPS; i++) {
+            if (i === 0) {
+                lastPoint = startPoint;
+            }
+            var newPoint = _this.findMidpoint(lastPoint, endPoint);
+            lastPoint = newPoint;
+            arrivalPoints.push(newPoint);
+        }
+
+        arrivalPoints.push(endPoint)
+
+        return arrivalPoints
+    };
+
+    this.smoothArrival = function() {
+
+        _this.arrivalPoints = _this.getArrivalPoints(MyAvatar.position, _this.intersection.intersection);
+        _this.smoothArrivalInterval = Script.setInterval(function() {
+            if (_this.arrivalPoints.length === 0) {
+                Script.clearInterval(_this.smoothArrivalInterval);
+                return;
+            }
+
+            var landingPoint = _this.arrivalPoints.shift();
+            MyAvatar.position = landingPoint;
+
+            if (_this.arrivalPoints.length === 1 || _this.arrivalPoints.length === 0) {
+                _this.deleteTargetOverlay();
+            }
+
+
+        }, SMOOTH_ARRIVAL_SPACING)
+    }
+}
+
+
+//related to repositioning the avatar after you teleport
+function getAvatarFootOffset() {
+    var data = getJointData();
+    var upperLeg, lowerLeg, foot, toe, toeTop;
+    data.forEach(function(d) {
+
+        var jointName = d.joint;
+        if (jointName === "RightUpLeg") {
+            upperLeg = d.translation.y;
+        }
+        if (jointName === "RightLeg") {
+            lowerLeg = d.translation.y;
+        }
+        if (jointName === "RightFoot") {
+            foot = d.translation.y;
+        }
+        if (jointName === "RightToeBase") {
+            toe = d.translation.y;
+        }
+        if (jointName === "RightToe_End") {
+            toeTop = d.translation.y
+        }
+    })
+
+    var myPosition = MyAvatar.position;
+    var offset = upperLeg + lowerLeg + foot + toe + toeTop;
+    offset = offset / 100;
+    return offset
+};
+
+function getJointData() {
+    var allJointData = [];
+    var jointNames = MyAvatar.jointNames;
+    jointNames.forEach(function(joint, index) {
+        var translation = MyAvatar.getJointTranslation(index);
+        var rotation = MyAvatar.getJointRotation(index)
+        allJointData.push({
+            joint: joint,
+            index: index,
+            translation: translation,
+            rotation: rotation
+        });
+    });
+
+    return allJointData;
+};
+
+var leftPad = new ThumbPad('left');
+var rightPad = new ThumbPad('right');
+var leftTrigger = new Trigger('left');
+var rightTrigger = new Trigger('right');
+
+var mappingName, teleportMapping;
+
+var TELEPORT_DELAY = 100;
+
+
+function registerMappings() {
+    mappingName = 'Hifi-Teleporter-Dev-' + Math.random();
+    teleportMapping = Controller.newMapping(mappingName);
+    teleportMapping.from(Controller.Standard.RT).peek().to(rightTrigger.buttonPress);
+    teleportMapping.from(Controller.Standard.LT).peek().to(leftTrigger.buttonPress);
+
+    teleportMapping.from(Controller.Standard.RightPrimaryThumb).peek().to(rightPad.buttonPress);
+    teleportMapping.from(Controller.Standard.LeftPrimaryThumb).peek().to(leftPad.buttonPress);
+
+    teleportMapping.from(Controller.Standard.LeftPrimaryThumb).when(leftTrigger.down).to(function(value) {
+        teleporter.enterTeleportMode('left')
+        return;
+    });
+    teleportMapping.from(Controller.Standard.RightPrimaryThumb).when(rightTrigger.down).to(function(value) {
+        teleporter.enterTeleportMode('right')
+        return;
+    });
+    teleportMapping.from(Controller.Standard.RT).when(Controller.Standard.RightPrimaryThumb).to(function(value) {
+        teleporter.enterTeleportMode('right')
+        return;
+    });
+    teleportMapping.from(Controller.Standard.LT).when(Controller.Standard.LeftPrimaryThumb).to(function(value) {
+        teleporter.enterTeleportMode('left')
+        return;
+    });
+
+}
+
+registerMappings();
+
+var teleporter = new Teleporter();
+
+Controller.enableMapping(mappingName);
+
+Script.scriptEnding.connect(cleanup);
+
+function cleanup() {
+    teleportMapping.disable();
+    teleporter.disableMappings();
+    teleporter.deleteTargetOverlay();
+    teleporter.turnOffOverlayBeams();
+    teleporter.deleteFadeSphere();
+    if (teleporter.updateConnected !== null) {
+        Script.update.disconnect(teleporter.update);
+    }
+}
\ No newline at end of file
diff --git a/scripts/system/notifications.js b/scripts/system/notifications.js
index 7d97470b8a..98a31d708c 100644
--- a/scripts/system/notifications.js
+++ b/scripts/system/notifications.js
@@ -49,10 +49,10 @@
 //  2. Declare a text string.
 //  3. Call createNotifications(text, NotificationType) parsing the text.
 //  example:
-//  if (key.text === "s") {
+//  if (key.text === "o") {
 //      if (ctrlIsPressed === true) {
-//          noteString = "Snapshot taken.";
-//          createNotification(noteString, NotificationType.SNAPSHOT);
+//          noteString = "Open script";
+//          createNotification(noteString, NotificationType.OPEN_SCRIPT);
 //      }
 //  }
 
@@ -233,8 +233,9 @@ function calculate3DOverlayPositions(noticeWidth, noticeHeight, y) {
 //  Pushes data to each array and sets up data for 2nd dimension array 
 //  to handle auxiliary data not carried by the overlay class
 //  specifically notification "heights", "times" of creation, and . 
-function notify(notice, button, height) {
-    var noticeWidth,
+function notify(notice, button, height, imageProperties, image) {
+    var notificationText,
+        noticeWidth,
         noticeHeight,
         positions,
         last;
@@ -246,20 +247,27 @@ function notify(notice, button, height) {
         noticeHeight = notice.height * NOTIFICATION_3D_SCALE;
 
         notice.size = { x: noticeWidth, y: noticeHeight };
-        notice.topMargin = 0.75 * notice.topMargin * NOTIFICATION_3D_SCALE;
-        notice.leftMargin = 2 * notice.leftMargin * NOTIFICATION_3D_SCALE;
-        notice.bottomMargin = 0;
-        notice.rightMargin = 0;
-        notice.lineHeight = 10.0 * (fontSize / 12.0) * NOTIFICATION_3D_SCALE;
-        notice.isFacingAvatar = false;
+
+        positions = calculate3DOverlayPositions(noticeWidth, noticeHeight, notice.y);
+
+        if (!image) {
+            notice.topMargin = 0.75 * notice.topMargin * NOTIFICATION_3D_SCALE;
+            notice.leftMargin = 2 * notice.leftMargin * NOTIFICATION_3D_SCALE;
+            notice.bottomMargin = 0;
+            notice.rightMargin = 0;
+            notice.lineHeight = 10.0 * (fontSize / 12.0) * NOTIFICATION_3D_SCALE;
+            notice.isFacingAvatar = false;
+
+            notificationText = Overlays.addOverlay("text3d", notice);
+            notifications.push(notificationText);
+        } else {
+            notifications.push(Overlays.addOverlay("image3d", notice));
+        }
 
         button.url = button.imageURL;
         button.scale = button.width * NOTIFICATION_3D_SCALE;
         button.isFacingAvatar = false;
 
-        positions = calculate3DOverlayPositions(noticeWidth, noticeHeight, notice.y);
-
-        notifications.push((Overlays.addOverlay("text3d", notice)));
         buttons.push((Overlays.addOverlay("image3d", button)));
         overlay3DDetails.push({
             notificationOrientation: positions.notificationOrientation,
@@ -269,23 +277,44 @@ function notify(notice, button, height) {
             height: noticeHeight
         });
     } else {
-        var notificationText = Overlays.addOverlay("text", notice);
-        notifications.push((notificationText));
-        buttons.push((Overlays.addOverlay("image", button)));
+        if (!image) {
+            notificationText = Overlays.addOverlay("text", notice);
+            notifications.push((notificationText));
+        } else {
+            notifications.push(Overlays.addOverlay("image", notice));
+        }
+        buttons.push(Overlays.addOverlay("image", button));
     }
 
     height = height + 1.0;
     heights.push(height);
     times.push(new Date().getTime() / 1000);
-    myAlpha.push(0);
     last = notifications.length - 1;
+    myAlpha.push(notifications[last].alpha);
     createArrays(notifications[last], buttons[last], times[last], heights[last], myAlpha[last]);
     fadeIn(notifications[last], buttons[last]);
+
+    if (imageProperties && !image) {
+        var imageHeight = notice.width / imageProperties.aspectRatio;
+        notice = {
+            x: notice.x,
+            y: notice.y + height,
+            width: notice.width,
+            height: imageHeight,
+            subImage: { x: 0, y: 0 },
+            color: { red: 255, green: 255, blue: 255},
+            visible: true,
+            imageURL: imageProperties.path,
+            alpha: backgroundAlpha
+        };
+        notify(notice, button, imageHeight, imageProperties, true);
+    }
+
     return notificationText;
 }
 
 //  This function creates and sizes the overlays
-function createNotification(text, notificationType) {
+function createNotification(text, notificationType, imageProperties) {
     var count = (text.match(/\n/g) || []).length,
         breakPoint = 43.0, // length when new line is added
         extraLine = 0,
@@ -308,6 +337,7 @@ function createNotification(text, notificationType) {
 
     level = (stack + 20.0);
     height = height + extraLine;
+
     noticeProperties = {
         x: overlayLocationX,
         y: level,
@@ -336,12 +366,11 @@ function createNotification(text, notificationType) {
     };
 
     if (Menu.isOptionChecked(PLAY_NOTIFICATION_SOUNDS_MENU_ITEM) &&
-        Menu.isOptionChecked(NotificationType.getMenuString(notificationType)))
-    {
+        Menu.isOptionChecked(NotificationType.getMenuString(notificationType))) {
         randomSounds.playRandom();
     }
 
-    return notify(noticeProperties, buttonProperties, height);
+    return notify(noticeProperties, buttonProperties, height, imageProperties);
 }
 
 function deleteNotification(index) {
@@ -362,21 +391,12 @@ function deleteNotification(index) {
 
 //  wraps whole word to newline
 function stringDivider(str, slotWidth, spaceReplacer) {
-    var p,
-        left,
-        right;
+    var left, right;
 
-    if (str.length > slotWidth) {
-        p = slotWidth;
-        while (p > 0 && str[p] !== ' ') {
-            p -= 1;
-        }
-
-        if (p > 0) {
-            left = str.substring(0, p);
-            right = str.substring(p + 1);
-            return left + spaceReplacer + stringDivider(right, slotWidth, spaceReplacer);
-        }
+    if (str.length > slotWidth && slotWidth > 0) {
+        left = str.substring(0, slotWidth);
+        right = str.substring(slotWidth);
+        return left + spaceReplacer + stringDivider(right, slotWidth, spaceReplacer);
     }
     return str;
 }
@@ -504,7 +524,15 @@ function onMuteStateChanged() {
 }
 
 function onDomainConnectionRefused(reason) {
-    createNotification("Connection refused: " + reason, NotificationType.CONNECTION_REFUSED );
+    createNotification("Connection refused: " + reason, NotificationType.CONNECTION_REFUSED);
+}
+
+function onSnapshotTaken(path) {
+    var imageProperties = {
+        path: Script.resolvePath("file:///" + path),
+        aspectRatio: Window.innerWidth / Window.innerHeight
+    }
+    createNotification(wordWrap("Snapshot saved to " + path), NotificationType.SNAPSHOT, imageProperties);
 }
 
 //  handles mouse clicks on buttons
@@ -541,13 +569,6 @@ function keyPressEvent(key) {
     if (key.key === 16777249) {
         ctrlIsPressed = true;
     }
-
-    if (key.text === "s") {
-        if (ctrlIsPressed === true) {
-            noteString = "Snapshot taken.";
-            createNotification(noteString, NotificationType.SNAPSHOT);
-        }
-    }
 }
 
 function setup() {
@@ -615,5 +636,6 @@ Script.update.connect(update);
 Script.scriptEnding.connect(scriptEnding);
 Menu.menuItemEvent.connect(menuItemEvent);
 Window.domainConnectionRefused.connect(onDomainConnectionRefused);
+Window.snapshotTaken.connect(onSnapshotTaken);
 
 setup();
diff --git a/tests/ui/qml/main.qml b/tests/ui/qml/main.qml
index 47d0f6d601..8ca9399b74 100644
--- a/tests/ui/qml/main.qml
+++ b/tests/ui/qml/main.qml
@@ -28,6 +28,16 @@ ApplicationWindow {
         property var toolbar;
         property var lastButton;
 
+        Button {
+            text: HMD.active ? "Disable HMD" : "Enable HMD"
+            onClicked: HMD.active = !HMD.active
+        }
+
+        Button {
+            text: desktop.hmdHandMouseActive ? "Disable HMD HandMouse" : "Enable HMD HandMouse"
+            onClicked: desktop.hmdHandMouseActive = !desktop.hmdHandMouseActive
+        }
+
         // Window visibility
         Button {
             text: "toggle desktop"
@@ -340,13 +350,13 @@ ApplicationWindow {
         }
         */
 
-        /*
         Window {
             id: blue
             closable: true
             visible: true
             resizable: true
             destroyOnHidden: false
+            title: "Blue"
 
             width: 100; height: 100
             x: 1280 / 2; y: 720 / 2
@@ -366,7 +376,33 @@ ApplicationWindow {
             }
         }
 
+        Window {
+            id: green
+            closable: true
+            visible: true
+            resizable: true
+            title: "Green"
+            destroyOnHidden: false
 
+            width: 100; height: 100
+            x: 1280 / 2; y: 720 / 2
+            Settings {
+                category: "TestWindow.Green"
+                property alias x: green.x
+                property alias y: green.y
+                property alias width: green.width
+                property alias height: green.height
+            }
+
+            Rectangle {
+                anchors.fill: parent
+                visible: true
+                color: "green"
+                Component.onDestruction: console.log("Green destroyed")
+            }
+        }
+
+/*
         Rectangle { width: 100; height: 100; x: 100; y: 100; color: "#00f" }
 
         Window {