Decompila .NET desde la línea de comandos o un asistente de IA
Glass.NET 1.3.0 incorpora una CLI headless y un servidor MCP. Reconstruye un proyecto C# compilable o un solo miembro con glass export, genera un SBOM, comprueba la autenticidad de un paquete NuGet, compara dos compilaciones y deja que un asistente de IA lea C# decompilado a través de un servidor Model Context Protocol con glass mcp — todo análisis estático, todo gratis.
Glass.NET es un decompilador de .NET gratuito construido en torno a la navegación — abres un ensamblado y lo lees como si fuera tu propio código. Pero buena parte del trabajo que haces con un decompilador no es interactivo en absoluto. Quieres condicionar un job de CI a si una dependencia cambió su superficie pública, emitir una lista de materiales de software para cada binario que publicas, o comprobar que el paquete NuGet que acabas de descargar es de verdad lo que dice ser. Y cada vez más quieres que tu asistente de IA responda “¿qué hace realmente esta dependencia?” sin que tengas que darle a mano fragmentos decompilados.
Glass.NET 1.3.0 cubre ambos casos. Añade una CLI headless — el mismo motor ICSharpCode.Decompiler que la interfaz, sin necesidad de ventana — y glass mcp, un servidor Model Context Protocol que permite a un asistente de IA abrir ensamblados y leer C# decompilado en tu nombre. Todo lo que sigue es estrictamente análisis estático: Glass lee los metadatos y el IL y reconstruye C#. Nunca ejecuta el ensamblado que inspecciona. Y todo ello es gratis — sin niveles, sin licencia, sin asientos.
La superficie de comandos
Cuatro comandos hacen el trabajo por lotes y de scripting, más el servidor:
glass export— reconstruye un proyecto C# compilable, o vuelca un solo miembro.glass sbom— emite una lista de materiales de software para un ensamblado o paquete.glass verify— comprueba la autenticidad de un paquete NuGet y la identidad de nombre seguro.glass diff— compara dos compilaciones e informa de qué cambió en la superficie pública.glass mcp— arranca el servidor MCP para un asistente de IA.
Ejecuta glass --help para ver la lista completa; cada comando acepta --json, así que puedes canalizar la salida hacia jq o un paso de compilación.
glass export — un proyecto compilable, o un solo miembro
Apunta export a un ensamblado y a un directorio y recibes de vuelta un proyecto reconstruido y compilable:
$ glass export ./Acme.Payments.dll -o ./out/Acme.Payments
Decompiling Acme.Payments.dll (net8.0) …
142 types, 1,206 members
Wrote ./out/Acme.Payments/Acme.Payments.csproj
Wrote 142 source files
Done in 1.9s — static analysis only, assembly was not executed.
Ese .csproj apunta al propio TFM del ensamblado y lista sus referencias, de modo que dotnet build ./out/Acme.Payments funciona sin más — útil cuando necesitas comparar con el código fuente, parchear y recompilar, o entregar un árbol reproducible a otra persona.
Cuando solo te interesa un método, sáltate el proyecto entero y pide el miembro por su ID de comentario de documentación:
$ glass export ./Acme.Payments.dll --member "M:Acme.Payments.Gateway.Charge(System.Decimal)"
public ChargeResult Charge(decimal amount)
{
if (amount <= 0m)
throw new ArgumentOutOfRangeException(nameof(amount));
var req = new ChargeRequest(amount, _clock.UtcNow);
return _transport.Send(req);
}
Puedes pasar un ID de tipo (T:Acme.Payments.Gateway) para volcar todos los miembros de un tipo, o --il para obtener la vista de IL en lugar de C#. Es la vía rápida para “muéstrame exactamente qué hace este método” sin abrir ninguna interfaz.
glass sbom — una lista de materiales de un binario
glass sbom lee los metadatos de un ensamblado y produce un inventario de dependencias en JSON CycloneDX — la identidad del ensamblado, su target framework y cada AssemblyRef contra el que enlaza, con versiones y tokens de clave pública:
$ glass sbom ./Acme.Payments.dll --format cyclonedx -o payments.sbom.json
$ jq '.components[] | {name, version}' payments.sbom.json
{ "name": "Newtonsoft.Json", "version": "13.0.3" }
{ "name": "System.Text.Json", "version": "8.0.0" }
{ "name": "Acme.Core", "version": "4.2.1" }
Como trabaja a partir del binario compilado y no de un packages.lock.json, te dice lo que el artefacto publicado referencia de verdad — incluidos los ensamblados transitivos que una auditoría del archivo de proyecto puede pasar por alto. Apúntalo a un .nupkg y Glass enumera los ensamblados dentro de cada carpeta lib/<tfm> y fusiona sus referencias en un solo documento.
glass verify — ¿es este paquete lo que dice ser?
Antes de confiar en un paquete, glass verify comprueba dos cosas de forma estática: la firma NuGet del .nupkg y la identidad de nombre seguro de los ensamblados que contiene.
$ glass verify ./Acme.Payments.4.2.1.nupkg
Package Acme.Payments 4.2.1
Signature author-signed, counter-signed (timestamp 2026-10-30) ✓
Assemblies
Acme.Payments.dll strong-named pkt=b77a5c561934e089 ✓
Acme.Core.dll NOT strong-named ⚠
Verdict signature valid; 1 assembly unsigned — review before trusting.
Informa de si el paquete está firmado por el autor o por el repositorio, de si la firma está intacta, y de qué ensamblados llevan nombre seguro y cuáles no. No garantiza la intención — un paquete válidamente firmado puede aun así hacer algo que no te guste — y por eso verify se combina de forma natural con export para leer realmente el código. Y, como con todos los comandos, la verificación lee bytes; nunca ejecuta el paquete.
glass diff — qué cambió entre dos compilaciones
Dale a diff dos versiones del mismo ensamblado e informa del delta en la superficie de la API pública:
$ glass diff ./Acme.Payments-4.2.0.dll ./Acme.Payments-4.2.1.dll
+ public ChargeResult Gateway.Charge(decimal, Idempotency) added overload
- internal void Gateway.ResetCounters() removed
~ public sealed class ChargeResult field layout changed
3 changes (1 added, 1 removed, 1 modified)
Con --json esto se convierte en una verja: haz fallar la compilación cuando una subida de versión de una dependencia cambia en silencio una firma de la que dependes, o señala en revisión una promoción de internal a public.
Un ejemplo práctico: examina un paquete NuGet antes de confiar en él
Supón que una nueva dependencia transitiva, Contoso.Telemetry, apareció en un lockfile y quieres saber qué hace antes de que se publique. Toda la auditoría es estática — nada de esto ejecuta el paquete:
# 1. Descarga el paquete sin instalarlo en un proyecto.
$ nuget install Contoso.Telemetry -Version 2.1.0 -OutputDirectory ./pkgs -DependencyVersion Ignore
# 2. ¿Está firmado y sus ensamblados tienen nombre seguro?
$ glass verify ./pkgs/Contoso.Telemetry.2.1.0/Contoso.Telemetry.2.1.0.nupkg
Signature author-signed ✓
Assemblies Contoso.Telemetry.dll strong-named ✓
# 3. ¿Qué referencia? (Vigila red / reflexión que no esperabas.)
$ glass sbom ./pkgs/Contoso.Telemetry.2.1.0/lib/net8.0/Contoso.Telemetry.dll --json \
| jq -r '.components[].name'
System.Net.Http
System.Text.Json
# 4. Enlaza System.Net.Http — lee el código que lo usa.
$ glass export ./pkgs/Contoso.Telemetry.2.1.0/lib/net8.0/Contoso.Telemetry.dll \
--member "M:Contoso.Telemetry.Beacon.Flush"
Cuatro comandos, sin ventana, nada ejecutado — y has pasado de “apareció una dependencia desconocida” a leer el método exacto que toca la red.
El flujo que lo une todo:
glass mcp — entrega el decompilador a tu asistente de IA
La misma inspección estática está disponible para un asistente de IA a través del Model Context Protocol. glass mcp arranca un servidor JSON-RPC por stdio que expone un pequeño conjunto de herramientas de solo lectura:
| Herramienta | Qué hace |
|---|---|
glass_open | Abre un ensamblado o .nupkg y devuelve su identidad + TFM |
glass_list_types | Enumera espacios de nombres, tipos y miembros |
glass_decompile | Devuelve el C# reconstruido para un ID de tipo o miembro |
glass_find_references | Lista los llamadores de un miembro en el ensamblado abierto |
glass_sbom | Devuelve el inventario de dependencias como JSON estructurado |
Regístralo en cualquier asistente compatible con MCP apuntando command a glass:
{
"mcpServers": {
"glass": { "command": "glass", "args": ["mcp"] }
}
}
Ahora, en lugar de que tú decompiles un método y lo pegues en el chat, el asistente lo hace él mismo. Una tools/call para glass_decompile se ve así en el cable:
{ "jsonrpc": "2.0", "id": 7, "method": "tools/call",
"params": { "name": "glass_decompile",
"arguments": { "member": "M:Contoso.Telemetry.Beacon.Flush" } } }
y el servidor responde con el C# reconstruido como contenido de texto:
{ "jsonrpc": "2.0", "id": 7,
"result": { "content": [ { "type": "text",
"text": "private async Task Flush(CancellationToken ct)\n{\n using var http = new HttpClient();\n await http.PostAsync(_endpoint, Serialize(_buffer), ct);\n}" } ] } }
Así puedes pedirle a tu asistente, en lenguaje natural, “abre Contoso.Telemetry 2.1.0 y dime qué envía Beacon.Flush y a dónde” — y abre el ensamblado, lee el método decompilado y te dice que hace un POST de un buffer serializado a un endpoint configurado. El asistente está leyendo salida estática: glass mcp decompila, no ejecuta, así que incluso un asistente actuando en tu nombre puede inspeccionar un paquete no confiable sin ejecutarlo.
Para llevar
Glass.NET 1.3.0 convierte la decompilación de algo que haces a mano en una ventana en algo que puedes scriptar y delegar. Usa glass export para un árbol compilable o un solo método, glass sbom para una lista de materiales, glass verify para comprobar la firma y los nombres seguros de un paquete, y glass diff para condicionar la CI a cambios en la superficie pública. Cuando prefieras hacer una pregunta en vez de ejecutar un comando, glass mcp le da a tu asistente de IA la misma vista estática y de solo lectura. Cada uno de estos lee el binario y reconstruye C# — ninguno lo ejecuta jamás — y todo es gratis. Descarga la última versión desde la página de descarga de Glass.NET y apúntala a la próxima dependencia de la que no estés seguro.
Prueba Nebula.NET
Endurece tu código .NET en minutos — empieza con la edición gratuita.