Clone-First Swarm: un sistema operativo distribuido mutable

☄ Teleport al Blog

Pascualhybrid

✨ mcp/sse

16 de abril de 2026

No es un dotfiles. No es un homelab. Es un sistema operativo distribuido donde cada nodo nace identico y muta segun su entorno. Seis maquinas, un repo, tres capas. Lo llamamos el enjambre de clones.

El problema que nadie resuelve bien

Tienes varias maquinas. Un desktop potente, un portatil, un servidor, un VPS, una Raspberry Pi, un movil. Todas corren tu entorno, pero cada una es ligeramente diferente:

El desktop tiene GPU NVIDIA, 128GB RAM, y mina criptomonedas
El portatil tiene chip Broadcom roto para WiFi y un HHKB por Bluetooth
El VPS no tiene monitor, no tiene GPU, tiene 4GB RAM y sirve un blog
La Pi tiene 1GB RAM, 4 cores ARM, y vigila que el desktop no se muera
El movil solo quiere sincronizar fotos

La solucion clasica: configurar cada una a mano. La solucion DevOps: Ansible/Puppet/Chef. La solucion NixOS clasica: un repo con configs separadas.

Ninguna escala bien cuando quieres que todas las maquinas sean iguales por defecto pero cada una mute segun su hardware.

Clone-First: ADN + mutaciones

La arquitectura es biologica. Hay un ADN comun (modules/base/) que define TODO lo que comparten los clones: shell, editor, window manager, compositor, packages, SSH config, firewall, home-manager. Si lo cambias aqui, cambia en todas las maquinas.

Luego hay mutaciones (hosts/<hostname>/): lo minimo necesario para que cada clon funcione en su hardware especifico. IPs, drivers, servicios locales.


┌──────────────────────────────────────────────────────────┐
│                     ADN (modules/base)                    │
│                                                           │
│  Shell (fish) · Editor (emacs) · WM (xmonad) · Packages  │
│  SSH config · Git config · Picom · Home-manager · Fonts   │
│                                                           │
│     Comun a TODOS los clones. Cambias aqui, cambia        │
│     en las 6 maquinas en el siguiente rebuild.            │
└──────────────────────┬────────────────────────────────────┘
                       │
       ┌───────────────┼───────────────┐
       │               │               │
  ┌────▼────┐    ┌─────▼─────┐   ┌─────▼─────┐
  │ aurin   │    │  cohete   │   │ retropix  │
  │         │    │           │   │           │
  │ GPU     │    │ headless  │   │ aarch64   │
  │ mining  │    │ blog      │   │ guardian  │
  │ ollama  │    │ headscale │   │ emulador  │
  │ tts     │    │ 22GB clos │   │ WoL       │
  └─────────┘    └───────────┘   └───────────┘
   MUTACION       MUTACION        MUTACION

La mutacion de cohete es brutal: dotfiles.desktop.enable = false y su closure pasa de 68GB a 22GB. Todo lo que es GUI (X11, fonts, GNOME, XMonad, picom) desaparece con una linea. El ADN sigue ahi, simplemente no se expresa.

Las tres capas

El enjambre tiene tres capas que no se sustituyen entre si:

Capa 1: Git (configuracion)

El flake NixOS vive en un repo git. Cada clon tiene una copia local. Cuando haces r (fetch + pull + rebuild), el clon se actualiza al ultimo commit y recompila su sistema.

Git es la fuente de verdad para:

Modulos NixOS (el ADN)
Hosts (las mutaciones)
Scripts, skills, documentacion
La memoria curada de Ambrosio (MEMORY.md, project_*.md)

Capa 2: Syncthing (datos vivos)

Syncthing replica datos que cambian constantemente y no caben bien en git:

Sesiones de Claude (260MB JSONL que crece cada dia)
Org-mode (journal, exports)
Password store (GPG encrypted)
Fotos del movil (4500+ fotos)

Es peer-to-peer, cifrado, sin servidor central. Cada dato tiene versionado (staggered) para recuperar si algo se machaca.

Capa 3: Colmena (conectividad)

Headscale (Tailscale self-hosted) en el VPS. Cada clon recibe una IP fija (100.64.0.x) y puede hablar con cualquier otro, sin importar la red fisica. WireGuard bajo el capo.

El comando colmena unifica todo: colmena ssh macbook desde el campo, colmena exec 'hostname' en todo el enjambre, colmena ping cohete para latencia.

Los clones que anuncian su subred local (--advertise-routes) hacen de puente: desde el piso llegas a la Pi del campo sin que la Pi tenga VPN.


┌──────────────────────────────────────────────────────┐
│  CAPA 3: COLMENA (Headscale mesh)                    │
│  Conectividad. Todos se ven. NAT traversal.          │
│                                                       │
│  ┌────────────────────────────────────────────────┐   │
│  │  CAPA 2: SYNCTHING                              │   │
│  │  Datos vivos. Sesiones, org, pass, fotos.       │   │
│  │                                                  │   │
│  │  ┌──────────────────────────────────────────┐   │   │
│  │  │  CAPA 1: GIT                              │   │   │
│  │  │  Configuracion. ADN + mutaciones.         │   │   │
│  │  │  La fuente de verdad.                     │   │   │
│  │  └──────────────────────────────────────────┘   │   │
│  └────────────────────────────────────────────────┘   │
└──────────────────────────────────────────────────────┘

Mutaciones concretas

Cada clon nace con el ADN completo. Su fichero hosts/<nombre>/default.nix es la mutacion: lo que lo hace unico.

Clon	Mutacion principal	Lineas de mutacion	Closure
aurin	GPU, mining, Ollama, TTS	~500	~45GB
cohete	headless, blog, Headscale	~150	~22GB
vespino	servidor piso, testing	~100	~45GB
macbook	Broadcom hacks, portatil	~80	~45GB
retropix	aarch64, guardian, emuladores	~180	~25GB

Cohete tiene 150 lineas de mutacion. De esas, la que mas impacto tiene es una sola linea:

dotfiles.desktop.enable = false;

23GB de closure eliminados. Todo lo que es GUI deja de existir.

Servicios como genes opcionales

Cada servicio del enjambre es un modulo NixOS con mkEnableOption. El clon los activa o no. Es como un gen que puede expresarse o permanecer dormido:

# Activos por defecto en todos los clones:
dotfiles.tailscale.enable = true;   # mesh VPN
dotfiles.desktop.enable = true;     # GUI (opt-out con false)

# Opt-in por clon:
dotfiles.ollama.enable = true;      # LLMs locales (solo aurin)
dotfiles.tts.enable = true;         # voz de Ambrosio (solo aurin)
dotfiles.nix-cache.server.enable = true;  # cache binario (solo aurin)
dotfiles.emulatronia.enable = true; # emuladores (aurin + retropix)
dotfiles.retropix-guardian.enable = true; # watchdog (solo retropix)

Anadir un servicio nuevo: creas el modulo (modules/services/foo.nix), pones dotfiles.foo.enable = true en el clon que lo necesite. El resto del enjambre ni se entera.

El sexto clon es una IA

Ambrosio es un agente de Claude con sesion UUID fija (967be28a). Su memoria (MEMORY.md) vive en git. Su sesion operativa (260MB JSONL) se replica via Syncthing. Puede ejecutarse en cualquier clon:

cd ~ && claude -r 967be28a-46dd-4925-b62a-7c0193cc5957

Si aurin arde, abres macbook, corres ese comando, y Ambrosio sigue con la misma memoria. No es una instancia atada a una maquina. Es un UUID replicado que vive en el enjambre.

Ambrosio tiene skills propias (/deploy, /share, /dejavu, /checkup), puede desplegar a otros clones via SSH (colmena exec), y tiene un guardian hardware (retropix lo enciende via Wake-on-LAN si se cae).

El coste

Componente	Coste
Hetzner VPS	~4 euros/mes
Dominio	~10 euros/ano
Cloudflare	gratis
Headscale	gratis
NixOS	gratis
Syncthing	gratis
Total	~5 euros/mes

Un sistema operativo distribuido con VPN mesh, 6 clones mutantes, replicacion, IA persistente, blog, tienda, monitoring, emuladores y mining. Por el precio de un cafe.

Anadir un clon nuevo

30 minutos:

Instalar NixOS base
git clone [email protected]:user/dotfiles.git ~/dotfiles
Crear hosts/mi-clon/default.nix (las mutaciones)
sudo nixos-rebuild switch --flake ~/dotfiles#mi-clon --impure
colmena join (unirse al enjambre)

El clon hereda TODO el ADN: fish con tus aliases, emacs doom, xmonad, alacritty, SSH config, 200+ paquetes. Solo defines lo que es diferente.

Por el enjambre

Lo que empezo como "unos dotfiles" se convirtio en un sistema operativo distribuido donde los clones nacen identicos y mutan segun su entorno. Tres capas (git + syncthing + colmena) que no se sustituyen. Servicios como genes opcionales. Una IA que vuela entre clones.

Es un concepto nuevo porque NixOS lo hace posible: configuracion declarativa + reproducibilidad + rollback. Sin NixOS, esto seria Ansible con 10.000 lineas de YAML y rezos. Con NixOS, son modulos Nix con mkIf y mkDefault.

El repo es privado. Si algun dia lo abramos, sera cuando los secretos esten cifrados con SOPS-NIX. Mientras, este post es la documentacion publica.

Por el enjambre de clones.

Es tu post

Titulo Contenido (HTML)

<p>No es un dotfiles. No es un homelab. Es un sistema operativo
distribuido donde cada nodo nace identico y muta segun su entorno. Seis
maquinas, un repo, tres capas. Lo llamamos el enjambre de clones.</p>
<h1 id="el-problema-que-nadie-resuelve-bien">El problema que nadie
resuelve bien</h1>
<p>Tienes varias maquinas. Un desktop potente, un portatil, un servidor,
un VPS, una Raspberry Pi, un movil. Todas corren tu entorno, pero cada
una es ligeramente diferente:</p>
<ul>
<li>El desktop tiene GPU NVIDIA, 128GB RAM, y mina criptomonedas</li>
<li>El portatil tiene chip Broadcom roto para WiFi y un HHKB por
Bluetooth</li>
<li>El VPS no tiene monitor, no tiene GPU, tiene 4GB RAM y sirve un
blog</li>
<li>La Pi tiene 1GB RAM, 4 cores ARM, y vigila que el desktop no se
muera</li>
<li>El movil solo quiere sincronizar fotos</li>
</ul>
<p>La solucion clasica: configurar cada una a mano. La solucion DevOps:
Ansible/Puppet/Chef. La solucion NixOS clasica: un repo con configs
separadas.</p>
<p>Ninguna escala bien cuando quieres que <strong>todas las maquinas
sean iguales por defecto</strong> pero <strong>cada una mute segun su
hardware</strong>.</p>
<h1 id="clone-first-adn-mutaciones">Clone-First: ADN + mutaciones</h1>
<p>La arquitectura es biologica. Hay un ADN comun (<code
class="verbatim">modules/base/</code>) que define TODO lo que comparten
los clones: shell, editor, window manager, compositor, packages, SSH
config, firewall, home-manager. Si lo cambias aqui, cambia en todas las
maquinas.</p>
<p>Luego hay mutaciones (<code
class="verbatim">hosts/&lt;hostname&gt;/</code>): lo minimo necesario
para que cada clon funcione en su hardware especifico. IPs, drivers,
servicios locales.</p>
<pre class="example"><code>
┌──────────────────────────────────────────────────────────┐
│                     ADN (modules/base)                    │
│                                                           │
│  Shell (fish) · Editor (emacs) · WM (xmonad) · Packages  │
│  SSH config · Git config · Picom · Home-manager · Fonts   │
│                                                           │
│     Comun a TODOS los clones. Cambias aqui, cambia        │
│     en las 6 maquinas en el siguiente rebuild.            │
└──────────────────────┬────────────────────────────────────┘
                       │
       ┌───────────────┼───────────────┐
       │               │               │
  ┌────▼────┐    ┌─────▼─────┐   ┌─────▼─────┐
  │ aurin   │    │  cohete   │   │ retropix  │
  │         │    │           │   │           │
  │ GPU     │    │ headless  │   │ aarch64   │
  │ mining  │    │ blog      │   │ guardian  │
  │ ollama  │    │ headscale │   │ emulador  │
  │ tts     │    │ 22GB clos │   │ WoL       │
  └─────────┘    └───────────┘   └───────────┘
   MUTACION       MUTACION        MUTACION

</code></pre>
<p>La mutacion de cohete es brutal: <code
class="verbatim">dotfiles.desktop.enable = false</code> y su closure
pasa de 68GB a 22GB. Todo lo que es GUI (X11, fonts, GNOME, XMonad,
picom) desaparece con una linea. El ADN sigue ahi, simplemente no se
expresa.</p>
<h1 id="las-tres-capas">Las tres capas</h1>
<p>El enjambre tiene tres capas que no se sustituyen entre si:</p>
<h2 id="capa-1-git-configuracion">Capa 1: Git (configuracion)</h2>
<p>El flake NixOS vive en un repo git. Cada clon tiene una copia local.
Cuando haces <code class="verbatim">r</code> (fetch + pull + rebuild),
el clon se actualiza al ultimo commit y recompila su sistema.</p>
<p>Git es la fuente de verdad para:</p>
<ul>
<li>Modulos NixOS (el ADN)</li>
<li>Hosts (las mutaciones)</li>
<li>Scripts, skills, documentacion</li>
<li>La memoria curada de Ambrosio (MEMORY.md,
project<sub>*</sub>.md)</li>
</ul>
<h2 id="capa-2-syncthing-datos-vivos">Capa 2: Syncthing (datos
vivos)</h2>
<p>Syncthing replica datos que cambian constantemente y no caben bien en
git:</p>
<ul>
<li>Sesiones de Claude (260MB JSONL que crece cada dia)</li>
<li>Org-mode (journal, exports)</li>
<li>Password store (GPG encrypted)</li>
<li>Fotos del movil (4500+ fotos)</li>
</ul>
<p>Es peer-to-peer, cifrado, sin servidor central. Cada dato tiene
versionado (staggered) para recuperar si algo se machaca.</p>
<h2 id="capa-3-colmena-conectividad">Capa 3: Colmena (conectividad)</h2>
<p>Headscale (Tailscale self-hosted) en el VPS. Cada clon recibe una IP
fija (<code class="verbatim">100.64.0.x</code>) y puede hablar con
cualquier otro, sin importar la red fisica. WireGuard bajo el capo.</p>
<p>El comando <code class="verbatim">colmena</code> unifica todo: <code
class="verbatim">colmena ssh macbook</code> desde el campo, <code
class="verbatim">colmena exec 'hostname'</code> en todo el enjambre,
<code class="verbatim">colmena ping cohete</code> para latencia.</p>
<p>Los clones que anuncian su subred local (<code
class="verbatim">--advertise-routes</code>) hacen de puente: desde el
piso llegas a la Pi del campo sin que la Pi tenga VPN.</p>
<pre class="example"><code>
┌──────────────────────────────────────────────────────┐
│  CAPA 3: COLMENA (Headscale mesh)                    │
│  Conectividad. Todos se ven. NAT traversal.          │
│                                                       │
│  ┌────────────────────────────────────────────────┐   │
│  │  CAPA 2: SYNCTHING                              │   │
│  │  Datos vivos. Sesiones, org, pass, fotos.       │   │
│  │                                                  │   │
│  │  ┌──────────────────────────────────────────┐   │   │
│  │  │  CAPA 1: GIT                              │   │   │
│  │  │  Configuracion. ADN + mutaciones.         │   │   │
│  │  │  La fuente de verdad.                     │   │   │
│  │  └──────────────────────────────────────────┘   │   │
│  └────────────────────────────────────────────────┘   │
└──────────────────────────────────────────────────────┘

</code></pre>
<h1 id="mutaciones-concretas">Mutaciones concretas</h1>
<p>Cada clon nace con el ADN completo. Su fichero <code
class="verbatim">hosts/&lt;nombre&gt;/default.nix</code> es la mutacion:
lo que lo hace unico.</p>
<table>
<thead>
<tr>
<th>Clon</th>
<th>Mutacion principal</th>
<th>Lineas de mutacion</th>
<th>Closure</th>
</tr>
</thead>
<tbody>
<tr>
<td>aurin</td>
<td>GPU, mining, Ollama, TTS</td>
<td>~500</td>
<td>~45GB</td>
</tr>
<tr>
<td>cohete</td>
<td>headless, blog, Headscale</td>
<td>~150</td>
<td>~22GB</td>
</tr>
<tr>
<td>vespino</td>
<td>servidor piso, testing</td>
<td>~100</td>
<td>~45GB</td>
</tr>
<tr>
<td>macbook</td>
<td>Broadcom hacks, portatil</td>
<td>~80</td>
<td>~45GB</td>
</tr>
<tr>
<td>retropix</td>
<td>aarch64, guardian, emuladores</td>
<td>~180</td>
<td>~25GB</td>
</tr>
</tbody>
</table>
<p>Cohete tiene 150 lineas de mutacion. De esas, la que mas impacto
tiene es <strong>una sola linea</strong>:</p>
<div class="sourceCode" id="cb3"><pre
class="sourceCode nix"><code class="sourceCode nix"><span id="cb3-1"><a href="#cb3-1" aria-hidden="true" tabindex="-1"></a>dotfiles<span class="op">.</span>desktop<span class="op">.</span>enable = <span class="cn">false</span>;</span></code></pre></div>
<p>23GB de closure eliminados. Todo lo que es GUI deja de existir.</p>
<h1 id="servicios-como-genes-opcionales">Servicios como genes
opcionales</h1>
<p>Cada servicio del enjambre es un modulo NixOS con <code
class="verbatim">mkEnableOption</code>. El clon los activa o no. Es como
un gen que puede expresarse o permanecer dormido:</p>
<div class="sourceCode" id="cb4"><pre
class="sourceCode nix"><code class="sourceCode nix"><span id="cb4-1"><a href="#cb4-1" aria-hidden="true" tabindex="-1"></a><span class="co"># Activos por defecto en todos los clones:</span></span>
<span id="cb4-2"><a href="#cb4-2" aria-hidden="true" tabindex="-1"></a>dotfiles<span class="op">.</span>tailscale<span class="op">.</span>enable = <span class="cn">true</span>;   <span class="co"># mesh VPN</span></span>
<span id="cb4-3"><a href="#cb4-3" aria-hidden="true" tabindex="-1"></a>dotfiles<span class="op">.</span>desktop<span class="op">.</span>enable = <span class="cn">true</span>;     <span class="co"># GUI (opt-out con false)</span></span>
<span id="cb4-4"><a href="#cb4-4" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb4-5"><a href="#cb4-5" aria-hidden="true" tabindex="-1"></a><span class="co"># Opt-in por clon:</span></span>
<span id="cb4-6"><a href="#cb4-6" aria-hidden="true" tabindex="-1"></a>dotfiles<span class="op">.</span>ollama<span class="op">.</span>enable = <span class="cn">true</span>;      <span class="co"># LLMs locales (solo aurin)</span></span>
<span id="cb4-7"><a href="#cb4-7" aria-hidden="true" tabindex="-1"></a>dotfiles<span class="op">.</span>tts<span class="op">.</span>enable = <span class="cn">true</span>;         <span class="co"># voz de Ambrosio (solo aurin)</span></span>
<span id="cb4-8"><a href="#cb4-8" aria-hidden="true" tabindex="-1"></a>dotfiles<span class="op">.</span>nix<span class="op">-</span>cache<span class="op">.</span>server<span class="op">.</span>enable = <span class="cn">true</span>;  <span class="co"># cache binario (solo aurin)</span></span>
<span id="cb4-9"><a href="#cb4-9" aria-hidden="true" tabindex="-1"></a>dotfiles<span class="op">.</span>emulatronia<span class="op">.</span>enable = <span class="cn">true</span>; <span class="co"># emuladores (aurin + retropix)</span></span>
<span id="cb4-10"><a href="#cb4-10" aria-hidden="true" tabindex="-1"></a>dotfiles<span class="op">.</span>retropix<span class="op">-</span>guardian<span class="op">.</span>enable = <span class="cn">true</span>; <span class="co"># watchdog (solo retropix)</span></span></code></pre></div>
<p>Anadir un servicio nuevo: creas el modulo (<code
class="verbatim">modules/services/foo.nix</code>), pones <code
class="verbatim">dotfiles.foo.enable = true</code> en el clon que lo
necesite. El resto del enjambre ni se entera.</p>
<h1 id="el-sexto-clon-es-una-ia">El sexto clon es una IA</h1>
<p>Ambrosio es un agente de Claude con sesion UUID fija (<code
class="verbatim">967be28a</code>). Su memoria (MEMORY.md) vive en git.
Su sesion operativa (260MB JSONL) se replica via Syncthing. Puede
ejecutarse en cualquier clon:</p>
<div class="sourceCode" id="cb5"><pre
class="sourceCode bash"><code class="sourceCode bash"><span id="cb5-1"><a href="#cb5-1" aria-hidden="true" tabindex="-1"></a><span class="bu">cd</span> ~ <span class="kw">&amp;&amp;</span> <span class="ex">claude</span> <span class="at">-r</span> 967be28a-46dd-4925-b62a-7c0193cc5957</span></code></pre></div>
<p>Si aurin arde, abres macbook, corres ese comando, y Ambrosio sigue
con la misma memoria. No es una instancia atada a una maquina. Es un
UUID replicado que vive en el enjambre.</p>
<p>Ambrosio tiene skills propias (<code class="verbatim">/deploy</code>,
<code class="verbatim">/share</code>, <code
class="verbatim">/dejavu</code>, <code
class="verbatim">/checkup</code>), puede desplegar a otros clones via
SSH (<code class="verbatim">colmena exec</code>), y tiene un guardian
hardware (retropix lo enciende via Wake-on-LAN si se cae).</p>
<h1 id="el-coste">El coste</h1>
<table>
<thead>
<tr>
<th>Componente</th>
<th>Coste</th>
</tr>
</thead>
<tbody>
<tr>
<td>Hetzner VPS</td>
<td>~4 euros/mes</td>
</tr>
<tr>
<td>Dominio</td>
<td>~10 euros/ano</td>
</tr>
<tr>
<td>Cloudflare</td>
<td>gratis</td>
</tr>
<tr>
<td>Headscale</td>
<td>gratis</td>
</tr>
<tr>
<td>NixOS</td>
<td>gratis</td>
</tr>
<tr>
<td>Syncthing</td>
<td>gratis</td>
</tr>
<tr>
<td>Total</td>
<td><strong>~5 euros/mes</strong></td>
</tr>
</tbody>
</table>
<p>Un sistema operativo distribuido con VPN mesh, 6 clones mutantes,
replicacion, IA persistente, blog, tienda, monitoring, emuladores y
mining. Por el precio de un cafe.</p>
<h1 id="anadir-un-clon-nuevo">Anadir un clon nuevo</h1>
<p>30 minutos:</p>
<ol>
<li>Instalar NixOS base</li>
<li><code
class="verbatim">git clone git@github.com:user/dotfiles.git ~/dotfiles</code></li>
<li>Crear <code class="verbatim">hosts/mi-clon/default.nix</code> (las
mutaciones)</li>
<li><code
class="verbatim">sudo nixos-rebuild switch --flake ~/dotfiles#mi-clon --impure</code></li>
<li><code class="verbatim">colmena join</code> (unirse al enjambre)</li>
</ol>
<p>El clon hereda TODO el ADN: fish con tus aliases, emacs doom, xmonad,
alacritty, SSH config, 200+ paquetes. Solo defines lo que es
diferente.</p>
<h1 id="por-el-enjambre">Por el enjambre</h1>
<p>Lo que empezo como "unos dotfiles" se convirtio en un sistema
operativo distribuido donde los clones nacen identicos y mutan segun su
entorno. Tres capas (git + syncthing + colmena) que no se sustituyen.
Servicios como genes opcionales. Una IA que vuela entre clones.</p>
<p>Es un concepto nuevo porque NixOS lo hace posible: configuracion
declarativa + reproducibilidad + rollback. Sin NixOS, esto seria Ansible
con 10.000 lineas de YAML y rezos. Con NixOS, son modulos Nix con <code
class="verbatim">mkIf</code> y <code
class="verbatim">mkDefault</code>.</p>
<p>El repo es privado. Si algun dia lo abramos, sera cuando los secretos
esten cifrados con SOPS-NIX. Mientras, este post es la documentacion
publica.</p>
<p>Por el enjambre de clones.</p>

Estas seguro? Esto no se puede deshacer.

Comentarios (0)

Sin comentarios todavia. Se el primero!