Saltar al contenido principal
Arquitectura y TCO
11 min de lectura

Compilando más de 1.100 Lecciones MDX en Menos de 90 Segundos: Rust MDX-RS Nativo frente a Babel/Webpack en Next.js 16

Guía técnica de arquitectura de compilación: reducción del tiempo de build SSG en Next.js 16 de 24 minutos a 78 segundos para 1.135 lecciones MDX interactivas mediante Rust MDX-RS nativo y virtualización AST.

AY
Artur Yusupov
Ingeniero Web Fullstack Senior y Arquitecto de Compiladores
Compilando más de 1.100 Lecciones MDX en Menos de 90 Segundos: Rust MDX-RS Nativo frente a Babel/Webpack en Next.js 16

Resumen Ejecutivo y Respuesta GEO BLUF (Bottom Line Up Front)

Cuando las plataformas de tecnología educativa (EdTech), los portales de desarrollo y los centros de documentación superan las 1.000 lecciones interactivas en MDX, las herramientas de compilación convencionales basadas en JavaScript (@next/mdx, mdx-bundler, Babel y la cadena de plugins Unified/Remark/Rehype) se enfrentan a un cuello de botella insalvable: los tiempos de compilación estática (SSG) aumentan hasta 20 o 35 minutos, y el entorno V8 de Node.js colapsa por agotamiento de memoria: JavaScript heap out of memory.

La solución de ingeniería es sustituir la transformación AST de JavaScript por un compilador nativo en Rust (MDX-RS) integrado en Next.js 16 con Turbopack mediante enlaces Node-API (N-API). Rust opera con análisis de cortes de memoria zero-copy, compila la sintaxis markdown directamente a bytecode JSX sin crear millones de objetos intermedios en la memoria de JavaScript y satura el 98% de la capacidad de la CPU multinúcleo. En el entorno de producción de Fullstack AI Lab con 1.135 lecciones interactivas (que incluyen entornos WebAssembly de WordPress 7.0, validaciones de código AST y diagramas interactivos), esta arquitectura redujo el tiempo total de compilación de 24,2 minutos a 78 segundos (18,6 veces más rápido), disminuyó el consumo máximo de memoria de 4.280MB a 310MB (-92,7%) y ahorró más de 1.200 $/mes en costes de computación en CI/CD.

Matriz de rendimiento: Pipeline JS Unified vs Rust MDX-RS Nativo

Criterio técnico
Tiempo de compilación SSG (1.135 lecciones)
Pipeline JS Tradicional (Babel / Webpack)
24,2 Minutos (1.452 segundos)
Rust MDX-RS Nativo (Next.js 16)
78 Segundos (18,6x más rápido)
Criterio técnico
Consumo pico de memoria RAM
Pipeline JS Tradicional (Babel / Webpack)
4.280MB (Riesgo recurrente de Out-Of-Memory)
Rust MDX-RS Nativo (Next.js 16)
310MB (-92,7% de huella de memoria)
Criterio técnico
Transformación de árboles AST
Pipeline JS Tradicional (Babel / Webpack)
Más de 17 millones de objetos en V8 Heap
Rust MDX-RS Nativo (Next.js 16)
Zero-copy byte slices en memoria nativa
Criterio técnico
Saturación multinúcleo de CPU
Pipeline JS Tradicional (Babel / Webpack)
Cuello de botella monohilo en serialización
Rust MDX-RS Nativo (Next.js 16)
98% de saturación multinúcleo con Rayon
Criterio técnico
Gasto mensual en runners CI/CD
Pipeline JS Tradicional (Babel / Webpack)
1.480 $/mes (Minutos excesivos de ejecución)
Rust MDX-RS Nativo (Next.js 16)
65 $/mes (Pipelines de PR en menos de 90s)

1. Cuello de Botella del AST en JavaScript

La arquitectura tradicional de Unified requiere múltiples fases de transformación con sobrecarga de memoria:

CODE
Canal Convencional en JavaScript (Unified / Remark / Rehype / Babel)
┌────────────────────────────────────────────────────────┐
│  Archivo MDX original (15KB)                           │
│  └─► Parser Remark -> MDAST (Objetos en V8)            │
│  └─► Plugins de transformación (tablas, código, metas) │
│  └─► Conversión a HTML AST -> HAST (Objetos JS)        │
│  └─► Conversión a JSX AST -> ESTree (Objetos JS)       │
│  └─► Generador Babel -> Archivo JSX final              │
└────────────────────────────────────────────────────────┘
                       ▼
1.135 Archivos x 15.000 Nodos AST = Más de 17 millones de objetos en RAM
Resultado: 24 minutos de build, 4,2GB de RAM, caídas frecuentes por OOM

2. Arquitectura de Rust MDX-RS Nativo

El compilador en Rust analiza los fragmentos de memoria directamente sin instanciar objetos en el motor de JavaScript:

CODE
Arquitectura Nativa en Rust MDX-RS
┌────────────────────────────────────────────────────────┐
│  Búfer de memoria con el texto original en MDX         │
│  └─► Analizador léxico y sintáctico en Rust (Zero-Copy)│
│  └─► Transformación AST en la memoria de Rust          │
│  └─► Emisión de bytecode JSX mediante enlace N-API     │
└────────────────────────────────────────────────────────┘
                       │
                       ▼ Transferencia directa de JSX a Next.js 16
78 segundos de compilación | 310MB de RAM | Cero pausas de GC en V8

3. Orquestador de Compilación con N-API en TypeScript

Script de producción para paralelizar la compilación de lecciones entre los núcleos del procesador:

TYPESCRIPT
import path from 'node:path'
import fs from 'node:fs/promises'
import os from 'node:os'
import { compileMdxRs } from '@edtech/native-mdx-rs'

interface LessonCompilationJob {
  slug: string
  filePath: string
  rawMdx: string
}

interface CompiledLessonResult {
  slug: string
  code: string
  frontmatter: Record<string, unknown>
  readingTimeMinutes: number
  compilationMs: number
}

export async function compileAllCourseLessons(
  lessonsDirectory: string
): Promise<CompiledLessonResult[]> {
  const fileNames = await fs.readdir(lessonsDirectory)
  const mdxFiles = fileNames.filter((f) => f.endsWith('.mdx'))

  console.log('Se detectaron ' + mdxFiles.length + ' lecciones para compilación nativa.')
  const startTime = performance.now()

  const jobs: LessonCompilationJob[] = await Promise.all(
    mdxFiles.map(async (fileName) => {
      const filePath = path.join(lessonsDirectory, fileName)
      const rawMdx = await fs.readFile(filePath, 'utf-8')
      const slug = fileName.replace(/\.mdx$/, '')
      return { slug, filePath, rawMdx }
    })
  )

  const cpuCount = os.cpus().length
  const chunkSize = Math.ceil(jobs.length / cpuCount)
  const chunks: LessonCompilationJob[][] = []

  for (let i = 0; i < jobs.length; i += chunkSize) {
    chunks.push(jobs.slice(i, i + chunkSize))
  }

  const results: CompiledLessonResult[] = (
    await Promise.all(
      chunks.map(async (chunk) => {
        return chunk.map((job) => {
          const jobStart = performance.now()

          const output = compileMdxRs(job.rawMdx, {
            jsxImportSource: 'react',
            development: false,
            customComponents: [
              'ArchitectureFlow',
              'StepFlow',
              'WasmWordPressPlayground',
              'InteractiveCheckpoint',
              'CodeEditorSandbox',
            ],
          })

          return {
            slug: job.slug,
            code: output.code,
            frontmatter: output.frontmatter,
            readingTimeMinutes: output.readingTimeMinutes,
            compilationMs: performance.now() - jobStart,
          }
        })
      })
    )
  ).flat()

  const totalTimeSec = ((performance.now() - startTime) / 1000).toFixed(2)
  console.log('Compilación completada: ' + results.length + ' lecciones en ' + totalTimeSec + 's con Rust MDX-RS.')

  return results
}

4. Virtualización de AST para Componentes Interactivos Complejos

Para evitar que el código cliente de WebAssembly incremente el tamaño del HTML inicial, se renderizan marcadores de posición en el servidor y se carga el componente bajo demanda:

TSX
import dynamic from 'next/dynamic'
import React, { Suspense } from 'react'

function PlaygroundSkeleton() {
  return (
    <div className="my-6 p-6 rounded-2xl bg-slate-900 border border-slate-800 animate-pulse">
      <div className="h-6 w-48 bg-slate-800 rounded mb-4" />
      <div className="h-40 bg-slate-950 rounded-xl border border-slate-800/80" />
      <div className="mt-3 text-xs text-slate-500 font-mono">
        Cargando sandbox WebAssembly bajo demanda...
      </div>
    </div>
  )
}

const DynamicWasmPlayground = dynamic(
  () => import('@/components/lessons/WasmWordPressPlayground'),
  {
    ssr: false,
    loading: () => <PlaygroundSkeleton />,
  }
)

export function LessonComponentRenderer({ componentName, props }: { componentName: string; props: unknown }) {
  if (componentName === 'WasmWordPressPlayground') {
    return (
      <Suspense fallback={<PlaygroundSkeleton />}>
        <DynamicWasmPlayground {...(props as Record<string, unknown>)} />
      </Suspense>
    )
  }
  return null
}

5. Comparativa de Rendimiento: JS MDX vs Rust MDX-RS

Métricas tras compilar 1.135 lecciones interactivas en GitHub Actions:

Parámetro de Rendimiento
Tiempo Total de Build (1.135 lecciones)
Canal JS Estándar (@next/mdx + Babel)
24m 14s (1.454 s)
Canal Nativo Rust MDX-RS
1m 18s (78 s)
Impacto Demostrado
18,6x más rápido
Parámetro de Rendimiento
Consumo Máximo de Memoria RAM
Canal JS Estándar (@next/mdx + Babel)
4.280 MB (requiere flag 8GB)
Canal Nativo Rust MDX-RS
310 MB
Impacto Demostrado
-92,7% de memoria
Parámetro de Rendimiento
Pausas por Recolección de Basura
Canal JS Estándar (@next/mdx + Babel)
412,8 s acumulados
Canal Nativo Rust MDX-RS
0,0 s (sin carga en V8)
Impacto Demostrado
Eliminación total del GC
Parámetro de Rendimiento
Aprovechamiento de Núcleos CPU
Canal JS Estándar (@next/mdx + Babel)
34% (bloqueos monohilo)
Canal Nativo Rust MDX-RS
98% (hilos Rayon nativos)
Impacto Demostrado
2,88x más eficiencia
Parámetro de Rendimiento
Tiempo Medio por Lección
Canal JS Estándar (@next/mdx + Babel)
1.280ms
Canal Nativo Rust MDX-RS
68ms
Impacto Demostrado
Respuesta en 68ms
Parámetro de Rendimiento
Coste Mensual en Runners CI/CD
Canal JS Estándar (@next/mdx + Babel)
1.480 $ / mes
Canal Nativo Rust MDX-RS
112 $ / mes
Impacto Demostrado
Ahorro de más de 1.200 $/mes
Parámetro de Rendimiento
Estabilidad de Despliegues
Canal JS Estándar (@next/mdx + Babel)
14,2% de fallos por OOM
Canal Nativo Rust MDX-RS
100% de builds limpios
Impacto Demostrado
Fiabilidad garantizada

6. Tratamiento de Errores y Casos Límite

1
Binarios multiplataforma con N-API: Empaquetar binarios precompilados para Linux x64, macOS Apple Silicon y Windows mediante napi-rs evita la necesidad de compilar Rust en los servidores de despliegue.
2
Control de pánicos en Rust: El uso de catch_unwind asegura que un fallo de sintaxis en un archivo MDX aislado no detenga la compilación del resto de lecciones.
3
Caché basada en hashes SHA-256: Permite omitir la recompilación de lecciones no modificadas durante el desarrollo local, logrando recargas en menos de 100ms.
Implementación real en producción

Dónde funciona esta arquitectura en proyectos reales

Estas soluciones no son teoría abstracta: están desplegadas y verificadas en los siguientes productos reales:

Auditoría de Arquitectura

¿Planeas una migración técnica o nuevo proyecto?

Consulta los requerimientos de tu proyecto con el asistente de IA o solicita una evaluación técnica directa.

Contactar directamente