diff --git a/BUILD.md b/BUILD.md
index 1421e80..2196332 100644
--- a/BUILD.md
+++ b/BUILD.md
@@ -23,6 +23,20 @@ change; the release is assembled and audited every time. `orchard run` boots its
 recovery on the attached device without installing, and `orchard install`
 installs it. The rest of this page is what that entry runs, step by step.
 
+### 32-bit (armv7)
+
+A release has one root of one architecture. `orchard build --platform apple-armv7`
+(or `tools/build.py --arch armv7`) builds the armv7 root and its own release, for
+orchard's 32-bit platforms: the same packages, services and configuration as the
+arm64 root, with Alpine's dropbear and udhcpd (`busybox-extras`) in place of
+orchard's static arm64 tools. `system/armv7/` builds it in the same pinned arm64
+Alpine image: the native `apk --arch armv7` unpacks the signed ARMv7 packages into
+`/armroot` without running their scripts, and the recipe does as files what those
+scripts would (applet links, accounts, `/etc/shells`), then merges `/usr` with the
+arm64 `merge-usr --root`. Nothing runs ARMv7 code, so no emulation is needed. The
+release takes the boards, loaders and layer from orchard's 32-bit index
+(`platforms-armv7.toml`, beside the unchanged arm64 `platforms.toml`).
+
 ## Local setup
 
 Requires uv and a native ARM64 Podman environment. Run commands from this
@@ -51,7 +65,7 @@ the few lines that find it and run its commands.
 ```sh
 export ORCHARD=/path/to/orchard PYTHONPATH=/path/to/orchard/src
 python3 boot/build-artwork.py --output out/artwork
-python3 build_base.py --output out/base/base.tar.gz
+python3 build_base.py --output out/base/base.tar.gz   # --arch armv7: the 32-bit root's base
 # What orchard supplies finished: kernels and boards per platform, m1n1, Pongo, tools.
 python3 -m orchard.inputs --output out/orchard-inputs.json --platform apple-16k
 python3 pin_components.py --loader M1N1 --splash out/artwork/splash --logo out/artwork/logo.bin \
@@ -75,7 +89,7 @@ signature or trust service.
 
 Use fresh output paths; producers refuse overwriting. The official Alpine OCI digest is pinned in `system/Containerfile`; APK repositories retain signature checking. The base records package versions in `/etc/alpine-packages.lock`. Its archive hash and all selected hardware hashes are recorded separately from the install contract. The APK mirror is not an immutable snapshot: future base rebuilds may select newer signed package revisions and must get new receipts.
 
-The producer composes Alpine-owned policy into one public gzip root for every platform (no kernel or modules: orchard's platform layer brings those at install, and orchard writes the boot entry), seals a recovery per platform to the root's receipt, adds orchard's layer per platform, and emits `release.toml` plus the index that pins it. Public build receipts omit local machine paths. No private firmware, SSH keys, ADT or machine IDs are embedded.
+The producer composes Alpine-owned policy into one public gzip root for every platform of its architecture (no kernel or modules: orchard's platform layer brings those at install, and orchard writes the boot entry), seals a recovery per platform to the root's receipt, adds orchard's layer per platform, and emits `release.toml` plus the index that pins it. Public build receipts omit local machine paths. No private firmware, SSH keys, ADT or machine IDs are embedded.
 
 ## Native isolated checks
 
diff --git a/README.md b/README.md
index d6afd38..225862e 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 A small Alpine-based Linux image for Apple devices, demonstrating the Orchard release format without a desktop or systemd requirement.
 
-A release covers every device orchard describes: one root image, and orchard's kernel, device trees and modules per platform. How well a device works is orchard's device data, which the installer shows; today the iPad 6 Wi-Fi (`iPad7,5`, J71b) is supported, the others are experimental. Boot is tethered and requires a host computer. The installer sets the password of its one user, `tablet`; the console on tty1 and the USB serial console take it.
+A release covers every device orchard describes for its architecture: one root image, and orchard's kernel, device trees and modules per platform. 64-bit devices take the arm64 release, Apple's 32-bit devices (apple-armv7) an armv7 release of the same system. How well a device works is orchard's device data, which the installer shows; today the iPad 6 Wi-Fi (`iPad7,5`, J71b) is supported, the others are experimental. Boot is tethered and requires a host computer. The installer sets the password of its one user, `tablet`; the console on tty1 and the USB serial console take it.
 
 ## Local development
 
diff --git a/audit.py b/audit.py
index 9a2bd55..e77bb6a 100644
--- a/audit.py
+++ b/audit.py
@@ -13,6 +13,20 @@
 HARDWARE = None  # the orchard snapshot; main() sets it, else orchard_root() finds it
 
 
+# Per root architecture: its ELF class and machine, and the musl loader.
+ARCHITECTURES = {'aarch64': {'class': 2, 'machine': 183, 'loader': 'usr/lib/ld-musl-aarch64.so.1'},
+                 'armv7': {'class': 1, 'machine': 40, 'loader': 'usr/lib/ld-musl-armhf.so.1'}}
+
+
+def check_elf_arch(data, arch):
+    """An ELF file of the root is of the root's architecture: no arm64 tool in an armv7 root, or back."""
+    if data[:4] != b'\x7fELF':
+        return False
+    target = ARCHITECTURES[arch]
+    assert data[4] == target['class'] and struct.unpack_from('<H', data, 18)[0] == target['machine']
+    return True
+
+
 def check_elf_pages(data):
     """The real J71b kernel uses 16 KiB pages; the container kernel may not."""
     if data[:6] != b'\x7fELF\x02\x01':
@@ -53,15 +67,22 @@ def audit(directory):
     manifest = tomllib.loads((directory / 'release.toml').read_text())
     assert manifest['schema'] == 2 and manifest['distro'] == 'minimal-linux'
     record = json.loads((directory / 'rootfs.json').read_text())
+    arch = record.get('architecture', 'aarch64')
     rootfile = directory / 'rootfs.tar.gz'
     assert rootfile.stat().st_size == record['bytes'] and sha(rootfile) == record['sha256']
     # The checks read the tree the image was made from; orchard.image.root_image made it, and checks it.
-    for row in (manifest['root'], manifest['root']['map'], manifest['logo'], manifest['pongo'], manifest['m1n1'],
-                manifest['install_tools']):
+    if arch == 'aarch64':
+        assert 'pongo' in manifest and 'm1n1' in manifest and 'logo' in manifest
+        files = [manifest['logo'], manifest['pongo'], manifest['m1n1']]
+    else:   # a board's Cascadia loader each; no Pongo, m1n1 or logo
+        assert manifest['boot_method'] == 'recovery-autogo' and manifest['cascadia']
+        assert not {'pongo', 'm1n1', 'logo'} & manifest.keys()
+        files = list(manifest['cascadia'].values())
+    for row in (manifest['root'], manifest['root']['map'], *files, manifest['install_tools']):
         path = directory / row['file']
         assert path.stat().st_size == row['bytes'] and sha(path) == row['sha256'], row['file']
     entries = {}
-    size = elf_loads = 0
+    size = elf_loads = elf_files = 0
     with tarfile.open(rootfile, 'r|gz') as archive:
         for m in archive:
             assert m.name not in entries
@@ -74,13 +95,16 @@ def audit(directory):
                                           'usr/bin/sudo', 'usr/libexec/omarchy-', 'usr/lib/modules/'))
             data = archive.extractfile(m).read() if m.isfile() else None
             if data is not None:
-                elf_loads += check_elf_pages(data)
+                elf_files += check_elf_arch(data, arch)
+                if arch == 'aarch64':
+                    elf_loads += check_elf_pages(data)
             entries[m.name] = (data, m.mode, m.linkname)
             size += m.size
     assert len(entries) == record['members'] and size == record['expanded_bytes']
     assert entries['lib'][2] == 'usr/lib'
     assert entries['usr/sbin/init'][2] == '/bin/busybox'
-    assert entries['usr/lib/ld-musl-aarch64.so.1'][0].startswith(b'\x7fELF')
+    assert entries[ARCHITECTURES[arch]['loader']][0].startswith(b'\x7fELF')
+    assert entries['etc/apk/arch'][0].strip() == arch.encode()
     assert 'usr/lib/libc.so.6' not in entries
     assert entries['etc/shadow'][0].startswith(b'root:!:')
     assert 'root/.ssh/authorized_keys' not in entries
@@ -89,7 +113,9 @@ def audit(directory):
     # Every boot is reachable over USB: a serial console login and session SSH.
     assert b'ttyGS0::respawn:/sbin/getty' in entries['etc/inittab'][0]
     assert 'usr/share/orchard/splash' in entries, 'the boot splash for orchard launch'
-    for name in ('usr/sbin/dropbear', 'etc/init.d/orchard-ssh', 'etc/init.d/orchard-usb',
+    # resize2fs and python3: what the install finish step runs in the root.
+    for name in ('usr/sbin/resize2fs', 'usr/bin/python3',
+                 'usr/sbin/dropbear', 'usr/libexec/minimal-linux/busybox', 'etc/init.d/orchard-ssh', 'etc/init.d/orchard-usb',
                  'etc/runlevels/default/orchard-ssh', 'etc/runlevels/default/orchard-usb',
                  'etc/init.d/orchard-splash', 'etc/orchard/udhcpd.conf'):
         assert name in entries, name
@@ -106,7 +132,8 @@ def audit(directory):
         # The installer refuses a layer file the root already has.
         assert not (layer.keys() & {n for n, (data, _, _) in entries.items() if data is not None})
         platforms[name] = {'boards': sorted(description['boards'])}
-    return {'root_sha256': record['sha256'], 'root_bytes': record['bytes'],
+    return {'architecture': arch, 'elf_files': elf_files,
+            'root_sha256': record['sha256'], 'root_bytes': record['bytes'],
             'expanded_bytes': size, 'root_members': len(entries), 'platforms': platforms,
             'elf_16k_compatible_load_segments': elf_loads,
             'signed_regulatory_database_present': True,
diff --git a/build.py b/build.py
index a17226a..0f2da30 100644
--- a/build.py
+++ b/build.py
@@ -1,8 +1,10 @@
 #!/usr/bin/env python3
-"""One Alpine/OpenRC release for every platform: the root as a block image, its logo, and orchard's files.
+"""One Alpine/OpenRC release for every platform of one architecture: the root as a block image, its logo, and orchard's files.
 
 The root holds no kernel; orchard's platform layer brings kernel, initrd, DTBs
-and modules at install, and orchard writes the boot entry.
+and modules at install, and orchard writes the boot entry. A release has one
+root: aarch64 for orchard's arm64 platforms, armv7 for its 32-bit ones (a
+release of its own, from orchard's 32-bit index).
 """
 import argparse
 import gzip
@@ -18,10 +20,18 @@
 import tempfile
 import tomllib
 
-from snapshot import command as orchard_command, root as orchard_root, sha
+from snapshot import command as orchard_command, platforms as orchard_platforms, root as orchard_root, sha
 
 PROJECT = Path(__file__).resolve().parent
 POLICY = PROJECT / 'system/image_policy.py'
+# Per root architecture: orchard's name for it, the index orchard.image.platforms_index writes, and the
+# boot method of its manifest (orchard docs/distribution-contract.md, "32-bit roots").
+ARCHITECTURES = {
+    'aarch64': {'orchard': 'arm64', 'index': 'platforms.toml', 'boot_method': 'checkm8-pongo'},
+    'armv7': {'orchard': 'arm', 'index': 'platforms-armv7.toml', 'boot_method': 'recovery-autogo'},
+}
+# An armv7 root has Alpine's udhcpd (busybox-extras) where an arm64 root has orchard's static BusyBox.
+ARMV7_BUSYBOX = 'usr/bin/busybox-extras'
 
 
 def verify_inputs(path):
@@ -47,15 +57,19 @@ def overlay():
     return result
 
 
-def root_archive(base, base_receipt, components, output, version, hardware):
+def root_archive(base, base_receipt, components, output, version, hardware, arch='aarch64'):
     receipt = json.loads(base_receipt.read_text())
     if base.is_symlink() or base.stat().st_size != receipt['bytes'] or sha(base) != receipt['sha256']:
         raise ValueError('Alpine base differs from receipt')
+    if receipt.get('architecture', 'aarch64') != arch:
+        raise ValueError(f'The Alpine base is {receipt.get("architecture", "aarch64")}, not {arch}')
     additions = overlay()
     additions['usr/libexec/minimal-linux/image_policy.py'] = (POLICY.read_bytes(), 0o644)
-    for source, target in (('busybox', 'usr/libexec/minimal-linux/busybox'),
-                           ('dropbear', 'usr/sbin/dropbear'), ('dropbearkey', 'usr/bin/dropbearkey')):
-        additions[target] = (components[source].read_bytes(), 0o755)
+    if arch == 'aarch64':
+        for source, target in (('busybox', 'usr/libexec/minimal-linux/busybox'),
+                               ('dropbear', 'usr/sbin/dropbear'), ('dropbearkey', 'usr/bin/dropbearkey')):
+            additions[target] = (components[source].read_bytes(), 0o755)
+    copied = {}  # an armv7 root's udhcpd BusyBox: Alpine's, copied from the base below
     # m1n1 paints it when the entry starts, before the kernel (orchard docs/boot-contract.md).
     additions['usr/share/orchard/splash'] = (components['splash'].read_bytes(), 0o644)
     additions['usr/sbin/capture-adt'] = ((hardware / 'boot/initramfs/recovery/capture-adt').read_bytes(), 0o755)
@@ -107,6 +121,8 @@ def add(member, data=None):
                     if name == 'root':
                         member.mode = 0o700
                     data = source.extractfile(member).read() if member.isfile() else None
+                    if arch != 'aarch64' and name == ARMV7_BUSYBOX:
+                        copied['usr/libexec/minimal-linux/busybox'] = (data, 0o755)
                     add(member, data)
 
             def parents(name):
@@ -122,6 +138,10 @@ def parents(name):
                     member.type, member.mode = tarfile.DIRTYPE, 0o755
                     add(member)
 
+            if arch != 'aarch64':
+                if not copied:
+                    raise ValueError(f'The {arch} base lacks {ARMV7_BUSYBOX}')
+                additions.update(copied)
             for name, (data, mode) in sorted(additions.items()):
                 parents(name)
                 member = tarfile.TarInfo(name)
@@ -140,7 +160,7 @@ def parents(name):
             member = tarfile.TarInfo('etc/runlevels/sysinit/cgroups')
             member.type, member.mode, member.linkname = tarfile.SYMTYPE, 0o777, '/etc/init.d/cgroups'
             add(member)
-    record = {'schema': 2, 'kind': 'rootfs', 'release': version,
+    record = {'schema': 2, 'kind': 'rootfs', 'release': version, 'architecture': arch,
               'bytes': path.stat().st_size, 'sha256': sha(path), 'compression': 'gzip',
               'expanded_bytes': expanded, 'members': count,
               'base_sha256': receipt['sha256'], 'removed_privileged_modes': privileged}
@@ -156,14 +176,15 @@ def receipt(path):
     return {'file': path.name, 'bytes': path.stat().st_size, 'sha256': sha(path)}
 
 
-def manifests(output, version, root, offered, orchard):
-    """release.toml (orchard's schema 2, every platform) and the index that pins it.
+def manifests(output, version, root, offered, orchard, arch='aarch64'):
+    """release.toml (orchard's schema 2, every platform of the root's architecture) and the index that pins it.
 
-    ROOT is orchard.image.root_image's table, OFFERED orchard's platforms.toml beside it.
+    ROOT is orchard.image.root_image's table, OFFERED orchard's index of the architecture beside it.
     """
+    boot_method = ARCHITECTURES[arch]['boot_method']
     document = ('schema = 2\nkind = "orchard.install"\ndistro = "minimal-linux"\n'
                 'name = "Minimal Alpine"\nversion = ' + json.dumps(version) + '\n'
-                'boot_method = "checkm8-pongo"\nmin_orchard = "0.2.0"\nprotocol = 1\n')
+                'boot_method = ' + json.dumps(boot_method) + '\nmin_orchard = "0.2.0"\nprotocol = 1\n')
     document += table('orchard', orchard)
     # The one regular user gets its password at install; no lock screen, so no PIN.
     # The ready file is minimal-ready's, once services and the splash are done.
@@ -172,8 +193,13 @@ def manifests(output, version, root, offered, orchard):
                                           'passwordless_sudo': False})
     document += table('root', {key: value for key, value in root.items() if key != 'map'})
     document += table('root.map', root['map'])
-    document += table('logo', receipt(output / 'logo.bin'))  # the Alpine mark, drawn by orchard's m1n1
-    document += table('pongo', offered['loaders']['pongo']) + table('m1n1', offered['loaders']['m1n1'])
+    if arch == 'aarch64':
+        document += table('logo', receipt(output / 'logo.bin'))  # the Alpine mark, drawn by orchard's m1n1
+        document += table('pongo', offered['loaders']['pongo']) + table('m1n1', offered['loaders']['m1n1'])
+    else:
+        # A 32-bit release names each board's Cascadia loader; it has no Pongo, m1n1 or logo.
+        for board, row in sorted(offered['loaders']['cascadia'].items()):
+            document += table(f'cascadia.{board}', row)
     document += table('install_tools', offered['install_tools'])
     for name, layer in sorted(offered['platforms'].items()):
         document += f'\n[platforms.{name}]\nboards = {json.dumps(layer["boards"])}\n'
@@ -190,6 +216,9 @@ def main():
     for name in ('base', 'base-receipt', 'inputs', 'output'):
         parser.add_argument('--' + name, type=Path, required=True)
     parser.add_argument('--version', required=True)
+    parser.add_argument('--arch', choices=sorted(ARCHITECTURES), default='aarch64', help="the root's architecture")
+    parser.add_argument('--platform', action='append', default=[],
+                        help='with --orchard-release: only this platform; repeat (default: every one of --arch)')
     parser.add_argument('--orchard', type=Path, help='orchard snapshot (default: ORCHARD_CHECKOUT, then .orchard)')
     source = parser.add_mutually_exclusive_group(required=True)
     source.add_argument('--orchard-release', metavar='TAG', help="take orchard's files finished from this build")
@@ -198,26 +227,37 @@ def main():
     if args.output.exists() or args.output.is_symlink():
         parser.error('Choose a new output directory')
     orchard = orchard_root(args.orchard)
+    known = orchard_platforms(orchard)
+    selected = args.platform or ([] if args.arch == 'aarch64' else
+                                 sorted(name for name, arch in known.items() if arch == args.arch))
     components, inputs = verify_inputs(args.inputs)
     resolved = json.loads(args.orchard_inputs.read_text()) if args.orchard_inputs else None
+    for name in (*selected, *(resolved['platforms'] if resolved else ())):
+        if known.get(name) != args.arch:
+            parser.error(f'{name} is not a platform of the {args.arch} root')
     revision = resolved['orchard'] if resolved else None
     args.output.parent.mkdir(parents=True, exist_ok=True)
     with tempfile.TemporaryDirectory(prefix='.minimal-build-', dir=args.output.parent) as temp:
         output = Path(temp) / 'release'
         output.mkdir()
-        root_archive(args.base, args.base_receipt, components, output, args.version, orchard)
-        source = ('--release', args.orchard_release) if args.orchard_release else ('--inputs', args.orchard_inputs)
+        root_archive(args.base, args.base_receipt, components, output, args.version, orchard, args.arch)
+        # --architecture only for 32-bit: the arm64 index is the default (and older orchards lack the option).
+        source = (('--release', args.orchard_release,
+                   *(('--architecture', ARCHITECTURES[args.arch]['orchard']) if args.arch != 'aarch64' else ()),
+                   *(part for name in selected for part in ('--platform', name)))
+                  if args.orchard_release else ('--inputs', args.orchard_inputs))
         orchard_command(orchard, 'image.platforms_index', output, *source, stdout=subprocess.DEVNULL)
-        offered = tomllib.loads((output / 'platforms.toml').read_text())
+        offered = tomllib.loads((output / ARCHITECTURES[args.arch]['index']).read_text())
         revision = revision or {'commit': offered['commit'], 'modified': False}
         orchard_command(orchard, 'image.root_image', output / 'rootfs.tar.gz', '--output', output)
         root = json.loads((output / 'root-image.json').read_text())
-        shutil.copyfile(components['logo'], output / 'logo.bin')
-        manifests(output, args.version, root, offered, revision)
+        if args.arch == 'aarch64':
+            shutil.copyfile(components['logo'], output / 'logo.bin')
+        manifests(output, args.version, root, offered, revision, args.arch)
         public_inputs = {**inputs, 'files': {name: {k: v for k, v in row.items() if k != 'path'}
                                              for name, row in inputs['files'].items()}}
         (output / 'build-receipt.json').write_text(json.dumps({'distro': 'minimal-linux',
-            'version': args.version, 'orchard': revision, 'platforms': offered['platforms'],
+            'version': args.version, 'architecture': args.arch, 'orchard': revision, 'platforms': offered['platforms'],
             'base': json.loads(args.base_receipt.read_text()), 'inputs': public_inputs,
             'physical_device_operations_performed': False, 'hardware_validated': False}, indent=2) + '\n')
         shutil.rmtree(output / '.work', ignore_errors=True)
diff --git a/build_base.py b/build_base.py
index 9d63a88..43ab6b8 100644
--- a/build_base.py
+++ b/build_base.py
@@ -15,15 +15,26 @@
 from snapshot import sha
 
 PROJECT = Path(__file__).resolve().parent
+# Per userspace architecture: its recipe directory, where the recipe leaves the root inside the
+# build image, and the receipt's description. Both are built by arm64 tools: the armv7 recipe
+# unpacks signed ARMv7 packages with the native apk and runs none of their code.
+ARCHITECTURES = {
+    'aarch64': {'recipe': 'system', 'root': '/',
+                'base': 'Alpine 3.24.3 arm64, official merged-/usr, signed APK repositories'},
+    'armv7': {'recipe': 'system/armv7', 'root': '/armroot',
+              'base': 'Alpine 3.24 armv7, unpacked by arm64 apk without package scripts, merged-/usr, '
+                      'signed APK repositories'},
+}
 
 
-def native_root(work):
+def native_root(work, arch='aarch64'):
     if os.geteuid() != 0 or platform.system() != 'Linux' or platform.machine() not in ('aarch64', 'arm64'):
         raise ValueError('Native base builds require Linux ARM64 as root')
     for tool in ('skopeo', 'umoci', 'chroot', 'tar', 'mount', 'umount'):
         if not shutil.which(tool):
             raise ValueError('Missing native base tool: ' + tool)
-    containerfile = (PROJECT / 'system/Containerfile').read_text()
+    recipe = PROJECT / ARCHITECTURES[arch]['recipe']
+    containerfile = (recipe / 'Containerfile').read_text()
     matches = re.findall(r'^FROM (\S+@sha256:[0-9a-f]{64})$', containerfile, re.MULTILINE)
     if len(matches) != 1:
         raise ValueError('Expected one digest-pinned Alpine base')
@@ -52,7 +63,7 @@ def native_root(work):
         for name, minor in (('null', 3), ('zero', 5), ('random', 8), ('urandom', 9)):
             os.mknod(root / 'dev' / name, stat.S_IFCHR | 0o666, os.makedev(1, minor))
         subprocess.run(['chroot', str(root), '/bin/sh', '-ec',
-                        (PROJECT / 'system/install-base').read_text()], check=True)
+                        (recipe / 'install-base').read_text()], check=True)
     finally:
         try:
             errors = []
@@ -67,7 +78,7 @@ def native_root(work):
             resolver.unlink(missing_ok=True)
             if present:
                 backup.rename(resolver)
-    return root, image
+    return root / ARCHITECTURES[arch]['root'].lstrip('/'), image
 
 
 def export(command, path):
@@ -87,7 +98,10 @@ def main():
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument('--output', type=Path, required=True)
     parser.add_argument('--native', action='store_true', help='use pinned OCI extraction and native chroot, without Podman')
+    parser.add_argument('--arch', choices=sorted(ARCHITECTURES), default='aarch64', help='userspace architecture')
     args = parser.parse_args()
+    target = ARCHITECTURES[args.arch]
+    recipe = PROJECT / target['recipe']
     receipt = args.output.with_suffix(args.output.suffix + '.json')
     if args.output.exists() or args.output.is_symlink() or receipt.exists() or receipt.is_symlink():
         parser.error('Choose a new base output path')
@@ -97,20 +111,25 @@ def main():
         with tempfile.TemporaryDirectory(dir=args.output.parent, prefix='.alpine-base-') as temp:
             work = Path(temp)
             if args.native:
-                root, image = native_root(work)
+                root, image = native_root(work, args.arch)
                 command = ['tar', '--numeric-owner', '--one-file-system', '-C', str(root), '-cf', '-', '.']
             else:
-                tag = 'localhost/orchard-minimal-alpine:3.24.3'
-                subprocess.run(['podman', 'build', '-t', tag, '-f', str(PROJECT / 'system/Containerfile'), str(PROJECT / 'system')], check=True)
+                tag = 'localhost/orchard-minimal-alpine:3.24.3' + ('' if args.arch == 'aarch64' else '-' + args.arch)
+                subprocess.run(['podman', 'build', '-t', tag, '-f', str(recipe / 'Containerfile'), str(recipe)], check=True)
                 image = subprocess.check_output(['podman', 'image', 'inspect', '--format', '{{.Id}}', tag], text=True).strip()
-                cid = subprocess.check_output(['podman', 'create', '--network', 'none', tag], text=True).strip()
-                command = ['podman', 'export', cid]
+                if args.arch == 'aarch64':
+                    cid = subprocess.check_output(['podman', 'create', '--network', 'none', tag], text=True).strip()
+                    command = ['podman', 'export', cid]
+                else:   # only the root the recipe made, not the arm64 image around it
+                    command = ['podman', 'run', '--rm', '--network', 'none', image,
+                               'tar', '--numeric-owner', '-C', target['root'], '-cf', '-', '.']
             path = work / 'base.tar.gz'
             export(command, path)
             record = {'bytes': path.stat().st_size, 'sha256': sha(path), 'container_image': image,
-                      'containerfile_sha256': sha(PROJECT / 'system/Containerfile'),
-                      'install_recipe_sha256': sha(PROJECT / 'system/install-base'),
-                      'base': 'Alpine 3.24.3 arm64, official merged-/usr, signed APK repositories'}
+                      'architecture': args.arch,
+                      'containerfile_sha256': sha(recipe / 'Containerfile'),
+                      'install_recipe_sha256': sha(recipe / 'install-base'),
+                      'base': target['base']}
             os.rename(path, args.output)
             receipt.write_text(json.dumps(record, indent=2) + '\n')
     finally:
diff --git a/pin_components.py b/pin_components.py
index bcc1448..a797b76 100644
--- a/pin_components.py
+++ b/pin_components.py
@@ -15,17 +15,24 @@
 
 from snapshot import sha
 
-ROLES = ('loader', 'splash', 'logo', 'pongo', 'busybox', 'dropbear', 'dropbearkey', 'wpa-supplicant', 'wpa-cli', 'iw')
+REQUIRED = ('splash', 'logo')
+# orchard's m1n1, Pongo and static arm64 tools: an arm64 root's; an armv7 root has Alpine's tools.
+ORCHARD = ('loader', 'pongo', 'busybox', 'dropbear', 'dropbearkey', 'wpa-supplicant', 'wpa-cli', 'iw')
+ROLES = (*REQUIRED, *ORCHARD)
 
 
 def main():
     parser = argparse.ArgumentParser(description=__doc__.split('\n\n')[0])
     for name in (*ROLES, 'output'):
-        parser.add_argument('--' + name, type=Path, required=True)
+        parser.add_argument('--' + name, type=Path, required=name not in ORCHARD)
     args = parser.parse_args()
     if args.output.exists() or args.output.is_symlink():
         parser.error('Choose a new component output directory')
-    sources = {name.replace('-', '_'): getattr(args, name.replace('-', '_')) for name in ROLES}
+    given = [name for name in ORCHARD if getattr(args, name.replace('-', '_')) is not None]
+    if given and len(given) != len(ORCHARD):
+        parser.error("orchard's components come all together or not at all: " + ', '.join(ORCHARD))
+    sources = {name.replace('-', '_'): getattr(args, name.replace('-', '_')) for name in ROLES
+               if getattr(args, name.replace('-', '_')) is not None}
     for path in sources.values():
         if path.is_symlink() or not path.is_file():
             parser.error(f'Explicit input must be a regular file: {path}')
diff --git a/snapshot.py b/snapshot.py
index 8dbeebd..35a7c9e 100644
--- a/snapshot.py
+++ b/snapshot.py
@@ -14,6 +14,7 @@
 import shutil
 import subprocess
 import sys
+import tomllib
 
 PROJECT = Path(__file__).resolve().parent
 
@@ -35,6 +36,21 @@ def command(snapshot, module, *argv, **kwargs):
     return subprocess.run(argv, env=environment, check=True, **kwargs)
 
 
+# The userspace architecture of a root for each kernel architecture orchard's platforms name.
+ARCHITECTURES = {'arm64': 'aarch64', 'arm': 'armv7'}
+
+
+def platforms(snapshot):
+    """{platform: userspace architecture} for every platform the snapshot describes (platforms/NAME.toml, data)."""
+    result = {}
+    for path in sorted((Path(snapshot) / 'platforms').glob('*.toml')):
+        kernel = tomllib.loads(path.read_text())['kernel']['arch']
+        if kernel not in ARCHITECTURES:
+            raise ValueError(f'{path.name}: no root for kernel architecture {kernel}')
+        result[path.stem] = ARCHITECTURES[kernel]
+    return result
+
+
 def sha(path):
     digest = hashlib.sha256()
     with Path(path).open('rb') as stream:
diff --git a/system/armv7/Containerfile b/system/armv7/Containerfile
new file mode 100644
index 0000000..1034b1e
--- /dev/null
+++ b/system/armv7/Containerfile
@@ -0,0 +1,5 @@
+# Alpine 3.24.3, official arm64 image (the same as system/Containerfile). Its native apk
+# unpacks signed ARMv7 packages into /armroot and runs none of their code: no emulation.
+FROM docker.io/library/alpine@sha256:be2656061b536c1883c4034790e21d0a09c5aaaf51968b89368a3c0371ea2c9a
+COPY install-base /tmp/install-base
+RUN sh /tmp/install-base && rm /tmp/install-base
diff --git a/system/armv7/install-base b/system/armv7/install-base
new file mode 100644
index 0000000..4c8db85
--- /dev/null
+++ b/system/armv7/install-base
@@ -0,0 +1,50 @@
+#!/bin/sh
+# The ARMv7 root, built by arm64 tools only. Packages are unpacked without their
+# scripts (they are ARMv7 code), so this does by hand, as files, what those
+# scripts and system/install-base do for the arm64 root.
+set -eu
+root=/armroot
+# Alpine's ARMv7 signing keys, as the pinned image's alpine-keys ships them.
+cp /usr/share/apk/keys/armv7/*.pub /etc/apk/keys/
+mkdir -p "$root/etc/apk"
+cp /etc/apk/repositories "$root/etc/apk/repositories"
+# The arm64 root's packages: the Alpine image's own, system/install-base's,
+# dropbear and busybox-extras (udhcpd) in place of orchard's arm64 static tools.
+apk --root "$root" --arch armv7 --initdb --no-scripts --no-cache --keys-dir /etc/apk/keys add \
+  alpine-baselayout alpine-keys alpine-release apk-tools busybox musl-utils \
+  openrc python3 bash kmod util-linux e2fsprogs e2fsprogs-extra openssh-client-default shadow openssl \
+  dropbear busybox-extras
+# Arm64 helpers for the steps below; they change only the builder.
+apk add --no-cache merge-usr shadow tar
+# What the skipped package scripts do on a fresh install, as files:
+# alpine-baselayout's shadow group, bash's /etc/shells line, and BusyBox's and
+# busybox-extras' applet links (from the lists they ship) and klogd account.
+grep -q '^shadow:' "$root/etc/group" || groupadd --root "$root" --system --gid 42 shadow
+grep -qx /bin/bash "$root/etc/shells" || echo /bin/bash >> "$root/etc/shells"
+for list in "$root"/etc/busybox-paths.d/*; do
+  case "$list" in *busybox-extras) target=/bin/busybox-extras ;; *) target=/bin/busybox ;; esac
+  while read -r applet; do
+    applet=${applet#/}
+    [ -n "$applet" ] || continue
+    if [ -e "$root/$applet" ] || [ -L "$root/$applet" ]; then continue; fi
+    mkdir -p "$root/$(dirname "$applet")"
+    ln -s "$target" "$root/$applet"
+  done < "$list"
+done
+groupadd --root "$root" --system klogd
+useradd --root "$root" --system --no-create-home --home-dir /dev/null --shell /sbin/nologin \
+  --gid klogd --comment klogd klogd
+# The one regular user; orchard's installer sets its password (chpasswd).
+useradd --root "$root" --create-home --uid 1000 --user-group --shell /bin/bash tablet
+merge-usr --root "$root" --dryrun
+merge-usr --root "$root"
+apk --root "$root" info -v > "$root/etc/alpine-packages.lock"
+rm -f "$root/etc/machine-id" "$root/var/lib/dbus/machine-id"
+test "$(cat "$root/etc/apk/arch")" = armv7
+test -x "$root/usr/sbin/resize2fs" -a -e "$root/usr/bin/python3"
+test "$(readlink "$root/lib")" = usr/lib
+test "$(readlink "$root/bin")" = usr/bin
+test "$(readlink "$root/sbin")" = usr/sbin
+test -x "$root/usr/bin/busybox" -a -L "$root/usr/bin/ls" -a -L "$root/usr/sbin/getty"
+test -e "$root/usr/lib/ld-musl-armhf.so.1"
+test ! -e "$root/usr/lib/systemd/systemd"
diff --git a/system/install-base b/system/install-base
index 481ba33..ce2ac5f 100644
--- a/system/install-base
+++ b/system/install-base
@@ -1,6 +1,6 @@
 #!/bin/sh
 set -eu
-apk add --no-cache openrc python3 bash kmod util-linux e2fsprogs openssh-client-default merge-usr \
+apk add --no-cache openrc python3 bash kmod util-linux e2fsprogs e2fsprogs-extra openssh-client-default merge-usr \
   shadow openssl
 # The one regular user; orchard's installer sets its password (chpasswd).
 useradd --create-home --uid 1000 --user-group --shell /bin/bash tablet
@@ -12,4 +12,5 @@ rm -f /etc/machine-id /var/lib/dbus/machine-id
 test "$(readlink /lib)" = usr/lib
 test "$(readlink /bin)" = usr/bin
 test "$(readlink /sbin)" = usr/sbin
+test -x /usr/sbin/resize2fs  # the install finish step grows the root
 test ! -e /usr/lib/systemd/systemd
diff --git a/system/overlay/usr/libexec/minimal-buttons b/system/overlay/usr/libexec/minimal-buttons
index 331a2f5..f6b35de 100644
--- a/system/overlay/usr/libexec/minimal-buttons
+++ b/system/overlay/usr/libexec/minimal-buttons
@@ -12,15 +12,17 @@ import stat
 import struct
 import subprocess
 
-EVENT = struct.Struct('<qqHHi')  # Linux ARM64 input_event, 24 bytes.
+# Linux input_event: two longs of time, then type, code, value (arm64: 24 bytes, armv7: 16).
+EVENT = struct.Struct('@llHHi')
 EV_KEY, VOLUME_DOWN, VOLUME_UP, POWER = 1, 114, 115, 116
 RUNTIME = Path('/run/minimal-linux')
+LONG_BITS = 8 * struct.calcsize('@l')  # the kernel's capability words are longs
 
 
 def key_bits(text):
     bits = 0
     for word in text.split():
-        bits = (bits << 64) | int(word, 16)
+        bits = (bits << LONG_BITS) | int(word, 16)
     return bits
 
 
diff --git a/system/overlay/usr/libexec/minimal-clear-splash b/system/overlay/usr/libexec/minimal-clear-splash
index a6b359a..403dcbe 100644
--- a/system/overlay/usr/libexec/minimal-clear-splash
+++ b/system/overlay/usr/libexec/minimal-clear-splash
@@ -2,7 +2,7 @@
 """Clear only the inherited simpledrm framebuffer; never change backlight/power.
 
 Run by the image's readiness helper, not by hardware preparation or Pongo.
-Linux ARM64 fbdev ABI; geometry and byte bounds come from the current driver.
+Linux fbdev ABI of this root's architecture (arm64 or armv7); geometry and byte bounds come from the current driver.
 """
 import fcntl
 import json
@@ -14,14 +14,16 @@ FBIOGET_VSCREENINFO = 0x4600
 FBIOGET_FSCREENINFO = 0x4602
 FBIOBLANK = 0x4611
 MAX_BYTES = 64 * 1024 * 1024
+# fb_fix_screeninfo has an unsigned long (smem_start) after its 16-byte id.
+LONG = struct.calcsize('@L')
 
 
 def black_frame(variable, fixed):
     x, y, xv, yv, xo, yo, bpp, gray = struct.unpack_from('<8I', variable)
     name = bytes(fixed[:16]).rstrip(b'\0')
-    capacity = struct.unpack_from('<I', fixed, 24)[0]
-    kind, auxiliary, visual = struct.unpack_from('<3I', fixed, 28)
-    stride = struct.unpack_from('<I', fixed, 48)[0]
+    capacity = struct.unpack_from('<I', fixed, 16 + LONG)[0]
+    kind, auxiliary, visual = struct.unpack_from('<3I', fixed, 20 + LONG)
+    stride = struct.unpack_from('<I', fixed, 40 + LONG)[0]
     if (name != b'simpledrmdrmfb' or kind != 0 or visual != 2 or gray or bpp != 32 or
             not (0 < x <= xv <= 8192 and 0 < y <= yv <= 8192) or
             xo + x > xv or yo + y > yv or stride < xv * 4 or stride % 4):
diff --git a/tests/test_armv7_root.py b/tests/test_armv7_root.py
new file mode 100644
index 0000000..7b9a4bc
--- /dev/null
+++ b/tests/test_armv7_root.py
@@ -0,0 +1,169 @@
+"""The armv7 root: built by arm64 tools only, released on its own from orchard's 32-bit index. No builds."""
+import gzip
+import importlib.util
+import io
+import json
+from pathlib import Path
+import struct
+import subprocess
+import sys
+import tarfile
+import tempfile
+import tomllib
+import unittest
+
+PROJECT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(PROJECT))
+import snapshot  # noqa: E402
+
+
+def load(name, path):
+    spec = importlib.util.spec_from_file_location(name, PROJECT / path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+build = load('minimal_build_armv7', 'build.py')
+audit = load('minimal_audit_armv7', 'audit.py')
+base = load('minimal_base_armv7', 'build_base.py')
+
+
+def elf(arch):
+    """The first bytes of an executable of ARCH."""
+    header = bytearray(64)
+    header[:4] = b'\x7fELF'
+    header[4] = audit.ARCHITECTURES[arch]['class']
+    header[5:7] = b'\x01\x01'
+    struct.pack_into('<HH', header, 16, 2, audit.ARCHITECTURES[arch]['machine'])
+    return bytes(header)
+
+
+class Recipe(unittest.TestCase):
+    def test_runs_no_armv7_code(self):
+        """Packages are unpacked by the arm64 apk without their scripts; nothing chroots into the root."""
+        recipe = (PROJECT / 'system/armv7/install-base').read_text()
+        self.assertIn('--arch armv7', recipe)
+        self.assertIn('--no-scripts', recipe)
+        self.assertNotIn('chroot', recipe)
+        self.assertNotIn('qemu', recipe.lower())
+        self.assertNotIn('binfmt', recipe)
+        containerfile = (PROJECT / 'system/armv7/Containerfile').read_text()
+        self.assertEqual(containerfile.split('FROM ')[1].split()[0],
+                         (PROJECT / 'system/Containerfile').read_text().split('FROM ')[1].split()[0],
+                         'both roots come from the one pinned arm64 Alpine image')
+
+    def test_same_services_as_the_arm64_root(self):
+        """The armv7 root carries the arm64 root's packages, plus Alpine's dropbear and udhcpd."""
+        def packages(path):
+            text = (PROJECT / path).read_text().replace('\\\n', ' ')
+            line = next(line for line in text.splitlines() if ' add ' in line and 'apk ' in line)
+            return set(line.split(' add ', 1)[1].split()) - {'--no-cache'}
+        arm64 = packages('system/install-base') - {'merge-usr'}
+        self.assertLessEqual(arm64, packages('system/armv7/install-base'))
+        self.assertLessEqual({'dropbear', 'busybox-extras'}, packages('system/armv7/install-base'))
+
+
+class Selection(unittest.TestCase):
+    def test_platform_descriptors_name_the_architecture(self):
+        with tempfile.TemporaryDirectory() as directory:
+            (Path(directory) / 'platforms').mkdir()
+            for name, arch in (('apple-16k', 'arm64'), ('apple-armv7', 'arm')):
+                (Path(directory) / 'platforms' / f'{name}.toml').write_text(f'[kernel]\narch = "{arch}"\n')
+            self.assertEqual(snapshot.platforms(directory), {'apple-16k': 'aarch64', 'apple-armv7': 'armv7'})
+
+    def test_base_receipt_records_the_architecture(self):
+        self.assertEqual(base.ARCHITECTURES['armv7']['recipe'], 'system/armv7')
+        self.assertEqual(base.ARCHITECTURES['armv7']['root'], '/armroot')
+
+    def test_pinning_without_orchards_arm64_tools(self):
+        with tempfile.TemporaryDirectory() as directory:
+            root = Path(directory)
+            for name in ('splash', 'logo', 'loader'):
+                (root / name).write_bytes(name.encode())
+            command = [sys.executable, str(PROJECT / 'pin_components.py'), '--splash', root / 'splash',
+                       '--logo', root / 'logo']
+            result = subprocess.run([*map(str, command), '--output', str(root / 'out')], capture_output=True, text=True)
+            self.assertEqual(result.returncode, 0, result.stderr)
+            self.assertEqual(sorted(json.loads((root / 'out/inputs.json').read_text())['files']), ['logo', 'splash'])
+            partial = subprocess.run([*map(str, command), '--loader', str(root / 'loader'),
+                                      '--output', str(root / 'other')], capture_output=True, text=True)
+            self.assertNotEqual(partial.returncode, 0)
+
+
+class Root(unittest.TestCase):
+    def base(self, directory, arch='armv7'):
+        path = directory / 'base.tar.gz'
+        with gzip.open(path, 'wb') as raw, tarfile.open(fileobj=raw, mode='w') as archive:
+            for name, data in (('usr/bin/busybox-extras', elf('armv7')), ('etc/apk/arch', b'armv7\n')):
+                member = tarfile.TarInfo(name)
+                member.size, member.mode = len(data), 0o755
+                archive.addfile(member, io.BytesIO(data))
+        receipt = directory / 'base.tar.gz.json'
+        receipt.write_text(json.dumps({'bytes': path.stat().st_size, 'sha256': snapshot.sha(path),
+                                       'architecture': arch}))
+        return path, receipt
+
+    def hardware(self, directory):
+        script = directory / 'orchard/boot/initramfs/recovery/capture-adt'
+        script.parent.mkdir(parents=True)
+        script.write_text('#!/bin/sh\n')
+        return directory / 'orchard'
+
+    def test_armv7_root_has_alpines_tools_not_orchards(self):
+        with tempfile.TemporaryDirectory() as directory:
+            directory = Path(directory)
+            path, receipt = self.base(directory)
+            components = {'splash': directory / 'base.tar.gz.json'}
+            output = directory / 'release'
+            output.mkdir()
+            record = build.root_archive(path, receipt, components, output, '1', self.hardware(directory), 'armv7')
+            self.assertEqual(record['architecture'], 'armv7')
+            with tarfile.open(output / 'rootfs.tar.gz') as archive:
+                names = archive.getnames()
+                copied = archive.extractfile('usr/libexec/minimal-linux/busybox').read()
+            self.assertEqual(copied, elf('armv7'))
+            self.assertNotIn('usr/sbin/dropbear', names, "orchard's arm64 dropbear stays out")
+
+    def test_an_arm64_base_is_refused_for_an_armv7_root(self):
+        with tempfile.TemporaryDirectory() as directory:
+            directory = Path(directory)
+            path, receipt = self.base(directory, arch='aarch64')
+            with self.assertRaisesRegex(ValueError, 'not armv7'):
+                build.root_archive(path, receipt, {}, directory, '1', self.hardware(directory), 'armv7')
+
+    def test_elf_files_must_match_the_root(self):
+        self.assertTrue(audit.check_elf_arch(elf('armv7'), 'armv7'))
+        self.assertFalse(audit.check_elf_arch(b'#!/bin/sh\n', 'armv7'))
+        with self.assertRaises(AssertionError):
+            audit.check_elf_arch(elf('aarch64'), 'armv7')
+
+
+class Manifest(unittest.TestCase):
+    def test_loaders_and_boards_come_from_the_32_bit_index(self):
+        with tempfile.TemporaryDirectory() as directory:
+            source = Path(directory)
+            for name in ('root.blocks.zst', 'root.map.json', 'cascadia-p105.bin', 'install-tools-armv7.tar.gz',
+                         'platform-apple-armv7.tar.gz'):
+                (source / name).write_bytes(name.encode())
+            root = {**build.receipt(source / 'root.blocks.zst'), 'compression': 'zstd', 'format': 'blocks',
+                    'expanded_bytes': 100, 'members': 3, 'map': build.receipt(source / 'root.map.json')}
+            # orchard's platforms-armv7.toml: a Cascadia loader per board.
+            offered = {'architecture': 'arm', 'loaders': {'cascadia': {'p105': build.receipt(source / 'cascadia-p105.bin')}},
+                       'install_tools': build.receipt(source / 'install-tools-armv7.tar.gz'),
+                       'platforms': {'apple-armv7': {**build.receipt(source / 'platform-apple-armv7.tar.gz'),
+                                                     'compression': 'gzip', 'expanded_bytes': 10, 'members': 2,
+                                                     'kernel_release': '6.12-armv7', 'boards': ['p105']}}}
+            manifest = tomllib.loads(build.manifests(source, '1', root, offered,
+                                                     {'commit': 'c' * 40, 'modified': False}, 'armv7').read_text())
+            self.assertEqual(manifest['boot_method'], 'recovery-autogo')
+            self.assertEqual(manifest['cascadia']['p105']['file'], 'cascadia-p105.bin')
+            self.assertNotIn('logo', manifest)
+            self.assertNotIn('pongo', manifest)
+            self.assertNotIn('m1n1', manifest)
+            self.assertEqual(manifest['platforms']['apple-armv7']['boards'], ['p105'])
+            self.assertEqual(manifest['root']['file'], 'root.blocks.zst')
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/test_controls.py b/tests/test_controls.py
index 68ae41c..aa89ada 100644
--- a/tests/test_controls.py
+++ b/tests/test_controls.py
@@ -91,7 +91,7 @@ def test_other_keys_and_touch_are_ignored(self):
     def test_actual_gpio_key_bitmap_and_abi(self):
         bits = buttons.key_bits('100000000000 1c000000000000 0')
         self.assertTrue(all(bits & (1 << key) for key in (114, 115, 116)))
-        self.assertEqual(buttons.EVENT.size, 24)
+        self.assertEqual(buttons.EVENT.size, 24 if buttons.LONG_BITS == 64 else 16)
 
     def test_device_selection_is_unique_and_not_touch(self):
         for event, name in (('event0', 'gpio-keys'), ('event1', 'touchscreen')):
diff --git a/tests/test_splash_clear.py b/tests/test_splash_clear.py
index 8b1d4cd..548618f 100644
--- a/tests/test_splash_clear.py
+++ b/tests/test_splash_clear.py
@@ -11,7 +11,7 @@
 loader.exec_module(module)
 
 
-def layout(width=4, height=3, stride=20, alpha=False):
+def layout(width=4, height=3, stride=20, alpha=False, long=8):
     variable, fixed = bytearray(160), bytearray(80)
     struct.pack_into('<8I', variable, 0, width, height, width, height, 0, 0, 32, 0)
     for offset, shift in ((32, 16), (44, 8), (56, 0)):
@@ -19,13 +19,23 @@ def layout(width=4, height=3, stride=20, alpha=False):
     if alpha:
         struct.pack_into('<3I', variable, 68, 24, 8, 0)
     fixed[:16] = b'simpledrmdrmfb\0\0\0'
-    struct.pack_into('<I', fixed, 24, stride * height)
-    struct.pack_into('<3I', fixed, 28, 0, 0, 2)
-    struct.pack_into('<I', fixed, 48, stride)
+    struct.pack_into('<I', fixed, 16 + long, stride * height)
+    struct.pack_into('<3I', fixed, 20 + long, 0, 0, 2)
+    struct.pack_into('<I', fixed, 40 + long, stride)
     return variable, fixed
 
 
 class Framebuffer(unittest.TestCase):
+    def test_32_bit_layout(self):
+        # armv7: fb_fix_screeninfo's unsigned long is 4 bytes.
+        original = module.LONG
+        module.LONG = 4
+        try:
+            frame, info = module.black_frame(*layout(long=4))
+        finally:
+            module.LONG = original
+        self.assertEqual(info['bytes'], 60)
+
     def test_padded_rows_are_black_without_overrun(self):
         frame, info = module.black_frame(*layout())
         self.assertEqual(frame, b'\0' * 60)
diff --git a/tools/build.py b/tools/build.py
index da0ff3d..483d102 100755
--- a/tools/build.py
+++ b/tools/build.py
@@ -2,7 +2,8 @@
 """orchard build's entry (orchard.toml [release]): the loader and Alpine base, then the release.
 
 orchard runs it as `tools/build.py --version VERSION --output DIRECTORY
-[--platform NAME ... | --platform all]` in this checkout. The loader and base land in out/components/NAME/KEY/, keyed
+[--platform NAME ... | --platform all] [--arch aarch64|armv7]` in this checkout. A release has one
+root, of one architecture: the selected platforms' (apple-armv7: armv7), else --arch, else aarch64. The loader and base land in out/components/NAME/KEY/, keyed
 by the files they are made from, so a build redoes only what changed.
 orchard supplies m1n1, Pongo, the static tools and every platform's kernel
 from its shared cache; the Alpine artwork is data for orchard's m1n1. The release itself is always assembled anew.
@@ -22,6 +23,7 @@
 # What each component is made from, relative to this checkout.
 INPUTS = {
     'base': ['build_base.py', 'system/Containerfile', 'system/install-base'],
+    'base-armv7': ['build_base.py', 'system/armv7/Containerfile', 'system/armv7/install-base'],
     'artwork': ['boot/build-artwork.py', 'boot/generate-logo.py', 'boot/splash.py', 'boot/artwork'],
 }
 
@@ -37,16 +39,34 @@ def main():
     parser.add_argument('--output', type=Path, required=True)
     parser.add_argument('--platform', action='append', default=[],
                         help='build this platform (repeat), or all; orchard passes the selection')
+    parser.add_argument('--arch', choices=sorted(set(snapshot.ARCHITECTURES.values())),
+                        help="the root's architecture (default: the selected platforms', else aarch64)")
     parser.add_argument('--orchard', type=Path, help='orchard snapshot (default: ORCHARD_CHECKOUT, then .orchard)')
     args = parser.parse_args()
     orchard = snapshot.root(args.orchard)
     if 'all' in args.platform and len(args.platform) > 1:
         parser.error('--platform all builds every platform and combines with no other')
-    # The release builder builds every platform when it is given none.
-    selected = [part for name in args.platform if name != 'all' for part in ('--platform', name)]
+    known = snapshot.platforms(orchard)
+    named = [name for name in args.platform if name != 'all']
+    unknown = sorted(set(named) - set(known))
+    if unknown:
+        parser.error(f'unknown platform {", ".join(unknown)}; orchard describes {", ".join(known)}')
+    architectures = {known[name] for name in named} | ({args.arch} if args.arch else set())
+    if len(architectures) > 1:
+        parser.error('one release has one root: choose platforms of one architecture')
+    arch = architectures.pop() if architectures else 'aarch64'
+    if not named and arch != 'aarch64':
+        named = sorted(name for name, value in known.items() if value == arch)
+    # Without names, orchard's inputs cover every arm64 platform.
+    selected = [part for name in named for part in ('--platform', name)]
 
-    base = snapshot.component('base', INPUTS['base'],
-                              lambda path, work: python('build_base.py', '--output', path), artifact='base.tar.gz')
+    if arch == 'aarch64':
+        base = snapshot.component('base', INPUTS['base'],
+                                  lambda path, work: python('build_base.py', '--output', path), artifact='base.tar.gz')
+    else:
+        base = snapshot.component(f'base-{arch}', INPUTS[f'base-{arch}'],
+                                  lambda path, work: python('build_base.py', '--arch', arch, '--output', path),
+                                  artifact='base.tar.gz')
     artwork = snapshot.component('artwork', INPUTS['artwork'],
                                  lambda path, work: python('boot/build-artwork.py', '--output', path),
                                  artifact='artwork')
@@ -57,15 +77,18 @@ def main():
     resolved.parent.mkdir(parents=True, exist_ok=True)
     with tempfile.TemporaryDirectory(prefix='.inputs-', dir=PROJECT / 'out') as temporary:
         snapshot.command(orchard, 'inputs', '--output', resolved, *selected)
-        shared = json.loads(resolved.read_text())['shared']
-        tools = {name: Path(path) for name, path in shared['tools'].items()}
         inputs = Path(temporary) / 'public'
-        python('pin_components.py', '--loader', shared['m1n1'], '--splash', artwork / 'splash',
-               '--logo', artwork / 'logo.bin', '--pongo', shared['pongo'],
-               '--busybox', tools['busybox'], '--dropbear', tools['dropbear'], '--dropbearkey', tools['dropbearkey'],
-               '--wpa-supplicant', tools['wpa_supplicant'], '--wpa-cli', tools['wpa_cli'], '--iw', tools['iw'],
-               '--output', inputs)
-        python('build.py', '--base', base, '--base-receipt', base.with_name(base.name + '.json'),
+        pinned = ['--splash', artwork / 'splash', '--logo', artwork / 'logo.bin']
+        if arch == 'aarch64':
+            # orchard's static arm64 tools; an armv7 root has Alpine's packages of them.
+            shared = json.loads(resolved.read_text())['shared']
+            tools = {name: Path(path) for name, path in shared['tools'].items()}
+            pinned += ['--loader', shared['m1n1'], '--pongo', shared['pongo'],
+                       '--busybox', tools['busybox'], '--dropbear', tools['dropbear'],
+                       '--dropbearkey', tools['dropbearkey'], '--wpa-supplicant', tools['wpa_supplicant'],
+                       '--wpa-cli', tools['wpa_cli'], '--iw', tools['iw']]
+        python('pin_components.py', *pinned, '--output', inputs)
+        python('build.py', '--arch', arch, '--base', base, '--base-receipt', base.with_name(base.name + '.json'),
                '--inputs', inputs / 'inputs.json', '--orchard-inputs', resolved, '--orchard', orchard,
                '--version', args.version, '--output', args.output)
     python('audit.py', args.output, '--orchard', orchard)