diff --git a/res/layout/user_folder.xml b/res/layout/user_folder.xml
index 208390d..af17250 100644
--- a/res/layout/user_folder.xml
+++ b/res/layout/user_folder.xml
@@ -26,10 +26,10 @@
         android:id="@+id/folder_content"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
-        android:paddingLeft="0dip"
-        android:paddingRight="0dip"
-        android:paddingTop="0dip"
-        android:paddingBottom="0dip"
+        android:paddingLeft="@dimen/folder_padding"
+        android:paddingRight="@dimen/folder_padding"
+        android:paddingTop="@dimen/folder_padding"
+        android:paddingBottom="@dimen/folder_padding"
         android:cacheColorHint="#ff333333"
         android:hapticFeedbackEnabled="false"
         launcher:widthGap="@dimen/folder_width_gap"
diff --git a/res/values-sw600dp-land/config.xml b/res/values-sw600dp-land/config.xml
new file mode 100644
index 0000000..822ea89
--- /dev/null
+++ b/res/values-sw600dp-land/config.xml
@@ -0,0 +1,7 @@
+<resources>
+<!-- Folders -->
+    <!-- Folder max bounds and max number of items. Note: folder_max_count_x * folder_max_count_y
+        >= folder_max_num_items. When these are set to -1, they are automatically determined. -->
+    <integer name="folder_max_count_x">8</integer>
+    <integer name="folder_max_count_y">5</integer>
+</resources>
diff --git a/res/values-sw600dp/config.xml b/res/values-sw600dp/config.xml
index d07391e..2a8e5df 100644
--- a/res/values-sw600dp/config.xml
+++ b/res/values-sw600dp/config.xml
@@ -11,9 +11,9 @@
 <!-- Folders -->
     <!-- Folder max bounds and max number of items. Note: folder_max_count_x * folder_max_count_y
         >= folder_max_num_items. When these are set to -1, they are automatically determined. -->
-    <integer name="folder_max_count_x">-1</integer>
-    <integer name="folder_max_count_y">-1</integer>
-    <integer name="folder_max_num_items">-1</integer>
+    <integer name="folder_max_count_x">6</integer>
+    <integer name="folder_max_count_y">6</integer>
+    <integer name="folder_max_num_items">36</integer>
 
     <!-- Camera distance for the overscroll effect. We use a higher value here because the 
          workspace screens run nearly flush to the edge of the screen-->
diff --git a/res/values-sw600dp/dimens.xml b/res/values-sw600dp/dimens.xml
index bb6cbc9..bf19e5c 100644
--- a/res/values-sw600dp/dimens.xml
+++ b/res/values-sw600dp/dimens.xml
@@ -46,6 +46,9 @@
     <dimen name="folder_preview_size">68dp</dimen>
     <dimen name="folder_cell_width">86dp</dimen>
     <dimen name="folder_cell_height">90dp</dimen>
+    <dimen name="folder_width_gap">3dp</dimen>
+    <dimen name="folder_height_gap">3dp</dimen>
+    <dimen name="folder_padding">6dp</dimen>
 
     <dimen name="cell_layout_left_padding_port">12dp</dimen>
     <dimen name="cell_layout_right_padding_port">12dp</dimen>
diff --git a/res/values-sw720dp/config.xml b/res/values-sw720dp/config.xml
index 1913d74..76d7da7 100644
--- a/res/values-sw720dp/config.xml
+++ b/res/values-sw720dp/config.xml
@@ -8,6 +8,13 @@
     <!-- Out of 100, the percent to shrink the workspace during spring loaded mode. -->
     <integer name="config_workspaceSpringLoadShrinkPercentage">90</integer>
 
+<!-- Folders -->
+    <!-- Folder max bounds and max number of items. Note: folder_max_count_x * folder_max_count_y
+        >= folder_max_num_items. When these are set to -1, they are automatically determined. -->
+    <integer name="folder_max_count_x">-1</integer>
+    <integer name="folder_max_count_y">-1</integer>
+    <integer name="folder_max_num_items">-1</integer>
+
 <!-- Workspace -->
     <!-- Whether or not the drop targets drop down as opposed to fade in -->
     <bool name="config_useDropTargetDownTransition">true</bool>
diff --git a/res/values-sw720dp/dimens.xml b/res/values-sw720dp/dimens.xml
index 9d73eca..54ac870 100644
--- a/res/values-sw720dp/dimens.xml
+++ b/res/values-sw720dp/dimens.xml
@@ -41,10 +41,6 @@
     <!-- 44dp high for the optical bounds -->
     <dimen name="search_bar_height">52dp</dimen>
 
-    <dimen name="folder_cell_width">96dp</dimen>
-    <dimen name="folder_cell_height">96dp</dimen>
-    <dimen name="folder_preview_size">75dp</dimen>
-
 <!-- AppsCustomize -->
     <dimen name="apps_customize_cell_width">96dp</dimen>
     <dimen name="apps_customize_cell_height">96dp</dimen>
@@ -71,6 +67,15 @@
     <dimen name="cell_layout_bottom_padding_port">0dp</dimen>
     <dimen name="cell_layout_bottom_padding_land">0dp</dimen>
 
+<!-- Folders -->
+    <!-- The size of the image which sits behind the preview of the folder contents -->
+    <dimen name="folder_cell_width">96dp</dimen>
+    <dimen name="folder_cell_height">96dp</dimen>
+    <dimen name="folder_preview_size">75dp</dimen>
+    <dimen name="folder_width_gap">2dp</dimen>
+    <dimen name="folder_height_gap">2dp</dimen>
+    <dimen name="folder_padding">4dp</dimen>
+
 <!-- Workspace padding -->
     <dimen name="workspace_left_padding_port">0dp</dimen>
     <dimen name="workspace_left_padding_land">0dp</dimen>
diff --git a/res/values/dimens.xml b/res/values/dimens.xml
index fb96c0d..d497c2d 100644
--- a/res/values/dimens.xml
+++ b/res/values/dimens.xml
@@ -120,6 +120,7 @@
     <dimen name="folder_name_padding">10dp</dimen>
     <dimen name="folder_width_gap">0dp</dimen>
     <dimen name="folder_height_gap">0dp</dimen>
+    <dimen name="folder_padding">0dp</dimen>
 
 <!-- CellLayout padding -->
     <dimen name="cell_layout_left_padding_port">0dp</dimen>
