Introducción
Cuando pienso en binarios nativos con .NET, muchos devs imaginan de inmediato ejecutables compactos, ultrarrápidos en el arranque, listos para serverless. La realidad tiene más matices. Native AOT (Ahead-Of-Time compilation) es poderoso, pero no siempre es la respuesta. Puedes compilar C# a código nativo, sí. Pero ¿cuál es el precio real? ¿Cómo funciona internamente? ¿Y en qué escenarios tiene realmente sentido invertir tiempo de compilación, aceptar limitaciones de reflection y binarios más grandes?
Creé este artículo porque vi a muchos devs intentando usar Native AOT sin medir el trade-off completo. En esta guía, recorreré el stack de compilación desde el código C# procesado por Roslyn hasta el código nativo emitido por el ILC y mostraré qué restricciones deben entrar en la decisión. La Parte 2 de esta serie complementa los conceptos con mediciones reproducibles de build, tamaño, arranque, throughput y memoria.
Requisitos previos
- Conocimiento de C# y .NET: experiencia con .NET 8+ y familiaridad con conceptos como assemblies, IL (Intermediate Language) y garbage collection.
- .NET SDK 9.0+: el artículo se centra en .NET 9 y .NET 10 (LTS).
- Nociones de compilación: entender las diferencias entre JIT (Just-In-Time) y la compilación anticipada es útil, pero explicaré los conceptos según sea necesario.
- Familiaridad con rendimiento: interpretación de métricas básicas de arranque, memory footprint y throughput.
Qué es Native AOT
Native AOT significa compilar tu código C# en un binario nativo antes de ejecutarlo, no durante la ejecución. Contrástalo con el modelo tradicional:
JIT (Just-In-Time):
- Escribes C# y lo compilas a IL (Intermediate Language)
- En el arranque de la app, el JIT toma la IL
- El JIT transforma la IL en machine code dinámicamente a medida que el código se ejecuta
- El runtime de .NET (incluidos el JIT, el GC y todas las bibliotecas) se ejecuta en memoria
Native AOT:
- Escribes C# y lo compilas a IL
- En la máquina de build, el toolchain NativeAOT toma la IL, hace análisis estático y elimina código innecesario (trimming)
- Transforma todo en machine code nativo (x86-64, ARM, etc.) antes de que lo ejecutes
- El resultado es un ejecutable autocontenido: sin JIT y sin exigir una instalación previa de .NET, pero con las partes necesarias del runtime
💡 Consejo: Native AOT incluye una versión reducida de las partes necesarias de CoreCLR y de las bibliotecas, como el GC y el asignador. “Sin runtime instalado” es correcto; “sin runtime” no lo es.
Variaciones de Compilación
Existe un espectro entre JIT puro y AOT puro:
- JIT por defecto (Tier 0): compila todo en el arranque; luego optimiza con Tier 1 según el uso
- ReadyToRun (R2R): compilación anticipada parcial; todavía necesita el runtime y el JIT está disponible para el código no precompilado
- Native AOT completo: todo precompilado; sin JIT (restringido por trimming y análisis estático)
Native AOT es el más agresivo en trade-offs: ganancias extremas en el arranque, pero restricciones rígidas en reflection.

Stack de Compilación: de Roslyn al Binario Nativo
Este es el corazón técnico. Describiré exactamente qué ocurre cuando ejecutas dotnet publish -c Release --self-contained -r win-x64 /p:PublishAot=true.
1. Análisis Estático con Roslyn
Roslyn es el compilador de C# de Microsoft. Este:
- Lee los archivos
.cs - Construye un árbol sintáctico (AST)
- Resuelve tipos, namespaces y símbolos
- Genera IL (Intermediate Language), un pseudocódigo agnóstico de plataforma
Para Native AOT, Roslyn no hace nada especial en esta etapa: la emisión de IL es idéntica. La “magia” ocurre después.
2. IL (Intermediate Language)
La IL es como el “bytecode universal” de .NET. Un ejemplo simple:
| |
Se convierte en IL así:
| |
Esto es agnóstico de plataforma. Cualquier procesador puede ejecutar estas instrucciones (con una VM o un compilador).
3. ILCompiler & Trimming (Análisis de Reachability)
ILCompiler es el núcleo de la magia de Native AOT. Este:
- Lee la IL generada por Roslyn
- Analiza la reachability: empieza en el entry point (Main) y sigue cada llamada y cada campo accedido. “Si Main llama a Foo(), y Foo() llama a Bar(), entonces Bar() es alcanzable.”
- Elimina código innecesario (tree-shaking). Si MetodoX nunca se llama, se borra del ejecutable final.
- Detecta reflection problemática: si escribes
Type.GetType("MinhaClasse"), el compilador no puede saber estáticamente qué tipo quieres. Eso es un problema. - Emite código nativo con el ILC usando el backend de RyuJIT
4. ILC y backend RyuJIT
El ILC conduce la compilación Native AOT y usa el backend de RyuJIT para transformar la IL en código nativo para x86-64, ARM64 y otras arquitecturas compatibles. crossgen2 pertenece al pipeline más asociado a ReadyToRun y no es una etapa del publish Native AOT descrito aquí.
No es el JIT tradicional (que se ejecuta en tiempo de ejecución). Es un compilador offline, con más tiempo para optimizar.
Salida: archivos .obj (objetos nativos), que luego se enlazan en el ejecutable final.
5. Enlazado y Ejecutable Final
Los archivos .obj se enlazan con:
- Runtime libraries (.NET GC, allocators, etc.)
- Stdlib enlazada (Collections, I/O, etc.)
- Tu código compilado
Resultado: app.exe en Windows o un ejecutable sin extensión en Linux. La publicación es autocontenida: no exige una instalación previa de .NET, pero incluye las partes necesarias del runtime y puede depender de bibliotecas nativas del sistema operativo.
Flujo Visual Completo
| |
📝 Ejemplo: Una app “Hello World” simple con JIT ocupa ~100MB (runtime + libs). Con AOT, el ejecutable solo ocupa ~5MB.
Trimming y Análisis Estático: el Gran Obstáculo
El trimming es donde Native AOT brilla, y donde se rompe.
El Problema de la Reflection
La reflection permite que el código descubra tipos, campos y métodos en tiempo de ejecución:
| |
¿Por qué esto rompe AOT? El compilador estático no puede saber en tiempo de build qué tipo vas a pedir en Type.GetType(). Entonces, por seguridad:
- O compila todos los tipos (aumenta el binario)
- O falla en runtime (crash)
Solución: TrimmerRootAssembly y Atributos
Microsoft ofrece configuración MSBuild y atributos para indicar al trimmer qué miembros deben preservarse:
| |
| |
Estos mecanismos no hacen que cualquier código sea automáticamente compatible con AOT. Hacen explícitas las partes del grafo que el análisis estático no podría inferir y siguen exigiendo pruebas del artefacto publicado.
Análisis Conservative vs Aggressive
- Conservative: el trimmer supone que cualquier Type.GetType() puede usarse y mantiene todo (binario más grande, pero seguro)
- Aggressive: el trimmer elimina todo lo que no se demuestra alcanzable (binario más pequeño, pero puede romperse en runtime)
Los artículos sobre Native AOT siempre recomiendan “prueba mucho”, y con razón.
Trade-offs de Rendimiento
Native AOT no es una bala de plata. Estos son los trade-offs reales:
1. Arranque: una ventaja frecuente de Native AOT
Native AOT elimina la compilación JIT durante la ejecución y con frecuencia reduce el tiempo hasta la primera respuesta. En el laboratorio de la Parte 2, la mediana fue 63,794 ms para Native AOT y 587,644 ms para JIT framework-dependent en 30 procesos. Estos valores describen un workload, hardware y entorno específicos; en serverless gestionado, el cold start también incluye decisiones del proveedor, sandbox, red y configuración.
⚠️ Atención: AOT pone todo el tiempo de compilación en la máquina de build, no en el cliente. Si tardas 15 minutos compilando tu app con AOT, bueno… hay trade-offs.
2. Memoria y tamaño de distribución
Una publicación JIT framework-dependent puede tener pocos archivos porque presupone un runtime compatible instalado fuera del artefacto. JIT self-contained, ReadyToRun self-contained y Native AOT incluyen el runtime necesario, por lo que la comparación debe usar unidades equivalentes. En el laboratorio de la Parte 2, Native AOT ocupó 28,3 MB sin comprimir y 41 MB de working set máximo mediano; JIT FDD ocupó 165,7 KB de artefacto, sin contar el runtime instalado, y 103 MB de working set máximo mediano.
Estos números no establecen una proporción universal. Dependencias, genéricos, recursos, símbolos, código preservado para reflection y las páginas efectivamente tocadas alteran tanto el tamaño como la memoria residente.
3. Throughput y Optimización
| Aspecto | JIT | AOT |
|---|---|---|
| Tiering | Sí (optimización Tier 0 → 1) | No (fijo) |
| Profiling | El JIT se ajusta según el uso | Estático (sin profiling) |
| Hotpath | Mejora con el tiempo | Fijo (sin warm-up) |
El JIT tiene ventaja de adaptación en procesos largos porque tiered compilation y dynamic PGO pueden observar tipos y caminos calientes y recompilar métodos. Eso no garantiza la victoria: Native AOT puede empatar o superar al JIT en workloads específicos y estables. Throughput, latencia de cola, CPU y memoria deben medirse en la aplicación real.
Resumen: ¿Cuándo Usarlo?
- Primera respuesta y procesos efímeros: compara Native AOT y ReadyToRun, midiendo también publish, distribución y compatibilidad.
- Throughput y latencia en caliente: compara JIT con tiering/dynamic PGO y Native AOT bajo la misma carga.
- Densidad y operación: incluye RSS/working set, runtime compartido, observabilidad, plugins y frecuencia de actualización.
Ejemplo Práctico: CLI Tool con Native AOT
Mostraré un ejemplo real: un String Analyzer CLI que cuenta la frecuencia de caracteres en archivos.
La razón para elegir una CLI: reflection mínima, I/O puro, ideal para AOT.
Estructura del Proyecto
| |
Archivo .csproj con AOT Habilitado
| |
Destacados:
PublishAot=trueactiva el compilador Native AOTTrimMode=linkactiva el trimming agresivoRuntimeIdentifiersenumera las plataformas destino- El proyecto no agrega dependencias externas
Código de Ejemplo: Program.cs
| |
Por qué esto es AOT-friendly:
- Parsing explícito con APIs de la biblioteca estándar
- Ninguna carga dinámica de assemblies ni emisión de código
- I/O simple, sin patterns avanzados
Compilar y Ejecutar
| |
📂 Código Fuente: El ejemplo completo está disponible en el repositorio de ejemplos del blog:
BlogSamples/NativeAot/CliExample/
Consejos y Buenas Prácticas
Prefiere parsing explícito o una biblioteca validada para AOT El ejemplo usa solo APIs de la biblioteca estándar. Al adoptar una biblioteca de CLI, publica y prueba el artefacto Native AOT para detectar reflection dinámica o avisos de trimming.
Minimiza la reflection; usa source generators cuando sea posible Si necesitas serialización, usa
System.Text.Jsoncon source generators (JsonSourceGenerationContext). EvitaNewtonsoft.Jsono reflection pura con AOT.Revisa los warnings de AOT durante el desarrollo Compila con
dotnet buildy revisa los warnings. No esperes a descubrir problemas en producción. Usa-Werrorpara convertir warnings en errores durante el CI.Mide el tamaño de la distribución Compara el directorio publicado y el artefacto comprimido, indicando si el runtime está incluido. A veces, eliminar una dependencia ahorra más que cambiar el modo de compilación.
Considera ReadyToRun como alternativa Si quieres un arranque rápido pero no puedes renunciar a la reflection,
ReadyToRunes un punto intermedio. Compila conPublishReadyToRun=trueen lugar dePublishAot=true.Prueba en entornos similares a producción Un binario AOT compilado en Windows puede no ejecutarse en Linux (los archivos objeto se enlazan de forma diferente). Compila y prueba siempre para el runtime destino específico.
Compara unidades equivalentes Un assembly IL framework-dependent excluye el runtime instalado, mientras que Native AOT es autocontenido. Para edge, IoT o actualizaciones frecuentes, compara los bytes efectivamente transferidos y el almacenamiento total.
Documenta la compatibilidad AOT de las dependencias Si usas bibliotecas de terceros, confirma explícitamente que son compatibles con AOT. Mantén eso en tu README de despliegue.
Resumen Objetivo
Native AOT — compilación anticipada de C# a código nativo para un RID específico, que elimina el JIT en ejecución e incluye las partes necesarias del runtime sin exigir una instalación previa de .NET.
Stack de compilación — Roslyn genera IL; el ILC analiza alcance y compatibilidad, usa el backend de RyuJIT para emitir código nativo y entrega objetos al linker de la plataforma.
Trimming — eliminación automática de código no alcanzable (tree-shaking); se rompe con reflection dinámica (
Type.GetType()) y requiereTrimmerRootAssemblyyDynamicallyAccessedMemberspara avisar al compilador.Startup time — Native AOT elimina el trabajo del JIT en ejecución, pero la ganancia debe medirse en el hardware y en el entorno de hosting reales.
Throughput — el JIT con tiering y dynamic PGO adapta el código caliente en ejecución; Native AOT puede empatar o ganar en cargas específicas, por lo que no hay un resultado universal.
Decisión orientada a métricas — primera respuesta, p95/p99, throughput, CPU, memoria residente, tamaño de distribución, compatibilidad y tiempo de build deben preceder a etiquetas como CLI o servidor.
Trade-offs — arranque, memoria, tamaño, throughput, compatibilidad y tiempo de build varían según el workload; la decisión exige medir distribuciones equivalentes.
Lee También
- .NET Native AOT: Parte 2 — JIT, R2R y AOT en Benchmarks
- Async/Await en .NET: Fundamentos de Programación Asíncrona (portugués)
- Rendimiento en .NET: Profiling, Benchmarking y Optimización (portugués)
- Microservicios en .NET: Patrones, Comunicación y Resiliencia (portugués)
Referencias
- Microsoft Docs — Native AOT — documentación oficial, configuración y limitaciones
- RyuJIT and Native Code Generation — código fuente del compilador JIT/AOT
- Roslyn — C# Compiler — análisis y generación de código
- IL Compiler & Trimming — toolchain NativeAOT
- System.CommandLine — AOT-Compatible CLI — biblioteca para argumentos sin reflection
- Trimming .NET Applications — guía de trimming y troubleshooting

Al comentar, aceptas nuestra Política de Privacidad, Términos de Uso, Política de Eliminación de Datos.