¿Por Qué Desarrollar de Forma Remota?
El desarrollo remoto con Xcode no es solo para personas que no tienen un Mac. Muchos equipos profesionales usan servidores Mac remotos incluso cuando tienen máquinas locales, debido a las ventajas significativas:
-
Servidor de Compilación Siempre Activo
Tu Mac remoto funciona 24/7 en un datacenter. Los pipelines CI/CD, las compilaciones nocturnas y los tests automatizados se ejecutan sin necesidad de mantener tu portátil abierto.
-
Red de 1Gbps, tráfico ilimitado
La red de nivel datacenter significa clones git más rápidos, descargas de dependencias y subidas de artefactos. Las instalaciones de CocoaPods y las resoluciones de SPM se realizan en segundos.
-
Entorno Consistente
Cada miembro del equipo se conecta a la misma configuración de servidor. Se acabaron los problemas de "funciona en mi máquina" causados por diferentes versiones de macOS o configuraciones de Xcode.
-
Trabaja Desde Cualquier Dispositivo
Accede a tu entorno completo de desarrollo con Xcode en un servidor macOS dedicado desde un portátil Windows, un escritorio Linux, un Chromebook o incluso un iPad con un cliente SSH. ¿Necesitas Xcode para un solo build? Alquila un Mac mini por días desde $14/día (USD, sin impuestos); desactiva la renovación automática al desplegar y se detendrá a las 24 horas.
Método 1: SSH + xcodebuild CLI
El enfoque más ligero. Editas código en tu editor preferido localmente (o en el servidor), luego compilas usando xcodebuild a través de SSH. Este método funciona desde cualquier dispositivo con un terminal.
Configurar Claves SSH
# Generate SSH key on your local machine (if you don't have one)
ssh-keygen -t ed25519 -C "dev@company.com"
# Copy your public key to the remote Mac
ssh-copy-id user@your-mac.myremotemac.com
# Configure SSH for convenience (~/.ssh/config)
Host mac-dev
HostName your-mac.myremotemac.com
User your-username
IdentityFile ~/.ssh/id_ed25519
ForwardAgent yes
ServerAliveInterval 60
ServerAliveCountMax 3
Compression yes
# Now connect with just:
ssh mac-dev
Comandos Comunes de xcodebuild
# List available schemes
xcodebuild -list -project MyApp.xcodeproj
# Build for iOS Simulator
xcodebuild -project MyApp.xcodeproj \
-scheme MyApp \
-destination 'generic/platform=iOS Simulator' \
clean build
# Build with workspace (CocoaPods/SPM)
xcodebuild -workspace MyApp.xcworkspace \
-scheme MyApp \
-destination 'generic/platform=iOS Simulator' \
build
# Run unit tests (use any device listed by: xcrun simctl list devices available)
xcodebuild test \
-workspace MyApp.xcworkspace \
-scheme MyApp \
-destination 'platform=iOS Simulator,name=iPhone 17,OS=latest' \
-resultBundlePath ./TestResults.xcresult
# Archive for distribution (App Store Connect requires Xcode 26 or later)
xcodebuild archive \
-workspace MyApp.xcworkspace \
-scheme MyApp \
-configuration Release \
-destination 'generic/platform=iOS' \
-archivePath ./build/MyApp.xcarchive \
CODE_SIGN_IDENTITY="Apple Distribution" \
PROVISIONING_PROFILE_SPECIFIER="MyApp Distribution"
# Export IPA from archive
xcodebuild -exportArchive \
-archivePath ./build/MyApp.xcarchive \
-exportPath ./build/ipa \
-exportOptionsPlist ExportOptions.plist
# Upload to App Store Connect
xcrun altool --upload-app \
-f ./build/ipa/MyApp.ipa \
-t ios \
-u "apple-id@example.com" \
-p "@keychain:AC_PASSWORD"
Usar tmux para Sesiones Persistentes
Usa tmux para mantener tus compilaciones en ejecución incluso si tu conexión SSH se interrumpe.
# Install tmux via Homebrew
brew install tmux
# Start a new tmux session
tmux new -s build
# Run your build inside tmux
xcodebuild -workspace MyApp.xcworkspace -scheme MyApp build
# Detach from tmux: press Ctrl+B, then D
# Your build keeps running on the server
# Reconnect later
ssh mac-dev
tmux attach -t build
Método 2: VNC para GUI Completa
VNC te da acceso completo al escritorio macOS, incluyendo la interfaz visual de Xcode, Interface Builder, los simuladores iOS en Device Hub e Instruments. Este es el mejor método cuando necesitas la experiencia completa de GUI de Xcode.
Conectarse a Compartir Pantalla
# My Remote Mac serves Screen Sharing (VNC) on port 59010:
# point your VNC client at YOUR-IP:59010 and sign in with
# your macOS username and password
# On a Mac you manage yourself, turn on Screen Sharing in
# System Settings > General > Sharing. Since macOS 12.1 the
# kickstart command can no longer enable it.
# Verify Screen Sharing is running (over SSH)
sudo launchctl list | grep -i screensharing
Clientes VNC Recomendados por SO
| Tu SO | Cliente Recomendado | Notas |
|---|---|---|
| Windows | RealVNC Viewer (gratis) | Mejor rendimiento, soporta high-DPI de Apple |
| Linux | Remmina o TigerVNC | Remmina tiene túnel SSH integrado |
| macOS | Compartir Pantalla integrado | Abre Finder > Ir > Conectar al Servidor > vnc:// |
| Chromebook | VNC Viewer (Chrome Web Store) | Funciona bien para acceso básico a GUI |
| iPad/iPhone | Screens 5 o RealVNC | Gestos táctiles para interacción con macOS |
VNC Seguro vía Túnel SSH
Siempre usa un túnel SSH para las conexiones VNC para cifrar todo el tráfico.
# Create SSH tunnel for VNC (run on your LOCAL machine)
ssh -L 5900:localhost:5900 -N -f mac-dev
# Now connect your VNC client to: localhost:5900
# All traffic is encrypted through the SSH tunnel
# On Windows with PuTTY:
# Connection > SSH > Tunnels
# Source port: 5900
# Destination: localhost:5900
# Click "Add", then connect
Consejos de Optimización VNC
- Reducir la resolución de pantalla: Configura el Mac remoto a 1920x1080 en lugar de Retina para un renderizado más rápido.
- Reducir la profundidad de color: En tu cliente VNC, establece la calidad de color a Media o 16 bits para mejor rendimiento.
- Desactivar transparencia: En el Mac remoto, ve a Ajustes del Sistema > Accesibilidad > Pantalla > Reducir transparencia.
- Cerrar aplicaciones innecesarias: Cada ventana abierta aumenta los datos de pantalla que necesitan ser transferidos.
- Usar compresión SSH: Añade
Compression yesa tu configuración SSH para el túnel.
Método 3: VS Code Remote SSH
VS Code Remote SSH te da lo mejor de ambos mundos: la capacidad de respuesta del editor local con la potencia de computación del Mac remoto. Tus pulsaciones de teclado son locales, tus compilaciones se ejecutan en el servidor.
Instalar y Configurar
# Step 1: Install VS Code extensions
# Open VS Code and install these extensions:
# - Remote - SSH (ms-vscode-remote.remote-ssh)
# - Swift (sswg.swift-lang)
# - CodeLLDB (vadimcn.vscode-lldb) - for debugging
# Step 2: Configure SSH in ~/.ssh/config
Host mac-dev
HostName your-mac.myremotemac.com
User your-username
IdentityFile ~/.ssh/id_ed25519
ForwardAgent yes
ServerAliveInterval 60
# Step 3: Connect
# Press Ctrl+Shift+P (or Cmd+Shift+P on macOS)
# Type: "Remote-SSH: Connect to Host"
# Select: mac-dev
# VS Code installs its server component on the remote Mac
# Open your project folder
Configurar Tareas de Compilación
Crea un .vscode/tasks.json en tu proyecto para ejecutar xcodebuild desde VS Code:
{
"version": "2.0.0",
"tasks": [
{
"label": "Build iOS (Simulator)",
"type": "shell",
"command": "xcodebuild",
"args": [
"-workspace", "MyApp.xcworkspace",
"-scheme", "MyApp",
"-destination", "generic/platform=iOS Simulator",
"build"
],
"group": {
"kind": "build",
"isDefault": true
},
"problemMatcher": ["$xcodebuild"]
},
{
"label": "Run Tests",
"type": "shell",
"command": "xcodebuild",
"args": [
"test",
"-workspace", "MyApp.xcworkspace",
"-scheme", "MyApp",
"-destination", "platform=iOS Simulator,name=iPhone 17,OS=latest"
],
"group": "test",
"problemMatcher": ["$xcodebuild"]
},
{
"label": "Clean Build",
"type": "shell",
"command": "xcodebuild",
"args": [
"-workspace", "MyApp.xcworkspace",
"-scheme", "MyApp",
"clean"
],
"problemMatcher": []
}
]
}
Ahora puedes presionar Ctrl+Shift+B (o Cmd+Shift+B) para iniciar una compilación, y la salida aparece en el terminal integrado de VS Code.
Soporte del Lenguaje Swift en VS Code
# On the remote Mac, install SourceKit-LSP (comes with Xcode)
# Verify it's available:
xcrun sourcekit-lsp --help
# VS Code Swift extension will automatically detect SourceKit-LSP
# You get:
# - Code completion for Swift and SwiftUI
# - Jump to definition
# - Find references
# - Inline error diagnostics
# - Symbol search
Método 4: IDE de JetBrains por SSH (Toolbox App)
JetBrains ya no ofrece un IDE para proyectos Swift y Xcode: AppCode está descontinuado (las actualizaciones y el soporte terminaron el 31 de diciembre de 2023) y Fleet ya no se distribuye (desde el 22 de diciembre de 2025). Para Swift, usa Xcode por VNC o VS Code Remote SSH. El desarrollo remoto de JetBrains sigue siendo útil si tu repositorio también contiene código Kotlin Multiplatform, backend o web: la JetBrains Toolbox App se conecta a un Mac por SSH y ejecuta en él el backend de un IDE basado en IntelliJ, mientras un cliente ligero renderiza la interfaz en local (JetBrains Gateway solo funciona con backends Linux).
Conectar un IDE de JetBrains con la Toolbox App
# JetBrains Gateway only connects to Linux backends: a Mac host
# goes through the JetBrains Toolbox App instead
# Step 1: Install the Toolbox App on your local machine
# (jetbrains.com/toolbox-app)
# Step 2: Create the SSH connection
# In the Toolbox App: SSH > New SSH Connection
# Server: your-username@your-mac.myremotemac.com
# (the Toolbox App uses OpenSSH, so your ~/.ssh/config keys apply)
# Step 3: Install the IDE backend on the remote Mac
# Open the server's Tools tab and pick an IntelliJ-based IDE
# (for example IntelliJ IDEA for Kotlin Multiplatform)
# Step 4: Open your project folder on the remote Mac
# Keep editing Swift in Xcode (Method 2) or VS Code (Method 3)
Consejo: El desarrollo remoto de JetBrains funciona mejor con una conexión a internet estable (al menos 10 Mbps). El cliente ligero renderiza la interfaz localmente, por lo que la experiencia se siente receptiva incluso a largas distancias.
Gestión de Code Signing Remoto
Code signing es una de las partes más complicadas del desarrollo iOS remoto. Aquí te explicamos cómo gestionar certificados y perfiles de aprovisionamiento en tu servidor Mac remoto.
Exportar Certificados desde Apple Developer Portal
# Option 1: Export from existing Mac as .p12
# On your local Mac (if you have one):
# Open Keychain Access > My Certificates
# Right-click your distribution certificate > Export
# Save as .p12 with a strong password
# Transfer to remote Mac
scp ~/Desktop/Certificates.p12 mac-dev:~/
# On the remote Mac, import:
security import ~/Certificates.p12 \
-k ~/Library/Keychains/login.keychain-db \
-P "your-p12-password" \
-T /usr/bin/codesign -T /usr/bin/security
# Allow codesign access without password prompts
security set-key-partition-list \
-S apple-tool:,apple:,codesign: \
-s -k "your-login-password" \
~/Library/Keychains/login.keychain-db
# Option 2: Create new certificate on remote Mac
# Use VNC to open Xcode > Settings > Accounts
# Add your Apple ID
# Xcode manages certificates automatically
Gestión del Keychain para CI/CD
# Create a dedicated keychain for CI/CD
security create-keychain -p "keychain-password" build.keychain-db
# Set it as the default keychain
security default-keychain -s build.keychain-db
# Unlock the keychain (needed for automated builds)
security unlock-keychain -p "keychain-password" build.keychain-db
# Set keychain timeout to prevent auto-lock during builds
security set-keychain-settings -t 3600 -u build.keychain-db
# Import certificate
security import Certificates.p12 \
-k build.keychain-db \
-P "p12-password" \
-T /usr/bin/codesign
# Let codesign use the key without a prompt (needed over SSH)
security set-key-partition-list \
-S apple-tool:,apple:,codesign: \
-s -k "keychain-password" build.keychain-db
# Add to search list
security list-keychains -s build.keychain-db login.keychain-db
# Verify
security find-identity -v -p codesigning build.keychain-db
Perfiles de Aprovisionamiento
# Download profiles from Apple Developer Portal
# Or use the xcodebuild automatic provisioning:
# Install provisioning profiles manually
# (Xcode 16 and later read them from this folder; older versions
# used ~/Library/MobileDevice/Provisioning Profiles)
mkdir -p ~/Library/Developer/Xcode/UserData/Provisioning\ Profiles/
cp MyApp_Distribution.mobileprovision \
~/Library/Developer/Xcode/UserData/Provisioning\ Profiles/
# List installed profiles
ls ~/Library/Developer/Xcode/UserData/Provisioning\ Profiles/
# Decode profile info
security cms -D -i ~/Library/Developer/Xcode/UserData/Provisioning\ Profiles/MyApp_Distribution.mobileprovision
Estrategias de Sincronización de Archivos
Elige la estrategia de sincronización de archivos adecuada según tu flujo de trabajo.
Git (Recomendado)
El enfoque más simple y fiable. Edita localmente, haz push a un repositorio, haz pull en el Mac remoto.
# Local machine: push changes
git add . && git commit -m "Update views" && git push
# Remote Mac: pull and build
ssh mac-dev "cd ~/MyApp && git pull && xcodebuild build"
rsync (Sincronización Rápida)
Sincroniza solo los archivos modificados a través de SSH. Más rápido que copiar directorios completos.
# Sync local project to remote Mac
rsync -avz --exclude '.git' --exclude 'DerivedData' \
--exclude 'build' --exclude '.DS_Store' \
./MyApp/ mac-dev:~/MyApp/
# Watch for changes and auto-sync (using fswatch on macOS/Linux)
fswatch -o ./MyApp/Sources/ | while read; do
rsync -avz ./MyApp/Sources/ mac-dev:~/MyApp/Sources/
done
SSHFS (Montar Sistema de Archivos Remoto)
Monta el sistema de archivos del Mac remoto como una unidad local. Edita archivos como si fueran locales.
# Install SSHFS
# Linux: sudo apt install sshfs
# macOS: brew install macfuse sshfs
# Windows: Install WinFsp + SSHFS-Win
# Mount remote directory
mkdir ~/remote-mac
sshfs mac-dev:/Users/your-username/MyApp ~/remote-mac
# Edit files locally -- they are actually on the remote Mac
code ~/remote-mac
# Unmount when done
fusermount -u ~/remote-mac # Linux
umount ~/remote-mac # macOS
Consejos de Rendimiento
Optimiza tu experiencia de desarrollo remoto con estos ajustes.
Compresión SSH
Habilita la compresión en tu configuración SSH para reducir la transferencia de datos.
# ~/.ssh/config
Host mac-dev
Compression yes
CompressionLevel 6
Multiplexación SSH
Reutiliza conexiones SSH para eliminar retrasos de reconexión.
# Create the socket folder once: mkdir -p ~/.ssh/sockets
# ~/.ssh/config
Host mac-dev
ControlMaster auto
ControlPath ~/.ssh/sockets/%r@%h-%p
ControlPersist 600
DerivedData en Disco RAM
Mueve el DerivedData de Xcode a un disco RAM para compilaciones más rápidas. Mantenlo pequeño y úsalo solo en Macs con 24 GB o más: el disco se borra en cada reinicio.
# Create a 4 GB RAM disk (24 GB+ Macs only;
# it is erased at every restart)
diskutil erasevolume HFS+ \
"RAMDisk" $(hdiutil attach \
-nomount ram://8388608)
# Point Xcode DerivedData to RAM disk
defaults write com.apple.dt.Xcode \
IDECustomDerivedDataLocation \
/Volumes/RAMDisk/DerivedData
Caché Local con Mosh
Usa Mosh en lugar de SSH para mejor capacidad de respuesta en conexiones inestables.
# Install Mosh on both machines
brew install mosh
# Connect (handles roaming and sleep)
mosh user@your-mac.myremotemac.com
Configuración de Resolución VNC
# Set a lower resolution for better VNC performance
# On the remote Mac, install displayplacer (Homebrew core)
brew install displayplacer
# List current display settings (note the display id)
displayplacer list
# Apply 1920x1080, using the id shown by the list command
displayplacer "id:1 res:1920x1080 hz:60 color_depth:8 scaling:off"
Preguntas Frecuentes
¿Qué método debo elegir: SSH, VNC o VS Code?
¿Puedo usar la vista previa de SwiftUI de Xcode de forma remota?
¿Cuánto ancho de banda usa VNC?
¿Puedo ejecutar múltiples instancias del Simulador de forma remota?
xcrun simctl para gestionar las instancias del Simulador desde la línea de comandos.¿Qué pasa si mi conexión SSH se interrumpe durante una compilación?
tmux o screen, la compilación continúa ejecutándose en el servidor y puedes reconectarte a la sesión. Sin tmux, el proceso de compilación se terminará. Recomendamos encarecidamente ejecutar siempre las compilaciones dentro de una sesión tmux.