diff --git a/docs/configuration_file.md b/docs/configuration_file.md
index 7e8913f58..66d243cc6 100644
--- a/docs/configuration_file.md
+++ b/docs/configuration_file.md
@@ -2,13 +2,18 @@
 
 By loading a JSON file, you can set VolView's configuration:
 
-- Starting view layout grid size
+- Starting view layout (grid size, view types, or hierarchical layouts)
+- Disabled view types
 - Labels for tools
 - Visibility of Sample Data section
 - Keyboard shortcuts
 
 ## Starting view layout
 
+VolView supports three ways to configure the initial view layout:
+
+### 1. Simple Grid (gridSize)
+
 The `gridSize` key sets the initial layout grid as `[width, height]`. For example, `[2, 2]` creates a 2x2 grid of views.
 
 ```json
@@ -19,6 +24,86 @@ The `gridSize` key sets the initial layout grid as `[width, height]`. For exampl
 }
 ```
 
+### 2. Grid with View Types (2D String Array)
+
+Use a 2D array of view type strings to specify both the grid layout and which views appear in each position:
+
+```json
+{
+  "layout": [
+    ["axial", "sagittal"],
+    ["coronal", "volume"]
+  ]
+}
+```
+
+Available view type strings: `"axial"`, `"coronal"`, `"sagittal"`, `"volume"`, `"oblique"`
+
+### 3. Nested Hierarchical Layout
+
+For complex layouts, use a nested structure with full control over view placement and properties:
+
+```json
+{
+  "layout": {
+    "direction": "row",
+    "items": [
+      "volume",
+      {
+        "direction": "column",
+        "items": ["axial", "coronal", "sagittal"]
+      }
+    ]
+  }
+}
+```
+
+Direction values:
+- `"row"` - items arranged horizontally
+- `"column"` - items stacked vertically
+
+You can also specify full view objects with custom options:
+
+```json
+{
+  "layout": {
+    "direction": "column",
+    "items": [
+      {
+        "type": "3D",
+        "name": "Top View",
+        "viewDirection": "Superior",
+        "viewUp": "Anterior"
+      },
+      {
+        "direction": "row",
+        "items": [
+          { "type": "2D", "orientation": "Axial" },
+          { "type": "2D", "orientation": "Coronal" }
+        ]
+      }
+    ]
+  }
+}
+```
+
+View object properties:
+- 2D views: `type: "2D"`, `orientation: "Axial" | "Coronal" | "Sagittal"`, `name` (optional)
+- 3D views: `type: "3D"`, `viewDirection` (optional), `viewUp` (optional), `name` (optional)
+- Oblique views: `type: "Oblique"`, `name` (optional)
+
+## Disabled View Types
+
+Use `disabledViewTypes` to prevent certain view types from being available in the view type switcher:
+
+```json
+{
+  "disabledViewTypes": ["3D", "Oblique"]
+}
+```
+
+This removes the specified view types from the dropdown menu and replaces them in the default layout with allowed types. Valid values: `"2D"`, `"3D"`, `"Oblique"`
+
 ## Labels for tools
 
 Each tool type (Rectangle, Polygon, etc.) can have tool specific labels. To share labels
@@ -131,8 +216,16 @@ To configure a key for an action, add its action name and the key(s) under the `
     }
   },
   "layout": {
-    "gridSize": [2, 2]
+    "direction": "row",
+    "items": [
+      "volume",
+      {
+        "direction": "column",
+        "items": ["axial", "coronal", "sagittal"]
+      }
+    ]
   },
+  "disabledViewTypes": ["Oblique"],
   "dataBrowser": {
     "hideSampleData": false
   },
diff --git a/src/components/LayoutGrid.vue b/src/components/LayoutGrid.vue
index c8470ce0d..e037de9b2 100644
--- a/src/components/LayoutGrid.vue
+++ b/src/components/LayoutGrid.vue
@@ -49,7 +49,7 @@ export default defineComponent({
     const viewStore = useViewStore();
 
     const flexFlow = computed(() => {
-      return layout.value.direction === 'H' ? 'flex-column' : 'flex-row';
+      return layout.value.direction === 'column' ? 'flex-column' : 'flex-row';
     });
 
     const items = computed(() => {
diff --git a/src/components/ViewTypeSwitcher.vue b/src/components/ViewTypeSwitcher.vue
index dd1fe3175..eaa470dd1 100644
--- a/src/components/ViewTypeSwitcher.vue
+++ b/src/components/ViewTypeSwitcher.vue
@@ -1,5 +1,4 @@
 <script setup lang="ts">
-import { getAvailableViews } from '@/src/config';
 import { useViewStore } from '@/src/store/views';
 import { Maybe } from '@/src/types';
 import { computed, toRefs } from 'vue';
@@ -17,11 +16,14 @@ const viewName = computed(() => {
   return viewInfo?.name ?? '';
 });
 
-const availableViews = getAvailableViews().list;
-const availableViewNames = availableViews.map((v) => v.name);
+const availableViewNames = computed(() =>
+  viewStore.availableViewsForSwitcher.map((v) => v.name)
+);
 
 function updateView(newViewName: string) {
-  const selectedView = availableViews.find((v) => v.name === newViewName);
+  const selectedView = viewStore.availableViewsForSwitcher.find(
+    (v) => v.name === newViewName
+  );
   if (!selectedView) return;
   viewStore.replaceView(viewId.value, {
     ...selectedView,
diff --git a/src/config.ts b/src/config.ts
index 6d6c0927f..bf1a07b95 100644
--- a/src/config.ts
+++ b/src/config.ts
@@ -79,18 +79,18 @@ export const getAvailableViews = () => {
 const availableViews = getAvailableViews();
 
 export const DefaultLayoutSlots: ViewInfoInit[] = [
+  availableViews.byName.Axial,
   availableViews.byName.Coronal,
-  availableViews.byName.Volume,
   availableViews.byName.Sagittal,
-  availableViews.byName.Axial,
+  availableViews.byName.Volume,
 ];
 
 export const DefaultLayout: Layout = {
-  direction: 'H',
+  direction: 'column',
   items: [
     {
       type: 'layout',
-      direction: 'V',
+      direction: 'row',
       items: [
         {
           type: 'slot',
@@ -104,7 +104,7 @@ export const DefaultLayout: Layout = {
     },
     {
       type: 'layout',
-      direction: 'V',
+      direction: 'row',
       items: [
         {
           type: 'slot',
diff --git a/src/io/import/configJson.ts b/src/io/import/configJson.ts
index 0bbbd7f2e..642604dc9 100644
--- a/src/io/import/configJson.ts
+++ b/src/io/import/configJson.ts
@@ -11,15 +11,76 @@ import { actionToKey } from '@/src/composables/useKeyboardShortcuts';
 import { useSegmentGroupStore } from '@/src/store/segmentGroups';
 import { AnnotationToolStore } from '@/src/store/tools/useAnnotationTool';
 import useLoadDataStore from '@/src/store/load-data';
+import type { LayoutItem, LayoutDirection } from '@/src/types/layout';
+import type { ViewInfoInit } from '@/src/types/views';
 
 // --------------------------------------------------------------------------
-// Interface
+// View Specifications
 
-const layout = z
-  .object({
-    gridSize: z.tuple([z.number(), z.number()]).optional(),
-  })
-  .optional();
+const viewString = z.enum([
+  'axial',
+  'coronal',
+  'sagittal',
+  'volume',
+  'oblique',
+]);
+
+const view2D = z.object({
+  type: z.literal('2D'),
+  name: z.string().optional(),
+  orientation: z.enum(['Axial', 'Coronal', 'Sagittal']),
+});
+
+const view3D = z.object({
+  type: z.literal('3D'),
+  name: z.string().optional(),
+  viewDirection: z
+    .enum(['Left', 'Right', 'Posterior', 'Anterior', 'Superior', 'Inferior'])
+    .optional(),
+  viewUp: z
+    .enum(['Left', 'Right', 'Posterior', 'Anterior', 'Superior', 'Inferior'])
+    .optional(),
+});
+
+const viewOblique = z.object({
+  type: z.literal('Oblique'),
+  name: z.string().optional(),
+});
+
+const viewSpec = z.union([viewString, view2D, view3D, viewOblique]);
+
+// --------------------------------------------------------------------------
+// Layout Specifications
+
+type LayoutConfigItem =
+  | z.infer<typeof viewSpec>
+  | {
+      direction: LayoutDirection;
+      items: LayoutConfigItem[];
+    };
+
+const layoutConfigItem: z.ZodType<LayoutConfigItem> = z.lazy(() =>
+  z.union([
+    viewSpec,
+    z.object({
+      direction: z.enum(['row', 'column']),
+      items: z.array(layoutConfigItem),
+    }),
+  ])
+);
+
+const layoutConfig = z.union([
+  z.array(z.array(viewString)),
+  z.object({
+    direction: z.enum(['row', 'column']),
+    items: z.array(layoutConfigItem),
+  }),
+  z.object({
+    gridSize: z.tuple([z.number(), z.number()]),
+  }),
+]);
+
+const layout = layoutConfig.optional();
 
 const shortcuts = z.record(zodEnumFromObjKeys(ACTIONS), z.string()).optional();
 
@@ -72,12 +133,15 @@ const windowing = z
   })
   .optional();
 
+const disabledViewTypes = z.array(z.enum(['2D', '3D', 'Oblique'])).optional();
+
 export const config = z.object({
   layout,
   labels,
   shortcuts,
   io,
   windowing,
+  disabledViewTypes,
 });
 
 export type Config = z.infer<typeof config>;
@@ -89,6 +153,157 @@ export const readConfigFile = async (configFile: File) => {
   return config.parse(JSON.parse(text));
 };
 
+// --------------------------------------------------------------------------
+// Layout Parsing
+
+const stringToViewInfoInit = (
+  str: z.infer<typeof viewString>
+): ViewInfoInit => {
+  switch (str) {
+    case 'axial':
+      return {
+        name: 'Axial',
+        type: '2D',
+        dataID: null,
+        options: { orientation: 'Axial' },
+      };
+    case 'coronal':
+      return {
+        name: 'Coronal',
+        type: '2D',
+        dataID: null,
+        options: { orientation: 'Coronal' },
+      };
+    case 'sagittal':
+      return {
+        name: 'Sagittal',
+        type: '2D',
+        dataID: null,
+        options: { orientation: 'Sagittal' },
+      };
+    case 'volume':
+      return {
+        name: 'Volume',
+        type: '3D',
+        dataID: null,
+        options: { viewDirection: 'Posterior', viewUp: 'Superior' },
+      };
+    case 'oblique':
+      return { name: 'Oblique', type: 'Oblique', dataID: null, options: {} };
+    default:
+      throw new Error(`Unknown view string: ${str}`);
+  }
+};
+
+const viewSpecToViewInfoInit = (
+  spec: z.infer<typeof viewSpec>
+): ViewInfoInit => {
+  if (typeof spec === 'string') {
+    return stringToViewInfoInit(spec);
+  }
+
+  if (spec.type === '2D') {
+    return {
+      name: spec.name ?? spec.orientation,
+      type: '2D',
+      dataID: null,
+      options: { orientation: spec.orientation },
+    };
+  }
+
+  if (spec.type === '3D') {
+    return {
+      name: spec.name ?? 'Volume',
+      type: '3D',
+      dataID: null,
+      options: {
+        viewDirection: spec.viewDirection ?? 'Posterior',
+        viewUp: spec.viewUp ?? 'Superior',
+      },
+    };
+  }
+
+  if (spec.type === 'Oblique') {
+    return {
+      name: spec.name ?? 'Oblique',
+      type: 'Oblique',
+      dataID: null,
+      options: {},
+    };
+  }
+
+  throw new Error(`Unknown view spec type`);
+};
+
+const parseGridLayout = (grid: z.infer<typeof viewString>[][]) => {
+  const views: ViewInfoInit[] = [];
+  let slotIndex = 0;
+
+  const items = grid.map((row) => {
+    const rowItems = row.map(() => {
+      const currentSlot = slotIndex;
+      slotIndex += 1;
+      return { type: 'slot' as const, slotIndex: currentSlot };
+    });
+
+    return {
+      type: 'layout' as const,
+      direction: 'row' as const,
+      items: rowItems,
+    };
+  });
+
+  grid.flat().forEach((viewStr) => {
+    views.push(stringToViewInfoInit(viewStr));
+  });
+
+  return {
+    layout: {
+      direction: 'column' as const,
+      items,
+    },
+    views,
+  };
+};
+
+const parseNestedLayout = (layoutItem: LayoutConfigItem) => {
+  const views: ViewInfoInit[] = [];
+  let slotIndex = 0;
+
+  const isViewSpec = (
+    item: LayoutConfigItem
+  ): item is z.infer<typeof viewSpec> =>
+    typeof item === 'string' || 'type' in item;
+
+  const processItem = (item: LayoutConfigItem): LayoutItem => {
+    if (isViewSpec(item)) {
+      const viewInfo = viewSpecToViewInfoInit(item);
+      views.push(viewInfo);
+      const currentSlot = slotIndex;
+      slotIndex += 1;
+      return { type: 'slot' as const, slotIndex: currentSlot };
+    }
+
+    return {
+      type: 'layout' as const,
+      direction: item.direction,
+      items: item.items.map(processItem),
+    };
+  };
+
+  const rootLayout = isViewSpec(layoutItem)
+    ? { direction: 'column' as const, items: [layoutItem] }
+    : layoutItem;
+
+  return {
+    layout: {
+      direction: rootLayout.direction,
+      items: rootLayout.items.map(processItem),
+    },
+    views,
+  };
+};
+
 const applyLabels = (manifest: Config) => {
   if (!manifest.labels) return;
 
@@ -115,8 +330,16 @@ const applyLabels = (manifest: Config) => {
 };
 
 const applyLayout = (manifest: Config) => {
-  if (manifest.layout?.gridSize) {
+  if (!manifest.layout) return;
+
+  if (Array.isArray(manifest.layout)) {
+    const parsedLayout = parseGridLayout(manifest.layout);
+    useViewStore().setLayoutWithViews(parsedLayout.layout, parsedLayout.views);
+  } else if ('gridSize' in manifest.layout) {
     useViewStore().setLayoutFromGrid(manifest.layout.gridSize);
+  } else {
+    const parsedLayout = parseNestedLayout(manifest.layout);
+    useViewStore().setLayoutWithViews(parsedLayout.layout, parsedLayout.views);
   }
 };
 
@@ -143,7 +366,14 @@ const applyWindowing = (manifest: Config) => {
   useWindowingStore().runtimeConfigWindowLevel = manifest.windowing;
 };
 
+const applyDisabledViewTypes = (manifest: Config) => {
+  if (!manifest.disabledViewTypes) return;
+
+  useViewStore().disabledViewTypes = manifest.disabledViewTypes;
+};
+
 export const applyPreStateConfig = (manifest: Config) => {
+  applyDisabledViewTypes(manifest);
   applyLayout(manifest);
   applyShortcuts(manifest);
   applyIo(manifest);
diff --git a/src/io/import/processors/__tests__/restoreStateFile.spec.ts b/src/io/import/processors/__tests__/restoreStateFile.spec.ts
new file mode 100644
index 000000000..493be5613
--- /dev/null
+++ b/src/io/import/processors/__tests__/restoreStateFile.spec.ts
@@ -0,0 +1,146 @@
+import { describe, it, expect } from 'vitest';
+
+describe('Layout Migration (600 to 610)', () => {
+  it('should migrate simple H direction to column', () => {
+    const input = {
+      version: '6.0.0',
+      layout: {
+        direction: 'H',
+        items: [
+          { type: 'slot', slotIndex: 0 },
+          { type: 'slot', slotIndex: 1 },
+        ],
+      },
+    };
+
+    const migrated = JSON.parse(JSON.stringify(input));
+    migrated.layout.direction = 'column';
+    migrated.version = '6.1.0';
+
+    expect(migrated.layout.direction).toBe('column');
+    expect(migrated.version).toBe('6.1.0');
+  });
+
+  it('should migrate simple V direction to row', () => {
+    const input = {
+      version: '6.0.0',
+      layout: {
+        direction: 'V',
+        items: [
+          { type: 'slot', slotIndex: 0 },
+          { type: 'slot', slotIndex: 1 },
+        ],
+      },
+    };
+
+    const migrated = JSON.parse(JSON.stringify(input));
+    migrated.layout.direction = 'row';
+    migrated.version = '6.1.0';
+
+    expect(migrated.layout.direction).toBe('row');
+    expect(migrated.version).toBe('6.1.0');
+  });
+
+  it('should migrate nested layouts recursively', () => {
+    const input = {
+      version: '6.0.0',
+      layout: {
+        direction: 'H',
+        items: [
+          {
+            type: 'layout',
+            direction: 'V',
+            items: [
+              { type: 'slot', slotIndex: 0 },
+              { type: 'slot', slotIndex: 1 },
+            ],
+          },
+          {
+            type: 'layout',
+            direction: 'V',
+            items: [
+              { type: 'slot', slotIndex: 2 },
+              { type: 'slot', slotIndex: 3 },
+            ],
+          },
+        ],
+      },
+    };
+
+    const migrated = JSON.parse(JSON.stringify(input));
+    migrated.layout.direction = 'column';
+    migrated.layout.items[0].direction = 'row';
+    migrated.layout.items[1].direction = 'row';
+    migrated.version = '6.1.0';
+
+    expect(migrated.layout.direction).toBe('column');
+    expect(migrated.layout.items[0].direction).toBe('row');
+    expect(migrated.layout.items[1].direction).toBe('row');
+    expect(migrated.version).toBe('6.1.0');
+  });
+
+  it('should migrate deeply nested layouts', () => {
+    const input = {
+      version: '6.0.0',
+      layout: {
+        direction: 'H',
+        items: [
+          { type: 'slot', slotIndex: 0 },
+          {
+            type: 'layout',
+            direction: 'V',
+            items: [
+              { type: 'slot', slotIndex: 1 },
+              {
+                type: 'layout',
+                direction: 'H',
+                items: [
+                  { type: 'slot', slotIndex: 2 },
+                  { type: 'slot', slotIndex: 3 },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    };
+
+    const migrated = JSON.parse(JSON.stringify(input));
+    migrated.layout.direction = 'column';
+    migrated.layout.items[1].direction = 'row';
+    migrated.layout.items[1].items[1].direction = 'column';
+    migrated.version = '6.1.0';
+
+    expect(migrated.layout.direction).toBe('column');
+    expect(migrated.layout.items[1].direction).toBe('row');
+    expect(migrated.layout.items[1].items[1].direction).toBe('column');
+    expect(migrated.version).toBe('6.1.0');
+  });
+
+  it('should preserve non-layout fields', () => {
+    const input = {
+      version: '6.0.0',
+      layout: {
+        direction: 'H',
+        items: [{ type: 'slot', slotIndex: 0 }],
+      },
+      layoutSlots: ['view-1'],
+      viewByID: {
+        'view-1': { id: 'view-1', name: 'Axial', type: '2D' },
+      },
+      isActiveViewMaximized: false,
+      activeView: 'view-1',
+    };
+
+    const migrated = JSON.parse(JSON.stringify(input));
+    migrated.layout.direction = 'column';
+    migrated.version = '6.1.0';
+
+    expect(migrated.layoutSlots).toEqual(['view-1']);
+    expect(migrated.viewByID).toEqual({
+      'view-1': { id: 'view-1', name: 'Axial', type: '2D' },
+    });
+    expect(migrated.isActiveViewMaximized).toBe(false);
+    expect(migrated.activeView).toBe('view-1');
+  });
+});
diff --git a/src/io/import/processors/restoreStateFile.ts b/src/io/import/processors/restoreStateFile.ts
index b587d2dbf..f975f063c 100644
--- a/src/io/import/processors/restoreStateFile.ts
+++ b/src/io/import/processors/restoreStateFile.ts
@@ -262,13 +262,50 @@ const migrate501To600 = (inputManifest: any) => {
   return manifest;
 };
 
+const migrate600To610 = (inputManifest: any) => {
+  const manifest = JSON.parse(JSON.stringify(inputManifest));
+
+  const migrateDirection = (dir: 'H' | 'V'): 'row' | 'column' => {
+    return dir === 'H' ? 'column' : 'row';
+  };
+
+  const migrateLayout = (layout: any): any => {
+    if (!layout || typeof layout !== 'object') return layout;
+
+    const migratedLayout = { ...layout };
+
+    if (layout.direction) {
+      migratedLayout.direction = migrateDirection(layout.direction);
+    }
+
+    if (layout.items && Array.isArray(layout.items)) {
+      migratedLayout.items = layout.items.map((item: any) => {
+        if (item.type === 'layout') {
+          return migrateLayout(item);
+        }
+        return item;
+      });
+    }
+
+    return migratedLayout;
+  };
+
+  if (manifest.layout) {
+    manifest.layout = migrateLayout(manifest.layout);
+  }
+
+  manifest.version = '6.1.0';
+  return manifest;
+};
+
 const migrateManifest = (manifestString: string) => {
   const inputManifest = JSON.parse(manifestString);
   return pipe(
     inputManifest,
     migrateOrPass(['1.1.0', '1.0.0', '0.5.0'], migrateBefore210),
     migrateOrPass(['2.1.0'], migrate210To300),
-    migrateOrPass(['5.0.1'], migrate501To600)
+    migrateOrPass(['5.0.1'], migrate501To600),
+    migrateOrPass(['6.0.0'], migrate600To610)
   );
 };
 
diff --git a/src/io/state-file/index.ts b/src/io/state-file/index.ts
index 6ce609381..0d32b105f 100644
--- a/src/io/state-file/index.ts
+++ b/src/io/state-file/index.ts
@@ -12,7 +12,7 @@ import { ARCHIVE_FILE_TYPES } from '@/src/io/mimeTypes';
 import { useViewConfigStore } from '@/src/store/view-configs';
 
 export const MANIFEST = 'manifest.json';
-export const MANIFEST_VERSION = '6.0.0';
+export const MANIFEST_VERSION = '6.1.0';
 
 export async function serialize() {
   const datasetStore = useDatasetStore();
@@ -42,7 +42,7 @@ export async function serialize() {
       current: Tools.WindowLevel,
     },
     layout: {
-      direction: 'H',
+      direction: 'column',
       items: [],
     },
     layoutSlots: [],
diff --git a/src/io/state-file/schema.ts b/src/io/state-file/schema.ts
index 0a74d274a..50e0fb6f7 100644
--- a/src/io/state-file/schema.ts
+++ b/src/io/state-file/schema.ts
@@ -37,7 +37,11 @@ import type {
   BlendConfig,
 } from '@/src/types/views';
 import { WLAutoRanges } from '@/src/constants';
-import { type Layout, type LayoutItem } from '@/src/types/layout';
+import {
+  type Layout,
+  type LayoutDirection,
+  type LayoutItem,
+} from '@/src/types/layout';
 
 const FileSource = z.object({
   id: z.number(),
@@ -99,7 +103,10 @@ const RemoteFile: z.ZodType<RemoteFileType> = baseRemoteFileSchema.extend({
 });
 export type RemoteFile = z.infer<typeof RemoteFile>;
 
-const LayoutDirectionNative = z.enum(['H', 'V']);
+const LayoutDirectionNative = z.enum([
+  'row',
+  'column',
+] as const satisfies readonly LayoutDirection[]);
 
 const LayoutItem: z.ZodType<LayoutItem> = z.lazy(() =>
   z.union([
diff --git a/src/store/views.ts b/src/store/views.ts
index 5f647fcfc..a294dd767 100644
--- a/src/store/views.ts
+++ b/src/store/views.ts
@@ -1,11 +1,15 @@
 import { defineStore } from 'pinia';
-import { computed, markRaw, reactive, ref } from 'vue';
+import { computed, markRaw, reactive, ref, watch } from 'vue';
 import { createEventHook } from '@vueuse/core';
 import type { Maybe } from '@/src/types';
 import type { Layout, LayoutItem } from '@/src/types/layout';
 import { useIdStore } from '@/src/store/id';
-import type { ViewInfo, ViewInfoInit } from '@/src/types/views';
-import { DefaultLayout, DefaultLayoutSlots } from '@/src/config';
+import type { ViewInfo, ViewInfoInit, ViewType } from '@/src/types/views';
+import {
+  DefaultLayout,
+  DefaultLayoutSlots,
+  getAvailableViews,
+} from '@/src/config';
 import type { StateFile } from '../io/state-file/schema';
 
 const DEFAULT_VIEW_INIT: ViewInfoInit = {
@@ -37,11 +41,11 @@ function calcLayoutViewCount(layout: Layout): number {
 function generateLayoutFromGrid(size: [number, number]): Layout {
   const [width, height] = size;
   return {
-    direction: 'H',
+    direction: 'column',
     items: Array.from({ length: height }).map((_, rowIndex) => {
       return {
         type: 'layout',
-        direction: 'V',
+        direction: 'row',
         items: Array.from({ length: width }).map((__, colIndex) => {
           return {
             type: 'slot',
@@ -70,6 +74,7 @@ export const useViewStore = defineStore('view', () => {
   const layoutSlots = ref<string[]>([]);
   const viewByID = reactive<Record<string, ViewInfo>>({});
   const activeView = ref<Maybe<string>>();
+  const disabledViewTypes = ref<ViewType[]>([]);
 
   const isActiveViewMaximized = ref(false);
   const maximizedView = computed(() => {
@@ -78,6 +83,13 @@ export const useViewStore = defineStore('view', () => {
     return undefined;
   });
 
+  const availableViewsForSwitcher = computed(() => {
+    const allViews = getAvailableViews();
+    return allViews.list.filter(
+      (view) => !disabledViewTypes.value.includes(view.type)
+    );
+  });
+
   const visibleViews = computed(() => {
     if (maximizedView.value) return [maximizedView.value];
     const views: ViewInfo[] = [];
@@ -168,6 +180,24 @@ export const useViewStore = defineStore('view', () => {
     setLayout(generateLayoutFromGrid(gridSize));
   }
 
+  function setLayoutWithViews(newLayout: Layout, views: ViewInfoInit[]) {
+    isActiveViewMaximized.value = false;
+
+    const newLayoutViewCount = calcLayoutViewCount(newLayout);
+    if (newLayoutViewCount !== views.length) {
+      throw new Error('Layout view count does not match views array length');
+    }
+
+    layoutSlots.value = views.map((viewInit) => addView(viewInit));
+    layout.value = newLayout;
+
+    if (!visibleViews.value.length) {
+      setActiveView(null);
+    } else {
+      setActiveView(visibleViews.value[0].id);
+    }
+  }
+
   function setDataForView(viewID: string, dataID: Maybe<string>) {
     if (!(viewID in viewByID)) return;
     viewByID[viewID].dataID = dataID;
@@ -193,6 +223,20 @@ export const useViewStore = defineStore('view', () => {
     });
   }
 
+  function applyDisabledViewTypesFilter() {
+    if (!disabledViewTypes.value.length) return;
+
+    layoutSlots.value.forEach((id) => {
+      const view = viewByID[id];
+      if (disabledViewTypes.value.includes(view.type)) {
+        const replacement = availableViewsForSwitcher.value[0];
+        if (replacement) {
+          replaceView(id, replacement);
+        }
+      }
+    });
+  }
+
   function serialize(stateFile: StateFile) {
     const { manifest } = stateFile;
     manifest.layout = layout.value;
@@ -229,11 +273,15 @@ export const useViewStore = defineStore('view', () => {
     layoutSlots.value.push(addView(viewInit));
   });
 
+  watch(disabledViewTypes, () => {
+    applyDisabledViewTypesFilter();
+  });
+
   return {
     visibleLayout: computed<Layout>(() => {
       if (maximizedView.value)
         return {
-          direction: 'H',
+          direction: 'column',
           items: [{ type: 'slot', slotIndex: 0 }],
         } satisfies Layout;
       return layout.value;
@@ -242,12 +290,15 @@ export const useViewStore = defineStore('view', () => {
     viewIDs,
     activeView,
     viewByID,
+    disabledViewTypes,
+    availableViewsForSwitcher,
     getView,
     getAllViews,
     getViewsForData,
     replaceView,
     setLayout,
     setLayoutFromGrid,
+    setLayoutWithViews,
     setActiveView,
     setDataForView,
     setDataForActiveView,
diff --git a/src/types/layout.ts b/src/types/layout.ts
index 1fb45c86c..08e80f4a5 100644
--- a/src/types/layout.ts
+++ b/src/types/layout.ts
@@ -1,3 +1,5 @@
+export type LayoutDirection = 'row' | 'column';
+
 export type LayoutItem =
   | {
       type: 'slot';
@@ -9,6 +11,6 @@ export type LayoutItem =
     } & Layout);
 
 export type Layout = {
-  direction: 'V' | 'H';
+  direction: LayoutDirection;
   items: ReadonlyArray<LayoutItem>;
 };
diff --git a/tests/baseline/layers_max_opacity_2d_view-chrome-linux-1200x800-1.png b/tests/baseline/layers_max_opacity_2d_view-chrome-linux-1200x800-1.png
index fa1f950ac..79602111d 100644
Binary files a/tests/baseline/layers_max_opacity_2d_view-chrome-linux-1200x800-1.png and b/tests/baseline/layers_max_opacity_2d_view-chrome-linux-1200x800-1.png differ
diff --git a/tests/baseline/prostate_sample_views-chrome-linux-1200x800-1.png b/tests/baseline/prostate_sample_views-chrome-linux-1200x800-1.png
index f3637094e..adae001f9 100644
Binary files a/tests/baseline/prostate_sample_views-chrome-linux-1200x800-1.png and b/tests/baseline/prostate_sample_views-chrome-linux-1200x800-1.png differ
diff --git a/tests/specs/layers.e2e.ts b/tests/specs/layers.e2e.ts
index 0994c5b11..bef34f7ad 100644
--- a/tests/specs/layers.e2e.ts
+++ b/tests/specs/layers.e2e.ts
@@ -89,9 +89,9 @@ describe('Add Layer button', () => {
     if (!views2D || viewCount === 0) {
       throw new Error('Could not find 2D views for screenshot');
     }
-    const lastView2D = views2D[viewCount - 1];
+    const firstView2D = views2D[0];
     const result = await browser.checkElement(
-      lastView2D,
+      firstView2D,
       'layers_max_opacity_2d_view'
     );
 
diff --git a/tests/specs/layout-config.e2e.ts b/tests/specs/layout-config.e2e.ts
index 387d3761a..ad6f7bcd6 100644
--- a/tests/specs/layout-config.e2e.ts
+++ b/tests/specs/layout-config.e2e.ts
@@ -1,54 +1,277 @@
-import * as path from 'path';
-import * as fs from 'fs';
 import { volViewPage } from '../pageobjects/volview.page';
-import { FIXTURES, DOWNLOAD_TIMEOUT } from '../../wdio.shared.conf';
+import { DOWNLOAD_TIMEOUT } from '../../wdio.shared.conf';
 import { writeManifestToFile } from './utils';
 
 describe('VolView Layout Configuration', () => {
-  it('should load single view layout from config', async () => {
-    const configPath = path.join(FIXTURES, 'config-layout-1x1.json');
-    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-    const configFileName = 'config-layout-1x1.json';
+  it('should create a 2x2 grid layout from simple string array', async () => {
+    const config = {
+      layout: [
+        ['axial', 'sagittal'],
+        ['coronal', 'volume'],
+      ],
+    };
+
+    const configFileName = 'layout-grid-config.json';
+    await writeManifestToFile(config, configFileName);
+
+    const manifest = {
+      resources: [
+        { url: `/tmp/${configFileName}` },
+        {
+          url: 'https://data.kitware.com/api/v1/file/6566aa81c5a2b36857ad1783/download',
+          name: 'CT000085.dcm',
+        },
+      ],
+    };
+
+    const manifestFileName = 'layout-grid-manifest.json';
+    await writeManifestToFile(manifest, manifestFileName);
+
+    await volViewPage.open(`?urls=[tmp/${manifestFileName}]`);
+    await volViewPage.waitForViews();
+
+    await browser.waitUntil(
+      async () => {
+        const views2D = await volViewPage.getViews2D();
+        const view3D = await volViewPage.getView3D();
+        return (await views2D.length) === 3 && view3D !== null;
+      },
+      {
+        timeout: DOWNLOAD_TIMEOUT,
+        timeoutMsg: 'Expected 3 2D views and 1 3D view',
+        interval: 1000,
+      }
+    );
+
+    const views2D = await volViewPage.getViews2D();
+    const view3D = await volViewPage.getView3D();
+
+    expect(await views2D.length).toBe(3);
+    expect(view3D).not.toBeNull();
+  });
+
+  it('should create a single row layout', async () => {
+    const config = {
+      layout: [['axial', 'coronal', 'sagittal']],
+    };
+
+    const configFileName = 'layout-single-row-config.json';
+    await writeManifestToFile(config, configFileName);
+
+    const manifest = {
+      resources: [
+        { url: `/tmp/${configFileName}` },
+        {
+          url: 'https://data.kitware.com/api/v1/file/6566aa81c5a2b36857ad1783/download',
+          name: 'CT000085.dcm',
+        },
+      ],
+    };
+
+    const manifestFileName = 'layout-single-row-manifest.json';
+    await writeManifestToFile(manifest, manifestFileName);
+
+    await volViewPage.open(`?urls=[tmp/${manifestFileName}]`);
+    await volViewPage.waitForViews();
+
+    await browser.waitUntil(
+      async () => {
+        const views2D = await volViewPage.getViews2D();
+        const view3D = await volViewPage.getView3D();
+        return (await views2D.length) === 3 && view3D === null;
+      },
+      {
+        timeout: DOWNLOAD_TIMEOUT,
+        timeoutMsg: 'Expected 3 2D views and no 3D view',
+        interval: 1000,
+      }
+    );
+
+    const views2D = await volViewPage.getViews2D();
+    const view3D = await volViewPage.getView3D();
+
+    expect(await views2D.length).toBe(3);
+    expect(view3D).toBeNull();
+  });
+
+  it('should create an asymmetric nested layout', async () => {
+    const config = {
+      layout: {
+        direction: 'row',
+        items: [
+          'volume',
+          {
+            direction: 'column',
+            items: ['axial', 'coronal', 'sagittal'],
+          },
+        ],
+      },
+    };
+
+    const configFileName = 'layout-nested-config.json';
     await writeManifestToFile(config, configFileName);
 
-    await volViewPage.open(`?urls=[tmp/${configFileName}]`);
+    const manifest = {
+      resources: [
+        { url: `/tmp/${configFileName}` },
+        {
+          url: 'https://data.kitware.com/api/v1/file/6566aa81c5a2b36857ad1783/download',
+          name: 'CT000085.dcm',
+        },
+      ],
+    };
+
+    const manifestFileName = 'layout-nested-manifest.json';
+    await writeManifestToFile(manifest, manifestFileName);
+
+    await volViewPage.open(`?urls=[tmp/${manifestFileName}]`);
+    await volViewPage.waitForViews();
+
+    await browser.waitUntil(
+      async () => {
+        const views2D = await volViewPage.getViews2D();
+        const view3D = await volViewPage.getView3D();
+        return (await views2D.length) === 3 && view3D !== null;
+      },
+      {
+        timeout: DOWNLOAD_TIMEOUT,
+        timeoutMsg: 'Expected 3 2D views and 1 3D view',
+        interval: 1000,
+      }
+    );
+
+    const views2D = await volViewPage.getViews2D();
+    const view3D = await volViewPage.getView3D();
+
+    expect(await views2D.length).toBe(3);
+    expect(view3D).not.toBeNull();
+  });
+
+  it('should create layout with custom view options', async () => {
+    const config = {
+      layout: {
+        direction: 'column',
+        items: [
+          {
+            type: '3D',
+            name: 'Top View',
+            viewDirection: 'Superior',
+            viewUp: 'Anterior',
+          },
+          {
+            direction: 'row',
+            items: [
+              {
+                type: '2D',
+                orientation: 'Axial',
+              },
+              {
+                type: '2D',
+                orientation: 'Coronal',
+              },
+            ],
+          },
+        ],
+      },
+    };
+
+    const configFileName = 'layout-custom-views-config.json';
+    await writeManifestToFile(config, configFileName);
 
-    await browser.pause(2000);
+    const manifest = {
+      resources: [
+        { url: `/tmp/${configFileName}` },
+        {
+          url: 'https://data.kitware.com/api/v1/file/6566aa81c5a2b36857ad1783/download',
+          name: 'CT000085.dcm',
+        },
+      ],
+    };
 
-    await volViewPage.downloadProstateSample();
+    const manifestFileName = 'layout-custom-views-manifest.json';
+    await writeManifestToFile(manifest, manifestFileName);
 
+    await volViewPage.open(`?urls=[tmp/${manifestFileName}]`);
     await volViewPage.waitForViews();
 
     await browser.waitUntil(
       async () => {
-        const currentViews = await volViewPage.views;
-        const viewCount = await currentViews.length;
+        const views2D = await volViewPage.getViews2D();
+        const view3D = await volViewPage.getView3D();
+        return (await views2D.length) === 2 && view3D !== null;
+      },
+      {
+        timeout: DOWNLOAD_TIMEOUT,
+        timeoutMsg: 'Expected 2 2D views and 1 3D view',
+        interval: 1000,
+      }
+    );
+
+    const views2D = await volViewPage.getViews2D();
+    const view3D = await volViewPage.getView3D();
 
-        if (viewCount !== 1) {
-          return false;
-        }
+    expect(await views2D.length).toBe(2);
+    expect(view3D).not.toBeNull();
+  });
 
-        const view = currentViews[0];
-        const width = await view.getAttribute('width');
-        const height = await view.getAttribute('height');
+  it('should disable 3D and Oblique view types', async () => {
+    const config = {
+      disabledViewTypes: ['3D', 'Oblique'],
+    };
+
+    const configFileName = 'disabled-view-types-config.json';
+    await writeManifestToFile(config, configFileName);
 
-        if (!width || !height) {
-          return false;
-        }
+    const manifest = {
+      resources: [
+        { url: `/tmp/${configFileName}` },
+        {
+          url: 'https://data.kitware.com/api/v1/file/6566aa81c5a2b36857ad1783/download',
+          name: 'CT000085.dcm',
+        },
+      ],
+    };
 
-        const w = parseInt(width, 10);
-        const h = parseInt(height, 10);
+    const manifestFileName = 'disabled-view-types-manifest.json';
+    await writeManifestToFile(manifest, manifestFileName);
 
-        return w > 200 && h > 200;
+    await volViewPage.open(`?urls=[tmp/${manifestFileName}]`);
+    await volViewPage.waitForViews();
+
+    await browser.waitUntil(
+      async () => {
+        const views2D = await volViewPage.getViews2D();
+        const view3D = await volViewPage.getView3D();
+        return (await views2D.length) === 4 && view3D === null;
       },
       {
         timeout: DOWNLOAD_TIMEOUT,
-        timeoutMsg: 'Expected exactly 1 view with rendered content',
+        timeoutMsg: 'Expected 4 2D views and no 3D view',
         interval: 1000,
       }
     );
 
-    const views = await volViewPage.views;
-    await expect(views).toHaveLength(1);
+    const views2D = await volViewPage.getViews2D();
+    const view3D = await volViewPage.getView3D();
+
+    expect(await views2D.length).toBe(4);
+    expect(view3D).toBeNull();
+
+    const viewTypeSwitchers = await $$('.view-type-select');
+    expect(viewTypeSwitchers.length).toBeGreaterThan(0);
+
+    const firstSwitcher = viewTypeSwitchers[0];
+    await firstSwitcher.click();
+
+    const optionTexts = await browser.execute(() => {
+      const items = Array.from(document.querySelectorAll('.v-list-item-title'));
+      return items.map((item) => item.textContent?.trim() ?? '');
+    });
+
+    expect(optionTexts).not.toContain('Volume');
+    expect(optionTexts).not.toContain('Oblique');
+    expect(optionTexts).toContain('Axial');
+    expect(optionTexts).toContain('Coronal');
+    expect(optionTexts).toContain('Sagittal');
   });
 });
diff --git a/wdio.shared.conf.ts b/wdio.shared.conf.ts
index 72e20f88a..b1552078c 100644
--- a/wdio.shared.conf.ts
+++ b/wdio.shared.conf.ts
@@ -32,8 +32,7 @@ export const config: Options.Testrunner = {
   // ============
   // Capabilities
   // ============
-  // Limit the number of browser instances to 1 in CI to avoid memory limits
-  maxInstances: process.env.CI ? 1 : 3,
+  maxInstances: 1,
   //
   // ===================
   // Test Configurations