diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp
index 61aeb2c680..858c3eb120 100644
--- a/interface/src/Application.cpp
+++ b/interface/src/Application.cpp
@@ -993,6 +993,7 @@ const bool DEFAULT_HMD_TABLET_BECOMES_TOOLBAR = false;
 const bool DEFAULT_PREFER_STYLUS_OVER_LASER = false;
 const bool DEFAULT_PREFER_AVATAR_FINGER_OVER_STYLUS = false;
 const QString DEFAULT_CURSOR_NAME = "DEFAULT";
+const bool DEFAULT_MINI_TABLET_ENABLED = true;
 
 Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer, bool runningMarkerExisted) :
     QApplication(argc, argv),
@@ -1012,6 +1013,7 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer, bo
     _preferAvatarFingerOverStylusSetting("preferAvatarFingerOverStylus", DEFAULT_PREFER_AVATAR_FINGER_OVER_STYLUS),
     _constrainToolbarPosition("toolbar/constrainToolbarToCenterX", true),
     _preferredCursor("preferredCursor", DEFAULT_CURSOR_NAME),
+    _miniTabletEnabledSetting("miniTabletEnabled", DEFAULT_MINI_TABLET_ENABLED),
     _scaleMirror(1.0f),
     _mirrorYawOffset(0.0f),
     _raiseMirror(0.0f),
@@ -3393,6 +3395,11 @@ void Application::setSettingConstrainToolbarPosition(bool setting) {
     DependencyManager::get<OffscreenUi>()->setConstrainToolbarToCenterX(setting);
 }
 
+void Application::setMiniTabletEnabled(bool enabled) {
+    _miniTabletEnabledSetting.set(enabled);
+    emit miniTabletEnabledChanged(enabled);
+}
+
 void Application::showHelp() {
     static const QString HAND_CONTROLLER_NAME_VIVE = "vive";
     static const QString HAND_CONTROLLER_NAME_OCULUS_TOUCH = "oculus";
diff --git a/interface/src/Application.h b/interface/src/Application.h
index b2a41dc421..6275feaf29 100644
--- a/interface/src/Application.h
+++ b/interface/src/Application.h
@@ -228,6 +228,9 @@ public:
     bool getPreferAvatarFingerOverStylus() { return false; }
     void setPreferAvatarFingerOverStylus(bool value);
 
+    bool getMiniTabletEnabled() { return _miniTabletEnabledSetting.get(); }
+    void setMiniTabletEnabled(bool enabled);
+
     float getSettingConstrainToolbarPosition() { return _constrainToolbarPosition.get(); }
     void setSettingConstrainToolbarPosition(bool setting);
 
@@ -338,6 +341,8 @@ signals:
 
     void loginDialogPoppedUp();
 
+    void miniTabletEnabledChanged(bool enabled);
+
 public slots:
     QVector<EntityItemID> pasteEntities(float x, float y, float z);
     bool exportEntities(const QString& filename, const QVector<EntityItemID>& entityIDs, const glm::vec3* givenOffset = nullptr);
@@ -631,6 +636,7 @@ private:
     Setting::Handle<bool> _preferAvatarFingerOverStylusSetting;
     Setting::Handle<bool> _constrainToolbarPosition;
     Setting::Handle<QString> _preferredCursor;
+    Setting::Handle<bool> _miniTabletEnabledSetting;
 
     float _scaleMirror;
     float _mirrorYawOffset;
diff --git a/interface/src/scripting/HMDScriptingInterface.cpp b/interface/src/scripting/HMDScriptingInterface.cpp
index f2f8d3b8d4..a365b84a15 100644
--- a/interface/src/scripting/HMDScriptingInterface.cpp
+++ b/interface/src/scripting/HMDScriptingInterface.cpp
@@ -27,6 +27,9 @@ HMDScriptingInterface::HMDScriptingInterface() {
     connect(qApp, &Application::activeDisplayPluginChanged, [this]{
         emit displayModeChanged(isHMDMode());
     });
+    connect(qApp, &Application::miniTabletEnabledChanged, [this](bool enabled) {
+        emit miniTabletEnabledChanged(enabled);
+    });
 }
 
 glm::vec3 HMDScriptingInterface::calculateRayUICollisionPoint(const glm::vec3& position, const glm::vec3& direction) const {
@@ -126,6 +129,15 @@ void HMDScriptingInterface::setShouldShowTablet(bool value) {
     }
 }
 
+void HMDScriptingInterface::setMiniTabletEnabled(bool enabled) {
+    qApp->setMiniTabletEnabled(enabled);
+}
+
+bool HMDScriptingInterface::getMiniTabletEnabled() {
+    return qApp->getMiniTabletEnabled();
+}
+
+
 QScriptValue HMDScriptingInterface::getHUDLookAtPosition2D(QScriptContext* context, QScriptEngine* engine) {
     glm::vec3 hudIntersection;
     auto instance = DependencyManager::get<HMDScriptingInterface>();
diff --git a/interface/src/scripting/HMDScriptingInterface.h b/interface/src/scripting/HMDScriptingInterface.h
index 6cc695762b..c634ec58b1 100644
--- a/interface/src/scripting/HMDScriptingInterface.h
+++ b/interface/src/scripting/HMDScriptingInterface.h
@@ -61,6 +61,8 @@ class QScriptEngine;
  * @property {Uuid} miniTabletScreenID - The UUID of the mini tablet's screen overlay. <code>null</code> if not in HMD mode.
  * @property {number} miniTabletHand - The hand that the mini tablet is displayed on: <code>0</code> for left hand, 
  *     <code>1</code> for right hand, <code>-1</code> if not in HMD mode.
+ * @property {bool} miniTabletEnabled=true - <code>true</code> if the mini tablet is enabled to be displayed, otherwise 
+ *     <code>false</code>.
  * @property {Rect} playArea=0,0,0,0 - The size and position of the HMD play area in sensor coordinates. <em>Read-only.</em>
  * @property {Vec3[]} sensorPositions=[]] - The positions of the VR system sensors in sensor coordinates. <em>Read-only.</em>
  */
@@ -77,6 +79,7 @@ class HMDScriptingInterface : public AbstractHMDScriptingInterface, public Depen
     Q_PROPERTY(QUuid miniTabletID READ getCurrentMiniTabletID WRITE setCurrentMiniTabletID)
     Q_PROPERTY(QUuid miniTabletScreenID READ getCurrentMiniTabletScreenID WRITE setCurrentMiniTabletScreenID)
     Q_PROPERTY(int miniTabletHand READ getCurrentMiniTabletHand WRITE setCurrentMiniTabletHand)
+    Q_PROPERTY(bool miniTabletEnabled READ getMiniTabletEnabled WRITE setMiniTabletEnabled)
     Q_PROPERTY(QVariant playArea READ getPlayAreaRect);
     Q_PROPERTY(QVector<glm::vec3> sensorPositions READ getSensorPositions);
 
@@ -355,8 +358,22 @@ signals:
      */
     bool shouldShowHandControllersChanged();
 
+    /**jsdoc
+     * Triggered when the tablet is shown or hidden.
+     * @function HMD.showTabletChanged
+     * @param {boolean} showTablet - <code>true</code> if the tablet is showing, otherwise <code>false</code>.
+     * @returns {Signal}
+     */
     void showTabletChanged(bool showTablet);
 
+    /**jsdoc
+     * Triggered when the ability to display the mini tablet has changed.
+     * @function HMD.miniTabletEnabledChanged
+     * @param {boolean} enabled - <code>true</code> if the mini tablet is enabled to be displayed, otherwise <code>false</code>.
+     * @returns {Signal}
+     */
+    bool miniTabletEnabledChanged(bool enabled);
+
 public:
     HMDScriptingInterface();
     static QScriptValue getHUDLookAtPosition2D(QScriptContext* context, QScriptEngine* engine);
@@ -390,6 +407,9 @@ public:
     void setCurrentMiniTabletHand(int miniTabletHand) { _miniTabletHand = miniTabletHand; }
     int getCurrentMiniTabletHand() const { return _miniTabletHand; }
 
+    void setMiniTabletEnabled(bool enabled);
+    bool getMiniTabletEnabled();
+
     QVariant getPlayAreaRect();
     QVector<glm::vec3> getSensorPositions();
 
@@ -404,6 +424,7 @@ private:
     QUuid _miniTabletID;
     QUuid _miniTabletScreenID;
     int _miniTabletHand { -1 };
+    bool _miniTabletEnabled { true };
 
     // Get the position of the HMD
     glm::vec3 getPosition() const;
diff --git a/interface/src/ui/PreferencesDialog.cpp b/interface/src/ui/PreferencesDialog.cpp
index d71ad9dc82..37fbefd67a 100644
--- a/interface/src/ui/PreferencesDialog.cpp
+++ b/interface/src/ui/PreferencesDialog.cpp
@@ -119,6 +119,12 @@ void setupPreferences() {
         preferences->addPreference(new CheckPreference(UI_CATEGORY, "Use reticle cursor instead of arrow", getter, setter));
     }
 
+    {
+        auto getter = []()->bool { return qApp->getMiniTabletEnabled(); };
+        auto setter = [](bool value) { qApp->setMiniTabletEnabled(value); };
+        preferences->addPreference(new CheckPreference(UI_CATEGORY, "Use mini tablet", getter, setter));
+    }
+
     static const QString VIEW_CATEGORY{ "View" };
     {
         auto getter = [myAvatar]()->float { return myAvatar->getRealWorldFieldOfView(); };
diff --git a/scripts/system/miniTablet.js b/scripts/system/miniTablet.js
index a2f0d074f0..a79332267b 100644
--- a/scripts/system/miniTablet.js
+++ b/scripts/system/miniTablet.js
@@ -21,6 +21,7 @@
         ui = null,
         State,
         miniState = null,
+        miniTabletEnabled = true,
 
         // Hands.
         NO_HAND = -1,
@@ -1012,17 +1013,21 @@
 
         if (message.action === "grab" && message.grabbedEntity === HMD.tabletID && HMD.active) {
             // Tablet may have been grabbed after it replaced expanded mini tablet.
-            miniState.setState(miniState.MINI_HIDDEN);
+            if (miniTabletEnabled) {
+                miniState.setState(miniState.MINI_HIDDEN);
+            }
         } else if (message.action === "grab" && miniState.getState() === miniState.MINI_VISIBLE) {
-            miniHand = miniState.getHand();
-            hand = message.joint === HAND_NAMES[miniHand] ? miniHand : otherHand(miniHand);
-            miniState.setState(miniState.MINI_EXPANDING, { hand: hand, goto: false });
+            if (miniTabletEnabled) {
+                miniHand = miniState.getHand();
+                hand = message.joint === HAND_NAMES[miniHand] ? miniHand : otherHand(miniHand);
+                miniState.setState(miniState.MINI_EXPANDING, { hand: hand, goto: false });
+            }
         }
     }
 
     function onWentAway() {
         // Mini tablet only available when user is not away.
-        if (HMD.active) {
+        if (HMD.active && miniTabletEnabled) {
             miniState.setState(miniState.MINI_HIDDEN);
         }
     }
@@ -1030,8 +1035,21 @@
     function onDisplayModeChanged() {
         // Mini tablet only available when HMD is active.
         if (HMD.active) {
-            miniState.setState(miniState.MINI_HIDDEN);
-        } else {
+            if (miniTabletEnabled && miniState.getState() !== miniState.MINI_HIDDEN) {
+                miniState.setState(miniState.MINI_HIDDEN);
+            }
+        } else if (miniState.getState() !== miniState.MINI_DISABLED) {
+            miniState.setState(miniState.MINI_DISABLED);
+        }
+    }
+
+    function onMiniTabletEnabledChanged(enabled) {
+        miniTabletEnabled = enabled;
+        if (miniTabletEnabled) {
+            if (HMD.active && miniState.getState() !== miniState.MINI_HIDDEN) {
+                miniState.setState(miniState.MINI_HIDDEN);
+            }
+        } else if (miniState.getState() !== miniState.MINI_DISABLED) {
             miniState.setState(miniState.MINI_DISABLED);
         }
     }
@@ -1040,12 +1058,16 @@
     function setUp() {
         miniState = new State();
 
+        HMD.miniTabletEnabledChanged.connect(onMiniTabletEnabledChanged);
+        miniTabletEnabled = HMD.miniTabletEnabled;
+
         Messages.subscribe(HIFI_OBJECT_MANIPULATION_CHANNEL);
         Messages.messageReceived.connect(onMessageReceived);
 
         MyAvatar.wentAway.connect(onWentAway);
         HMD.displayModeChanged.connect(onDisplayModeChanged);
-        if (HMD.active) {
+
+        if (HMD.active && miniTabletEnabled) {
             miniState.setState(miniState.MINI_HIDDEN);
         }
     }
@@ -1059,6 +1081,8 @@
         Messages.messageReceived.disconnect(onMessageReceived);
         Messages.unsubscribe(HIFI_OBJECT_MANIPULATION_CHANNEL);
 
+        HMD.miniTabletEnabledChanged.disconnect(onMiniTabletEnabledChanged);
+
         miniState.destroy();
         miniState = null;
     }