feat: add ARM64 architecture support with emulation

- Detect ARM64 architecture and provide helpful warnings
- Automatically use Rosetta 2 on macOS for x86_64 emulation
- Support qemu-x86_64 on Linux for ARM64 systems
- Show one-time warning with installation instructions
- Gracefully handle missing emulation layer with clear guidance

This makes solc-select usable on ARM64 systems including:
- Apple Silicon Macs (M1/M2/M3)
- ARM64 Linux servers and VMs
- Raspberry Pi and other ARM devices

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: dguido

solc_select/__main__.py

@@ -11,6 +11,7 @@
 )
 from .solc_select import (
     current_version,
+    get_emulation_prefix,
     get_installable_versions,
     halt_incompatible_system,
     halt_old_architecture,
@@ -101,11 +102,12 @@ def solc() -> None:
         path = ARTIFACTS_DIR.joinpath(f"solc-{version}", f"solc-{version}")
         halt_old_architecture(path)
         halt_incompatible_system(path)
+
+        # Use emulation if needed for ARM64 systems
+        cmd = get_emulation_prefix() + [str(path)] + sys.argv[1:]
+
         try:
-            subprocess.run(
-                [str(path)] + sys.argv[1:],
-                check=True,
-            )
+            subprocess.run(cmd, check=True)
         except subprocess.CalledProcessError as e:
             sys.exit(e.returncode)
     else:

solc_select/solc_select.py

@@ -1,9 +1,12 @@
 import argparse
+import contextlib
 import hashlib
 import json
 import os
+import platform
 import re
 import shutil
+import subprocess
 import sys
 import urllib.request
 from pathlib import Path
@@ -28,6 +31,102 @@
 Path.mkdir(ARTIFACTS_DIR, parents=True, exist_ok=True)
 
 
+def get_arch() -> str:
+    """Get the current system architecture."""
+    machine = platform.machine().lower()
+    if machine in ["x86_64", "amd64"]:
+        return "amd64"
+    elif machine in ["aarch64", "arm64"]:
+        return "arm64"
+    elif machine in ["i386", "i686"]:
+        return "386"
+    return machine
+
+
+def check_emulation_available() -> bool:
+    """Check if x86_64 emulation is available."""
+    if get_arch() != "arm64":
+        return False
+
+    # On macOS, check for Rosetta 2
+    if sys.platform == "darwin":
+        # Check if we can run x86_64 binaries
+        try:
+            result = subprocess.run(["arch", "-x86_64", "true"], capture_output=True, check=False)
+            return result.returncode == 0
+        except (FileNotFoundError, OSError):
+            return False
+
+    # On Linux, check for qemu-x86_64
+    try:
+        result = subprocess.run(
+            ["which", "qemu-x86_64"], capture_output=True, text=True, check=False
+        )
+        return result.returncode == 0
+    except (FileNotFoundError, OSError):
+        return False
+
+
+def get_emulation_prefix() -> list:
+    """Get the command prefix for emulation if needed."""
+    if get_arch() != "arm64":
+        return []
+
+    # On macOS, use arch command for Rosetta 2
+    if sys.platform == "darwin" and check_emulation_available():
+        return ["arch", "-x86_64"]
+
+    # On Linux, use qemu
+    if sys.platform.startswith("linux") and check_emulation_available():
+        return ["qemu-x86_64"]
+
+    return []
+
+
+def warn_about_arm64(force: bool = False) -> None:
+    """Warn ARM64 users about compatibility and suggest solutions."""
+    if get_arch() != "arm64":
+        return
+
+    # Check if we've already warned
+    warning_file = SOLC_SELECT_DIR.joinpath(".arm64_warning_shown")
+    if not force and warning_file.exists():
+        return
+
+    print("\n⚠️  WARNING: ARM64 Architecture Detected", file=sys.stderr)
+    print("=" * 50, file=sys.stderr)
+
+    if check_emulation_available():
+        if sys.platform == "darwin":
+            print("✓ Rosetta 2 detected - will use emulation for x86 binaries", file=sys.stderr)
+        else:
+            print("✓ qemu-x86_64 detected - will use emulation for x86 binaries", file=sys.stderr)
+        print("  Note: Performance will be slower than native execution", file=sys.stderr)
+    else:
+        if sys.platform == "darwin":
+            print(
+                "✗ solc binaries are x86_64 only, and Rosetta 2 is not available", file=sys.stderr
+            )
+        else:
+            print("✗ solc binaries are x86_64 only, and qemu is not installed", file=sys.stderr)
+        print("\nTo use solc-select on ARM64, you can:", file=sys.stderr)
+        print("  1. Install qemu for x86_64 emulation:", file=sys.stderr)
+        if sys.platform.startswith("linux"):
+            print("     sudo apt-get install qemu-user-static  # Debian/Ubuntu", file=sys.stderr)
+            print("     sudo dnf install qemu-user-static      # Fedora", file=sys.stderr)
+            print("     sudo pacman -S qemu-user-static        # Arch", file=sys.stderr)
+        elif sys.platform == "darwin":
+            print("     Use Rosetta 2 (installed automatically on Apple Silicon)", file=sys.stderr)
+        print("  2. Use an x86_64 Docker container", file=sys.stderr)
+        print("  3. Use a cloud-based development environment", file=sys.stderr)
+    print("=" * 50, file=sys.stderr)
+    print(file=sys.stderr)
+
+    # Mark that we've shown the warning
+    with contextlib.suppress(OSError):
+        warning_file.touch()
+
+
 def validate_url_scheme(url: str) -> None:
     """Validate that URL uses a safe scheme (http or https only)."""
     parsed = urlparse(url)
@@ -107,6 +206,10 @@ def artifact_path(version: str) -> Path:
 
 
 def install_artifacts(versions: [str], silent: bool = False) -> bool:
+    # Warn ARM64 users about compatibility on first install
+    if get_arch() == "arm64" and not silent:
+        warn_about_arm64()
+
     releases = get_available_versions()
     versions = [get_latest_release() if ver == "latest" else ver for ver in versions]