diff --git a/.changeset/calm-trays-mix.md b/.changeset/calm-trays-mix.md
new file mode 100644
index 0000000..887e37c
--- /dev/null
+++ b/.changeset/calm-trays-mix.md
@@ -0,0 +1,5 @@
+---
+'basekit': minor
+---
+
+Add universal magnetic trays and tray-compatible base pockets for mixing miniature sizes on one continuous Gridfinity deck.
diff --git a/AGENTS.md b/AGENTS.md
index a11437d..60fe487 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -24,6 +24,7 @@ Read [README.md](README.md) first for what the app does and what the controls me
 - **The edge profile must leave wall beside the recess floor.** The well is cut from the full-size inner outline while the outer loft is inset near the build plate. If that inset reaches the well outline where the floor begins, the cut severs the rim and only the ribs join it back. `maxProfileSize` samples the same profile steps as the loft, the UI caps against it, and `buildBase` rejects callers that bypass the control.
 - **Every magnet boss sits on a rib.** That is the invariant `base.test.ts` asserts across every preset, and the counts are chosen to hold it: a ring gets one spoke each, and a row gets an even count, because every magnet in a row shares the long axis so one spoke down it passes through all of them. `ribAngles` takes its phase from a boss bearing so the alignment is exact. It used to fall out of both series using the same `π/2 + 2πi/n`, which meant it held only when the counts happened to match, and flipped as the size changed. A rib on a boss gussets its root, prints as one connected feature instead of an island, and collects the clear floor into a few wide gaps, which is what lets the size label stay large. Phase makes almost no difference to floor stiffness — a boss is a 7mm inclusion in a plate tens of millimetres across.
 - **Automatic magnet counts combine holding demand with stability.** `automaticMagnetCount` starts from the existing 5×2mm balanced recommendation, scales demand by the practical `diameter² × thickness` strength proxy, applies a minimum of three magnets for a ring or two for a row, then rounds up to a supported balanced count. This assumes ordinary neodymium magnets; it is a recommendation, not a pull-force claim. A `magnetCounts` entry is a per-footprint manual override, while an absent entry means automatic. Every automatic count must appear in `MAGNET_CHOICES` and every rib count in `RIB_CHOICES`; tests assert both.
+- **Universal trays and tray-compatible bases share one canonical staggered lattice.** The pitch belongs to workspace magnet settings and is projected into both generators. Compatible base pockets must be exact lattice nodes, split tray modules must preserve the assembled tray's global lattice phase, and ribs must still pass through every boss. The sparse default is 30mm; automatic compatible counts step down when a footprint cannot contain the recommended count at that pitch. Exterior tray edges also reserve half the configured smallest-base size, while internal module seams reserve only pocket clearance. Balanced and five-pocket-cross layouts remain valid but do not promise universal-tray alignment.
 - **Label bearings come from the gaps between everything solid**, ribs and bosses together, widest first. Bisecting the ribs alone worked only while ribs and bosses shared a bearing; the moment they did not, a rib bisector aimed straight at a boss. Bases and holders both use `src/geometry/label.ts`, so changes to fitting rules affect both generators.
 - **The size label must never disappear silently.** If it cannot be placed it is simply absent from the model, with no error, so changes to `fitLabel` need a test that a cramped base still gains volume from its label.
 - **Magnets are flush with the face that meets the tray, whatever their thickness.** The bore is cut down from `z = height` by `magnets.thickness + magnets.depthClearance`, leaving optional room for adhesive behind a magnet held flush during assembly. Anchoring the bore at `floorThickness` instead looks like it puts the magnet "on the floor", but that floor is the opposite face of the base, so it strands the magnet as far from the tray as the geometry allows. `base.test.ts` asserts the bore's ceiling is `z = height` at every thickness.
diff --git a/README.md b/README.md
index ba4f334..6fa5ba3 100644
--- a/README.md
+++ b/README.md
@@ -34,6 +34,8 @@ Add miniature groups, choose the available rows and columns, and BaseKit packs m
 
 Modules export as separate STL files in one archive or separate build plates in one 3MF. You can combine groups into one holder, engrave sizes in each slot or once per module, and add matching magnet pockets. Requests that do not fit report the omitted models without blocking the rest of the plan.
 
+Universal trays provide a continuous alternative when a collection changes often. Choose the Gridfinity footprint and shared magnet-grid pitch, then generate bases with the tray-compatible pocket layout so every base magnet lands on the same staggered lattice. The sparse 30mm default reduces tray magnet count, and a smallest-base setting omits perimeter holes where a miniature could not fit on the deck. Automatic base layouts use only the compatible magnets that physically fit at that spacing. Large trays can export as printer-sized Gridfinity pieces while retaining walls remain only around the assembled perimeter. Existing balanced and five-pocket-cross bases remain supported, but cannot guarantee that more than one magnet aligns with a universal tray.
+
 ## Designed for one job 🎯
 
 - Round, oval, pill, rectangle, and regular polygon bases.
diff --git a/e2e/generator.spec.ts b/e2e/generator.spec.ts
index 8b35fd1..debf83a 100644
--- a/e2e/generator.spec.ts
+++ b/e2e/generator.spec.ts
@@ -301,6 +301,37 @@ test('loads the Gridfinity holder directly from its route', { tag: '@ci' }, asyn
   await expect(footer(page)).toContainText('holder-1x4-5x-round-32mm')
 })
 
+test('builds a universal magnetic tray without miniature slots', { tag: '@ci' }, async ({ page }) => {
+  await page.getByRole('link', { name: 'Holders' }).click()
+  await settled(page)
+  const previous = await triangles(page)
+  await pickChoice(page, 'Holder type', 'Universal grid')
+  await rebuilt(page, previous)
+
+  await expect(page.getByText('Universal deck', { exact: true })).toBeVisible()
+  await expect(page.getByText('Miniatures', { exact: true })).not.toBeVisible()
+  await expect(page.getByLabel('Magnet pitch in mm')).toHaveValue('30')
+  await expect(page.getByLabel('Smallest base in mm')).toHaveValue('25')
+  await expect(page.getByRole('switch', { name: 'Tray magnets' })).toBeChecked()
+  await expect(footer(page)).toContainText('universal-tray-7x5-30mm-grid')
+
+  const unsplit = await triangles(page)
+  await page.getByRole('switch', { name: 'Split tray into pieces' }).click()
+  await rebuilt(page, unsplit)
+  await expect(page.getByLabel('Maximum piece columns')).toHaveValue('3')
+  await expect(page.getByLabel('Maximum piece rows')).toHaveValue('3')
+  await expect(page.getByText(/Exports 6 Gridfinity-aligned pieces/)).toBeVisible()
+  await expect(page.getByRole('button', { name: 'Download STLs' })).toBeVisible()
+
+  await page.getByLabel('Magnet pitch in mm').fill('14')
+  await page.getByLabel('Magnet pitch in mm').blur()
+  await expect(footer(page)).toContainText('universal-tray-7x5-14mm-grid')
+  await page.getByRole('link', { name: 'Bases' }).click()
+  await settled(page)
+  await expect(page.getByRole('combobox', { name: 'Pocket layout' })).toContainText('Tray-compatible')
+  await expect(page.getByLabel('Tray grid pitch in mm')).toHaveValue('14')
+})
+
 test('updates integer holder inputs immediately without losing focus', async ({ page }) => {
   await page.getByRole('link', { name: 'Holders' }).click()
   await settled(page)
diff --git a/src/App.tsx b/src/App.tsx
index b9cf628..8c2dcf3 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -9,7 +9,7 @@ import { ScrollArea } from '@/components/ui/scroll-area'
 import { Sheet, SheetContent, SheetHeader, SheetTitle, SheetTrigger } from '@/components/ui/sheet'
 import { TitleBlock } from '@/components/TitleBlock'
 import { Viewer } from '@/components/Viewer'
-import { supportsFivePocketCross } from '@/geometry/base'
+import { supportsFivePocketCross, trayCompatibleMagnetCounts } from '@/geometry/base'
 import {
   defaultHolderConfig,
   holderGroup,
@@ -20,6 +20,7 @@ import {
   maxHolderMagnetThickness,
   maxHolderSlotDepth,
   minHolderHeight,
+  universalMagnetCenters,
 } from '@/geometry/holder'
 import { baseName, defaultLabel, footprint, isElongated, trimNumber } from '@/geometry/outline'
 import {
@@ -69,6 +70,7 @@ const PROFILES: { value: EdgeProfile; label: string }[] = [
 
 const MAGNET_LAYOUTS: { value: MagnetLayout; label: string }[] = [
   { value: 'balanced', label: 'Balanced' },
+  { value: 'lattice', label: 'Tray-compatible' },
   { value: 'five-cross', label: 'Five-pocket cross' },
 ]
 const counts = (values: number[]) => values.map((value) => ({ value, label: value === 0 ? 'None' : String(value) }))
@@ -83,6 +85,10 @@ const ENGRAVING_PLACEMENTS = [
   { value: 'slots' as const, label: 'In slots' },
   { value: 'module' as const, label: 'On module' },
 ]
+const HOLDER_MODES = [
+  { value: 'fitted' as const, label: 'Fitted slots' },
+  { value: 'universal' as const, label: 'Universal grid' },
+]
 const BASE_DEFAULTS = presetFor(DEFAULT_PRESET)
 const HOLDER_DEFAULTS = defaultHolderConfig()
 
@@ -165,6 +171,10 @@ export function App() {
       : { slotDepth: Math.min(next.slotDepth, Math.floor(maxHolderSlotDepth(next) / 0.5) * 0.5) }),
   })
   const plan = useMemo(() => holderPlan(holder), [holder])
+  const universalPocketCount = useMemo(
+    () => plan.modules.reduce((total, module) => total + universalMagnetCenters(module.config).length, 0),
+    [plan],
+  )
   const requestedModels = useMemo(() => holder.groups.reduce((total, group) => total + group.quantity, 0), [holder.groups])
   const fittedByGroup = useMemo(() => {
     const fitted = new Map<string, number>()
@@ -196,7 +206,7 @@ export function App() {
     })
   const partWidth = model === 'base' ? width : holderSize.width
   const partLength = model === 'base' ? length : holderSize.length
-  const partHeight = model === 'base' ? config.height : holder.height
+  const partHeight = model === 'base' ? config.height : holder.height + (holder.mode === 'universal' ? holder.universal.rimHeight : 0)
   const partName = model === 'base' ? baseName(config) : holderName(holder)
   const {
     exporting,
@@ -220,14 +230,15 @@ export function App() {
   const magnetCountValue: MagnetCountChoice = magnetCountOverride ?? AUTOMATIC_MAGNET_COUNT
   const magnetCountOptions: { value: MagnetCountChoice; label: string }[] = [
     { value: AUTOMATIC_MAGNET_COUNT, label: `Auto · ${config.magnets.count}` },
-    ...counts(MAGNET_CHOICES),
+    ...counts(config.magnets.layout === 'lattice' ? trayCompatibleMagnetCounts(config) : MAGNET_CHOICES),
   ]
-  const magnetLayoutOptions =
-    config.magnets.patternVersion === 1 || supportsFivePocketCross(config.shape, config.width) ? MAGNET_LAYOUTS : MAGNET_LAYOUTS.slice(0, 1)
+  const magnetLayoutOptions = MAGNET_LAYOUTS.filter(
+    ({ value }) => value !== 'five-cross' || config.magnets.patternVersion === 1 || supportsFivePocketCross(config.shape, config.width),
+  )
   const holderSupportsFiveCross =
     holder.magnets.patternVersion === 1 || holder.groups.some((group) => supportsFivePocketCross(group.shape, group.width))
-  const holderMagnetLayout = holderSupportsFiveCross ? holder.magnets.layout : 'balanced'
-  const holderMagnetLayoutOptions = holderSupportsFiveCross ? MAGNET_LAYOUTS : MAGNET_LAYOUTS.slice(0, 1)
+  const holderMagnetLayout = holderSupportsFiveCross || holder.magnets.layout !== 'five-cross' ? holder.magnets.layout : 'balanced'
+  const holderMagnetLayoutOptions = MAGNET_LAYOUTS.filter(({ value }) => value !== 'five-cross' || holderSupportsFiveCross)
 
   const loadPreset = (size: SizePreset) => {
     posthog.capture('base_size_selected', { size: size.label, shape: config.shape })
@@ -237,7 +248,7 @@ export function App() {
   }
 
   const setSharedMagnets = (
-    changes: Partial<Pick<BaseConfig['magnets'], 'layout' | 'diameter' | 'thickness' | 'clearance' | 'depthClearance'>>,
+    changes: Partial<Pick<BaseConfig['magnets'], 'layout' | 'latticePitch' | 'diameter' | 'thickness' | 'clearance' | 'depthClearance'>>,
   ) => {
     setWorkspace((current) => ({
       ...current,
@@ -380,6 +391,17 @@ export function App() {
             options={magnetLayoutOptions}
             onChange={(layout) => setSharedMagnets({ layout })}
           />
+          {config.magnets.layout === 'lattice' && (
+            <Dimension
+              label="Tray grid pitch"
+              value={config.magnets.latticePitch}
+              min={Math.ceil(config.magnets.diameter + config.magnets.clearance + 1)}
+              max={30}
+              step={1}
+              defaultValue={BASE_DEFAULTS.magnets.latticePitch}
+              onChange={(latticePitch) => setSharedMagnets({ latticePitch })}
+            />
+          )}
           {config.magnets.layout !== 'five-cross' && (
             <Choice
               label="Magnets per base"
@@ -392,7 +414,9 @@ export function App() {
           <FieldDescription>
             {config.magnets.layout === 'five-cross'
               ? 'The cross always provides one centre and four outer pockets.'
-              : 'Automatic balances the footprint using the selected magnet dimensions.'}
+              : config.magnets.layout === 'lattice'
+                ? 'Every pocket lands on the same staggered lattice as a universal tray.'
+                : 'Automatic balances the footprint using the selected magnet dimensions.'}
           </FieldDescription>
         </Section>
 
@@ -606,7 +630,30 @@ export function App() {
   const holderPanel = (
     <ScrollArea className="h-full w-81 max-w-[85vw] shrink-0 border-border bg-card md:border-r">
       <aside aria-label="Holder settings" className="pb-4 [counter-reset:schedule]">
+        <Section title="Holder type">
+          <Choice
+            label="Holder type"
+            value={holder.mode}
+            defaultValue={HOLDER_DEFAULTS.mode}
+            options={HOLDER_MODES}
+            onChange={(mode) => {
+              posthog.capture('holder_mode_changed', { mode })
+              setWorkspace((current) => ({
+                ...current,
+                holder: { ...current.holder, mode },
+                shared:
+                  mode === 'universal' ? { ...current.shared, magnets: { ...current.shared.magnets, layout: 'lattice' } } : current.shared,
+              }))
+            }}
+          />
+          <FieldDescription>
+            {holder.mode === 'universal'
+              ? 'A continuous deck accepts mixed base sizes wherever their magnets meet the grid.'
+              : 'Recesses locate each configured miniature and match its base magnets.'}
+          </FieldDescription>
+        </Section>
         <Section
+          hidden={holder.mode !== 'fitted'}
           title="Miniatures"
           aside={
             <span className="readout text-xs text-muted-foreground">
@@ -796,7 +843,7 @@ export function App() {
           }
         >
           <Dimension
-            label="Maximum columns"
+            label={holder.mode === 'universal' ? 'Tray columns' : 'Maximum columns'}
             value={holder.maxColumns}
             min={1}
             max={12}
@@ -806,7 +853,7 @@ export function App() {
             onChange={(maxColumns) => setHolder({ ...holder, maxColumns: Math.round(maxColumns) })}
           />
           <Dimension
-            label="Maximum rows"
+            label={holder.mode === 'universal' ? 'Tray rows' : 'Maximum rows'}
             value={holder.maxRows}
             min={1}
             max={12}
@@ -815,35 +862,41 @@ export function App() {
             defaultValue={HOLDER_DEFAULTS.maxRows}
             onChange={(maxRows) => setHolder({ ...holder, maxRows: Math.round(maxRows) })}
           />
-          <Dimension
-            label="Between miniatures"
-            value={holder.spacing}
-            min={0}
-            max={10}
-            step={0.5}
-            defaultValue={HOLDER_DEFAULTS.spacing}
-            onChange={(spacing) => setHolder({ ...holder, spacing })}
-          />
-          <ToggleSetting
-            label="Split into modules"
-            checked={holder.splitGroups}
-            defaultChecked={HOLDER_DEFAULTS.splitGroups}
-            onChange={(splitGroups) => setHolder({ ...holder, splitGroups })}
-          />
-          <div className="space-y-1 border-y border-border py-3 text-xs">
-            {plan.modules.map((module, index) => (
-              <div
-                key={`${module.config.groups[0].id}-${module.column}-${module.row}`}
-                className="flex flex-wrap justify-between gap-x-3 gap-y-1"
-              >
-                <span className="text-muted-foreground">Module {index + 1}</span>
-                <span className="readout text-right">
-                  {module.config.groups.map((group) => `${group.quantity}×${holderGroupLabel(group)}`).join(' + ')} ·{' '}
-                  {module.layout.unitsWide}×{module.layout.unitsDeep}
-                </span>
-              </div>
-            ))}
-          </div>
+          {holder.mode === 'fitted' && (
+            <Dimension
+              label="Between miniatures"
+              value={holder.spacing}
+              min={0}
+              max={10}
+              step={0.5}
+              defaultValue={HOLDER_DEFAULTS.spacing}
+              onChange={(spacing) => setHolder({ ...holder, spacing })}
+            />
+          )}
+          {holder.mode === 'fitted' && (
+            <ToggleSetting
+              label="Split into modules"
+              checked={holder.splitGroups}
+              defaultChecked={HOLDER_DEFAULTS.splitGroups}
+              onChange={(splitGroups) => setHolder({ ...holder, splitGroups })}
+            />
+          )}
+          {holder.mode === 'fitted' && (
+            <div className="space-y-1 border-y border-border py-3 text-xs">
+              {plan.modules.map((module, index) => (
+                <div
+                  key={`${module.config.groups[0]?.id ?? 'universal'}-${module.column}-${module.row}`}
+                  className="flex flex-wrap justify-between gap-x-3 gap-y-1"
+                >
+                  <span className="text-muted-foreground">Module {index + 1}</span>
+                  <span className="readout text-right">
+                    {module.config.groups.map((group) => `${group.quantity}×${holderGroupLabel(group)}`).join(' + ')} ·{' '}
+                    {module.layout.unitsWide}×{module.layout.unitsDeep}
+                  </span>
+                </div>
+              ))}
+            </div>
+          )}
           <Dimension
             label="Holder height"
             value={holder.height}
@@ -855,41 +908,134 @@ export function App() {
           />
         </Section>
 
-        <Section title="Slots" aside={<span className="readout text-xs text-muted-foreground">{trimNumber(holder.slotDepth)}mm deep</span>}>
-          <Dimension
-            label="Slot depth"
-            value={holder.slotDepth}
-            min={1}
-            max={maxSlotDepth}
-            step={0.5}
-            defaultValue={HOLDER_DEFAULTS.slotDepth}
-            onChange={(slotDepth) => setHolder({ ...holder, slotDepth })}
-          />
-          <Dimension
-            label="Slot clearance"
-            value={holder.slotClearance}
-            min={0.1}
-            max={2}
-            step={0.1}
-            defaultValue={HOLDER_DEFAULTS.slotClearance}
-            onChange={(slotClearance) => setHolder({ ...holder, slotClearance })}
-          />
-          <ToggleSetting
-            label="Size labels"
-            checked={holder.engraving.enabled}
-            defaultChecked={HOLDER_DEFAULTS.engraving.enabled}
-            onChange={setSharedLabels}
-          />
-          {holder.engraving.enabled && (
-            <Choice
-              label="Label location"
-              value={holder.engraving.placement}
-              defaultValue={HOLDER_DEFAULTS.engraving.placement}
-              options={ENGRAVING_PLACEMENTS}
-              onChange={(placement) => setHolder(fitSlotDepth({ ...holder, engraving: { ...holder.engraving, placement } }))}
+        {holder.mode === 'fitted' ? (
+          <Section
+            title="Slots"
+            aside={<span className="readout text-xs text-muted-foreground">{trimNumber(holder.slotDepth)}mm deep</span>}
+          >
+            <Dimension
+              label="Slot depth"
+              value={holder.slotDepth}
+              min={1}
+              max={maxSlotDepth}
+              step={0.5}
+              defaultValue={HOLDER_DEFAULTS.slotDepth}
+              onChange={(slotDepth) => setHolder({ ...holder, slotDepth })}
             />
-          )}
-        </Section>
+            <Dimension
+              label="Slot clearance"
+              value={holder.slotClearance}
+              min={0.1}
+              max={2}
+              step={0.1}
+              defaultValue={HOLDER_DEFAULTS.slotClearance}
+              onChange={(slotClearance) => setHolder({ ...holder, slotClearance })}
+            />
+            <ToggleSetting
+              label="Size labels"
+              checked={holder.engraving.enabled}
+              defaultChecked={HOLDER_DEFAULTS.engraving.enabled}
+              onChange={setSharedLabels}
+            />
+            {holder.engraving.enabled && (
+              <Choice
+                label="Label location"
+                value={holder.engraving.placement}
+                defaultValue={HOLDER_DEFAULTS.engraving.placement}
+                options={ENGRAVING_PLACEMENTS}
+                onChange={(placement) => setHolder(fitSlotDepth({ ...holder, engraving: { ...holder.engraving, placement } }))}
+              />
+            )}
+          </Section>
+        ) : (
+          <Section
+            title="Universal deck"
+            aside={<span className="readout text-xs text-muted-foreground">{universalPocketCount} pockets</span>}
+          >
+            <FieldDescription>The staggered grid is the canonical lattice used by tray-compatible bases.</FieldDescription>
+            <Dimension
+              label="Magnet pitch"
+              value={holder.universal.pitch}
+              min={Math.ceil(holder.magnets.diameter + holder.magnets.clearance + 1)}
+              max={40}
+              step={1}
+              defaultValue={HOLDER_DEFAULTS.universal.pitch}
+              onChange={(latticePitch) => setSharedMagnets({ latticePitch })}
+            />
+            <Dimension
+              label="Smallest base"
+              value={holder.universal.minimumBaseSize}
+              min={20}
+              max={50}
+              step={1}
+              defaultValue={HOLDER_DEFAULTS.universal.minimumBaseSize}
+              onChange={(minimumBaseSize) => setHolder({ ...holder, universal: { ...holder.universal, minimumBaseSize } })}
+            />
+            <Dimension
+              label="Retaining rim height"
+              value={holder.universal.rimHeight}
+              min={0}
+              max={10}
+              step={0.5}
+              defaultValue={HOLDER_DEFAULTS.universal.rimHeight}
+              onChange={(rimHeight) => setHolder({ ...holder, universal: { ...holder.universal, rimHeight } })}
+            />
+            {holder.universal.rimHeight > 0 && (
+              <Dimension
+                label="Retaining rim thickness"
+                value={holder.universal.rimThickness}
+                min={1.2}
+                max={5}
+                step={0.2}
+                defaultValue={HOLDER_DEFAULTS.universal.rimThickness}
+                onChange={(rimThickness) => setHolder({ ...holder, universal: { ...holder.universal, rimThickness } })}
+              />
+            )}
+            <ToggleSetting
+              label="Split tray into pieces"
+              checked={holder.universal.split}
+              defaultChecked={HOLDER_DEFAULTS.universal.split}
+              onChange={(split) => setHolder({ ...holder, universal: { ...holder.universal, split } })}
+            />
+            {holder.universal.split && (
+              <>
+                <Dimension
+                  label="Maximum piece columns"
+                  value={holder.universal.maxPieceColumns}
+                  min={1}
+                  max={holder.maxColumns}
+                  step={1}
+                  unit=""
+                  defaultValue={HOLDER_DEFAULTS.universal.maxPieceColumns}
+                  onChange={(maxPieceColumns) =>
+                    setHolder({
+                      ...holder,
+                      universal: { ...holder.universal, maxPieceColumns: Math.round(maxPieceColumns) },
+                    })
+                  }
+                />
+                <Dimension
+                  label="Maximum piece rows"
+                  value={holder.universal.maxPieceRows}
+                  min={1}
+                  max={holder.maxRows}
+                  step={1}
+                  unit=""
+                  defaultValue={HOLDER_DEFAULTS.universal.maxPieceRows}
+                  onChange={(maxPieceRows) =>
+                    setHolder({ ...holder, universal: { ...holder.universal, maxPieceRows: Math.round(maxPieceRows) } })
+                  }
+                />
+                <FieldDescription>
+                  Exports {plan.modules.length} Gridfinity-aligned pieces. Retaining walls remain only around the assembled perimeter.
+                </FieldDescription>
+              </>
+            )}
+            <FieldDescription>
+              Smaller pitch increases the chance of alignment, but also the number, weight, and cost of magnets.
+            </FieldDescription>
+          </Section>
+        )}
 
         <Section
           title="Magnets"
@@ -900,20 +1046,22 @@ export function App() {
           }
         >
           <ToggleSetting
-            label="Slot magnets"
+            label={holder.mode === 'universal' ? 'Tray magnets' : 'Slot magnets'}
             checked={holder.magnets.enabled}
             defaultChecked={HOLDER_DEFAULTS.magnets.enabled}
             onChange={(enabled) => setHolder(fitSlotDepth({ ...holder, magnets: { ...holder.magnets, enabled } }))}
           />
           {holder.magnets.enabled && (
             <>
-              <Choice
-                label="Pocket layout"
-                value={holderMagnetLayout}
-                defaultValue={HOLDER_DEFAULTS.magnets.layout}
-                options={holderMagnetLayoutOptions}
-                onChange={(layout) => setSharedMagnets({ layout })}
-              />
+              {holder.mode === 'fitted' && (
+                <Choice
+                  label="Pocket layout"
+                  value={holderMagnetLayout}
+                  defaultValue={HOLDER_DEFAULTS.magnets.layout}
+                  options={holderMagnetLayoutOptions}
+                  onChange={(layout) => setSharedMagnets({ layout })}
+                />
+              )}
               <Dimension
                 label="Magnet diameter"
                 value={holder.magnets.diameter}
@@ -950,7 +1098,11 @@ export function App() {
                 defaultValue={HOLDER_DEFAULTS.magnets.depthClearance}
                 onChange={(depthClearance) => setSharedMagnets({ depthClearance })}
               />
-              <FieldDescription>Automatic base recommendations also apply to matching holder slots.</FieldDescription>
+              <FieldDescription>
+                {holder.mode === 'universal'
+                  ? 'Install every tray magnet with the same pole facing up, opposite to the tray-facing pole on every base.'
+                  : 'Automatic base recommendations also apply to matching holder slots.'}
+              </FieldDescription>
             </>
           )}
         </Section>
diff --git a/src/components/controls.tsx b/src/components/controls.tsx
index 9f9614f..10b5d64 100644
--- a/src/components/controls.tsx
+++ b/src/components/controls.tsx
@@ -6,9 +6,9 @@ import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@
 import { Switch } from '@/components/ui/switch'
 
 /** A group of always-visible controls, with an optional figure in the header. */
-export function Section({ title, children, aside }: { title: string; children: ReactNode; aside?: ReactNode }) {
+export function Section({ title, children, aside, hidden }: { title: string; children: ReactNode; aside?: ReactNode; hidden?: boolean }) {
   return (
-    <FieldSet className="gap-3 border-t border-border px-5 py-4">
+    <FieldSet hidden={hidden} className="gap-3 border-t border-border px-5 py-4">
       <div className="flex items-baseline justify-between gap-2">
         <FieldLegend variant="label" className="note schedule-index mb-0">
           {title}
diff --git a/src/geometry/base.test.ts b/src/geometry/base.test.ts
index 95309ce..804d630 100644
--- a/src/geometry/base.test.ts
+++ b/src/geometry/base.test.ts
@@ -2,7 +2,7 @@ import { readFileSync } from 'node:fs'
 import type { Mesh } from 'manifold-3d'
 import { parse, type Font } from 'opentype.js'
 import { beforeAll, describe, expect, it } from 'vitest'
-import { buildBase, magnetPositions, ribAngles } from './base'
+import { buildBase, magnetPositions, ribAngles, trayCompatibleMagnetCounts } from './base'
 import { toStl } from './exporters'
 import { LABEL_MARGIN, pointInContours } from './label'
 import { loadManifold } from './manifold'
@@ -461,6 +461,49 @@ describe('rib placement', () => {
   })
 })
 
+describe('tray-compatible magnet placement', () => {
+  const pitch = 15
+  const rowPitch = (pitch * Math.sqrt(3)) / 2
+  const isLatticeNode = ({ x, y }: { x: number; y: number }) => {
+    const row = y / rowPitch
+    const column = x / pitch - row / 2
+    return Math.abs(row - Math.round(row)) < 1e-6 && Math.abs(column - Math.round(column)) < 1e-6
+  }
+
+  it.each([1, 2, 3, 4, 5, 6, 8])('places all %s round-base magnets on the canonical staggered lattice', (count) => {
+    const magnets = magnetPositions(count, 90, 90, 4, { layout: 'lattice', latticePitch: pitch })
+    expect(magnets).toHaveLength(count)
+    expect(magnets.every(isLatticeNode)).toBe(true)
+  })
+
+  it.each([1, 2, 4, 6, 8])('places all %s elongated-base magnets on the canonical staggered lattice', (count) => {
+    const magnets = magnetPositions(count, 90, 30, 4, { layout: 'lattice', latticePitch: pitch })
+    expect(magnets).toHaveLength(count)
+    expect(magnets.every(isLatticeNode)).toBe(true)
+  })
+
+  it('runs a rib through every tray-compatible magnet boss', () => {
+    const magnets = magnetPositions(8, 90, 90, 4, { layout: 'lattice', latticePitch: pitch })
+    const spokes = ribAngles(8, magnets, true)
+    const clearance = (angle: number, boss: { x: number; y: number }) => Math.abs(-Math.sin(angle) * boss.x + Math.cos(angle) * boss.y)
+    expect(magnets.every((boss) => spokes.some((angle) => clearance(angle, boss) < 1e-6))).toBe(true)
+  })
+
+  it('rejects a pitch that cannot fit the requested magnets', () => {
+    expect(() => magnetPositions(3, 20, 20, 4, { layout: 'lattice', latticePitch: 20 })).toThrow('Tray-compatible magnet pitch is too wide')
+  })
+
+  it.each([...ROUND_SIZES, ...POLYGON_SIZES, ...OVAL_SIZES, ...PILL_SIZES, ...RECT_SIZES].map((size) => [size.label, size] as const))(
+    'builds the standard %s footprint with its tray-compatible automatic count',
+    (_label, size) => {
+      const config = presetFor(size)
+      config.magnets.layout = 'lattice'
+      config.magnets.count = trayCompatibleMagnetCounts(config).findLast((count) => count <= config.magnets.count)!
+      expect(buildBase(wasm, config, font).stats.solid).toBe(true)
+    },
+  )
+})
+
 describe('scaling with the footprint', () => {
   const rounds = ROUND_SIZES.map((size) => presetFor(size))
 
diff --git a/src/geometry/base.ts b/src/geometry/base.ts
index e95c4fb..7c5a90c 100644
--- a/src/geometry/base.ts
+++ b/src/geometry/base.ts
@@ -25,6 +25,66 @@ export interface Circle {
 interface MagnetPositionOptions {
   ellipticalRow?: boolean
   layout?: MagnetLayout
+  latticePitch?: number
+}
+
+const latticePoint = (column: number, row: number, pitch: number): Circle => ({
+  x: (column + row / 2) * pitch,
+  y: row * pitch * (Math.sqrt(3) / 2),
+  r: 0,
+})
+
+function latticeMagnetPositions(count: number, halfWidth: number, halfLength: number, clear: number, pitch: number): Circle[] {
+  const elongated = !magnetsRing(halfWidth, halfLength)
+  let points: Circle[]
+  if (elongated) {
+    const pairs = Math.floor(count / 2)
+    const alongX = halfWidth >= halfLength
+    points = count % 2 === 1 ? [{ x: 0, y: 0, r: 0 }] : []
+    for (let level = 1; level <= pairs; level++) {
+      points.push(
+        { x: alongX ? -level * pitch : 0, y: alongX ? 0 : -level * pitch, r: 0 },
+        { x: alongX ? level * pitch : 0, y: alongX ? 0 : level * pitch, r: 0 },
+      )
+    }
+  } else {
+    const hex = [
+      latticePoint(1, 0, pitch),
+      latticePoint(0, 1, pitch),
+      latticePoint(-1, 1, pitch),
+      latticePoint(-1, 0, pitch),
+      latticePoint(0, -1, pitch),
+      latticePoint(1, -1, pitch),
+    ]
+    const cross = [latticePoint(1, 0, pitch), latticePoint(-1, 0, pitch), latticePoint(-1, 2, pitch), latticePoint(1, -2, pitch)]
+    if (count === 1) points = [{ x: 0, y: 0, r: 0 }]
+    else if (count === 2) points = [hex[0], hex[3]]
+    else if (count === 3) points = [hex[0], hex[2], hex[4]]
+    else if (count === 4) points = cross
+    else if (count === 5) points = [{ x: 0, y: 0, r: 0 }, ...cross]
+    else if (count === 6) points = hex
+    else if (count === 8) points = [...hex, latticePoint(2, 0, pitch), latticePoint(-2, 0, pitch)]
+    else throw new Error(`The tray-compatible layout does not support ${count} magnets`)
+  }
+  if (points.some(({ x, y }) => Math.abs(x) > halfWidth - clear + 1e-6 || Math.abs(y) > halfLength - clear + 1e-6)) {
+    throw new Error('Tray-compatible magnet pitch is too wide for this base and magnet count')
+  }
+  return points
+}
+
+export function trayCompatibleMagnetCounts(config: BaseConfig): number[] {
+  const halfWidth = Math.max(0, config.width / 2 - config.wallThickness)
+  const halfLength = Math.max(0, config.length / 2 - config.wallThickness)
+  const clear = (config.magnets.diameter + config.magnets.clearance) / 2 + config.magnets.bossWall + LABEL_MARGIN
+  return [0, 1, 2, 3, 4, 5, 6, 8].filter((count) => {
+    if (count === 0) return true
+    try {
+      latticeMagnetPositions(count, halfWidth, halfLength, clear, config.magnets.latticePitch)
+      return true
+    } catch {
+      return false
+    }
+  })
 }
 
 /** Whether magnets sit on a ring, rather than in a row down the long axis. */
@@ -48,6 +108,9 @@ export function magnetPositions(
   options: MagnetPositionOptions = {},
 ): Circle[] {
   if (count <= 0) return []
+  if (options.layout === 'lattice') {
+    return latticeMagnetPositions(count, halfWidth, halfLength, clear, options.latticePitch ?? 15)
+  }
   if (options.layout === 'five-cross') {
     return [{ x: 0, y: 0, r: 0 }, ...magnetPositions(4, halfWidth, halfLength, clear, { ...options, layout: 'balanced' })]
   }
@@ -100,13 +163,21 @@ function angleBetween(a: number, b: number): number {
  * lands closest to the rest wins. A single central magnet has no bearing at
  * all, and every rib meets it at the centre regardless.
  */
-export function ribAngles(count: number, magnets: Circle[]): number[] {
+export function ribAngles(count: number, magnets: Circle[], followMagnets = false): number[] {
   if (count <= 0) return []
   const spacing = TAU / count
   const spokes = (phase: number) => Array.from({ length: count }, (_, i) => phase + spacing * i)
 
   const bosses = magnets.filter((m) => Math.hypot(m.x, m.y) > 1e-6).map((m) => Math.atan2(m.y, m.x))
   if (bosses.length === 0) return spokes(Math.PI / 2)
+  if (followMagnets) {
+    const result = bosses.filter((bearing, index) => bosses.findIndex((candidate) => angleBetween(candidate, bearing) < 1e-6) === index)
+    for (const candidate of spokes(Math.PI / 2)) {
+      if (result.length >= count) break
+      if (result.every((bearing) => angleBetween(bearing, candidate) > 1e-6)) result.push(candidate)
+    }
+    return result.slice(0, count)
+  }
 
   let best = bosses[0]
   let closest = Infinity
@@ -187,7 +258,8 @@ export function buildBase(wasm: ManifoldToplevel, config: BaseConfig, font?: Fon
       config.magnets.layout === 'five-cross' && (config.magnets.patternVersion === 1 || supportsFivePocketCross(config.shape, config.width))
     const magnets = magnetPositions(config.magnets.count, halfWidth, halfLength, bossRadius + LABEL_MARGIN, {
       ellipticalRow: config.shape === 'oval',
-      layout: fiveCross ? 'five-cross' : 'balanced',
+      layout: fiveCross ? 'five-cross' : config.magnets.layout === 'lattice' ? 'lattice' : 'balanced',
+      latticePitch: config.magnets.latticePitch,
     })
 
     /*
@@ -209,7 +281,7 @@ export function buildBase(wasm: ManifoldToplevel, config: BaseConfig, font?: Fon
 
     // Single spokes from the centre outwards, phased to run through the bosses.
     // Intersecting the well stops them at the wall.
-    const spokeAngles = ribAngles(config.ribs.count, magnets)
+    const spokeAngles = ribAngles(config.ribs.count, magnets, config.magnets.layout === 'lattice')
     const ribHeight = Math.min(config.ribs.height, wellDepth)
     if (spokeAngles.length > 0 && ribHeight > 0) {
       const reach = wellReach + config.wallThickness
diff --git a/src/geometry/holder.test.ts b/src/geometry/holder.test.ts
index 77d82b6..1759990 100644
--- a/src/geometry/holder.test.ts
+++ b/src/geometry/holder.test.ts
@@ -13,6 +13,7 @@ import {
   maxHolderMagnetThickness,
   maxHolderSlotDepth,
   minHolderHeight,
+  universalMagnetCenters,
 } from './holder'
 import { loadManifold } from './manifold'
 
@@ -293,9 +294,113 @@ describe('holderPlan', () => {
     }
     expect(holderPlan(config).modules).toHaveLength(1)
   })
+
+  it('splits a universal tray to the requested printable piece size', () => {
+    const defaults = defaultHolderConfig()
+    const config = {
+      ...defaults,
+      mode: 'universal' as const,
+      maxColumns: 7,
+      maxRows: 5,
+      universal: { ...defaults.universal, split: true, maxPieceColumns: 3, maxPieceRows: 3 },
+    }
+    const plan = holderPlan(config)
+
+    expect(plan.modules.map(({ layout }) => `${layout.unitsWide}x${layout.unitsDeep}`)).toEqual(['3x3', '3x3', '1x3', '3x2', '3x2', '1x2'])
+    expect(plan.modules.map(({ column, row }) => `${column},${row}`)).toEqual(['0,0', '3,0', '6,0', '0,3', '3,3', '6,3'])
+    expect(plan.modules[0].config.universal.rimEdges).toEqual({ left: true, right: false, front: true, back: false })
+    expect(plan.modules[4].config.universal.rimEdges).toEqual({ left: false, right: false, front: false, back: true })
+    expect(plan.modules[5].config.universal.rimEdges).toEqual({ left: false, right: true, front: false, back: true })
+    const pitch = config.universal.pitch
+    const rowPitch = (pitch * Math.sqrt(3)) / 2
+    for (const module of plan.modules) {
+      for (const point of universalMagnetCenters(module.config)) {
+        const globalX = point.x + module.config.universal.latticeOffset.x
+        const globalY = point.y + module.config.universal.latticeOffset.y
+        const latticeRow = globalY / rowPitch
+        const latticeColumn = globalX / pitch - latticeRow / 2
+        expect(latticeRow).toBeCloseTo(Math.round(latticeRow), 6)
+        expect(latticeColumn).toBeCloseTo(Math.round(latticeColumn), 6)
+      }
+    }
+  })
+
+  it('does not split a universal tray until piece splitting is enabled', () => {
+    const defaults = defaultHolderConfig()
+    const config = { ...defaults, mode: 'universal' as const, maxColumns: 7, maxRows: 5 }
+    expect(holderPlan(config).modules).toHaveLength(1)
+  })
 })
 
 describe('buildHolder', () => {
+  it('builds a universal magnetic deck across the requested Gridfinity footprint', () => {
+    const defaults = defaultHolderConfig()
+    const config = { ...defaults, mode: 'universal' as const, maxColumns: 2, maxRows: 2 }
+    const centers = universalMagnetCenters(config)
+    const result = buildHolder(wasm, config)
+
+    expect(centers).toHaveLength(5)
+    expect(result.stats.solid).toBe(true)
+    expect(bounds(result.mesh).size).toEqual([83.5, 83.5, 17])
+    expect(holderPlan(config)).toMatchObject({ unitsWide: 2, unitsDeep: 2, omitted: [], modules: [{ layout: { slotCenters: [] } }] })
+  })
+
+  it('keeps the default universal tray sparse', () => {
+    const defaults = defaultHolderConfig()
+    expect(holderMagnetPocketCount({ ...defaults, mode: 'universal' })).toBe(59)
+  })
+
+  it('keeps universal pockets within the retaining rim and rejects overlapping grids', () => {
+    const defaults = defaultHolderConfig()
+    const config = { ...defaults, mode: 'universal' as const, maxColumns: 1, maxRows: 1 }
+    const edge = 41.5 / 2 - config.universal.minimumBaseSize / 2
+
+    expect(universalMagnetCenters(config).every(({ x, y }) => Math.abs(x) <= edge && Math.abs(y) <= edge)).toBe(true)
+    expect(() => buildHolder(wasm, { ...config, universal: { ...config.universal, pitch: 6 } })).toThrow(
+      'Magnet grid pitch leaves too little material between pockets',
+    )
+  })
+
+  it('applies the base-fit margin only to the assembled perimeter, not split seams', () => {
+    const defaults = defaultHolderConfig()
+    const config = {
+      ...defaults,
+      mode: 'universal' as const,
+      maxColumns: 4,
+      maxRows: 5,
+      universal: { ...defaults.universal, split: true, maxPieceColumns: 2, maxPieceRows: 5, minimumBaseSize: 40 },
+    }
+    const leftModule = holderPlan(config).modules[0]
+    const centers = universalMagnetCenters(leftModule.config)
+    const distanceFromInternalEdge = Math.min(...centers.map(({ x }) => leftModule.layout.width / 2 - x))
+    expect(leftModule.config.universal.rimEdges.right).toBe(false)
+    expect(distanceFromInternalEdge).toBeLessThan(config.universal.minimumBaseSize / 2)
+  })
+
+  it('opens universal magnet pockets flush with the deck', () => {
+    const defaults = defaultHolderConfig()
+    const config = {
+      ...defaults,
+      mode: 'universal' as const,
+      maxColumns: 1,
+      maxRows: 1,
+      universal: { ...defaults.universal, pitch: 40, rimHeight: 0 },
+    }
+    const { mesh } = buildHolder(wasm, config)
+    const { numProp, vertProperties } = mesh
+    const radius = (config.magnets.diameter + config.magnets.clearance) / 2
+    let minZ = Infinity
+    let maxZ = -Infinity
+    for (let i = 0; i < vertProperties.length; i += numProp) {
+      if (Math.hypot(vertProperties[i], vertProperties[i + 1]) <= radius + 0.05) {
+        minZ = Math.min(minZ, vertProperties[i + 2])
+        maxZ = Math.max(maxZ, vertProperties[i + 2])
+      }
+    }
+    expect(minZ).toBeCloseTo(config.height - config.magnets.thickness - config.magnets.depthClearance, 2)
+    expect(maxZ).toBeCloseTo(config.height, 2)
+  })
+
   it('builds a solid with the exact Gridfinity footprint and requested height', () => {
     const config = defaultHolderConfig()
     const result = buildHolder(wasm, config)
diff --git a/src/geometry/holder.ts b/src/geometry/holder.ts
index 7a4c334..f15428f 100644
--- a/src/geometry/holder.ts
+++ b/src/geometry/holder.ts
@@ -70,6 +70,7 @@ const DEFAULT_MAGNET_SETTINGS: HolderMagnetSettings = {
     layout: 'balanced',
     patternVersion: 2,
     maxCount: 8,
+    latticePitch: 30,
     diameter: 5,
     clearance: 0.2,
     depthClearance: 0.1,
@@ -160,11 +161,14 @@ export function holderSlotMagnetCenters(
   const halfLength = Math.max(0, slotLength(slot) / 2 - settings.baseWallThickness)
   return magnetPositions(count, halfWidth, halfLength, bossRadius + LABEL_MARGIN, {
     ellipticalRow: slot.shape === 'oval',
-    layout: fiveCross ? 'five-cross' : 'balanced',
+    layout: fiveCross ? 'five-cross' : settings.magnets.layout === 'lattice' ? 'lattice' : 'balanced',
+    latticePitch: settings.magnets.latticePitch,
   }).map(({ x, y }) => ({ x, y }))
 }
 
 export function holderMagnetPocketCount(config: HolderConfig): number {
+  if (config.mode === 'universal')
+    return holderPlan(config).modules.reduce((total, module) => total + universalMagnetCenters(module.config).length, 0)
   return holderLayout(config).slotCenters.reduce((total, slot) => total + holderSlotMagnetCenters(slot, config).length, 0)
 }
 
@@ -206,13 +210,15 @@ export function maxHolderSlotDepth(config: HolderConfig): number {
 }
 
 export function maxHolderMagnetThickness(config: HolderConfig): number {
-  return config.height - config.slotDepth - PROFILE.at(-1)!.z - MIN_SLOT_FLOOR_THICKNESS - config.magnets.depthClearance
+  const deckDepth = config.mode === 'universal' ? 0 : config.slotDepth
+  return config.height - deckDepth - PROFILE.at(-1)!.z - MIN_SLOT_FLOOR_THICKNESS - config.magnets.depthClearance
 }
 
 export function minHolderHeight(config: HolderConfig): number {
   const engravingDepth = config.engraving.enabled && config.engraving.placement === 'slots' ? ENGRAVING_DEPTH : 0
   const magnetDepth = config.magnets.enabled ? config.magnets.thickness + config.magnets.depthClearance : 0
-  const required = PROFILE.at(-1)!.z + MIN_SLOT_FLOOR_THICKNESS + config.slotDepth + Math.max(engravingDepth, magnetDepth)
+  const deckDepth = config.mode === 'universal' ? 0 : config.slotDepth
+  const required = PROFILE.at(-1)!.z + MIN_SLOT_FLOOR_THICKNESS + deckDepth + Math.max(engravingDepth, magnetDepth)
   return Math.max(BASE_HEIGHT, Math.ceil((required - 1e-6) / BASE_HEIGHT) * BASE_HEIGHT)
 }
 
@@ -503,6 +509,56 @@ export function holderPlan(config: HolderConfig): HolderPlan {
   const key = JSON.stringify(config)
   const cached = planCache.get(key)
   if (cached) return cached
+  if (config.mode === 'universal') {
+    const unitsWide = columns
+    const unitsDeep = rows
+    const pieceColumns = config.universal.split ? Math.max(1, Math.round(config.universal.maxPieceColumns)) : unitsWide
+    const pieceRows = config.universal.split ? Math.max(1, Math.round(config.universal.maxPieceRows)) : unitsDeep
+    const modules: HolderModule[] = []
+    for (let row = 0; row < unitsDeep; row += pieceRows) {
+      const moduleRows = Math.min(pieceRows, unitsDeep - row)
+      for (let column = 0; column < unitsWide; column += pieceColumns) {
+        const moduleColumns = Math.min(pieceColumns, unitsWide - column)
+        const layout = {
+          unitsWide: moduleColumns,
+          unitsDeep: moduleRows,
+          width: moduleColumns * GRID - GAP,
+          length: moduleRows * GRID - GAP,
+          slotCenters: [],
+        }
+        modules.push({
+          config: {
+            ...config,
+            maxColumns: moduleColumns,
+            maxRows: moduleRows,
+            universal: {
+              ...config.universal,
+              split: false,
+              rimEdges: {
+                left: column === 0,
+                right: column + moduleColumns === unitsWide,
+                front: row === 0,
+                back: row + moduleRows === unitsDeep,
+              },
+              latticeOffset: {
+                x: (column + moduleColumns / 2 - unitsWide / 2) * GRID,
+                y: (row + moduleRows / 2 - unitsDeep / 2) * GRID,
+              },
+            },
+          },
+          layout,
+          column,
+          row,
+        })
+      }
+    }
+    return cacheResult(planCache, key, {
+      modules,
+      omitted: [],
+      unitsWide,
+      unitsDeep,
+    })
+  }
   const addOmitted = (omitted: HolderGroup[], group: HolderGroup, quantity: number) => {
     if (quantity <= 0) return
     const existing = omitted.find((entry) => entry.id === group.id)
@@ -630,6 +686,7 @@ export function holderLayout(config: HolderConfig): HolderLayout {
 export function defaultHolderConfig(): HolderConfig {
   return {
     kind: 'holder',
+    mode: 'fitted',
     groups: [holderGroup('models-1', 5, { width: 32 })],
     maxColumns: 7,
     maxRows: 5,
@@ -639,6 +696,18 @@ export function defaultHolderConfig(): HolderConfig {
     slotClearance: 0.5,
     slotDepth: 3,
     height: 14,
+    universal: {
+      pitch: 30,
+      layout: 'staggered',
+      rimHeight: 3,
+      rimThickness: 2,
+      split: false,
+      maxPieceColumns: 3,
+      maxPieceRows: 3,
+      minimumBaseSize: 25,
+      rimEdges: { left: true, right: true, front: true, back: true },
+      latticeOffset: { x: 0, y: 0 },
+    },
     ...DEFAULT_MAGNET_SETTINGS,
     magnets: { ...DEFAULT_MAGNET_SETTINGS.magnets },
     magnetCounts: { ...DEFAULT_MAGNET_SETTINGS.magnetCounts },
@@ -648,10 +717,47 @@ export function defaultHolderConfig(): HolderConfig {
 
 export function holderName(config: HolderConfig): string {
   const layout = holderLayout(config)
+  if (config.mode === 'universal')
+    return `universal-tray-${layout.unitsWide}x${layout.unitsDeep}-${trimNumber(config.universal.pitch)}mm-grid`
   const models = config.groups.map(holderGroupNamePart).join('-')
   return `holder-${layout.unitsWide}x${layout.unitsDeep}-${models}`
 }
 
+export function universalMagnetCenters(config: HolderConfig): { x: number; y: number }[] {
+  if (!config.magnets.enabled) return []
+  const layout = holderLayout(config)
+  const radius = (config.magnets.diameter + config.magnets.clearance) / 2
+  const openMargin = radius + 1
+  const rimMargin = config.universal.rimThickness + radius + 0.5
+  const attachmentMargin = config.universal.minimumBaseSize / 2
+  const edgeMargin = (hasRim: boolean) =>
+    hasRim ? Math.max(attachmentMargin, config.universal.rimHeight > 0 ? rimMargin : openMargin) : openMargin
+  const left = edgeMargin(config.universal.rimEdges.left)
+  const right = edgeMargin(config.universal.rimEdges.right)
+  const front = edgeMargin(config.universal.rimEdges.front)
+  const back = edgeMargin(config.universal.rimEdges.back)
+  const minX = config.universal.latticeOffset.x - layout.width / 2 + left
+  const maxX = config.universal.latticeOffset.x + layout.width / 2 - right
+  const minY = config.universal.latticeOffset.y - layout.length / 2 + front
+  const maxY = config.universal.latticeOffset.y + layout.length / 2 - back
+  if (minX > maxX || minY > maxY) return []
+  const pitch = config.universal.pitch
+  const pitchY = config.universal.layout === 'staggered' ? (pitch * Math.sqrt(3)) / 2 : pitch
+  const centers: { x: number; y: number }[] = []
+  for (let row = Math.ceil(minY / pitchY); row <= Math.floor(maxY / pitchY); row++) {
+    const offset = config.universal.layout === 'staggered' ? row * pitch * 0.5 : 0
+    const firstColumn = Math.ceil((minX - offset) / pitch)
+    const lastColumn = Math.floor((maxX - offset) / pitch)
+    for (let column = firstColumn; column <= lastColumn; column++) {
+      centers.push({
+        x: column * pitch + offset - config.universal.latticeOffset.x,
+        y: row * pitchY - config.universal.latticeOffset.y,
+      })
+    }
+  }
+  return centers
+}
+
 function slotOutline(wasm: ManifoldToplevel, slot: HolderSlot, clearance: number, segments: number): CrossSection {
   const { CrossSection } = wasm
   const width = slotWidth(slot) + clearance
@@ -688,10 +794,23 @@ function buildSingleHolder(wasm: ManifoldToplevel, config: HolderConfig, font?:
   try {
     if (config.maxColumns < 1 || config.maxRows < 1) throw new Error('A holder needs at least one allowed row and column')
     if (config.height < BASE_HEIGHT) throw new Error('Holder height must be at least one Gridfinity unit')
-    if (config.slotDepth > maxHolderSlotDepth(config)) throw new Error('Slots leave too little material above the Gridfinity foot')
+    if (config.mode === 'fitted' && config.slotDepth > maxHolderSlotDepth(config))
+      throw new Error('Slots leave too little material above the Gridfinity foot')
+    if (config.mode === 'universal' && config.universal.pitch < config.magnets.diameter + config.magnets.clearance + 1)
+      throw new Error('Magnet grid pitch leaves too little material between pockets')
 
-    const layout = singleHolderLayout(config)
-    if (layout.slotCenters.length === 0) throw new Error('Miniatures do not fit within the maximum Gridfinity rows and columns')
+    const layout =
+      config.mode === 'universal'
+        ? {
+            unitsWide: Math.max(1, Math.round(config.maxColumns)),
+            unitsDeep: Math.max(1, Math.round(config.maxRows)),
+            width: Math.max(1, Math.round(config.maxColumns)) * GRID - GAP,
+            length: Math.max(1, Math.round(config.maxRows)) * GRID - GAP,
+            slotCenters: [],
+          }
+        : singleHolderLayout(config)
+    if (config.mode === 'fitted' && layout.slotCenters.length === 0)
+      throw new Error('Miniatures do not fit within the maximum Gridfinity rows and columns')
     const tolerance = curveTolerance(Math.max(layout.width, layout.length), config.segments)
     const preview = config.segments <= 256
     const segmentsFor = (diameter: number, previewMinimum: number) =>
@@ -726,6 +845,43 @@ function buildSingleHolder(wasm: ManifoldToplevel, config: HolderConfig, font?:
     const raisedBridge = solidOf(bridge.translate([0, 0, PROFILE.at(-1)!.z]))
     let solid = solidOf(Manifold.union([...feet, raisedBridge]))
 
+    if (config.mode === 'universal') {
+      const cutters: Manifold[] = []
+      if (config.magnets.enabled) {
+        const radius = (config.magnets.diameter + config.magnets.clearance) / 2
+        const disc = section(CrossSection.circle(radius, segmentsFor(radius * 2, 32)))
+        const outlines = universalMagnetCenters(config).map(({ x, y }) => section(disc.translate([x, y])))
+        if (outlines.length > 0) {
+          const pockets = section(CrossSection.union(outlines))
+          const depth = config.magnets.thickness + config.magnets.depthClearance
+          const drill = solidOf(pockets.extrude(depth + 0.001))
+          cutters.push(solidOf(drill.translate([0, 0, config.height - depth])))
+        }
+      }
+      if (cutters.length > 0) solid = solidOf(Manifold.difference([solid, ...cutters]))
+      if (config.universal.rimHeight > 0) {
+        const { rimThickness: thickness, rimEdges } = config.universal
+        const bars: CrossSection[] = []
+        const addBar = (width: number, length: number, x: number, y: number) => {
+          const bar = section(CrossSection.square([width, length], true))
+          bars.push(section(bar.translate([x, y])))
+        }
+        if (rimEdges.left) addBar(thickness, layout.length, -layout.width / 2 + thickness / 2, 0)
+        if (rimEdges.right) addBar(thickness, layout.length, layout.width / 2 - thickness / 2, 0)
+        if (rimEdges.front) addBar(layout.width, thickness, 0, -layout.length / 2 + thickness / 2)
+        if (rimEdges.back) addBar(layout.width, thickness, 0, layout.length / 2 - thickness / 2)
+        if (bars.length > 0) {
+          const ring = section(CrossSection.union(bars))
+          const rim = solidOf(ring.extrude(config.universal.rimHeight))
+          const raisedRim = solidOf(rim.translate([0, 0, config.height]))
+          solid = solidOf(Manifold.union([solid, raisedRim]))
+        }
+      }
+      const volume = solid.volume()
+      const triangles = solid.numTri()
+      return { mesh: solid.getMesh(), stats: { triangles, volume, grams: volume * PLA_DENSITY, solid: volume > 0 && triangles > 0 } }
+    }
+
     const slotOutlines = layout.slotCenters.map((slot) => {
       const detail = Math.max(slotWidth(slot), slotLength(slot)) + config.slotClearance
       return section(slotOutline(wasm, slot, config.slotClearance, segmentsFor(detail, 64)).translate([slot.x, slot.y]))
diff --git a/src/geometry/presets.ts b/src/geometry/presets.ts
index b5adc7b..16dd0f6 100644
--- a/src/geometry/presets.ts
+++ b/src/geometry/presets.ts
@@ -219,6 +219,7 @@ export function presetFor(preset: SizePreset, maxMagnets = 8, patternVersion: Ma
       layout: 'balanced',
       patternVersion,
       maxCount: maxMagnets,
+      latticePitch: 30,
       diameter: 5,
       clearance: 0.2,
       depthClearance: 0.1,
diff --git a/src/geometry/types.ts b/src/geometry/types.ts
index e742a2a..c9cf768 100644
--- a/src/geometry/types.ts
+++ b/src/geometry/types.ts
@@ -4,7 +4,7 @@ export type ShapeKind = 'round' | 'oval' | 'pill' | 'rect' | 'polygon'
 /** Edge treatment applied where the wall meets the table-contact bottom. */
 export type EdgeProfile = 'taper' | 'straight' | 'bevel' | 'round'
 
-export type MagnetLayout = 'balanced' | 'five-cross'
+export type MagnetLayout = 'balanced' | 'five-cross' | 'lattice'
 export type MagnetPatternVersion = 1 | 2
 
 export interface MagnetSpec {
@@ -16,6 +16,8 @@ export interface MagnetSpec {
   patternVersion: MagnetPatternVersion
   /** Upper bound for counts chosen automatically from the footprint. */
   maxCount: number
+  /** Centre spacing shared with a universal tray when using the lattice layout. */
+  latticePitch: number
   diameter: number
   /** Added to the diameter so a nominal magnet actually drops in. */
   clearance: number
@@ -80,6 +82,7 @@ export interface BaseStats {
 
 export interface HolderConfig {
   kind: 'holder'
+  mode: 'fitted' | 'universal'
   groups: HolderGroup[]
   maxColumns: number
   maxRows: number
@@ -94,11 +97,29 @@ export interface HolderConfig {
   slotClearance: number
   slotDepth: number
   height: number
+  universal: {
+    /** Centre-to-centre spacing of tray magnet pockets. */
+    pitch: number
+    layout: 'square' | 'staggered'
+    /** Wall height above the magnetic deck. Zero disables the retaining rim. */
+    rimHeight: number
+    rimThickness: number
+    split: boolean
+    maxPieceColumns: number
+    maxPieceRows: number
+    /** Smallest centred base that must fit wholly on the assembled deck. */
+    minimumBaseSize: number
+    /** Derived per exported module so only the assembled tray perimeter is raised. */
+    rimEdges: { left: boolean; right: boolean; front: boolean; back: boolean }
+    /** Derived module centre in the assembled tray's canonical lattice coordinates. */
+    latticeOffset: { x: number; y: number }
+  }
   magnets: {
     enabled: boolean
     layout: MagnetLayout
     patternVersion: MagnetPatternVersion
     maxCount: number
+    latticePitch: number
     diameter: number
     clearance: number
     depthClearance: number
diff --git a/src/lib/workspace.test.ts b/src/lib/workspace.test.ts
index b457eb5..cdb10c1 100644
--- a/src/lib/workspace.test.ts
+++ b/src/lib/workspace.test.ts
@@ -31,6 +31,7 @@ describe('workspace state', () => {
       layout: 'five-cross',
       patternVersion: 2,
       maxCount: 8,
+      latticePitch: 15,
       diameter: 6,
       thickness: 1.5,
       clearance: 0.3,
@@ -58,6 +59,32 @@ describe('workspace state', () => {
     }).toEqual({ baseWall: 2.5, baseBoss: 1.1, holderWall: 2.5, holderBoss: 1.1 })
   })
 
+  it('shares one canonical lattice pitch between tray-compatible bases and universal trays', () => {
+    const state = defaultWorkspace()
+    state.holder.mode = 'universal'
+    state.shared.magnets.layout = 'lattice'
+    state.shared.magnets.latticePitch = 12
+
+    const synchronized = synchronizeWorkspace(state)
+    expect({
+      baseLayout: synchronized.base.magnets.layout,
+      basePitch: synchronized.base.magnets.latticePitch,
+      holderLayout: synchronized.holder.magnets.layout,
+      trayPitch: synchronized.holder.universal.pitch,
+      trayGrid: synchronized.holder.universal.layout,
+    }).toEqual({ baseLayout: 'lattice', basePitch: 12, holderLayout: 'lattice', trayPitch: 12, trayGrid: 'staggered' })
+  })
+
+  it('reduces automatic compatible counts when the sparse pitch does not fit a base', () => {
+    const state = defaultWorkspace()
+    state.shared.magnets.layout = 'lattice'
+    state.shared.magnets.latticePitch = 30
+
+    const medium = synchronizeWorkspace({ ...state, base: { ...state.base, width: 65, length: 65 } })
+    const large = synchronizeWorkspace({ ...state, base: { ...state.base, width: 80, length: 80 } })
+    expect({ medium: medium.base.magnets.count, large: large.base.magnets.count }).toEqual({ medium: 1, large: 3 })
+  })
+
   it('limits new five-pocket crosses to round bases at least 50mm wide', () => {
     const state = defaultWorkspace()
     state.shared.magnets.layout = 'five-cross'
@@ -131,6 +158,47 @@ describe('workspace state', () => {
     })
   })
 
+  it('migrates existing fitted holders without changing their layout', () => {
+    const storage = memoryStorage()
+    const legacy = JSON.parse(JSON.stringify(defaultWorkspace()))
+    delete legacy.holder.mode
+    delete legacy.holder.universal
+    storage.setItem('mini-bases.workspace', JSON.stringify({ version: 3, workspace: legacy }))
+
+    expect(loadWorkspace(storage).holder).toMatchObject({
+      mode: 'fitted',
+      groups: [{ width: 32 }],
+      universal: { pitch: 30, layout: 'staggered', rimHeight: 3, rimThickness: 2 },
+    })
+  })
+
+  it('adds printable piece defaults to saved universal trays', () => {
+    const storage = memoryStorage()
+    const legacy = JSON.parse(JSON.stringify(defaultWorkspace()))
+    legacy.holder.mode = 'universal'
+    delete legacy.holder.universal.split
+    delete legacy.holder.universal.maxPieceColumns
+    delete legacy.holder.universal.maxPieceRows
+    delete legacy.holder.universal.rimEdges
+    storage.setItem('mini-bases.workspace', JSON.stringify({ version: 4, workspace: legacy }))
+
+    expect(loadWorkspace(storage).holder.universal).toMatchObject({
+      split: false,
+      maxPieceColumns: 3,
+      maxPieceRows: 3,
+      rimEdges: { left: true, right: true, front: true, back: true },
+    })
+  })
+
+  it('adds the minimum attachable base size to existing universal trays', () => {
+    const storage = memoryStorage()
+    const legacy = JSON.parse(JSON.stringify(defaultWorkspace()))
+    delete legacy.holder.universal.minimumBaseSize
+    storage.setItem('mini-bases.workspace', JSON.stringify({ version: 6, workspace: legacy }))
+
+    expect(loadWorkspace(storage).holder.universal.minimumBaseSize).toBe(25)
+  })
+
   it('automatically responds to magnet dimensions until the count is overridden', () => {
     const state = defaultWorkspace()
     state.base = { ...state.base, width: 80, length: 80 }
@@ -174,6 +242,7 @@ describe('workspace state', () => {
       layout: 'five-cross',
       patternVersion: 1,
       maxCount: 8,
+      latticePitch: 15,
       diameter: 6,
       thickness: 2,
       clearance: 0.3,
diff --git a/src/lib/workspace.ts b/src/lib/workspace.ts
index 046d217..28920cc 100644
--- a/src/lib/workspace.ts
+++ b/src/lib/workspace.ts
@@ -1,10 +1,10 @@
 import { defaultHolderConfig } from '../geometry/holder'
-import { supportsFivePocketCross } from '../geometry/base'
+import { supportsFivePocketCross, trayCompatibleMagnetCounts } from '../geometry/base'
 import { automaticMagnetCount, DEFAULT_PRESET, footprintKey, presetFor, ribCountFor } from '../geometry/presets'
 import type { BaseConfig, HolderConfig } from '../geometry/types'
 
 const WORKSPACE_KEY = 'mini-bases.workspace'
-const WORKSPACE_VERSION = 3
+const WORKSPACE_VERSION = 7
 
 interface SettingsStorage {
   getItem(key: string): string | null
@@ -23,7 +23,10 @@ export interface SharedSettings {
   wallThickness: number
   magnetBossWall: number
   magnetCounts: Record<string, number>
-  magnets: Pick<BaseConfig['magnets'], 'layout' | 'patternVersion' | 'maxCount' | 'diameter' | 'thickness' | 'clearance' | 'depthClearance'>
+  magnets: Pick<
+    BaseConfig['magnets'],
+    'layout' | 'patternVersion' | 'maxCount' | 'latticePitch' | 'diameter' | 'thickness' | 'clearance' | 'depthClearance'
+  >
 }
 
 export function saveWorkspace(storage: SettingsStorage, workspace: WorkspaceState): void {
@@ -44,6 +47,7 @@ function sharedFromBase(base: BaseConfig): SharedSettings {
       layout: base.magnets.layout,
       patternVersion: base.magnets.patternVersion,
       maxCount: base.magnets.maxCount,
+      latticePitch: base.magnets.latticePitch,
       diameter: base.magnets.diameter,
       thickness: base.magnets.thickness,
       clearance: base.magnets.clearance,
@@ -56,9 +60,9 @@ export function synchronizeWorkspace(state: WorkspaceState): WorkspaceState {
   const { shared } = state
   const legacyPattern = shared.magnets.patternVersion === 1
   const fiveCross = shared.magnets.layout === 'five-cross' && (legacyPattern || supportsFivePocketCross(state.base.shape, state.base.width))
-  const layout = fiveCross ? 'five-cross' : 'balanced'
+  const layout = fiveCross ? 'five-cross' : shared.magnets.layout === 'lattice' ? 'lattice' : 'balanced'
   const key = footprintKey(state.base.shape, state.base.width, state.base.length)
-  const count = fiveCross
+  const requestedCount = fiveCross
     ? 5
     : legacyPattern
       ? shared.magnetCounts[key]
@@ -70,6 +74,15 @@ export function synchronizeWorkspace(state: WorkspaceState): WorkspaceState {
           shared.magnets.diameter,
           shared.magnets.thickness,
         ))
+  const compatibleCounts = trayCompatibleMagnetCounts({
+    ...state.base,
+    wallThickness: shared.wallThickness,
+    magnets: { ...state.base.magnets, ...shared.magnets, bossWall: shared.magnetBossWall },
+  })
+  const count =
+    layout === 'lattice' && shared.magnetCounts[key] === undefined
+      ? (compatibleCounts.findLast((candidate) => candidate <= (requestedCount ?? 1)) ?? 0)
+      : requestedCount
   return {
     ...state,
     base: {
@@ -100,6 +113,7 @@ export function synchronizeWorkspace(state: WorkspaceState): WorkspaceState {
       magnetBossWall: shared.magnetBossWall,
       magnetCounts: shared.magnetCounts,
       engraving: { ...state.holder.engraving, enabled: shared.labelsEnabled },
+      universal: { ...state.holder.universal, pitch: shared.magnets.latticePitch, layout: 'staggered' },
       magnets: { ...state.holder.magnets, ...shared.magnets },
     },
   }
@@ -117,11 +131,21 @@ export function loadWorkspace(storage: SettingsStorage): WorkspaceState {
     const parsed = JSON.parse(saved) as { version?: unknown; workspace?: unknown }
     const workspace =
       parsed.version === 1
-        ? migrateWorkspaceV2(migrateWorkspaceV1(parsed.workspace))
+        ? migrateWorkspaceV6(
+            migrateWorkspaceV5(migrateWorkspaceV4(migrateWorkspaceV3(migrateWorkspaceV2(migrateWorkspaceV1(parsed.workspace))))),
+          )
         : parsed.version === 2
-          ? migrateWorkspaceV2(parsed.workspace)
-          : parsed.workspace
-    if (parsed.version !== WORKSPACE_VERSION && parsed.version !== 1 && parsed.version !== 2) return defaultWorkspace()
+          ? migrateWorkspaceV6(migrateWorkspaceV5(migrateWorkspaceV4(migrateWorkspaceV3(migrateWorkspaceV2(parsed.workspace)))))
+          : parsed.version === 3
+            ? migrateWorkspaceV6(migrateWorkspaceV5(migrateWorkspaceV4(migrateWorkspaceV3(parsed.workspace))))
+            : parsed.version === 4
+              ? migrateWorkspaceV6(migrateWorkspaceV5(migrateWorkspaceV4(parsed.workspace)))
+              : parsed.version === 5
+                ? migrateWorkspaceV6(migrateWorkspaceV5(parsed.workspace))
+                : parsed.version === 6
+                  ? migrateWorkspaceV6(parsed.workspace)
+                  : parsed.workspace
+    if (![1, 2, 3, 4, 5, 6, WORKSPACE_VERSION].includes(parsed.version as number)) return defaultWorkspace()
     if (!isWorkspaceState(workspace, defaultWorkspace())) return defaultWorkspace()
     const base = { ...workspace.base } as BaseConfig & { underside?: unknown }
     delete base.underside
@@ -131,6 +155,56 @@ export function loadWorkspace(storage: SettingsStorage): WorkspaceState {
   }
 }
 
+function migrateWorkspaceV6(value: unknown): unknown {
+  if (typeof value !== 'object' || value === null) return value
+  const workspace = value as Record<string, unknown>
+  const holder = workspace.holder as Record<string, unknown> | undefined
+  const universal = holder?.universal as Record<string, unknown> | undefined
+  if (!holder || !universal) return value
+  return { ...workspace, holder: { ...holder, universal: { ...defaultHolderConfig().universal, ...universal } } }
+}
+
+function migrateWorkspaceV5(value: unknown): unknown {
+  if (typeof value !== 'object' || value === null) return value
+  const workspace = value as Record<string, unknown>
+  const shared = workspace.shared as Record<string, unknown> | undefined
+  const base = workspace.base as Record<string, unknown> | undefined
+  const holder = workspace.holder as Record<string, unknown> | undefined
+  const sharedMagnets = shared?.magnets as Record<string, unknown> | undefined
+  const baseMagnets = base?.magnets as Record<string, unknown> | undefined
+  const holderMagnets = holder?.magnets as Record<string, unknown> | undefined
+  if (!shared || !base || !holder || !sharedMagnets || !baseMagnets || !holderMagnets) return value
+  return {
+    ...workspace,
+    shared: { ...shared, magnets: { latticePitch: 30, ...sharedMagnets } },
+    base: { ...base, magnets: { latticePitch: 30, ...baseMagnets } },
+    holder: {
+      ...holder,
+      universal: { ...defaultHolderConfig().universal, ...(holder.universal as Record<string, unknown>) },
+      magnets: { latticePitch: 30, ...holderMagnets },
+    },
+  }
+}
+
+function migrateWorkspaceV4(value: unknown): unknown {
+  if (typeof value !== 'object' || value === null) return value
+  const workspace = value as Record<string, unknown>
+  const holder = workspace.holder as Record<string, unknown> | undefined
+  const universal = holder?.universal as Record<string, unknown> | undefined
+  if (!holder || !universal) return value
+  const defaults = defaultHolderConfig().universal
+  return { ...workspace, holder: { ...holder, universal: { ...defaults, ...universal } } }
+}
+
+function migrateWorkspaceV3(value: unknown): unknown {
+  if (typeof value !== 'object' || value === null) return value
+  const workspace = value as Record<string, unknown>
+  const holder = workspace.holder
+  if (typeof holder !== 'object' || holder === null) return value
+  const defaults = defaultHolderConfig()
+  return { ...workspace, holder: { ...defaults, ...(holder as Record<string, unknown>), mode: 'fitted', universal: defaults.universal } }
+}
+
 function migrateWorkspaceV2(value: unknown): unknown {
   if (typeof value !== 'object' || value === null) return value
   const workspace = value as Record<string, unknown>
@@ -183,7 +257,7 @@ function isWorkspaceState(value: unknown, template: WorkspaceState): value is Wo
   const workspace = value as WorkspaceState
   return (
     ['round', 'oval', 'pill', 'rect', 'polygon'].includes(workspace.base.shape) &&
-    ['balanced', 'five-cross'].includes(workspace.shared.magnets.layout) &&
+    ['balanced', 'five-cross', 'lattice'].includes(workspace.shared.magnets.layout) &&
     [1, 2].includes(workspace.shared.magnets.patternVersion) &&
     workspace.holder.groups.every((group) => ['round', 'oval', 'pill', 'rect', 'polygon'].includes(group.shape)) &&
     Object.values(workspace.shared.magnetCounts).every((count) => typeof count === 'number' && Number.isFinite(count))