Introduction

If you’ve tried to create a bootable OS X El Capitan installer on a modern Apple Silicon Mac, you’ve likely encountered frustrating compatibility errors. The legacy installer package includes architecture checks that prevent installation on ARM-based systems or macOS versions newer than 10.11. This technical barrier can feel like a roadblock when you need to restore or upgrade an older Intel-based Mac.

Fortunately, you can bypass these limitations by manually extracting and processing the installer files directly from the DMG. This guide demonstrates how to use built-in macOS tools like pkgutil, hdiutil, and asr (Apple Software Restore) to build a complete bootable installer without running the incompatible installer application.

🌟 Why This Matters

Legacy Mac systems (2006-2010 era) often require older operating systems like El Capitan for optimal performance or compatibility with specific software. Whether you’re:

…this technique enables you to create proper installation media from modern hardware.

🎯 What You’ll Learn

By following this guide, you’ll be able to:

📋 Before We Begin

Important Warnings:

What You’ll Need:

🏗️ Phase 1: Preparation and Environment Setup

Verify Your Installation Media

First, ensure you have the correct El Capitan installer file:

  1. Locate the DMG: Your El Capitan installer should be named “InstallMacOSX.dmg” or similar, typically in your Downloads folder
  2. Verify integrity: Check the file size (approximately 6.2 GB for the complete installer)
  3. Source verification: Ensure you obtained the installer from Apple’s official support site

Prepare Your SD Card or USB Drive

⚠️ Critical Step: This process completely erases your target media. Back up any existing data first.

Using Disk Utility

  1. Insert your media: Connect the SD card (via card reader if needed) or USB drive to your Mac
  2. Open Disk Utility:
  3. Select the device:
  4. Erase and format:
  5. Verify: The formatted volume should now appear in Finder under /Volumes/SDCard

Quick Terminal Alternative

If you prefer the command line, identify your device first:

# List all disks (identify your SD card carefully!)
diskutil list

Then erase it (replace diskX with your actual disk identifier):

# DANGER: This erases the entire disk
sudo diskutil eraseDisk JHFS+ SDCard GPT /dev/diskX

🔧 Phase 2: Extract Installer Components

This phase bypasses the compatibility checks by manually extracting the installer payload without running the incompatible installer application.

Step 1: Mount the Installer DMG

Objective: Access the installer package files

Implementation:

# Mount the El Capitan installer DMG
hdiutil attach ~/Downloads/InstallMacOSX.dmg -noverify -nobrowse

Expected Result: A volume named “OS X El Capitan Install” (or similar) appears in Finder

What’s Happening: The -noverify flag speeds up mounting by skipping checksum verification, while -nobrowse prevents the volume from appearing in Finder windows (though it’s still accessible).

Step 2: Copy the Installer Package

Objective: Extract the installer package to a working location

Via Finder:

  1. Open Finder and locate the mounted volume “OS X El Capitan Install”
  2. Drag the InstallMacOSX.pkg file to your Desktop

Via Terminal (faster):

# Copy the installer package to Desktop
cp /Volumes/Install\ OS\ X\ El\ Capitan/InstallMacOSX.pkg ~/Desktop/

Step 3: Expand the Package Archive

Objective: Extract the package contents without running the installer

Implementation:

# Open Terminal if not already open
# Navigate to Desktop
cd ~/Desktop

# Expand the .pkg file into a directory structure
pkgutil --expand InstallMacOSX.pkg Installer

Expected Result: A new folder named Installer appears on your Desktop containing the unpacked package structure

Understanding pkgutil: The --expand option flattens the package structure, making individual components accessible without installation.

Step 4: Extract the Payload

Objective: Unpack the compressed payload containing the actual installer files

Implementation:

# Navigate into the expanded package
cd ~/Desktop/Installer/InstallMacOSX.pkg

# Extract the tar-compressed payload
tar -xvf Payload

Expected Result: You’ll see extraction progress for numerous files. The -xvf flags mean:

Troubleshooting: If you see “No such file or directory”, verify you’re in the correct directory with pwd (should show /Users/[yourname]/Desktop/Installer/InstallMacOSX.pkg)

Step 5: Locate the Essential Installer Image

Objective: Find and extract the InstallESD.dmg file, which contains the actual OS installation files

Implementation:

# The extracted files create an Applications directory structure
# Move the critical InstallESD.dmg to Desktop for easier access
mv InstallESD.dmg ~/Desktop/

# Alternative: Find it if the structure differs
find ~/Desktop/Installer -name "InstallESD.dmg" -exec mv {} ~/Desktop/ \;

Expected Result: InstallESD.dmg now exists on your Desktop (approximately 6 GB)

Step 6: Cleanup Initial Extraction

Objective: Free up disk space and unmount the original installer

# Eject the original mounted DMG
hdiutil detach "/Volumes/Install OS X El Capitan"

# Optional: Remove the expanded package to save space
rm -rf ~/Desktop/Installer

What We’ve Accomplished: You now have the core installer image (InstallESD.dmg) extracted and ready for processing, without running any incompatible installer code.

⚡ Phase 3: Build the Bootable Image

This phase transforms the extracted installer into a complete, bootable disk image. We’ll use a sparse image format for efficient manipulation before creating the final compressed image.

Step 1: Mount the InstallESD Image

Objective: Access the base system files needed for booting

Implementation:

# Mount InstallESD.dmg to a specific location
hdiutil attach ~/Desktop/InstallESD.dmg -noverify -nobrowse -mountpoint /Volumes/install_app

Expected Result: The image mounts silently at /Volumes/install_app

Technical Note: Custom mount points prevent conflicts if you have other volumes mounted and provide predictable paths for scripting.

Step 2: Convert Base System to Sparse Image

Objective: Create a modifiable working copy of the base system

Implementation:

# Convert BaseSystem.dmg to a sparse (resizable) format
hdiutil convert /Volumes/install_app/BaseSystem.dmg -format UDSP -o /tmp/Installer

Expected Result: Creates /tmp/Installer.sparseimage (approximately 2 GB initially)

Why Sparse Images?: Unlike standard DMG files, sparse images can grow dynamically as we add content, making them perfect for building custom installers.

Step 3: Resize to Accommodate All Files

Objective: Expand the sparse image to hold the complete installer

Implementation:

# Resize to 8GB (sufficient for El Capitan installer)
hdiutil resize -size 8g /tmp/Installer.sparseimage

Expected Result: Image capacity increases to 8 GB without immediately using that disk space

Troubleshooting: If you see “Resource busy”, ensure no other process is accessing the image. Use lsof | grep Installer to check.

Step 4: Mount the Working Image

Objective: Access the sparse image to add installer components

Implementation:

# Mount the resized sparse image
hdiutil attach /tmp/Installer.sparseimage -noverify -nobrowse -mountpoint /Volumes/install_build

Expected Result: Mounted at /Volumes/install_build, ready for modification

Step 5: Replace Placeholder Packages

Objective: Remove the symbolic link and add actual installer packages

Implementation:

# Remove the placeholder Packages symlink
rm -r /Volumes/install_build/System/Installation/Packages

# Copy the complete package directory from the source
cp -av /Volumes/install_app/Packages /Volumes/install_build/System/Installation/

Expected Result: Progress output showing copied files (approximately 5.5 GB)

Understanding -av flags:

Troubleshooting: If the copy fails with “Operation not permitted”, ensure Terminal has Full Disk Access:

Step 6: Copy Essential Boot Files

Objective: Add the files needed for the installer to boot correctly

Implementation:

# Copy the chunklist verification file
cp -av /Volumes/install_app/BaseSystem.chunklist /Volumes/install_build/

# Copy the base system image
cp -av /Volumes/install_app/BaseSystem.dmg /Volumes/install_build/

Expected Result: Two additional files copied to the root of the installer

What Are These Files?:

Step 7: Unmount All Working Volumes

Objective: Safely detach volumes before finalizing the image

Implementation:

# Unmount the source installer
hdiutil detach /Volumes/install_app

# Unmount the working sparse image
hdiutil detach /Volumes/install_build

Expected Result: Both volumes disappear from Finder and /Volumes/

Why This Matters: Unmounting ensures all file buffers are flushed to disk and prevents corruption.

Step 8: Optimize Image Size

Objective: Shrink the sparse image to its minimum required size

Implementation:

# Calculate minimum size and resize
hdiutil resize -size $(hdiutil resize -limits /tmp/Installer.sparseimage | tail -n 1 | awk '{print $1}')b /tmp/Installer.sparseimage

Expected Result: Image size reduces to approximately 6.2 GB (just enough for the content)

Command Breakdown:

Step 9: Create Final Compressed Image

Objective: Convert the sparse image to a compressed, efficient DMG

Implementation:

# Convert to compressed DMG format
hdiutil convert /tmp/Installer.sparseimage -format UDZO -o /tmp/Installer

Expected Result: Creates /tmp/Installer.dmg (approximately 5.8 GB compressed)

Format Details:

Step 10: Move to Accessible Location

Objective: Place the final installer image where it’s easy to find

Implementation:

# Move the completed installer to Desktop
mv /tmp/Installer.dmg ~/Desktop/ElCapitan-Bootable.dmg

Expected Result: ElCapitan-Bootable.dmg now on your Desktop, ready to restore to physical media

Cleanup (optional):

# Remove the sparse image to free up space
rm /tmp/Installer.sparseimage

🚀 Phase 4: Restore to Physical Media

The final phase writes the bootable installer image to your SD card or USB drive using Apple Software Restore (ASR).

Step 1: Verify Your Target Media

Objective: Confirm the target device is mounted and ready

Implementation:

# List all mounted volumes
ls -la /Volumes/

# Specifically check for your SD card
ls -la /Volumes/SDCard

Expected Result: You should see your formatted SD card listed (we named it “SDCard” earlier)

Troubleshooting: If not found:

Step 2: Restore the Image Using ASR

Objective: Block-copy the bootable installer to physical media

Implementation:

# Restore the image to your SD card
sudo asr restore --source ~/Desktop/ElCapitan-Bootable.dmg --target /Volumes/SDCard --noprompt --noverify --erase

You’ll Be Asked For: Your administrator password

Expected Result:

Command Breakdown:

Progress Indicators:

Validating target...done
Validating source...done
Retrieving scan information...done
Validating sizes...done
Restoring  ....10....20....30....40....50....60....70....80....90....100
Verifying  ....10....20....30....40....50....60....70....80....90....100
Restored target device is /Volumes/OS X Base System

Step 3: Verify Successful Restoration

Objective: Confirm the bootable installer is properly written

Implementation:

# Check the renamed volume
ls -la /Volumes/

# Verify installer contents
ls -la "/Volumes/OS X Base System/"

Expected Result:

Additional Verification (optional):

# Check the volume's bootability
bless --info "/Volumes/OS X Base System" --getBless

This should show blessing information confirming the volume is bootable.

Step 4: Safe Ejection

Objective: Properly unmount the media before physical removal

Via Finder:

  1. Locate “OS X Base System” in Finder sidebar
  2. Click the eject icon next to it
  3. Wait for the volume to disappear

Via Terminal:

# Safely eject the volume
diskutil eject "/Volumes/OS X Base System"

Expected Result: Message confirming successful ejection

Critical: Always eject properly to prevent data corruption. Don’t just pull out the media!

🧹 Phase 5: Cleanup and Testing

Cleanup Working Files

Objective: Free up disk space by removing temporary files

Implementation:

# Remove the extracted installer files (if still present)
rm -rf ~/Desktop/Installer

# Remove the working DMG files
rm ~/Desktop/InstallESD.dmg
rm ~/Desktop/InstallMacOSX.pkg

# Optional: Keep the final bootable DMG for future use
# rm ~/Desktop/ElCapitan-Bootable.dmg

Expected Result: Approximately 12 GB of disk space freed

Best Practice: Keep ElCapitan-Bootable.dmg as a master copy for creating additional bootable media later.

Testing the Bootable Installer

On Target Intel Mac (2009 or Compatible)

Objective: Verify the installer boots correctly on legacy hardware

Implementation Steps:

  1. Insert the media into your target Mac:
  2. Power on with boot menu:
  3. Select the installer:
  4. Wait for boot:

Expected Result: OS X Utilities menu with options:

Success Indicators:

Alternative Boot Methods

Firmware Boot Picker (if Option key doesn’t work):

  1. Power on while holding Command (⌘) + Option (⌥) + O + F
  2. At the OpenFirmware prompt, type: 
    boot usb0/disk@1:2,\\:tbxi

    Or try variations: usb1, sd0, etc.

Target Disk Mode Test (advanced):

  1. Connect target Mac to another Mac via FireWire/Thunderbolt
  2. Boot target Mac holding T key
  3. Verify the installer appears as an external disk
  4. Check folder structure matches expectations

Troubleshooting Common Issues

Issue 1: SD Card Not Recognized for Booting

Symptoms: SD card doesn’t appear in Startup Manager

Causes:

Solutions:

  1. Use USB drive instead: Repeat process with USB drive (higher compatibility)
  2. Check Apple Support: Verify your Mac model supports SD card booting
  3. Test the card: Try the SD card in Disk Utility on a working Mac

Command to check:

# See if your Mac's model identifier supports SD boot
system_profiler SPHardwareDataType | grep "Model Identifier"

Then search Apple’s support database for your specific model.

Issue 2: “Prohibited” Symbol on Boot

Symptoms: Circle with line through it (🚫) appears when booting

Causes:

Solutions:

  1. Re-create the installer: Start the process fresh
  2. Verify source DMG: Re-download from Apple if suspect
  3. Check target Mac: Confirm El Capitan compatibility

Issue 3: Kernel Panic During Boot

Symptoms: Multi-language panic message appears

Causes:

Solutions:

  1. Test RAM: Run Apple Hardware Test on target Mac
  2. Try different media: USB vs SD card
  3. Reset NVRAM: Boot holding Command + Option + P + R

Symptoms: Progress bar freezes, Mac doesn’t respond

Causes:

Solutions:

  1. Wait longer: First boot can take 10-15 minutes
  2. Use faster media: Try USB 3.0 drive if available
  3. Check connections: Ensure solid contact in ports

Issue 5: Permission Errors During Creation

Symptoms: “Operation not permitted” when copying files

Causes: Terminal lacks Full Disk Access

Solutions:

  1. Grant Terminal access:
  2. Alternative approach: 
    # Run with explicit sudo if needed
sudo bash -c 'cp -av /source /destination'

✅ Validation and Success Criteria

Verification Checklist

Before considering this project complete, verify:

Testing on Actual Hardware

Best Practice: Test installation on a non-critical Mac first

  1. Prepare test target:
  2. Full installation test:

Virtual Machine Testing (Alternative)

If you have access to VMware Fusion or Parallels:

# Create VM with El Capitan support
# Configure VM to boot from your bootable DMG
# Test installer flow in isolated environment

Note: VM testing confirms image integrity but doesn’t guarantee hardware compatibility.

💡 Understanding the Process: Technical Deep Dive

Why Manual Extraction Is Necessary

Apple’s installer packages include built-in compatibility checks that verify:

When you try to run InstallMacOSX.pkg on an Apple Silicon Mac, these checks fail because:

  1. The package expects Intel architecture
  2. Your Mac is running macOS 11+ (El Capitan is 10.11)
  3. The installer binary itself is Intel-only

Manual extraction bypasses these checks by accessing the payload directly without running any verification code.

The Role of Each File

Understanding what each component does helps troubleshoot issues:

File/Component Purpose Critical?
InstallESD.dmg Complete installer image with all OS files ✅ Essential
BaseSystem.dmg Minimal bootable system that runs the installer ✅ Essential
BaseSystem.chunklist Cryptographic verification for secure boot ✅ Essential
Packages/ Individual OS components and updates ✅ Essential
InstallMacOSX.pkg Wrapper with compatibility checks ⚠️ Only for extraction

Image Format Deep Dive

Sparse Images (UDSP):

Compressed Images (UDZO):

Conversion Process:

Read/Write DMG → Sparse Image → Modified Sparse → Compressed DMG
(BaseSystem.dmg) → (Working copy) → (Added packages) → (Final installer)

ASR (Apple Software Restore) Explained

ASR performs block-level copying with several advantages:

  1. Bit-perfect restoration: Exact sector-by-sector copy
  2. Partition table creation: Sets up GUID/GPT correctly
  3. Blessing the system: Marks the volume as bootable
  4. Metadata preservation: Keeps all extended attributes

Why not just copy files?: Simple file copying misses:

🚀 Next Steps and Advanced Applications

Creating Multiple Bootable Installers

Once you have ElCapitan-Bootable.dmg, you can easily create additional installers:

# Fast restoration to another drive (replace diskX)
sudo asr restore --source ~/Desktop/ElCapitan-Bootable.dmg \
  --target /Volumes/AnotherDrive --noprompt --erase

Automating the Process

Create a reusable script (make-elcapitan-installer.sh):

#!/bin/bash
# Automated El Capitan Bootable Installer Creator
# Usage: ./make-elcapitan-installer.sh /path/to/InstallMacOSX.dmg

set -e  # Exit on any error

SOURCE_DMG="$1"
WORK_DIR="/tmp/elcapitan-build"
OUTPUT="$HOME/Desktop/ElCapitan-Bootable.dmg"

if [ -z "$SOURCE_DMG" ]; then
    echo "Usage: $0 <path-to-InstallMacOSX.dmg>"
    exit 1
fi

echo "🚀 Starting El Capitan bootable installer creation..."

# Create work directory
mkdir -p "$WORK_DIR"
cd "$WORK_DIR"

# Mount source
echo "📦 Mounting source installer..."
hdiutil attach "$SOURCE_DMG" -noverify -nobrowse -mountpoint /Volumes/install_source

# Extract package
echo "📂 Extracting installer package..."
pkgutil --expand /Volumes/install_source/InstallMacOSX.pkg "$WORK_DIR/Installer"
cd "$WORK_DIR/Installer/InstallMacOSX.pkg"
tar -xvf Payload

# Get InstallESD
echo "💾 Locating InstallESD.dmg..."
find . -name "InstallESD.dmg" -exec cp {} "$WORK_DIR/" \;

# Build bootable image
echo "🔨 Building bootable image..."
hdiutil attach "$WORK_DIR/InstallESD.dmg" -noverify -nobrowse -mountpoint /Volumes/install_app
hdiutil convert /Volumes/install_app/BaseSystem.dmg -format UDSP -o "$WORK_DIR/Installer"
hdiutil resize -size 8g "$WORK_DIR/Installer.sparseimage"
hdiutil attach "$WORK_DIR/Installer.sparseimage" -noverify -nobrowse -mountpoint /Volumes/install_build

# Copy packages
echo "📦 Copying installer packages..."
rm -rf /Volumes/install_build/System/Installation/Packages
cp -av /Volumes/install_app/Packages /Volumes/install_build/System/Installation/
cp -av /Volumes/install_app/BaseSystem.* /Volumes/install_build/

# Finalize
echo "✨ Finalizing image..."
hdiutil detach /Volumes/install_app
hdiutil detach /Volumes/install_build
hdiutil resize -size $(hdiutil resize -limits "$WORK_DIR/Installer.sparseimage" | tail -n 1 | awk '{print $1}')b "$WORK_DIR/Installer.sparseimage"
hdiutil convert "$WORK_DIR/Installer.sparseimage" -format UDZO -o "$OUTPUT"

# Cleanup
echo "🧹 Cleaning up..."
hdiutil detach /Volumes/install_source
rm -rf "$WORK_DIR"

echo "✅ Complete! Bootable installer: $OUTPUT"

Make it executable and use:

chmod +x make-elcapitan-installer.sh
./make-elcapitan-installer.sh ~/Downloads/InstallMacOSX.dmg

Extending to Other Legacy macOS Versions

This technique works for other legacy macOS releases:

For Sierra and later, the installer is an app bundle, so adjust the extraction:

# For Sierra-style installers
cp -R "/Volumes/Install macOS Sierra/Install macOS Sierra.app" /Applications/
sudo /Applications/Install\ macOS\ Sierra.app/Contents/Resources/createinstallmedia \
  --volume /Volumes/SDCard --applicationpath /Applications/Install\ macOS\ Sierra.app

Network Installation Option

For multiple Mac restorations, consider NetBoot:

  1. Set up macOS Server (or compatible NetBoot server)
  2. Create NetInstall image from your bootable DMG
  3. Boot target Macs holding N key for network boot
  4. Install over network (requires ethernet for older Macs)

Creating Hybrid Installation Media

Combine multiple installers on one large USB drive:

# Partition the drive
diskutil partitionDisk /dev/diskX 2 GPT \
  JHFS+ "El Capitan" 8G \
  JHFS+ "Sierra" 8G

# Restore each partition
sudo asr restore --source ~/Desktop/ElCapitan-Bootable.dmg \
  --target /Volumes/El\ Capitan --noprompt --erase
sudo asr restore --source ~/Desktop/Sierra-Bootable.dmg \
  --target /Volumes/Sierra --noprompt --erase

Result: Single USB drive with multiple bootable partitions.

📚 Resources and Further Learning

Essential Documentation

Disk Utility Alternatives:

Verification Tools:

# Verify bootability
bless --info "/Volumes/OS X Base System" --getBless

# Check partition scheme
diskutil info "/Volumes/OS X Base System" | grep "Partition Type"

# Verify file integrity
shasum -a 256 ~/Desktop/ElCapitan-Bootable.dmg

Community Resources

Video Tutorials

Search for these topics on YouTube:

Books and Guides

🎓 Key Takeaways and Learning Summary

What You’ve Mastered

Through this guide, you’ve learned:

  1. Manual Package Extraction: Using pkgutil and tar to bypass installer restrictions
  2. Disk Image Manipulation: Converting between formats with hdiutil
  3. Sparse Image Workflows: Dynamic storage allocation for efficient building
  4. Apple Software Restore: Block-level disk restoration with asr
  5. Bootable Media Creation: Complete process from source DMG to working installer
  6. Legacy System Support: Techniques applicable to multiple macOS versions

Core Concepts

Architecture Limitations: Understanding why certain software won’t run on incompatible hardware architecture (ARM vs Intel).

Installer Anatomy: Modern macOS installers are multi-layered with:

Bootability Requirements: For media to boot a Mac, it needs:

Skill Progression Path

You’ve completed: 🟡 Intermediate system administration

Next challenges to tackle:

Real-World Applications

These skills are valuable for:

IT Support Roles:

Personal Projects:

Professional Development:

🔍 Troubleshooting Quick Reference

Command Checklist

If something goes wrong, verify these key steps:

# 1. Verify source DMG integrity
hdiutil verify ~/Downloads/InstallMacOSX.dmg

# 2. Check available disk space (need ~12GB free)
df -h

# 3. Verify Terminal permissions
ls -la ~/Desktop/InstallESD.dmg

# 4. Check target media is writable
diskutil info /Volumes/SDCard | grep "Read-Only"

# 5. Verify final image is valid
hdiutil verify ~/Desktop/ElCapitan-Bootable.dmg

Error Code Reference

Error Message Likely Cause Solution
“Operation not permitted” Permissions issue Grant Terminal Full Disk Access
“Resource busy” Volume in use Unmount with diskutil unmount
“No such file or directory” Wrong path Verify path with pwd and ls
“Not enough space” Insufficient disk space Free up space or use external drive
“Invalid argument” Syntax error Check command syntax carefully
“Device not found” Media not mounted Check with diskutil list

Recovery Strategies

If the process fails mid-way:

  1. Unmount all volumes: 
    hdiutil detach /Volumes/install_app
hdiutil detach /Volumes/install_build
  2. Clean up temp files: 
    rm -rf /tmp/Installer*
rm -rf ~/Desktop/Installer

  3. Start fresh: Re-download the source DMG if suspect corruption

  4. Check system logs for detailed errors: 
    log show --predicate 'process == "hdiutil"' --last 10m

📝 Final Thoughts

Creating bootable installers for legacy macOS versions on modern Apple Silicon Macs demonstrates an important principle in system administration: understanding the underlying technology enables creative problem-solving. While Apple’s tools include restrictions designed to prevent errors, knowing how to work around them (safely and purposefully) is a valuable skill.

This technique preserves access to older systems that remain useful for specific tasks, software compatibility, or historical preservation. Whether you’re maintaining a vintage Mac lab, supporting legacy applications, or simply exploring computing history, these skills bridge the gap between modern and legacy technology.

Share Your Experience

Did this guide help you successfully create an El Capitan installer? Encounter any unique challenges or discover improvements to the process? Share your experience in the comments below to help others in the community.

What’s Next?

Continue your legacy Mac journey:

Article last updated: October 13, 2025
Tested on: MacBook Pro (M3, 2024) running macOS Sequoia 15.0
Target hardware: MacBook (Late 2009, Early 2010)