TypeScript cotidiano
Las clases, los genéricos, las uniones, los decoradores, los módulos, async/await y las funciones modernas del sistema de tipos son compatibles en los flujos de SharpTS.
Código abierto — Licencia MIT
SharpTS
Un intérprete de TypeScript y compilador AOT para .NET
Ejecútalo como un script para obtener resultados al instante, o compílalo a un ensamblado .NET nativo — con acceso completo al ecosistema .NET.
curl -fsSL https://sharpts.dev/setup.sh | shirm https://sharpts.dev/setup.ps1 | iexexample.ts
// Ejecuta TypeScript directamente en .NET
interface Greeter {
greet(name: string): string;
}
class WelcomeBot implements Greeter {
constructor(private prefix: string) {}
greet(name: string): string {
return `${this.prefix}, ${name}! Welcome to SharpTS.`;
}
}
const bot = new WelcomeBot("Hello");
console.log(bot.greet("Developer"));
// → Hello, Developer! Welcome to SharpTS.Qué hace SharpTS
Escribe TypeScript que se ejecuta en el runtime de .NET — interpretado para iterar rápido, o compilado a ensamblados .NET nativos.
Ejecútalo al instante
Apunta SharpTS a un archivo .ts y se ejecuta — sin paso de compilación ni configuración. Ideal para scripts, automatización y probar ideas en el REPL.
Compila a .NET
Compilación anticipada a un ensamblado .NET real — una DLL, un ejecutable autónomo o un paquete NuGet — que se ejecuta a la velocidad nativa del CLR.
Interoperabilidad en ambos sentidos
Llama a bibliotecas .NET desde TypeScript con @DotNetType, y usa tu TypeScript compilado desde C#. Reutiliza la BCL, los paquetes NuGet y el código que ya tienes.
Amplio soporte de TypeScript
Usa el TypeScript que conoces — genéricos, clases, decoradores, async, módulos y más — con comprobación de tipos antes de ejecutar el código. Consulta el resumen práctico de compatibilidad más abajo.
Encaja en tu build de .NET
Añade el SharpTS.Sdk a un proyecto .NET y dotnet build compila tu TypeScript junto a tu C# — la misma cadena de herramientas, el mismo resultado.
Soporte del editor
Un servidor de lenguaje aporta autocompletado, comprobación de tipos e ir a definición en VS Code y Visual Studio.
Míralo en acción
TypeScript real ejecutándose en el runtime de .NET
const greeting: string = "Hello from SharpTS!";
const version: number = 1.0;
console.log(`${greeting} v${version}`);
const languages = ["TypeScript", "C#", ".NET"];
languages.forEach(lang => console.log(` ✓ ${lang}`));Salida
Hello from SharpTS! v1 ✓ TypeScript ✓ C# ✓ .NET
interface Comparable<T> { compareTo(other: T): number; }
class Temperature implements Comparable<Temperature> {
constructor(private celsius: number) {}
get fahrenheit(): number { return this.celsius * 9 / 5 + 32; }
compareTo(other: Temperature): number { return this.celsius - other.celsius; }
toString(): string { return `${this.celsius}°C (${this.fahrenheit}°F)`; }
}
const temps = [new Temperature(100), new Temperature(0), new Temperature(37)];
temps.sort((a, b) => a.compareTo(b));
temps.forEach(t => console.log(t.toString()));Salida
0°C (32°F) 37°C (98.6°F) 100°C (212°F)
async function delay(ms: number): Promise<string> { return `Done after ${ms}ms`; }
async function main() {
console.log(await delay(100));
const all = await Promise.all([delay(50), delay(100), delay(150)]);
all.forEach(result => console.log(result));
}
main();Salida
Done after 100ms Done after 50ms Done after 100ms Done after 150ms
const data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const result = data.filter(n => n % 2 === 0).map(n => n ** 2).reduce((sum, n) => sum + n, 0);
console.log(`Sum of squares of evens: ${result}`);
const [first, second, ...rest] = data;
console.log(`First: ${first}, Second: ${second}`);
console.log(`Rest: [${rest.join(", ")}]`);Salida
Sum of squares of evens: 220 First: 1, Second: 2 Rest: [3, 4, 5, 6, 7, 8, 9, 10]
console.log(`PI = ${Math.PI}`);
console.log(`E = ${Math.E}`);
console.log(`sqrt(144) = ${Math.sqrt(144)}`);
const now = new Date("2026-03-02T12:00:00.000Z");
console.log(`ISO: ${now.toISOString()}`);
const obj = { name: "SharpTS", nums: [1, 2, 3] };
console.log(`JSON: ${JSON.stringify(obj)}`);Salida
PI = 3.141592653589793
E = 2.718281828459045
sqrt(144) = 12
ISO: 2026-03-02T12:00:00.000Z
JSON: {"name":"SharpTS","nums":[1,2,3]}// Full CLI interop (the public playground intentionally disables module loading)
@DotNetType("System.Text.StringBuilder")
declare class StringBuilder {
constructor();
append(value: string): StringBuilder;
toString(): string;
}
@DotNetType("System.TimeSpan")
declare class TimeSpan {
static fromHours(value: number): TimeSpan;
readonly totalMinutes: number;
}
const sb = new StringBuilder();
sb.append("1.5 hours = ");
sb.append(`${TimeSpan.fromHours(1.5).totalMinutes} minutes`);
console.log(sb.toString());Salida
1.5 hours = 90 minutes
Cuándo encaja SharpTS
Situaciones concretas en las que TypeScript sobre .NET gana a recurrir a Node — o a C#.
Scripts y automatización para equipos .NET
Escribe scripts de build, herramientas de desarrollo y automatización puntual en TypeScript con toda la BCL disponible — en máquinas que ya tienen el SDK de .NET y ninguna cadena de herramientas de Node. Sin package.json, sin paso de compilación: apunta sharpts al archivo.
Terminal
sharpts rotate-logs.tsDistribuye lógica TypeScript como biblioteca .NET
Compila un módulo TypeScript a un ensamblado real y publícalo como paquete NuGet versionado. Con un ensamblado de referencia, el código C# instancia tus clases y llama a tus métodos con tipado completo.
Terminal
sharpts --compile pricing.ts --ref-asm
sharpts --compile pricing.ts --packDesarrolladores TypeScript en una base de código .NET
Deja que tus compañeros que vienen de TypeScript contribuyan en el lenguaje que mejor conocen. Con SharpTS.Sdk, sus archivos .ts se compilan dentro del mismo dotnet build que los proyectos C# que los rodean — una sola cadena de herramientas, un solo pipeline de CI.
app.csproj
<Project Sdk="SharpTS.Sdk/1.0.0">
<PropertyGroup>
<TargetFramework>net10.0</TargetFramework>
<SharpTSEntryPoint>src/main.ts</SharpTSEntryPoint>
</PropertyGroup>
</Project>Herramientas de línea de comandos autónomas
Compila a un único ejecutable autónomo que funciona sin instalar un runtime aparte — sin Node en la máquina de destino, sin carpeta node_modules junto a tu herramienta.
Terminal
sharpts --compile tool.ts -t exe
./toolCómo funciona
Una canalización de varias etapas, desde el código fuente hasta la ejecución
Código fuenteLexerAnalizadorComprobador de tiposIntérpreteCompilador de IL
Descubre cómo funcionaEntorno de pruebas interactivo
Escribe TypeScript y ejecútalo en .NET, directamente en tu navegador
Salida
Haz clic en Ejecutar o pulsa Ctrl+Entrar para ejecutar
Qué es compatible
Un resumen práctico de las funciones de TypeScript y del runtime disponibles hoy. Para consultar resultados medidos, explora Conformidad.
Runtime estándar
Están disponibles las API comunes de Array, String, colecciones, Promise, Date, RegExp, JSON, Symbol y arrays tipados.
Paquetes y Node.js
Los imports sin ruta y los campos exports/imports de los paquetes se pueden resolver, pero los paquetes siguen dependiendo de sintaxis y API de runtime compatibles con SharpTS. Los paquetes que distribuyen código fuente TypeScript son los más adecuados.
Limitaciones conocidas
Proxy y WeakRef no están implementados. Los resultados del intérprete y AOT también pueden diferir en casos límite de la especificación.
Preguntas frecuentes
Las preguntas que surgen primero — respondidas sin rodeos.
¿En qué se diferencia SharpTS de tsc?
tsc comprueba los tipos de tu código y emite JavaScript para que lo ejecute un motor como Node. SharpTS nunca produce JavaScript: comprueba los tipos del mismo TypeScript y luego lo ejecuta directamente o lo compila a un ensamblado .NET. No hay Node en ninguna parte de la cadena. El script de instalación usa el SDK de .NET cuando está disponible o instala una versión autónoma cuando no lo está.
¿Por qué no integrar un motor JavaScript como Jint o ClearScript?
Esos proyectos ejecutan JavaScript plano y sin tipos dentro de un host .NET — perfectos para pequeños scripts embebidos. SharpTS ejecuta TypeScript en sí, con tipos comprobados antes de la ejecución, y añade lo que un motor JS embebido no puede: compilación anticipada a IL, empaquetado NuGet e interoperabilidad tipada en ambos sentidos entre TypeScript y C#.
¿Puedo usar paquetes de npm?
Parcialmente. Los imports sin ruta se resuelven mediante node_modules, y los modos de resolución compatibles pueden aplicar los campos exports/imports y los destinos condicionales de los paquetes. Aun así, un paquete puede fallar si depende de sintaxis no compatible, complementos nativos, variables globales del navegador o API de runtime ausentes. Los paquetes que distribuyen código fuente TypeScript son los más adecuados.
Ver el seguimiento de compatibilidad con Node.js →¿Es rápido?
Cada modo responde de forma distinta. El intérprete recorre el árbol sintáctico y está afinado para arrancar al instante — ideal para scripts y el REPL, no para cálculo intensivo. El modo compilado emite IL que el CLR compila al vuelo como cualquier ensamblado C#, así que se ejecuta como código .NET nativo. En ambos modos, los tipos se comprueban por adelantado y luego se borran — no cuestan nada en tiempo de ejecución.
¿Qué madurez tiene SharpTS?
Es un proyecto joven, con licencia MIT y en desarrollo activo. El resumen de compatibilidad de arriba presenta las funciones habituales, la Conformidad medida publica las pruebas detalladas y STATUS.md registra las carencias de implementación.
Sigue el progreso en STATUS.md →Empezar
Funcionando en tres pasos
1
Instalar
Ejecuta el script de instalación para instalar la versión de SharpTS adecuada para este equipo
curl -fsSL https://sharpts.dev/setup.sh | shirm https://sharpts.dev/setup.ps1 | iex2
Escribir
Crea un archivo TypeScript
hello.ts
interface Config {
name: string;
debug: boolean;
}
const config: Config = { name: "MyApp", debug: true };
console.log(`Starting ${config.name}...`);3
Ejecutar
Interpreta directamente o compila a un ensamblado .NET
Terminal
# Interpretar (inicio instantáneo)
sharpts hello.ts
# Compilar a un ensamblado .NET
sharpts --compile hello.ts -o hello