Workstations · Desarrollo

Desarrollo de software: compilación, contenedores y VMs

Qué escala con núcleos (compilar), qué no (enlazar, el IDE), cuánta RAM comen Docker y las VMs, por qué el disco solo importa la primera vez y qué cambia con Apple Silicon.

Una workstation de desarrollo vive entre dos extremos. Compilar un proyecto grande desde cero reparte miles de ficheros entre todos los núcleos y se traga gigabytes de RAM por cada trabajo en paralelo. El bucle diario, en cambio, es otro: cambias tres líneas, se recompila un fichero, se enlaza el binario y el IDE reindexa. Ahí manda un solo núcleo. Y debajo de todo eso corren Docker, un clúster de Kubernetes local o una VM, que no piden GHz sino memoria. Elegir bien es saber qué parte de tu día pertenece a cada extremo.

Qué hace un compilador con tus núcleos

Un proyecto en C, C++ o Rust se compila por unidades independientes: cada fichero fuente (o cada crate en Rust) se convierte en un objeto sin mirar a los demás. Esa independencia es lo que permite lanzar tantos trabajos como hilos tenga la CPU. Ninja y Make lo hacen por defecto; cargo reparte los crates que no dependen entre sí, y dentro de cada uno rustc divide el código en unidades de generación (16 por defecto en compilaciones normales, 256 en incrementales) para que LLVM las procese en paralelo.

El coste oculto es la memoria. Cada trabajo de compilación de C++ moderno con plantillas pesadas y símbolos de depuración usa fácilmente entre 1 y 2 GB de RAM; es una cifra de experiencia, no de ficha, y en compilaciones de depuración de LLVM o Chromium puede ser mayor. Con 32 hilos lanzando 32 trabajos, la cuenta se dispara.

RAM que pide una compilación paralela

RAM (GB) ≈ trabajos en paralelo × GB por trabajo + sistema e IDE

Ryzen 9 9950X: 32 × 1,5 + 8 ≈ 56 GB → 64 GB

Un Ryzen 9 9950X tiene 16 núcleos y 32 hilos. Si aprovechas los 32 hilos con trabajos de 1,5GB necesitas 48GB solo para compilar, más lo que ya ocupan el sistema, el navegador y el IDE. Con 32 GB instalados el sistema pagina a mitad de la compilación. Por eso 64 GB es el mínimo cómodo con 16 núcleos, y por eso la documentación de Chromium pide «más de 16 GB, muy recomendado» incluso con menos hilos, y 100GB de disco libre.

Si no tienes esa RAM, la solución no es comprar menos núcleos sino limitar los trabajos: ninja -j16 en vez de -j32. Compilar con 16 trabajos y RAM de sobra es más rápido que con 32 trabajos y swap.

trabajos útiles = mín(hilos de CPU, RAM libre ÷ GB por trabajo)

Hasta dónde escala una compilación

Una compilación nunca es 100 % paralela. Hay una fase de configuración (CMake, gn gen), un grafo de dependencias que obliga a esperar a que termine una biblioteca antes de compilar lo que la usa, y al final el enlazado. La ley de Amdahl pone número a ese límite: la parte secuencial marca el techo por mucho que añadas núcleos.

Ley de Amdahl

aceleración = 1 ÷ ((1 − p) + p ÷ n)

p = 0,95, n = 32: 1 ÷ (0,05 + 0,0297) = 12,6×

Con un 95 % de trabajo paralelizable, 16 núcleos aceleran 9,1×, 32 núcleos 12,6× y 64 núcleos 15,4×. Duplicar de 32 a 64 núcleos gana un 23 %, no un 100 %. Si el proyecto es más secuencial (p = 0,90, típico cuando el enlazado pesa mucho), 64 núcleos se quedan en 8,8×. Solo los proyectos enormes y bien estructurados (p ≈ 0,99: Chromium, LLVM, el kernel de Linux) justifican un Threadripper de 64 núcleos por sí mismos.

Aceleración teórica según la fracción paralela

  • p = 0,99
  • p = 0,95
  • p = 0,90
02040601101001kNúcleos (log)Aceleración (×)p = 0,99p = 0,95p = 0,90
Ley de Amdahl: aceleración frente a número de núcleos para tres fracciones paralelizables. La curva del 90 % se aplana antes de los 16 núcleos (cálculo propio con la fórmula).

Con esto en la mano, la tabla de CPUs se lee distinta. Un Threadripper 9970X dobla los núcleos del 9950X, pero también dobla los canales de memoria (4 frente a 2) y triplica los carriles PCIe (80 frente a 24). Para compilar, lo primero importa; lo segundo y lo tercero solo si además metes varios NVMe y una GPU para IA.

CPUs candidatas para desarrollo (fuente: src/data/cpus.json). Apple no publica TDP ni precio del chip suelto; el boost del M4 Max es medido, no oficial.
EquipoNúcleosHilosBoost (GHz)L3 (MB)CanalesRAM (GB/s)TDP (W)Precio (USD)
AMD Ryzen 9 9950X16325,764289,6170649
Intel Core Ultra 9 285K24245,7362102125589
AMD Ryzen Threadripper 9970X32645,412842053502 499
AMD Ryzen Threadripper 9980X641285,425642053504 999
Apple M4 Max (16 núcleos CPU / 40 GPU)16164,5—8546——
AMD Ryzen AI Max+ 395 (Strix Halo)16325,164425655—

CPUs candidatas para desarrollo (fuente: src/data/cpus.json). Apple no publica TDP ni precio del chip suelto; el boost del M4 Max es medido, no oficial.

Enlazar: la parte que no se reparte

Cuando compilas desde cero, enlazar es un porcentaje pequeño. En el bucle diario de editar, compilar un fichero y enlazar, es casi todo. El enlazador lee todos los objetos, resuelve símbolos y escribe un binario de cientos de megabytes; los clásicos (GNU ld, gold) lo hacen en un solo hilo.

La diferencia entre enlazadores es mayor que la diferencia entre CPUs. En un Threadripper 7980X de 64 núcleos, enlazar una compilación de depuración de Chromium 145 tarda 16,64s con lld (el enlazador de LLVM, ya paralelo) y 1,65s con mold, que reparte el trabajo entre todos los núcleos. Un 10× en la operación que repites cien veces al día, por una línea de configuración.

Enlazado de una compilación debug (menos es mejor)

  • lld
  • wild
  • mold
05101520Chromium 145 · lld16,64 sChromium 145 · wild3,98 sChromium 145 · mold1,65 sClang 21 · lld6,19 sClang 21 · wild3,71 sClang 21 · mold1,34 sFirefox 149 · lld5,11 sFirefox 149 · mold0,78 ss
Tiempo de enlazado de compilaciones de depuración en un Threadripper 7980X de 64 núcleos, en segundos (fuente: repositorio de mold, agosto de 2026; wild no soporta «--icf=all» en Chromium release).

Lo mismo pasa con el resto del bucle interior. El IDE analiza el fichero que estás editando en un hilo (clangd, rust-analyzer, el servidor de TypeScript), git status sobre un repositorio grande recorre el árbol en pocos hilos, y en Rust una compilación release con LTO «fat» serializa la optimización de todo el programa en la fase final. Todo eso escala con la frecuencia y el IPC de un núcleo, no con el número de núcleos. Por eso un 9950X a 5,7 GHz de boost no se siente más lento que un Threadripper 9980X (base 3,2 GHz, boost 5,4) en el día a día.

RAM: contenedores, Kubernetes local y VMs

Docker en Linux comparte el kernel del anfitrión: un contenedor es un proceso aislado y ocupa lo que ocupe su carga, nada más. En macOS y Windows no existe esa opción: Docker Desktop arranca una VM Linux y todos los contenedores viven dentro. Por defecto la VM reserva el 50 % de la RAM del anfitrión en macOS. En un MacBook de 32 GB eso son 16 GB que desaparecen para el sistema en cuanto arrancas Docker, aunque solo tengas un contenedor de Postgres en marcha.

IDE y navegadormacOS · 8–12 GBVM LinuxVirtualization.framework · 50 % de la RAMContenedoresPostgres, Redis, tu appCódigo fuenteVirtioFS ↔ disco de macOSAPI de Dockerkernel Linux compartidobind mount · VirtioFS
Docker Desktop en un Mac con Apple Silicon: los contenedores no tocan macOS directamente, pasan por una VM Linux y VirtioFS (fuente: documentación de Docker Desktop).

Con VMs completas la cuenta es igual de simple y más cara: cada VM de Windows o Linux con escritorio pide de 4 a 8 GB que quedan reservados mientras esté encendida. Un clúster local de Kubernetes (kind, minikube, k3d) son de 2 a 4 GB por nodo antes de desplegar nada tuyo. Por eso 64 GB es la cifra estándar de una workstation de desarrollo, y 128 GB la de quien compila y virtualiza a la vez.

Presupuesto de RAM de una workstation de desarrollo

RAM = sistema + IDE + VM de Docker + otras VMs + (trabajos de compilación × GB por trabajo)

8 + 4 + 16 + 8 + 16 × 1,5 = 60 GB → 64 GB

Sistema y navegador (8GB), un IDE con indexación (4GB), la VM de Docker con tres o cuatro servicios (16GB), una VM de Windows para probar (8GB) y una compilación con 16 trabajos (24GB) suman 60GB. Cabe en 64 GB sin paginar. Con 32 GB tendrías que apagar la VM y limitar la compilación a 8 trabajos. La RAM es lo que más veces se queda corto, aunque en 2026 DDR5 ya no es un regalo: entre 13 y 18 $ por GB según el índice de Tom’s Hardware de septiembre.

32 GB16GB para Dockerla VM se lleva la mitad por defecto
64 GB32GB para Dockerestándar para dev + contenedores
128 GB64GB para Dockercompilar + virtualizar a la vez

La velocidad de la RAM, en cambio, importa poco. Compilar es un trabajo de cachés y de latencia, no de ancho de banda: los 64 MB de L3 del 9950X pesan más que la diferencia entre DDR5-5600 y DDR5-6400. Los detalles están en memoria RAM y en la jerarquía de memoria.

Disco: por qué el primer build nota el NVMe y el segundo no

Un repositorio de desarrollo no se parece a un fichero de vídeo. Son cientos de miles de ficheros pequeños: la carpeta node_modules de un proyecto web mediano supera los 100 000, y Chromium necesita 100 GB libres solo para el árbol de fuentes y los objetos. Lo que sufre es la latencia por operación y las IOPS en cola baja, no los GB/s secuenciales de la caja del SSD.

Pero hay un matiz que ahorra dinero: el sistema operativo guarda en RAM los ficheros que ya ha leído (la page cache). La primera compilación tras reiniciar lee todo del disco; la segunda, si sobra RAM, no lo toca. La propia documentación de Chromium lo ilustra con una máquina antigua: compilar sobre tmpfs (todo en RAM) bajó una compilación de depuración de 15 min 40 s a 12 min 20 s. Con 64 GB de RAM consigues lo mismo gratis: el árbol entero cabe en la caché, y un NVMe PCIe 4.0 decente rinde igual que el PCIe 5.0 más caro. Cómo leer latencia e IOPS está en almacenamiento.

Donde el disco sí manda es en Docker Desktop de macOS: un bind mount del código fuente cruza la frontera entre macOS y la VM en cada lectura. VirtioFS, el mecanismo por defecto, redujo ese coste hasta un 98 % respecto a la implementación anterior según Docker, pero sigue siendo mucho más lento que un npm install dentro de un volumen nativo de la VM. Si un proyecto vuela en Linux y se arrastra en Mac, casi siempre es esto.

Apple Silicon frente a x86

La ventaja de un Mac para desarrollo no está en la compilación pura, sino en el rendimiento por vatio. Un M4 Max mantiene sus 16 núcleos a plena carga con batería y sin ventilador audible; un portátil x86 de 16 núcleos baja la frecuencia en cuanto se desenchufa. No incluimos tiempos de compilación cruzados Mac frente a x86 porque no hemos encontrado una medición homogénea (mismo compilador, mismas fuentes, misma versión) que podamos verificar.

Los inconvenientes son tres, y son de arquitectura, no de velocidad. Primero, la RAM es unificada y soldada: los 36, 48 o 128 GB que compres son los que tendrás, y la VM de Docker se queda con la mitad por defecto. Segundo, todo contenedor corre en esa VM, con el coste de VirtioFS descrito arriba. Tercero, las imágenes amd64 no son nativas: Docker Desktop las ejecuta con Rosetta (opción «acelerar la emulación de binarios x86/AMD64», disponible con Apple Virtualization framework), que funciona pero va más lento. Si tu producción corre en x86 y dependes de imágenes sin variante arm64, un Mac te obliga a emular en cada prueba.

CI local o remoto

La pregunta de fondo no es «qué máquina» sino «dónde se compila». Si cinco personas compilan desde cero cuatro veces al día en portátiles de 8 núcleos, son veinte horas diarias de espera; un servidor compartido con un Threadripper 9980X o un EPYC de 64 núcleos y una caché de objetos (ccache, sccache, la caché remota de Bazel) las convierte en compilaciones incrementales de minutos. El portátil se queda con el bucle interior, que es single-thread de todos modos, y el servidor con la parte paralela.

La cuenta se hace con Amdahl y con euros. Un Threadripper 9980X cuesta 4 999 $ solo el chip y consume 350 W; un runner en la nube de 64 vCPU se paga por horas y se apaga. Para un solo desarrollador la máquina local gana casi siempre; para un equipo, el servidor compartido amortiza en meses y saca las compilaciones largas de la máquina en la que escribes.

Lo que debes recordar

  • Compilar desde cero escala con núcleos, pero cada trabajo paralelo pide 1–2 GB de RAM: 32 hilos sin 64 GB acaban paginando.
  • La ley de Amdahl frena antes de lo que parece: con un 95 % paralelizable, 64 núcleos solo son un 23 % más rápidos que 32.
  • El bucle diario (editar, enlazar, indexar) es single-thread: frecuencia, IPC y un enlazador moderno (mold, 10× frente a lld en Chromium) pesan más que el número de núcleos.
  • Docker Desktop en macOS y Windows es una VM que reserva el 50 % de la RAM por defecto; cada VM y cada nodo de Kubernetes local se suman al presupuesto. 64 GB es el estándar.
  • El SSD importa en la primera compilación; después la page cache en RAM hace el trabajo. Apple Silicon gana en rendimiento por vatio y pierde en imágenes amd64 y en bind mounts.

Para mirar en una ficha técnica

  • Núcleos e hilos: mira las dos cifras por separado y qué núcleos son P y cuáles E. Trampa: «24 núcleos» de Arrow Lake son 24 hilos; los 32 hilos de un Ryzen son 16 núcleos.
  • Frecuencia boost de un núcleo: es la que sientes al enlazar y en el IDE. Trampa: un Threadripper con boost 5,4 GHz arranca de una base de 3,2 GHz y en cargas ligeras no siempre llega.
  • Capacidad máxima de RAM y si está soldada: en portátiles y Macs es la cifra definitiva. Trampa: «hasta 128 GB» en la gama, 36 GB en el modelo que te venden.
  • Canales de memoria: 2 en escritorio, 4 en Threadripper, 8 en PRO. Para compilar importa poco; para simulación e IA, mucho. Trampa: pagar Threadripper por los canales cuando solo compilas.
  • Latencia e IOPS del SSD, no GB/s: y RAM de sobra para que la page cache haga el resto.

Fuentes

  1. Chromium — Checking out and building Chromium on Linux — requisitos de RAM (8 GB mínimo, más de 16 GB muy recomendado), 100 GB de disco, compilación en tmpfs 12 min 20 s frente a 15 min 40 s, component build para reducir memoria al enlazar.
  2. mold — A Modern Linker (repositorio oficial) — tiempos de enlazado de Chromium 145, Clang 21 y Firefox 149 con lld, wild y mold en un Threadripper 7980X (agosto de 2026).
  3. The rustc book — Codegen Options — codegen-units por defecto (16 no incremental, 256 incremental), LTO fat y thin, linker-plugin-lto.
  4. Docker Desktop — Settings — memoria por defecto de la VM en macOS (50 % del anfitrión), Apple Virtualization framework y Docker VMM, Rosetta para amd64, VirtioFS (hasta un 98 % menos de tiempo en operaciones de ficheros).
  5. AMD Ryzen 9 9950X — ficha oficial — 16 núcleos / 32 hilos, 5,7 GHz boost, 64 MB L3, TDP 170 W, 2 canales DDR5-5600 (vía src/data/cpus.json).
  6. Intel Core Ultra 9 285K — especificaciones — 8P + 16E, 24 hilos, sin Hyper-Threading, 5,7 GHz (vía src/data/cpus.json).
  7. AMD Ryzen Threadripper 9980X y 9970X — nota de prensa — 64 y 32 núcleos, 4 canales DDR5-6400, 80 carriles PCIe 5.0, 350 W, 4 999 y 2 499 $ (vía src/data/cpus.json).
  8. Apple — Apple introduces M4 Pro and M4 Max — CPU de 16 núcleos, hasta 128 GB unificados a 546 GB/s (vía src/data/cpus.json).
  9. Tom’s Hardware — RAM price index 2026 — DDR5 a 13–18 $/GB en septiembre de 2026 (vía src/data/memory-tech.json).

Escribe para buscar en artículos, herramientas y glosario. Esc para cerrar.