diff --git a/res/values-large/config.xml b/res/values-large/config.xml
index f0ce348..6274364 100644
--- a/res/values-large/config.xml
+++ b/res/values-large/config.xml
@@ -1,4 +1,6 @@
 <resources>
+    <bool name="config_largeHeap">true</bool>
+
 <!-- AllApps/Customize/AppsCustomize -->
     <!-- Out of 100, the percent to shrink the workspace during spring loaded mode. -->
     <integer name="config_workspaceSpringLoadShrinkPercentage">90</integer>
diff --git a/res/values/config.xml b/res/values/config.xml
index 5ddf0a1..9a2c1f2 100644
--- a/res/values/config.xml
+++ b/res/values/config.xml
@@ -1,5 +1,6 @@
 <resources>
     <bool name="config_hardwareAccelerated">true</bool>
+    <bool name="config_largeHeap">false</bool>
 
 <!-- AllApps/Customize/AppsCustomize -->
     <!-- The alpha of the AppsCustomize bg in spring loaded mode -->
